NAG FL Interface
e05jbf (bnd_​mcs_​solve)

     Subroutine objfun(n,x,f,nstate,iuser,ruser,inform)

!       Routine to evaluate E05JBF objective function.

!       .. Scalar Arguments ..
        Real (Kind=nag_wp), Intent (Out) :: f
        Integer, Intent (Out)          :: inform
        Integer, Intent (In)           :: n, nstate
!       .. Array Arguments ..
        Real (Kind=nag_wp), Intent (Inout) :: ruser(*)
        Real (Kind=nag_wp), Intent (In) :: x(n)
        Integer, Intent (Inout)        :: iuser(*)

!     Compute objective at point x
      f = ...
      Return
   End Subroutine objfun

   Subroutine objfun(nvar,x,f,inform,iuser,ruser,cpuser)

!     .. Use Statements ..
      Use, Intrinsic                 :: iso_c_binding, Only: c_ptr
!     .. Implicit None Statement ..
      Implicit None
!     .. Scalar Arguments ..
      Type (c_ptr), Intent (In)      :: cpuser
      Real (Kind=nag_wp), Intent (Out) :: f
      Integer, Intent (Inout)        :: inform
      Integer, Intent (In)           :: nvar
!     .. Array Arguments ..
      Real (Kind=nag_wp), Intent (Inout) :: ruser(*)
      Real (Kind=nag_wp), Intent (In) :: x(nvar)
      Integer, Intent (Inout)        :: iuser(*)
!     .. Executable Statements ..

!     Compute objective at point x
      f = ...

      Return
   End Subroutine objfun

ifail = -1
Call e05jbf(n,objfun,ibound,iinit,bl,bu,sdlist,list,numpts,initpt,monit, &
            x,obj,comm,lcomm,iuser,ruser,ifail)

!     .. Use Statements ..
      Use, Intrinsic                   :: iso_c_binding, Only: c_null_ptr, c_ptr

!     ...

!     Initialize problem with n variables
      ifail = 0
      Call e04raf(handle,n,ifail)

!     Add nonlinear objective function with dense gradient
!     (dependent on all variables)
      ifail = 0
      Call e04rgf(handle,n,(/(j,j=1,n)/),ifail)

!     Define Simple box bounds
      bl(1:nvar) = (/-3.0_nag_wp,-3.0_nag_wp/)
      bu(1:nvar) = (/3.0_nag_wp,3.0_nag_wp/)
      ifail = 0
      Call e04rhf(handle,nvar,bl,bu,ifail)

!     Solve the problem
      cpuser = c_null_ptr
      ifail = -1
Call e05kbf(handle,objfun,e04kfu,nvar,x,rinfo,stats,iuser,ruser,cpuser,  &
        ifail)

1 Purpose

2 Specification

3 Description

Call e05jaf (n_r, comm, lcomm, ...)
Call e05jdf (optstr, comm, lcomm, ...)
Call e05jbf (n, objfun, ...)

4 References

5 Arguments

1: $\mathbf{n}$ – Integer Input

On entry: $n$, the number of variables.

Constraint: $\mathbf{n}>0$.

2: $\mathbf{objfun}$ – Subroutine, supplied by the user. External Procedure

objfun must evaluate the objective function $F\left(\mathbf{x}\right)$ for a specified $n$-vector $\mathbf{x}$.

The specification of objfun is:

Fortran Interface copy

Subroutine objfun ( n, x, f, nstate, iuser, ruser, inform) Integer, Intent (In) :: n, nstate Integer, Intent (Inout) :: iuser(*) Integer, Intent (Out) :: inform Real (Kind=nag_wp), Intent (In) :: x(n) Real (Kind=nag_wp), Intent (Inout) :: ruser(*) Real (Kind=nag_wp), Intent (Out) :: f

C Header Interface copy

void  objfun (const Integer *n, const double x[], double *f, const Integer *nstate, Integer iuser[], double ruser[], Integer *inform)

C++ Header Interface copy

#include <nag.h> extern "C" { void  objfun (const Integer &n, const double x[], double &f, const Integer &nstate, Integer iuser[], double ruser[], Integer &inform) }

1: $\mathbf{n}$ – Integer Input

On entry: $n$, the number of variables.

2: $\mathbf{x}\left(\mathbf{n}\right)$ – Real (Kind=nag_wp) array Input

On entry: $\mathbf{x}$, the vector at which the objective function is to be evaluated.

3: $\mathbf{f}$ – Real (Kind=nag_wp) Output

On exit: must be set to the value of the objective function at $\mathbf{x}$.

4: $\mathbf{nstate}$ – Integer Input

On entry: if $\mathbf{nstate}=1$ then e05jbf is calling objfun for the first time. This argument setting allows you to save computation time if certain data must be read or calculated only once.

5: $\mathbf{iuser}\left(*\right)$ – Integer array User Workspace

6: $\mathbf{ruser}\left(*\right)$ – Real (Kind=nag_wp) array User Workspace

objfun is called with the arguments iuser and ruser as supplied to e05jbf. You should use the arrays iuser and ruser to supply information to objfun.

7: $\mathbf{inform}$ – Integer Output

On exit: must be set to a value describing the action to be taken by the solver on return from objfun. Specifically, if the value is negative the solution of the current problem will terminate immediately; otherwise, computations will continue.

objfun must either be a module subprogram USEd by, or declared as EXTERNAL in, the (sub)program from which e05jbf is called. Arguments denoted as Input must not be changed by this procedure.

Note: objfun should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by e05jbf. If your code inadvertently does return any NaNs or infinities, e05jbf is likely to produce unexpected results.

3: $\mathbf{ibound}$ – Integer Input

On entry: indicates whether the facility for dealing with bounds of special forms is to be used. ibound must be set to one of the following values.

$\mathbf{ibound}=0$

You will supply $\mathbf{\ell }$ and $\mathbf{u}$ individually.

$\mathbf{ibound}=1$

There are no bounds on $\mathbf{x}$.

$\mathbf{ibound}=2$

There are semi-infinite bounds $0\le \mathbf{x}$.

$\mathbf{ibound}=3$

There are constant bounds $\mathbf{\ell }={\ell }_1$ and $\mathbf{u}=u_1$.

Note that it only makes sense to fix any components of $\mathbf{x}$ when $\mathbf{ibound}=0$.

Constraint: $\mathbf{ibound}=0$, $1$, $2$ or $3$.

4: $\mathbf{iinit}$ – Integer Input

On entry: selects which initialization method to use.

$\mathbf{iinit}=0$

Simple initialization (boundary and midpoint), with
$\mathbf{numpts}\left(i\right)=3$, $\mathbf{initpt}\left(i\right)=2$ and
$\mathbf{list}(i,1)=\mathbf{bl}\left(i\right)$, $\mathbf{list}(i,2)=(\mathbf{bl}\left(i\right)+\mathbf{bu}\left(i\right))/2$, $\mathbf{list}(i,3)=\mathbf{bu}\left(i\right)$,
for $i=1,2,\dots ,\mathbf{n}$.

$\mathbf{iinit}=1$

Simple initialization (off-boundary and midpoint), with
$\mathbf{numpts}\left(i\right)=3$, $\mathbf{initpt}\left(i\right)=2$ and
$\mathbf{list}(i,1)=(5\mathbf{bl}\left(i\right)+\mathbf{bu}\left(i\right))/6$, $\mathbf{list}(i,2)=(\mathbf{bl}\left(i\right)+\mathbf{bu}\left(i\right))/2$, $\mathbf{list}(i,3)=(\mathbf{bl}\left(i\right)+5\mathbf{bu}\left(i\right))/6$,
for $i=1,2,\dots ,\mathbf{n}$.

$\mathbf{iinit}=2$

Initialization using linesearches.

$\mathbf{iinit}=3$

You are providing your own initialization list.

$\mathbf{iinit}=4$

Generate a random initialization list.

For more information on methods $\mathbf{iinit}=2$, $3$ or $4$ see Section 11.1.

If ‘infinite’ values (as determined by the value of the optional parameter Infinite Bound Size) are detected by e05jbf when you are using a simple initialization method ($\mathbf{iinit}=0$ or $1$), a safeguarded initialization procedure will be attempted, to avoid overflow.

Suggested value: $\mathbf{iinit}=0$.

Constraint: $\mathbf{iinit}=0$, $1$, $2$, $3$ or $4$.

5: $\mathbf{bl}\left(\mathbf{n}\right)$ – Real (Kind=nag_wp) array Input/Output

6: $\mathbf{bu}\left(\mathbf{n}\right)$ – Real (Kind=nag_wp) array Input/Output

On entry: $\mathbf{bl}$ is $\mathbf{\ell }$, the array of lower bounds. $\mathbf{bu}$ is $\mathbf{u}$, the array of upper bounds.

If $\mathbf{ibound}=0$, you must set $\mathbf{bl}\left(\mathit{i}\right)$ to ${\ell }_{\mathit{i}}$ and $\mathbf{bu}\left(\mathit{i}\right)$ to $u_{\mathit{i}}$, for $\mathit{i}=1,2,\dots ,\mathbf{n}$. If a particular $x_i$ is to be unbounded below, the corresponding $\mathbf{bl}\left(i\right)$ should be set to $-\mathit{infbnd}$, where $\mathit{infbnd}$ is the value of the optional parameter Infinite Bound Size. Similarly, if a particular $x_i$ is to be unbounded above, the corresponding $\mathbf{bu}\left(i\right)$ should be set to $\mathit{infbnd}$.

If $\mathbf{ibound}=1$ or $2$, arrays bl and bu need not be set on input.

If $\mathbf{ibound}=3$, you must set $\mathbf{bl}\left(1\right)$ to ${\ell }_1$ and $\mathbf{bu}\left(1\right)$ to $u_1$. The remaining elements of bl and bu will then be populated by these initial values.

On exit: unless $\mathbf{ifail}=\mathbf{1}$ or $\mathbf{2}$ on exit, bl and bu are the actual arrays of bounds used by e05jbf.

Constraints:

• if $\mathbf{ibound}=0$, $\mathbf{bl}\left(\mathit{i}\right)\le \mathbf{bu}\left(\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,\mathbf{n}$;
• if $\mathbf{ibound}=3$, $\mathbf{bl}\left(1\right)<\mathbf{bu}\left(1\right)$.

7: $\mathbf{sdlist}$ – Integer Input

On entry: the second dimension of the array list as declared in the (sub)program from which e05jbf is called. sdlist is, at least, the maximum over $i$ of the number of points in coordinate $i$ at which to split according to the initialization list list; that is, $\mathbf{sdlist}\ge {\displaystyle \underset{i}{\max }}\mathbf{numpts}\left(i\right)$.

Internally, e05jbf uses list to determine sets of points along each coordinate direction to which it fits quadratic interpolants. Since fitting a quadratic requires at least three distinct points, this puts a lower bound on sdlist. Furthermore, in the case of initialization by linesearches ($\mathbf{iinit}=2$) internal storage considerations require that sdlist be at least $192$, but not all of this space may be used.

Constraints:

• if $\mathbf{iinit}\ne 2$, $\mathbf{sdlist}\ge 3$;
• if $\mathbf{iinit}=2$, $\mathbf{sdlist}\ge 192$;
• if $\mathbf{iinit}=3$, $\mathbf{sdlist}\ge {\displaystyle \underset{\mathit{i}}{\max }}\left\{\mathbf{numpts}\left(\mathit{i}\right)\right\}$.

8: $\mathbf{list}(\mathbf{n},\mathbf{sdlist})$ – Real (Kind=nag_wp) array Input/Output

On entry: this argument need not be set on entry if you wish to use one of the preset initialization methods ($\mathbf{iinit}\ne 3$).

list is the ‘initialization list’: whenever a sub-box in the algorithm is split for the first time (either during the initialization procedure or later), for each non-fixed coordinate $i$ the split is done at the values $\mathbf{list}(i,1:\mathbf{numpts}\left(i\right))$, as well as at some adaptively chosen intermediate points. The array sections $\mathbf{list}(\mathit{i},1:\mathbf{numpts}\left(\mathit{i}\right))$, for $\mathit{i}=1,2,\dots ,\mathbf{n}$, must be in ascending order with each entry being distinct. In this context, ‘distinct’ should be taken to mean relative to the safe-range parameter (see x02amf).

On exit: unless $\mathbf{ifail}=\mathbf{1}$, $\mathbf{2}$ or $-\mathbf{999}$ on exit, the actual initialization data used by e05jbf. If you wish to monitor the contents of list you are advised to do so solely through monit, not through the output value here.

Constraints:

if $\mathbf{x}\left(\mathit{i}\right)$ is not fixed,

• $\mathbf{list}(\mathit{i},1:\mathbf{numpts}\left(\mathit{i}\right))$ is in ascending order with each entry being distinct, for $\mathit{i}=1,2,\dots ,\mathbf{n}$;
• $\mathbf{bl}\left(\mathit{i}\right)\le \mathbf{list}(\mathit{i},\mathit{j})\le \mathbf{bu}\left(\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,\mathbf{n}$ and $\mathit{j}=1,2,\dots ,\mathbf{numpts}\left(\mathit{i}\right)$.

9: $\mathbf{numpts}\left(\mathbf{n}\right)$ – Integer array Input/Output

On entry: this argument need not be set on entry if you wish to use one of the preset initialization methods ($\mathbf{iinit}\ne 3$).

numpts encodes the number of splitting points in each non-fixed dimension.

On exit: unless $\mathbf{ifail}=\mathbf{1}$, $\mathbf{2}$ or $-\mathbf{999}$ on exit, the actual initialization data used by e05jbf.

Constraints:

• if $\mathbf{x}\left(\mathit{i}\right)$ is not fixed, $\mathbf{numpts}\left(\mathit{i}\right)\le \mathbf{sdlist}$;
• $\mathbf{numpts}\left(\mathit{i}\right)\ge 3$, for $\mathit{i}=1,2,\dots ,\mathbf{n}$.

10: $\mathbf{initpt}\left(\mathbf{n}\right)$ – Integer array Input/Output

On entry: this argument need not be set on entry if you wish to use one of the preset initialization methods ($\mathbf{iinit}\ne 3$).

You must designate a point stored in list that you wish e05jbf to consider as an ‘initial point’ for the purposes of the splitting procedure. Call this initial point ${\mathbf{x}}^{*}$. The coordinates of ${\mathbf{x}}^{*}$ correspond to a set of indices $J_{\mathit{i}}$, for $\mathit{i}=1,2,\dots ,n$, such that ${\mathbf{x}}_{\mathit{i}}^{*}$ is stored in $\mathbf{list}(\mathit{i},J_{\mathit{i}})$, for $\mathit{i}=1,2,\dots ,n$. You must set $\mathbf{initpt}\left(\mathit{i}\right)=J_{\mathit{i}}$, for $\mathit{i}=1,2,\dots ,n$.

On exit: unless $\mathbf{ifail}=\mathbf{1}$, $\mathbf{2}$ or $-\mathbf{999}$ on exit, the actual initialization data used by e05jbf.

Constraint: if $\mathbf{x}\left(\mathit{i}\right)$ is not fixed, $1\le \mathbf{initpt}\left(\mathit{i}\right)\le \mathbf{sdlist}$, for $\mathit{i}=1,2,\dots ,\mathbf{n}$.

11: $\mathbf{monit}$ – Subroutine, supplied by the NAG Library or the user. External Procedure

monit may be used to monitor the optimization process. It is invoked upon every successful completion of the procedure in which a sub-box is considered for splitting. It will also be called just before e05jbf exits if that splitting procedure was not successful.

If no monitoring is required, monit may be the dummy monitoring routine e05jbk supplied by the NAG Library.

The specification of monit is:

Fortran Interface copy

Subroutine monit ( n, ncall, xbest, icount, ninit, list, numpts, initpt, nbaskt, xbaskt, boxl, boxu, nstate, iuser, ruser, inform) Integer, Intent (In) :: n, ncall, icount(6), ninit, numpts(n), initpt(n), nbaskt, nstate Integer, Intent (Inout) :: iuser(*) Integer, Intent (Out) :: inform Real (Kind=nag_wp), Intent (In) :: xbest(n), list(n,ninit), xbaskt(n,nbaskt), boxl(n), boxu(n) Real (Kind=nag_wp), Intent (Inout) :: ruser(*)

C Header Interface copy

void  monit (const Integer *n, const Integer *ncall, const double xbest[], const Integer icount[], const Integer *ninit, const double list[], const Integer numpts[], const Integer initpt[], const Integer *nbaskt, const double xbaskt[], const double boxl[], const double boxu[], const Integer *nstate, Integer iuser[], double ruser[], Integer *inform)

C++ Header Interface copy

#include <nag.h> extern "C" { void  monit (const Integer &n, const Integer &ncall, const double xbest[], const Integer icount[], const Integer &ninit, const double list[], const Integer numpts[], const Integer initpt[], const Integer &nbaskt, const double xbaskt[], const double boxl[], const double boxu[], const Integer &nstate, Integer iuser[], double ruser[], Integer &inform) }

1: $\mathbf{n}$ – Integer Input

On entry: $n$, the number of variables.

2: $\mathbf{ncall}$ – Integer Input

On entry: the cumulative number of calls to objfun.

3: $\mathbf{xbest}\left(\mathbf{n}\right)$ – Real (Kind=nag_wp) array Input

On entry: the current best point.

4: $\mathbf{icount}\left(6\right)$ – Integer array Input

On entry: an array of counters.

$\mathbf{icount}\left(1\right)$

$\mathit{nboxes}$, the current number of sub-boxes.

$\mathbf{icount}\left(2\right)$

$\mathit{ncloc}$, the cumulative number of calls to objfun made in local searches.

$\mathbf{icount}\left(3\right)$

$\mathit{nloc}$, the cumulative number of points used as start points for local searches.

$\mathbf{icount}\left(4\right)$

$\mathit{nsweep}$, the cumulative number of sweeps through levels.

$\mathbf{icount}\left(5\right)$

$\mathit{m}$, the cumulative number of splits by initialization list.

$\mathbf{icount}\left(6\right)$

$\mathit{s}$, the current lowest level containing non-split boxes.

5: $\mathbf{ninit}$ – Integer Input

On entry: the maximum over $i$ of the number of points in coordinate $i$ at which to split according to the initialization list list. See also the description of the argument numpts.

6: $\mathbf{list}(\mathbf{n},\mathbf{ninit})$ – Real (Kind=nag_wp) array Input

On entry: the initialization list.

7: $\mathbf{numpts}\left(\mathbf{n}\right)$ – Integer array Input

On entry: the number of points in each coordinate at which to split according to the initialization list list.

8: $\mathbf{initpt}\left(\mathbf{n}\right)$ – Integer array Input

On entry: a pointer to the ‘initial point’ in list. Element $\mathbf{initpt}\left(i\right)$ is the column index in list of the $i$th coordinate of the initial point.

9: $\mathbf{nbaskt}$ – Integer Input

On entry: the number of points in the ‘shopping basket’ xbaskt.

10: $\mathbf{xbaskt}(\mathbf{n},\mathbf{nbaskt})$ – Real (Kind=nag_wp) array Input

Note: the $j$th candidate minimum has its $i$th coordinate stored in $\mathbf{xbaskt}(\mathit{j},\mathit{i})$, for $\mathit{i}=1,2,\dots ,\mathbf{n}$ and $\mathit{j}=1,2,\dots ,\mathbf{nbaskt}$.

On entry: the ‘shopping basket’ of candidate minima.

11: $\mathbf{boxl}\left(\mathbf{n}\right)$ – Real (Kind=nag_wp) array Input

On entry: the array of lower bounds of the current search box.

12: $\mathbf{boxu}\left(\mathbf{n}\right)$ – Real (Kind=nag_wp) array Input

On entry: the array of upper bounds of the current search box.

13: $\mathbf{nstate}$ – Integer Input

On entry: is set by e05jbf to indicate at what stage of the minimization monit was called.

$\mathbf{nstate}=1$

This is the first time that monit has been called.

$\mathbf{nstate}=\mathrm{-1}$

This is the last time monit will be called.

$\mathbf{nstate}=0$

This is the first and last time monit will be called.

14: $\mathbf{iuser}\left(*\right)$ – Integer array User Workspace

15: $\mathbf{ruser}\left(*\right)$ – Real (Kind=nag_wp) array User Workspace

monit is called with the arguments iuser and ruser as supplied to e05jbf. You should use the arrays iuser and ruser to supply information to monit.

16: $\mathbf{inform}$ – Integer Output

On exit: must be set to a value describing the action to be taken by the solver on return from monit. Specifically, if the value is negative the solution of the current problem will terminate immediately; otherwise, computations will continue.

monit must either be a module subprogram USEd by, or declared as EXTERNAL in, the (sub)program from which e05jbf is called. Arguments denoted as Input must not be changed by this procedure.

12: $\mathbf{x}\left(\mathbf{n}\right)$ – Real (Kind=nag_wp) array Output

On exit: if $\mathbf{ifail}=\mathbf{0}$, contains an estimate of the global optimum (see also Section 7).

13: $\mathbf{obj}$ – Real (Kind=nag_wp) Output

On exit: if $\mathbf{ifail}=\mathbf{0}$, contains the function value at x.

If you request early termination of e05jbf in objfun or monit, there is no guarantee that the function value at x equals obj.

14: $\mathbf{comm}\left(\mathbf{lcomm}\right)$ – Real (Kind=nag_wp) array Communication Array

On exit: comm must not be altered between calls to any of the routines e05jbf, e05jcf, e05jdf, e05jef, e05jff, e05jgf, e05jhf, e05jjf, e05jkf and e05jlf.

15: $\mathbf{lcomm}$ – Integer Input

On entry: the dimension of the array comm as declared in the (sub)program from which e05jbf is called.

Constraint: $\mathbf{lcomm}\ge 100$.

16: $\mathbf{iuser}\left(*\right)$ – Integer array User Workspace

17: $\mathbf{ruser}\left(*\right)$ – Real (Kind=nag_wp) array User Workspace

iuser and ruser are not used by e05jbf, but are passed directly to objfun and monit and may be used to pass information to these routines.

18: $\mathbf{ifail}$ – Integer Input/Output

On entry: ifail must be set to $0$, $\mathrm{-1}$ or $1$ to set behaviour on detection of an error; these values have no effect when no error is detected.

A value of $0$ causes the printing of an error message and program execution will be halted; otherwise program execution continues. A value of $\mathrm{-1}$ means that an error message is printed while a value of $1$ means that it is not.

If halting is not appropriate, the value $\mathrm{-1}$ or $1$ is recommended. If message printing is undesirable, then the value $1$ is recommended. Otherwise, the value $0$ is recommended. When the value $-\mathbf{1}$ or $\mathbf{1}$ is used it is essential to test the value of ifail on exit.

On exit: $\mathbf{ifail}=\mathbf{0}$ unless the routine detects an error or a warning has been flagged (see Section 6).

e05jbf returns with $\mathbf{ifail}=\mathbf{0}$ if your termination criterion has been met: either a target value has been found to the required relative error (as determined by the values of the optional parameters Target Objective Value, Target Objective Error and Target Objective Safeguard), or the best function value was static for the number of sweeps through levels given by the optional parameter Static Limit. The latter criterion is the default.

6 Error Indicators and Warnings

$\mathbf{ifail}=1$

Initialization routine e05jaf has not been called.

On entry, $\mathbf{lcomm}=⟨\mathit{\text{value}}⟩$.
Constraint: $\mathbf{lcomm}\ge 100$.

$\mathbf{ifail}=2$

A value of Splits Limit ($\mathit{smax}$) smaller than $n_r+3$ was set: $\mathit{smax}=⟨\mathit{\text{value}}⟩$, $n_r=⟨\mathit{\text{value}}⟩$.

On entry, $\mathbf{ibound}=⟨\mathit{\text{value}}⟩$.
Constraint: $\mathbf{ibound}=0$, $1$, $2$ or $3$.

On entry, $\mathbf{ibound}=0$ or $3$ and $\mathbf{bl}\left(i\right)=⟨\mathit{\text{value}}⟩$, $\mathbf{bu}\left(i\right)=⟨\mathit{\text{value}}⟩$ and $i=⟨\mathit{\text{value}}⟩$.
Constraint: if $\mathbf{ibound}=0$ then $\mathbf{bl}\left(\mathit{i}\right)\le \mathbf{bu}\left(\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,\mathbf{n}$; if $\mathbf{ibound}=3$ then $\mathbf{bl}\left(1\right)<\mathbf{bu}\left(1\right)$.

On entry, $\mathbf{ibound}=3$ and $\mathbf{bl}\left(1\right)=\mathbf{bu}\left(1\right)=⟨\mathit{\text{value}}⟩$.
Constraint: if $\mathbf{ibound}=3$ then $\mathbf{bl}\left(1\right)<\mathbf{bu}\left(1\right)$.

On entry, $\mathbf{iinit}=⟨\mathit{\text{value}}⟩$.
Constraint: $\mathbf{iinit}=0$, $1$, $2$, $3$ or $4$.

On entry, $\mathbf{iinit}=2$ and $\mathbf{sdlist}=⟨\mathit{\text{value}}⟩$.
Constraint: if $\mathbf{iinit}=2$ then $\mathbf{sdlist}\ge 192$.

On entry, $\mathbf{iinit}=⟨\mathit{\text{value}}⟩$ and $\mathbf{sdlist}=⟨\mathit{\text{value}}⟩$.
Constraint: if $\mathbf{iinit}\ne 2$ then $\mathbf{sdlist}\ge 3$.

On entry, $\mathbf{n}=⟨\mathit{\text{value}}⟩$.
Constraint: $\mathbf{n}>0$.

On entry, user-supplied $\mathbf{initpt}\left(i\right)=⟨\mathit{\text{value}}⟩$, $i=⟨\mathit{\text{value}}⟩$.
Constraint: if $\mathbf{x}\left(i\right)$ is not fixed then $\mathbf{initpt}\left(\mathit{i}\right)\ge 1$, for $\mathit{i}=1,2,\dots ,\mathbf{n}$.

On entry, user-supplied $\mathbf{initpt}\left(i\right)=⟨\mathit{\text{value}}⟩$, $i=⟨\mathit{\text{value}}⟩$ and $\mathbf{sdlist}=⟨\mathit{\text{value}}⟩$.
Constraint: if $\mathbf{x}\left(i\right)$ is not fixed then $\mathbf{initpt}\left(\mathit{i}\right)\le \mathbf{sdlist}$, for $\mathit{i}=1,2,\dots ,\mathbf{n}$.

On entry, user-supplied $\mathbf{list}(i,j)=⟨\mathit{\text{value}}⟩$, $i=⟨\mathit{\text{value}}⟩$, $j=⟨\mathit{\text{value}}⟩$, and $\mathbf{bl}\left(i\right)=⟨\mathit{\text{value}}⟩$.
Constraint: if $\mathbf{x}\left(i\right)$ is not fixed then $\mathbf{list}(\mathit{i},\mathit{j})\ge \mathbf{bl}\left(\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,\mathbf{n}$ and $\mathit{j}=1,2,\dots ,\mathbf{numpts}\left(\mathit{i}\right)$.

On entry, user-supplied $\mathbf{list}(i,j)=⟨\mathit{\text{value}}⟩$, $i=⟨\mathit{\text{value}}⟩$, $j=⟨\mathit{\text{value}}⟩$, and $\mathbf{bu}\left(i\right)=⟨\mathit{\text{value}}⟩$.
Constraint: if $\mathbf{x}\left(i\right)$ is not fixed then $\mathbf{list}(\mathit{i},\mathit{j})\le \mathbf{bu}\left(\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,\mathbf{n}$ and $\mathit{j}=1,2,\dots ,\mathbf{numpts}\left(\mathit{i}\right)$.

On entry, user-supplied $\mathbf{numpts}\left(i\right)=⟨\mathit{\text{value}}⟩$, $i=⟨\mathit{\text{value}}⟩$.
Constraint: if $\mathbf{x}\left(i\right)$ is not fixed then $\mathbf{numpts}\left(\mathit{i}\right)\ge 3$, for $\mathit{i}=1,2,\dots ,\mathbf{n}$.

On entry, user-supplied $\mathbf{numpts}\left(i\right)=⟨\mathit{\text{value}}⟩$, $i=⟨\mathit{\text{value}}⟩$ and $\mathbf{sdlist}=⟨\mathit{\text{value}}⟩$.
Constraint: if $\mathbf{x}\left(i\right)$ is not fixed then $\mathbf{numpts}\left(\mathit{i}\right)\le \mathbf{sdlist}$, for $\mathit{i}=1,2,\dots ,\mathbf{n}$.

On entry, user-supplied section $\mathbf{list}(i,1:\mathbf{numpts}\left(i\right))$ contained $\mathit{ndist}$ distinct elements, and $\mathit{ndist}<\mathbf{numpts}\left(i\right)$: $\mathit{ndist}=⟨\mathit{\text{value}}⟩$, $\mathbf{numpts}\left(i\right)=⟨\mathit{\text{value}}⟩$, $i=⟨\mathit{\text{value}}⟩$.

On entry, user-supplied section $\mathbf{list}(i,1:\mathbf{numpts}\left(i\right))$ was not in ascending order: $\mathbf{numpts}\left(i\right)=⟨\mathit{\text{value}}⟩$, $i=⟨\mathit{\text{value}}⟩$.

The number of non-fixed variables $n_r=0$.
Constraint: $n_r>0$.

$\mathbf{ifail}=3$

A finite initialization list could not be computed internally. Consider reformulating the bounds on the problem, try providing your own initialization list, use the randomization option ($\mathbf{iinit}=4$) or vary the value of Infinite Bound Size.

The user-supplied initialization list contained infinite values, as determined by the optional parameter Infinite Bound Size.

$\mathbf{ifail}=4$

The division procedure completed but your target value could not be reached.
Despite every sub-box being processed Splits Limit times, the target value you provided in Target Objective Value could not be found to the tolerances given in Target Objective Error and Target Objective Safeguard. You could try reducing Splits Limit or the objective tolerances.

$\mathbf{ifail}=5$

The function evaluations limit was exceeded.
Approximately Function Evaluations Limit function calls have been made without your chosen termination criterion being satisfied.

$\mathbf{ifail}=6$

User-supplied monitoring routine requested termination.

User-supplied objective function requested termination.

$\mathbf{ifail}=7$

An error occurred during initialization. It is likely that points from the initialization list are very close together. Try relaxing the bounds on the variables or use a different initialization method.

An error occurred during linesearching. It is likely that your objective function is badly scaled: try rescaling it. Also, try relaxing the bounds or use a different initialization method. If the problem persists, please contact NAG quoting error code $⟨\mathit{\text{value}}⟩$.

$\mathbf{ifail}=-99$

An unexpected error has been triggered by this routine. Please contact NAG.

See Section 7 in the Introduction to the NAG Library FL Interface for further information.

$\mathbf{ifail}=-399$

Your licence key may have expired or may not have been installed correctly.

See Section 8 in the Introduction to the NAG Library FL Interface for further information.

$\mathbf{ifail}=-999$

Dynamic memory allocation failed.

See Section 9 in the Introduction to the NAG Library FL Interface for further information.

7 Accuracy

8 Parallelism and Performance

9 Further Comments

10 Example

10.1 Program Text

10.2 Program Data

10.3 Program Results

11 Algorithmic Details

11.1 Initialization and Sweeps

Figure 1: Examples of the initialization procedure

11.2 Splitting

1. (i)Splitting by rank
   If $s>2n_r\left(\min n_j+1\right)$, the box is always split. The splitting index is set to a coordinate $i$ such that $n_i=\min n_j$.
2. (ii)Splitting by expected gain
   If $s\le 2n_r\left(\min n_j+1\right)$, the sub-box could be split along a coordinate where a maximal gain in function value is expected. This gain is estimated according to a local separable quadratic model obtained by fitting to $2n_r+1$ function values. If the expected gain is too small the sub-box is not split at all, and its level is increased by $1$.

11.2.1 Splitting by rank

11.2.2 Splitting by expected gain

11.3 Local Search

12 Optional Parameters

• Defaults
• Function Evaluations Limit
• Infinite Bound Size
• List
• Local Searches
• Local Searches Limit
• Local Searches Tolerance
• Maximize
• Minimize
• Nolist
• Repeatability
• Splits Limit
• Static Limit
• Target Objective Error
• Target Objective Safeguard
• Target Objective Value

 Begin
   Static Limit = 50
 End

Call e05jcf (iopts, comm, lcomm, ifail)

12.1 Description of the Optional Parameters

• a parameter value, where the letters $a$, $i$ and $r$ denote options that take character, integer and real values respectively, and where the letter $a$ denotes an option that takes an $\mathrm{ON}$ or $\mathrm{OFF}$ value;
• the default value, where the symbol $\epsilon$ is a generic notation for machine precision (see x02ajf), the symbol $r_{\max }$ stands for the largest positive model number (see x02alf), $n_r$ represents the number of non-fixed variables, and the symbol $d$ stands for the maximum number of decimal digits that can be represented (see x02bef).