NAG Library Function Document

nag_glopt_nlp_multistart_sqp_lsq (e05usc)

1  Purpose

2  Specification

3  Description

4  References

5  Arguments

1:    $\mathbf{m}$ – IntegerInput

On entry: $m$, the number of subfunctions associated with $F\left(x\right)$.

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

2:    $\mathbf{n}$ – IntegerInput

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

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

3:    $\mathbf{nclin}$ – IntegerInput

On entry: $n_L$, the number of general linear constraints.

Constraint: $\mathbf{nclin}\ge 0$.

4:    $\mathbf{ncnln}$ – IntegerInput

On entry: $n_N$, the number of nonlinear constraints.

Constraint: $\mathbf{ncnln}\ge 0$.

5:    $\mathbf{a}\left[\mathit{dim}\right]$ – const doubleInput

Note: the dimension, dim, of the array a must be at least $\mathbf{pda}\times \mathbf{n}$ when $\mathbf{nclin}>0$.

Where $\mathbf{A}\left(i,j\right)$ appears in this document, it refers to the array element $\mathbf{a}\left[\left(j-1\right)\times \mathbf{pda}+i-1\right]$.

On entry: the matrix $A_L$ of general linear constraints in (1). That is, $\mathbf{A}\left(\mathit{i},\mathit{j}\right)$ must contain the $\mathit{j}$th coefficient of the $\mathit{i}$th general linear constraint, for $\mathit{j}=1,2,\dots ,\mathbf{n}$ and $\mathit{i}=1,2,\dots ,\mathbf{nclin}$. If $\mathbf{nclin}=0$ then a may be specified as NULL.

6:    $\mathbf{pda}$ – IntegerInput

On entry: the stride separating matrix row elements in the array a.

Constraint: $\mathbf{pda}\ge \mathbf{nclin}$.

7:    $\mathbf{bl}\left[\mathbf{n}+\mathbf{nclin}+\mathbf{ncnln}\right]$ – const doubleInput

8:    $\mathbf{bu}\left[\mathbf{n}+\mathbf{nclin}+\mathbf{ncnln}\right]$ – const doubleInput

On entry: bl must contain the lower bounds and bu the upper bounds for all the constraints in the following order. The first $n$ elements of each array must contain the bounds on the variables, the next $n_L$ elements the bounds for the general linear constraints (if any) and the next $n_N$ elements the bounds for the general nonlinear constraints (if any). To specify a nonexistent lower bound (i.e., $l_j=-\infty$), set $\mathbf{bl}\left[j-1\right]\le -\mathit{bigbnd}$, and to specify a nonexistent upper bound (i.e., $u_j=+\infty$), set $\mathbf{bu}\left[j-1\right]\ge \mathit{bigbnd}$; the default value of $\mathit{bigbnd}$ is ${10}^{20}$, but this may be changed by the optional argument $\mathbf{Infinite\; Bound\; Size}$. To specify the $j$th constraint as an equality, set $\mathbf{bl}\left[j-1\right]=\mathbf{bu}\left[j-1\right]=\beta$, say, where $\left|\beta \right|<\mathit{bigbnd}$.

Constraints:

• $\mathbf{bl}\left[\mathit{j}-1\right]\le \mathbf{bu}\left[\mathit{j}-1\right]$, for $\mathit{j}=1,2,\dots ,\mathbf{n}+\mathbf{nclin}+\mathbf{ncnln}$;
• if $\mathbf{bl}\left[j-1\right]=\mathbf{bu}\left[j-1\right]=\beta$, $\left|\beta \right|<\mathit{bigbnd}$.

9:    $\mathbf{y}\left[\mathbf{m}\right]$ – const doubleInput

On entry: the coefficients of the constant vector $y$ of the objective function.

10:  $\mathbf{confun}$ – function, supplied by the userExternal Function

confun must calculate the vector $c\left(x\right)$ of nonlinear constraint functions and (optionally) its Jacobian ($=\frac{\partial c}{\partial x}$) for a specified $n$-element vector $x$. If there are no nonlinear constraints (i.e., $\mathbf{ncnln}=0$), confun will never be called by nag_glopt_nlp_multistart_sqp_lsq (e05usc) and the NAG defined null void function pointer, NULLFN, may be supplied in the call instead. If there are nonlinear constraints, the first call to confun will occur before the first call to objfun.

The specification of confun is:

void  confun (Integer *mode, Integer ncnln, Integer n, Integer pdcjsl, const Integer needc[], const double x[], double c[], double cjsl[], Integer nstate, Nag_Comm *comm)

1:    $\mathbf{mode}$ – Integer *Input/Output

On entry: indicates which values must be assigned during each call of confun. Only the following values need be assigned, for each value of $i$ such that $\mathbf{needc}\left[i-1\right]>0$:

$\mathbf{mode}=0$

$\mathbf{c}\left[i-1\right]$, the $i$th nonlinear constraint.

$\mathbf{mode}=1$

All available elements in $\mathbf{CJSL}\left(i,\mathit{j}\right)$, for $\mathit{j}=1,2,\dots ,\mathbf{n}$ (see cjsl for the definition of CJSL).

$\mathbf{mode}=2$

$\mathbf{c}\left[i-1\right]$ and all available elements in $\mathbf{CJSL}\left(i,\mathit{j}\right)$, for $\mathit{j}=1,2,\dots ,\mathbf{n}$ (see cjsl for the definition of CJSL).

On exit: may be set to a negative value if you wish to abandon the solution to the current local minimization problem. In this case nag_glopt_nlp_multistart_sqp_lsq (e05usc) will move to the next local minimization problem.

2:    $\mathbf{ncnln}$ – IntegerInput

On entry: $n_N$, the number of nonlinear constraints.

3:    $\mathbf{n}$ – IntegerInput

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

4:    $\mathbf{pdcjsl}$ – IntegerInput

On entry: the stride separating matrix row elements in the array cjsl.

5:    $\mathbf{needc}\left[\mathbf{ncnln}\right]$ – const IntegerInput

On entry: the indices of the elements of c and/or cjsl that must be evaluated by confun. If $\mathbf{needc}\left[i-1\right]>0$, $\mathbf{c}\left[i-1\right]$ and/or the available elements of $\mathbf{CJSL}\left(i,\mathit{j}\right)$, for $\mathit{j}=1,2,\dots ,\mathbf{n}$ (see argument mode) must be evaluated at $x$. See cjsl for the definition of CJSL.

6:    $\mathbf{x}\left[\mathbf{n}\right]$ – const doubleInput

On entry: $x$, the vector of variables at which the constraint functions and/or the available elements of the constraint Jacobian are to be evaluated.

7:    $\mathbf{c}\left[\mathbf{ncnln}\right]$ – doubleOutput

On exit: if $\mathbf{needc}\left[i-1\right]>0$ and $\mathbf{mode}=0$ or $2$, $\mathbf{c}\left[i-1\right]$ must contain the value of $c_i\left(x\right)$. The remaining elements of c, corresponding to the non-positive elements of needc, need not be set.

8:    $\mathbf{cjsl}\left[\mathit{dim}\right]$ – doubleInput/Output

Note: the dimension, dim, of the array cjsl is $\mathbf{pdcjsl}\times \mathbf{n}$.

Where $\mathbf{CJSL}\left(i,j\right)$ appears in this document, it refers to the array element $\mathbf{cjsl}\left[\left(j-1\right)\times \mathbf{pdcjsl}+i-1\right]$.

CJSL may be regarded as a two-dimensional ‘slice’ in column order of the three-dimensional matrix CJAC stored in the array cjac of nag_glopt_nlp_multistart_sqp_lsq (e05usc).

On entry: unless $\mathbf{Derivative\; Level}=2$ or $3$, the elements of cjsl are set to special values which enable nag_glopt_nlp_multistart_sqp_lsq (e05usc) to detect whether they are changed by confun.

On exit: if $\mathbf{needc}\left[i-1\right]>0$ and $\mathbf{mode}=1$ or $2$, $\mathbf{CJSL}\left(i,\mathit{j}\right)$, for $\mathit{j}=1,2,\dots ,\mathbf{n}$, must contain the available elements of the vector $\nabla c_i$ given by

$$\nabla c_i={\left(\frac{\partial c_i}{\partial x_1},\frac{\partial c_i}{\partial x_2},\dots ,\frac{\partial c_i}{\partial x_n}\right)}^{\mathrm{T}}\text{,}$$

where $\frac{\partial c_i}{\partial x_j}$ is the partial derivative of the $i$th constraint with respect to the $j$th variable, evaluated at the point $x$. See also the argument nstate. The remaining $\mathbf{CJSL}\left(i,\mathit{j}\right)$, for $\mathit{j}=1,2,\dots ,\mathbf{n}$, corresponding to non-positive elements of needc, need not be set.

If all elements of the constraint Jacobian are known (i.e., $\mathbf{Derivative\; Level}=2$ or $3$), any constant elements may be assigned to cjsl one time only at the start of each local optimization. An element of cjsl that is not subsequently assigned in confun will retain its initial value throughout the local optimization. Constant elements may be loaded into cjsl during the first call to confun for the local optimization (signalled by the value $\mathbf{nstate}=1$). The ability to preload constants is useful when many Jacobian elements are identically zero, in which case cjsl may be initialized to zero and nonzero elements may be reset by confun.

Note that constant nonzero elements do affect the values of the constraints. Thus, if $\mathbf{CJSL}\left(i,j\right)$ is set to a constant value, it need not be reset in subsequent calls to confun, but the value $\mathbf{CJSL}\left(i,j\right)\times \mathbf{x}\left[j-1\right]$ must nonetheless be added to $\mathbf{c}\left[i-1\right]$. For example, if $\mathbf{CJSL}\left(1,1\right)=2$ and $\mathbf{CJSL}\left(1,2\right)=-5$ then the term $2\times \mathbf{x}\left[0\right]-5\times \mathbf{x}\left[1\right]$ must be included in the definition of $\mathbf{c}\left[0\right]$.

It must be emphasized that, if $\mathbf{Derivative\; Level}=0$ or $1$, unassigned elements of cjsl are not treated as constant; they are estimated by finite differences, at nontrivial expense. If you do not supply a value for the optional argument $\mathbf{Difference\; Interval}$, an interval for each element of $x$ is computed automatically at the start of each local optimization. The automatic procedure can usually identify constant elements of cjsl, which are then computed once only by finite differences.

9:    $\mathbf{nstate}$ – IntegerInput

On entry: if $\mathbf{nstate}=1$ then nag_glopt_nlp_multistart_sqp_lsq (e05usc) is calling confun for the first time on the current local optimization problem. This argument setting allows you to save computation time if certain data must be read or calculated only once.

10:  $\mathbf{comm}$ – Nag_Comm *

Pointer to structure of type Nag_Comm; the following members are relevant to confun.

user – double *

iuser – Integer *

p – Pointer 

The type Pointer will be void *. Before calling nag_glopt_nlp_multistart_sqp_lsq (e05usc) you may allocate memory and initialize these pointers with various quantities for use by confun when called from nag_glopt_nlp_multistart_sqp_lsq (e05usc) (see Section 3.2.1.1 in the Essential Introduction).

confun should be tested separately before being used in conjunction with nag_glopt_nlp_multistart_sqp_lsq (e05usc). See also the description of the optional argument $\mathbf{Verify}$.

11:  $\mathbf{objfun}$ – function, supplied by the userExternal Function

objfun must calculate either the $i$th element of the vector $f\left(x\right)={\left(f_1\left(x\right),f_2\left(x\right),\dots ,f_m\left(x\right)\right)}^{\mathrm{T}}$ or all $m$ elements of $f\left(x\right)$ and (optionally) its Jacobian ($=\frac{\partial f}{\partial x}$) for a specified $n$-element vector $x$.

The specification of objfun is:

void  objfun (Integer *mode, Integer m, Integer n, Integer pdfjsl, Integer needfi, const double x[], double f[], double fjsl[], Integer nstate, Nag_Comm *comm)

1:    $\mathbf{mode}$ – Integer *Input/Output

On entry: indicates which values must be assigned during each call of objfun. Only the following values need be assigned:

$\mathbf{mode}=0$ and $\mathbf{needfi}=i$, where $i>0$

$\mathbf{f}\left[i-1\right]$.

$\mathbf{mode}=0$ and $\mathbf{needfi}<0$

f.

$\mathbf{mode}=1$ and $\mathbf{needfi}<0$

All available elements of fjsl.

$\mathbf{mode}=2$ and $\mathbf{needfi}<0$

f and all available elements of fjsl.

On exit: may be set to a negative value if you wish to abandon the solution to the current local minimization problem. In this case nag_glopt_nlp_multistart_sqp_lsq (e05usc) will move to the next local minimization problem.

2:    $\mathbf{m}$ – IntegerInput

On entry: $m$, the number of subfunctions.

3:    $\mathbf{n}$ – IntegerInput

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

4:    $\mathbf{pdfjsl}$ – IntegerInput

On entry: the stride separating matrix row elements in the array fjsl.

5:    $\mathbf{needfi}$ – IntegerInput

On entry: if $\mathbf{needfi}=i>0$, only the $i$th element of $f\left(x\right)$ needs to be evaluated at $x$; the remaining elements need not be set. This can result in significant computational savings when $m\gg n$.

6:    $\mathbf{x}\left[\mathbf{n}\right]$ – const doubleInput

On entry: $x$, the vector of variables at which the objective function and/or all available elements of its gradient are to be evaluated.

7:    $\mathbf{f}\left[\mathbf{m}\right]$ – doubleOutput

On exit: if $\mathbf{mode}=0$ and $\mathbf{needfi}=i>0$, $\mathbf{f}\left[i-1\right]$ must contain the value of $f_i$ at $x$.

If $\mathbf{mode}=0$ or $2$ and $\mathbf{needfi}<0$, $\mathbf{f}\left[\mathit{i}-1\right]$ must contain the value of $f_{\mathit{i}}$ at $x$, for $\mathit{i}=1,2,\dots ,m$.

8:    $\mathbf{fjsl}\left[\mathit{dim}\right]$ – doubleInput/Output

Note: the dimension, dim, of the array fjsl is $\mathbf{pdfjsl}\times \mathbf{n}$.

The $\left(i,j\right)$th element of the matrix is stored in $\mathbf{fjsl}\left[\left(j-1\right)\times \mathbf{pdfjsl}+i-1\right]$.

FJSL may be regarded as a two-dimensional ‘slice’ in column order of the three-dimensional matrix FJAC stored in the array fjac of nag_glopt_nlp_multistart_sqp_lsq (e05usc).

On entry: is set to a special value.

On exit: if $\mathbf{mode}=1$ or $2$ and $\mathbf{needfi}<0$, the $i$th row of fjsl must contain the available elements of the vector $\nabla f_i$ given by

$$\nabla f_i={\left(\partial f_i/\partial x_1,\partial f_i/\partial x_2,\dots ,\partial f_i/\partial x_n\right)}^{\mathrm{T}}\text{,}$$

evaluated at the point $x$. See also the argument nstate.

9:    $\mathbf{nstate}$ – IntegerInput

On entry: if $\mathbf{nstate}=1$ then nag_glopt_nlp_multistart_sqp_lsq (e05usc) is calling objfun for the first time on the current local optimization problem. This argument setting allows you to save computation time if certain data must be read or calculated only once.

10:  $\mathbf{comm}$ – Nag_Comm *

Pointer to structure of type Nag_Comm; the following members are relevant to objfun.

user – double *

iuser – Integer *

p – Pointer 

The type Pointer will be void *. Before calling nag_glopt_nlp_multistart_sqp_lsq (e05usc) you may allocate memory and initialize these pointers with various quantities for use by objfun when called from nag_glopt_nlp_multistart_sqp_lsq (e05usc) (see Section 3.2.1.1 in the Essential Introduction).

objfun should be tested separately before being used in conjunction with nag_glopt_nlp_multistart_sqp_lsq (e05usc). See also the description of the optional argument $\mathbf{Verify}$.

12:  $\mathbf{npts}$ – IntegerInput

On entry: the number of different starting points to be generated and used. The more points used, the more likely that the best returned solution will be a global minimum.

Constraint: $1\le \mathbf{nb}\le \mathbf{npts}$.

13:  $\mathbf{x}\left[\mathit{dim}\right]$ – doubleOutput

Note: the dimension, dim, of the array x must be at least $\mathbf{pdx}\times \mathbf{nb}$.

Where $\mathbf{X}\left(j,i\right)$ appears in this document, it refers to the array element $\mathbf{x}\left[\left(i-1\right)\times \mathbf{pdx}+j-1\right]$.

On exit: $\mathbf{X}\left(\mathit{j},i\right)$ contains the final estimate of the $i$th solution, for $\mathit{j}=1,2,\dots ,\mathbf{n}$.

14:  $\mathbf{pdx}$ – IntegerInput

On entry: the first dimension of X as stored in the array x.

Constraint: $\mathbf{pdx}\ge \mathbf{n}$.

15:  $\mathbf{start}$ – function, supplied by the userExternal Function

start must calculate the npts starting points to be used by the local optimizer. If you do not wish to write a function specific to your problem then you can specify the NAG defined null void function pointer, NULLFN in the call. In this case, a default function uses the NAG quasi-random number generators to distribute starting points uniformly across the domain. It is affected by the value of repeat1.

The specification of start is:

void  start (Integer npts, double quas[], Integer n, Nag_Boolean repeat1, const double bl[], const double bu[], Nag_Comm *comm, Integer *mode)

1:    $\mathbf{npts}$ – IntegerInput

On entry: indicates the number of starting points.

2:    $\mathbf{quas}\left[\mathbf{n}\times \mathbf{npts}\right]$ – doubleInput/Output

Note: where $\mathbf{QUAS}\left(j,i\right)$ appears in this document, it refers to the array element $\mathbf{quas}\left[\left(i-1\right)\times \mathbf{n}+j-1\right]$.

On entry: all elements of quas will have been set to zero, so only nonzero values need be set subsequently.

On exit: must contain the starting points for the npts local minimizations, i.e., $\mathbf{QUAS}\left(j,i\right)$ must contain the $j$th component of the $i$th starting point.

3:    $\mathbf{n}$ – IntegerInput

On entry: the number of variables.

4:    $\mathbf{repeat1}$ – Nag_BooleanInput

On entry: specifies whether a repeatable or non-repeatable sequence of points are to be generated.

5:    $\mathbf{bl}\left[\mathbf{n}\right]$ – const doubleInput

On entry: the lower bounds on the variables. These may be used to ensure that the starting points generated in some sense ‘cover’ the region, but there is no requirement that a starting point be feasible.

6:    $\mathbf{bu}\left[\mathbf{n}\right]$ – const doubleInput

On entry: the upper bounds on the variables. (See bl.)

7:    $\mathbf{comm}$ – Nag_Comm *

Pointer to structure of type Nag_Comm; the following members are relevant to start.

user – double *

iuser – Integer *

p – Pointer 

The type Pointer will be void *. Before calling nag_glopt_nlp_multistart_sqp_lsq (e05usc) you may allocate memory and initialize these pointers with various quantities for use by start when called from nag_glopt_nlp_multistart_sqp_lsq (e05usc) (see Section 3.2.1.1 in the Essential Introduction).

8:    $\mathbf{mode}$ – Integer *Input/Output

On entry: mode will contain $0$.

On exit: if you set mode to a negative value then nag_glopt_nlp_multistart_sqp_lsq (e05usc) will terminate immediately with $\mathbf{fail}\mathbf{.}\mathbf{code}=$ NE_USER_STOP. Provided fail is not NAGERR_DEFAULT on entry to nag_glopt_nlp_multistart_sqp_lsq (e05usc), fail$\mathbf{.}\mathbf{errnum}$ will contain this value of mode.

16:  $\mathbf{repeat1}$ – Nag_BooleanInput

On entry: is passed as an argument to start and may be used to initialize a random number generator to a repeatable, or non-repeatable, sequence. See Section 9 for more detail.

17:  $\mathbf{nb}$ – IntegerInput

On entry: the number of solutions to be returned. The function saves up to nb local minima ordered by increasing value of the final objective function. If the defining criterion for ‘best solution’ is only that the value of the objective function is as small as possible then nb should be set to $1$. However, if you want to look at other solutions that may have desirable properties then setting $\mathbf{nb}>1$ will produce nb local minima, ordered by increasing value of their objective functions at the minima.

Constraint: $1\le \mathbf{nb}\le \mathbf{npts}$.

18:  $\mathbf{objf}\left[\mathbf{nb}\right]$ – doubleOutput

On exit: $\mathbf{objf}\left[i-1\right]$ contains the value of the objective function at the final iterate for the $i$th solution.

19:  $\mathbf{f}\left[\mathit{dim}\right]$ – doubleOutput

Note: the dimension, dim, of the array f must be at least $\mathbf{m}\times \mathbf{nb}$.

Where $\mathbf{F}\left(j,i\right)$ appears in this document, it refers to the array element $\mathbf{f}\left[\left(i-1\right)\times \mathbf{m}+j-1\right]$.

On exit: $\mathbf{F}\left(\mathit{j},i\right)$ contains the value of the $\mathit{j}$th function $f_j$ at the final iterate, for $\mathit{j}=1,2,\dots ,\mathbf{m}$, for the $\mathit{i}$th solution, for $\mathit{i}=1,2,\dots ,\mathbf{nb}$.

20:  $\mathbf{fjac}\left[\mathit{dim}\right]$ – doubleOutput

Note: the dimension, dim, of the array fjac must be at least $\mathbf{ldfjac}\times \mathbf{sdfjac}\times \mathbf{nb}$.

Where $\mathbf{FJAC}\left(k,j,i\right)$ appears in this document, it refers to the array element $\mathbf{fjac}\left[\left(i-1\right)\times \mathbf{ldfjac}\times \mathbf{sdfjac}+\left(j-1\right)\times \mathbf{ldfjac}+k-1\right]$.

On exit: for the $i$th returned solution, the Jacobian matrix of the functions $f_1,f_2,\dots ,f_m$ at the final iterate, i.e., $\mathbf{FJAC}\left(\mathit{k},\mathit{j},\mathit{i}\right)$ contains the partial derivative of the $\mathit{k}$th function with respect to the $\mathit{j}$th variable, for $\mathit{k}=1,2,\dots ,\mathbf{m}$, $\mathit{j}=1,2,\dots ,\mathbf{n}$ and $\mathit{i}=1,2,\dots ,\mathbf{nb}$. (See also the discussion of argument fjsl under objfun.)

21:  $\mathbf{ldfjac}$ – IntegerInput

On entry: the first dimension of the matrix FJAC as stored in the array fjac.

Constraint: $\mathbf{ldfjac}\ge \mathbf{m}$.

22:  $\mathbf{sdfjac}$ – IntegerInput

On entry: the second dimension of the matrix FJAC as stored in the array fjac.

Constraint: $\mathbf{sdfjac}\ge \mathbf{n}$.

23:  $\mathbf{iter}\left[\mathbf{nb}\right]$ – IntegerOutput

On exit: $\mathbf{iter}\left[i-1\right]$ contains the number of major iterations performed to obtain the $i$th solution. If less than nb solutions are returned then $\mathbf{iter}\left[\mathbf{nb}-1\right]$ contains the number of starting points that have resulted in a converged solution. If this is close to npts then this might be indicative that fewer than nb local minima exist.

24:  $\mathbf{c}\left[\mathit{dim}\right]$ – doubleOutput

Note: the dimension, dim, of the array c must be at least $\mathbf{pdc}\times \mathbf{nb}$.

Where $\mathbf{C}\left(j,i\right)$ appears in this document, it refers to the array element $\mathbf{c}\left[\left(i-1\right)\times \mathbf{pdc}+j-1\right]$.

On exit: if $\mathbf{ncnln}>0$, $\mathbf{C}\left(\mathit{j},\mathit{i}\right)$ contains the value of the $\mathit{j}$th nonlinear constraint function $c_{\mathit{j}}$ at the final iterate, for the $\mathit{i}$th solution, for $\mathit{j}=1,2,\dots ,\mathbf{ncnln}$.

If $\mathbf{ncnln}=0$, the array c is not referenced and may be specified as NULL.

25:  $\mathbf{pdc}$ – IntegerInput

On entry: the first dimension of C as stored in the array c.

Constraint: $\mathbf{pdc}\ge \mathbf{ncnln}$.

26:  $\mathbf{cjac}\left[\mathit{dim}\right]$ – doubleOutput

Note: the dimension, dim, of the array cjac must be at least $\mathbf{ldcjac}\times \mathbf{sdcjac}\times \mathbf{nb}$.

Where $\mathbf{CJAC}\left(k,j,i\right)$ appears in this document, it refers to the array element $\mathbf{cjac}\left[\left(i-1\right)\times \mathbf{ldcjac}\times \mathbf{sdcjac}+\left(j-1\right)\times \mathbf{ldcjac}+k-1\right]$.

On exit: if $\mathbf{ncnln}>0$, cjac contains the Jacobian matrices of the nonlinear constraint functions at the final iterate for each of the returned solutions, i.e., $\mathbf{CJAC}\left(\mathit{k},\mathit{j},i\right)$ contains the partial derivative of the $\mathit{k}$th constraint function with respect to the $\mathit{j}$th variable, for $\mathit{k}=1,2,\dots ,\mathbf{ncnln}$ and $\mathit{j}=1,2,\dots ,\mathbf{n}$, for the $i$th solution. (See the discussion of argument cjsl under confun.)

If $\mathbf{ncnln}=0$, the array cjac is not referenced and may be specified as NULL.

27:  $\mathbf{ldcjac}$ – IntegerInput

On entry: the first dimension of the matrix CJAC as stored in the array cjac.

Constraint: $\mathbf{ldcjac}\ge \mathbf{ncnln}$.

28:  $\mathbf{sdcjac}$ – IntegerInput

On entry: the second dimension of the matrix CJAC as stored in the array cjac.

Constraint: if $\mathbf{ncnln}>0$, $\mathbf{sdcjac}\ge \mathbf{n}$.

29:  $\mathbf{clamda}\left[\mathit{dim}\right]$ – doubleOutput

Note: the dimension, dim, of the array clamda must be at least $\mathbf{pdclamda}\times \mathbf{nb}$.

Where $\mathbf{CLAMDA}\left(j,i\right)$ appears in this document, it refers to the array element $\mathbf{clamda}\left[\left(i-1\right)\times \mathbf{pdclamda}+j-1\right]$.

On exit: the values of the QP multipliers from the last QP subproblem solved for the $i$th solution. $\mathbf{CLAMDA}\left(j,i\right)$ should be non-negative if $\mathbf{ISTATE}\left(j,i\right)=1$ and non-positive if $\mathbf{ISTATE}\left(j,i\right)=2$.

30:  $\mathbf{pdclamda}$ – IntegerInput

On entry: the stride separating matrix row elements in the array clamda.

Constraint: $\mathbf{pdclamda}\ge \mathbf{n}+\mathbf{nclin}+\mathbf{ncnln}$.

31:  $\mathbf{istate}\left[\mathit{dim}\right]$ – IntegerOutput

Note: the dimension, dim, of the array istate must be at least $\mathbf{pdistate}\times \mathbf{nb}$.

Where $\mathbf{ISTATE}\left(j,i\right)$ appears in this document, it refers to the array element $\mathbf{istate}\left[\left(i-1\right)\times \mathbf{pdistate}+j-1\right]$.

On exit: $\mathbf{ISTATE}\left(j,i\right)$ contains the status of the constraints in the QP working set for the $i$th solution. The significance of each possible value of $\mathbf{ISTATE}\left(j,i\right)$ is as follows:

$\mathbf{ISTATE}\left(j,i\right)$	Meaning
$\phantom{-}0$	The constraint is satisfied to within the feasibility tolerance, but is not in the QP working set.
$\phantom{-}1$	This inequality constraint is included in the QP working set at its lower bound.
$\phantom{-}2$	This inequality constraint is included in the QP working set at its upper bound.
$\phantom{-}3$	This constraint is included in the QP working set as an equality. This value of istate can occur only when $\mathbf{bl}\left[j-1\right]=\mathbf{bu}\left[j-1\right]$.

32:  $\mathbf{pdistate}$ – IntegerInput

On entry: the stride separating matrix row elements in the array istate.

Constraint: $\mathbf{pdistate}\ge \mathbf{n}+\mathbf{nclin}+\mathbf{ncnln}$.

33:  $\mathbf{iopts}\left[740\right]$ – IntegerCommunication Array

34:  $\mathbf{opts}\left[485\right]$ – doubleCommunication Array

The arrays iopts and opts MUST NOT be altered between calls to any of the functions nag_glopt_nlp_multistart_sqp_lsq (e05usc) and nag_glopt_opt_set (e05zkc).

35:  $\mathbf{comm}$ – Nag_Comm *

The NAG communication argument (see Section 3.2.1.1 in the Essential Introduction).

36:  $\mathbf{info}\left[\mathbf{nb}\right]$ – IntegerOutput

On exit: if $\mathbf{fail}\mathbf{.}\mathbf{code}=$ NE_NOERROR, $\mathbf{info}\left[i-1\right]$ contains one of $0$, $1$ or $6$.

$\mathbf{info}\left[i-1\right]=1$

The final iterate $x$ satisfies the first-order Kuhn–Tucker conditions (see Section 11 in nag_opt_nlp_solve (e04wdc)) to the accuracy requested, but the sequence of iterates has not yet converged. The local optimizer was terminated because no further improvement could be made in the merit function (see Section 9.1).

$\mathbf{info}\left[i-1\right]=6$

$x$ does not satisfy the first-order Kuhn–Tucker conditions (see Section 11) and no improved point for the merit function (see Section 9.1) could be found during the final linesearch.

This sometimes occurs because an overly stringent accuracy has been requested, i.e., the value of the optional argument $\mathbf{Optimality\; Tolerance}$ ($\text{default value}={\epsilon }_R^{0.8}$, where ${\epsilon }_R$ is the value of the optional argument $\mathbf{Function\; Precision}$ ($\text{default value}={\epsilon }^{0.9}$, where $\epsilon$ is the machine precision)) is too small.

As usual $0$ denotes success.

If $\mathbf{fail}\mathbf{.}\mathbf{code}=$ NW_SOME_SOLUTIONS on exit, then not all nb solutions have been found, and $\mathbf{info}\left[\mathbf{nb}-1\right]$ contains the number of solutions actually found.

37:  $\mathbf{fail}$ – NagError *Input/Output

The NAG error argument (see Section 3.6 in the Essential Introduction).

6  Error Indicators and Warnings

NE_ALLOC_FAIL

Dynamic memory allocation failed.
See Section 3.2.1.2 in the Essential Introduction for further information.

NE_BAD_PARAM

On entry, argument $〈\mathit{\text{value}}〉$ had an illegal value.

NE_BOUND

On entry, $\mathbf{bl}\left[i-1\right]>\mathbf{bu}\left[i-1\right]$: $i=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{bl}\left[i-1\right]\le \mathbf{bu}\left[i-1\right]$, for all $i$.

NE_DERIV_ERRORS

The user-supplied derivatives of the objective function and/or nonlinear constraints appear to be incorrect.

Large errors were found in the derivatives of the objective function and/or nonlinear constraints. This value of fail.code will occur if the verification process indicated that at least one gradient or Jacobian element had no correct figures. You should refer to or enable the printed output to determine which elements are suspected to be in error.

As a first-step, you should check that the code for the objective and constraint values is correct – for example, by computing the function at a point where the correct value is known. However, care should be taken that the chosen point fully tests the evaluation of the function. It is remarkable how often the values $x=0$ or $x=1$ are used to test function evaluation procedures, and how often the special properties of these numbers make the test meaningless.

Gradient checking will be ineffective if the objective function uses information computed by the constraints, since they are not necessarily computed before each function evaluation.

Errors in programming the function may be quite subtle in that the function value is ‘almost’ correct. For example, the function may not be accurate to full precision because of the inaccurate calculation of a subsidiary quantity, or the limited accuracy of data upon which the function depends. A common error on machines where numerical calculations are usually performed in double precision is to include even one single precision constant in the calculation of the function; since some compilers do not convert such constants to double precision, half the correct figures may be lost by such a seemingly trivial error.

NE_INITIALIZATION

Failed to initialize optional argument arrays.

NE_INT

On entry, $\mathbf{m}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{m}>0$.

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

On entry, $\mathbf{nclin}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{nclin}\ge 0$.

On entry, $\mathbf{ncnln}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{ncnln}\ge 0$.

NE_INT_2

On entry, $\mathbf{ldcjac}=〈\mathit{\text{value}}〉$ and $\mathbf{ncnln}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{ldcjac}\ge \mathbf{ncnln}$.

On entry, $\mathbf{ldfjac}=〈\mathit{\text{value}}〉$ and $\mathbf{m}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{ldfjac}\ge \mathbf{m}$.

On entry, $\mathbf{nb}=〈\mathit{\text{value}}〉$ and $\mathbf{npts}=〈\mathit{\text{value}}〉$.
Constraint: $1\le \mathbf{nb}\le \mathbf{npts}$.

On entry, $\mathbf{pda}=〈\mathit{\text{value}}〉$ and $\mathbf{nclin}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{pda}\ge \mathbf{nclin}$.

On entry, $\mathbf{pdc}=〈\mathit{\text{value}}〉$ and $\mathbf{ncnln}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{pdc}\ge \mathbf{ncnln}$.

On entry, $\mathbf{pdx}=〈\mathit{\text{value}}〉$ and $\mathbf{n}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{pdx}\ge \mathbf{n}$.

On entry, $\mathbf{sdfjac}=〈\mathit{\text{value}}〉$ and $\mathbf{n}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{sdfjac}\ge \mathbf{n}$.

NE_INT_3

On entry, $\mathbf{ncnln}>0$, $\mathbf{sdcjac}=〈\mathit{\text{value}}〉$ and $\mathbf{n}=〈\mathit{\text{value}}〉$.
Constraint: if $\mathbf{ncnln}>0$, $\mathbf{sdcjac}\ge \mathbf{n}$.

NE_INT_4

On entry, $\mathbf{pdclamda}=〈\mathit{\text{value}}〉$, $\mathbf{n}=〈\mathit{\text{value}}〉$, $\mathbf{nclin}=〈\mathit{\text{value}}〉$ and $\mathbf{ncnln}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{pdclamda}\ge \mathbf{n}+\mathbf{nclin}+\mathbf{ncnln}$.

On entry, $\mathbf{pdistate}=〈\mathit{\text{value}}〉$, $\mathbf{n}=〈\mathit{\text{value}}〉$, $\mathbf{nclin}=〈\mathit{\text{value}}〉$ and $\mathbf{ncnln}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{pdistate}\ge \mathbf{n}+\mathbf{nclin}+\mathbf{ncnln}$.

NE_INTERNAL_ERROR

An internal error has occurred in this function. Check the function call and any array sizes. If the call is correct then please contact NAG for assistance.

An unexpected error has been triggered by this function. Please contact NAG.
See Section 3.6.6 in the Essential Introduction for further information.

NE_LIN_NOT_FEASIBLE

nag_glopt_nlp_multistart_sqp_lsq (e05usc) has terminated without finding any solutions. The majority of calls to the local optimizer have failed to find a feasible point for the linear constraints and bounds, which means that either no feasible point exists for the given value of the optional argument $\mathbf{Linear\; Feasibility\; Tolerance}$ (default value $\sqrt{\mathit{macheps}}$, where $\mathit{macheps}$ is the machine precision), or no feasible point could be found in the number of iterations specified by the optional argument $\mathbf{Minor\; Iteration\; Limit}$. You should check that there are no constraint redundancies. If the data for the constraints are accurate only to an absolute precision $\sigma$, you should ensure that the value of the optional argument $\mathbf{Linear\; Feasibility\; Tolerance}$ is greater than $\sigma$. For example, if all elements of $A_L$ are of order unity and are accurate to only three decimal places, $\mathbf{Linear\; Feasibility\; Tolerance}$ should be at least ${10}^{-3}$.

NE_NO_LICENCE

Your licence key may have expired or may not have been installed correctly.
See Section 3.6.5 in the Essential Introduction for further information.

NE_NO_SOLUTION

nag_glopt_nlp_multistart_sqp_lsq (e05usc) has failed to find any solutions. The majority of local optimizations have failed because the limiting number of iterations have been reached.

NE_NONLIN_NOT_FEASIBLE

nag_glopt_nlp_multistart_sqp_lsq (e05usc) has failed to find any solutions. The majority of local optimizations could not find a feasible point for the nonlinear constraints. The problem may have no feasible solution. This behaviour will occur if there is no feasible point for the nonlinear constraints. (However, there is no general test that can determine whether a feasible point exists for a set of nonlinear constraints.)

NE_USER_STOP

User terminated computation from start procedure: $\mathbf{mode}=〈\mathit{\text{value}}〉$.

NW_SOME_SOLUTIONS

Only $〈\mathit{\text{value}}〉$ solutions obtained.

Not all nb solutions have been found. $\mathbf{info}\left[\mathbf{nb}-1\right]$ contains the number actually found.

7  Accuracy

8  Parallelism and Performance

9  Further Comments

9.1  Description of the Printed Output

10  Example

10.1  Program Text

Program Text (e05usce.c)

10.2  Program Data

Program Data (e05usce.d)

10.3  Program Results

Program Results (e05usce.r)

11  Algorithmic Details

12  Optional Arguments

• Central Difference Interval
• Crash Tolerance
• Defaults
• Derivative Level
• Difference Interval
• Feasibility Tolerance
• Function Precision
• Infinite Bound Size
• Infinite Step Size
• Iteration Limit
• Iters
• Itns
• Linear Feasibility Tolerance
• Line Search Tolerance
• List
• Major Iteration Limit
• Major Print Level
• Minor Iteration Limit
• Minor Print Level
• Monitoring File
• Nolist
• Nonlinear Feasibility Tolerance
• Optimality Tolerance
• Out_Level
• Print Level
• Punch Unit
• Start Constraint Check At Variable
• Start Objective Check At Variable
• Step Limit
• Stop Constraint Check At Variable
• Stop Objective Check At Variable
• Verify
• Verify Constraint Gradients
• Verify Gradients
• Verify Level
• Verify Objective Gradients

12.1  Description of the Optional Arguments

• the keywords, where the minimum abbreviation of each keyword is underlined (if no characters of an optional qualifier are underlined, the qualifier may be omitted)
• a parameter value, where the letters $a$, $i$ and $r$ denote options that take character, integer and real values respectively
• the default value, where the symbol $\epsilon$ is a generic notation for machine precision (see nag_machine_precision (X02AJC)), and ${\epsilon }_r$ denotes the relative precision of the objective function $\mathbf{Function\; Precision}$, and $\mathit{bigbnd}$ signifies the value of $\mathbf{Infinite\; Bound\; Size}$

13  Description of Monitoring Information