NAG Toolbox: nag_glopt_nlp_multistart_sqp (e05uc)

Purpose

Syntax

Description

References

Parameters

Compulsory Input Parameters

1:     $\mathrm{n}$ – int64int32nag_int scalar

$n$, the number of variables.

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

2:     $\mathrm{ncnln}$ – int64int32nag_int scalar

$n_N$, the number of nonlinear constraints.

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

3:     $\mathrm{a}\left(\mathit{lda},:\right)$ – double array

The first dimension of the array a must be at least $\mathbf{nclin}$.

The second dimension of the array a must be at least $\mathbf{n}$ if $\mathbf{nclin}>0$, and at least $1$ otherwise.

The matrix $A_L$ of general linear constraints in (1). That is, the $\mathit{i}$th row contains the coefficients of the $\mathit{i}$th general linear constraint, for $\mathit{i}=1,2,\dots ,\mathbf{nclin}$.

If $\mathbf{nclin}=0$, the array a is not referenced.

4:     $\mathrm{bl}\left(\mathbf{n}+\mathbf{nclin}+\mathbf{ncnln}\right)$ – double array

5:     $\mathrm{bu}\left(\mathbf{n}+\mathbf{nclin}+\mathbf{ncnln}\right)$ – double array

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\right)\le -\mathit{bigbnd}$, and to specify a nonexistent upper bound (i.e., $u_j=+\infty$), set $\mathbf{bu}\left(j\right)\ge \mathit{bigbnd}$; the default value of $\mathit{bigbnd}$ is ${10}^{20}$, but this may be changed by the optional parameter Infinite Bound Size. To specify the $j$th constraint as an equality, set $\mathbf{bl}\left(j\right)=\mathbf{bu}\left(j\right)=\beta$, say, where $\left|\beta \right|<\mathit{bigbnd}$.

Constraints:

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

6:     $\mathrm{confun}$ – function handle or string containing name of m-file

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 (e05uc) and confun may be the string nag_opt_nlp1_dummy_confun (e04udm). (nag_opt_nlp1_dummy_confun (e04udm) is included in the NAG Toolbox.) If there are nonlinear constraints, the first call to confun will occur before the first call to objfun.

[mode, c, cjsl, user] = confun(mode, ncnln, n, ldcjsl, needc, x, cjsl, nstate, user)

Input Parameters

1:     $\mathrm{mode}$ – int64int32nag_int scalar

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\right)>0$:

$\mathbf{mode}=0$

$\mathbf{c}\left(i\right)$.

$\mathbf{mode}=1$

All available elements in the $i$th row of cjsl.

$\mathbf{mode}=2$

$\mathbf{c}\left(i\right)$ and all available elements in the $i$th row of cjsl.

2:     $\mathrm{ncnln}$ – int64int32nag_int scalar

$n_N$, the number of nonlinear constraints.

3:     $\mathrm{n}$ – int64int32nag_int scalar

$n$, the number of variables.

4:     $\mathrm{ldcjsl}$ – int64int32nag_int scalar

ldcjsl is the same value as ldcjac in the call to nag_glopt_nlp_multistart_sqp (e05uc).

5:     $\mathrm{needc}\left(\mathbf{ncnln}\right)$ – int64int32nag_int array

The indices of the elements of c and/or cjsl that must be evaluated by confun. If $\mathbf{needc}\left(i\right)>0$, $\mathbf{c}\left(i\right)$ and/or the available elements of the $i$th row of cjsl (see argument mode) must be evaluated at $x$.

6:     $\mathrm{x}\left(\mathbf{n}\right)$ – double array

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

7:     $\mathrm{cjsl}\left(\mathbf{ldcjsl},\mathbf{n}\right)$ – double array

cjsl may be regarded as a two-dimensional ‘slice’ of the three-dimensional array cjac of nag_glopt_nlp_multistart_sqp (e05uc).

Unless $\mathbf{Derivative\; Level}=2$ or $3$ (the default setting is $\mathbf{Derivative\; Level}=3$, the elements of cjsl are set to special values which enable nag_glopt_nlp_multistart_sqp (e05uc) to detect whether they are changed by confun.

8:     $\mathrm{nstate}$ – int64int32nag_int scalar

If $\mathbf{nstate}=1$ then nag_glopt_nlp_multistart_sqp (e05uc) 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 calculated only once.

9:     $\mathrm{user}$ – Any MATLAB object

confun is called from nag_glopt_nlp_multistart_sqp (e05uc) with the object supplied to nag_glopt_nlp_multistart_sqp (e05uc).

Output Parameters

1:     $\mathrm{mode}$ – int64int32nag_int scalar

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 (e05uc) will move to the next local minimization problem.

2:     $\mathrm{c}\left(\mathbf{ncnln}\right)$ – double array

If $\mathbf{needc}\left(k\right)>0$ and $\mathbf{mode}=0$ or $2$, $\mathbf{c}\left(k\right)$ must contain the value of $c_k\left(x\right)$. The remaining elements of c, corresponding to the non-positive elements of needc, need not be set.

3:     $\mathrm{cjsl}\left(\mathbf{ldcjsl},\mathbf{n}\right)$ – double array

cjsl may be regarded as a two-dimensional ‘slice’ of the three-dimensional array cjac of nag_glopt_nlp_multistart_sqp (e05uc).

If $\mathbf{needc}\left(k\right)>0$ and $\mathbf{mode}=1$ or $2$, the $k$th row of cjsl must contain the available elements of the vector $\nabla c_k$ given by

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

where $\frac{\partial c_k}{\partial x_j}$ is the partial derivative of the $k$th constraint with respect to the $j$th variable, evaluated at the point $x$. See also the argument nstate. The remaining rows of cjsl, 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(k,j\right)$ is set to a constant value, it need not be reset in subsequent calls to confun, but the value $\mathbf{cjsl}\left(k,j\right)\times \mathbf{x}\left(j\right)$ must nonetheless be added to $\mathbf{c}\left(k\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(1\right)-5\times \mathbf{x}\left(2\right)$ must be included in the definition of $\mathbf{c}\left(1\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 parameter 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.

4:     $\mathrm{user}$ – Any MATLAB object

confun should be tested separately before being used in conjunction with nag_glopt_nlp_multistart_sqp (e05uc). See also the description of the optional parameter Verify.

7:     $\mathrm{objfun}$ – function handle or string containing name of m-file

objfun must calculate the objective function $F\left(x\right)$ and (optionally) its gradient $g\left(x\right)=\frac{\partial F}{\partial x}$ for a specified $n$-vector $x$.

[mode, objf, objgrd, user] = objfun(mode, n, x, objgrd, nstate, user)

Input Parameters

1:     $\mathrm{mode}$ – int64int32nag_int scalar

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

$\mathbf{mode}=0$

objf.

$\mathbf{mode}=1$

All available elements of objgrd.

$\mathbf{mode}=2$

objf and all available elements of objgrd.

2:     $\mathrm{n}$ – int64int32nag_int scalar

$n$, the number of variables.

3:     $\mathrm{x}\left(\mathbf{n}\right)$ – double array

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

4:     $\mathrm{objgrd}\left(\mathbf{n}\right)$ – double array

The elements of objgrd are set to special values which enable nag_glopt_nlp_multistart_sqp (e05uc) to detect whether they are changed by objfun.

5:     $\mathrm{nstate}$ – int64int32nag_int scalar

If $\mathbf{nstate}=1$ then nag_glopt_nlp_multistart_sqp (e05uc) 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 calculated only once.

6:     $\mathrm{user}$ – Any MATLAB object

objfun is called from nag_glopt_nlp_multistart_sqp (e05uc) with the object supplied to nag_glopt_nlp_multistart_sqp (e05uc).

Output Parameters

1:     $\mathrm{mode}$ – int64int32nag_int scalar

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 (e05uc) will move to the next local minimization problem.

2:     $\mathrm{objf}$ – double scalar

If $\mathbf{mode}=0$ or $2$, objf must be set to the value of the objective function at $x$.

3:     $\mathrm{objgrd}\left(\mathbf{n}\right)$ – double array

If $\mathbf{mode}=1$ or $2$, objgrd must return the available elements of the gradient evaluated at $x$.

4:     $\mathrm{user}$ – Any MATLAB object

objfun should be tested separately before being used in conjunction with nag_glopt_nlp_multistart_sqp (e05uc). See also the description of the optional parameter Verify.

8:     $\mathrm{npts}$ – int64int32nag_int scalar

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}$.

9:     $\mathrm{start}$ – function handle or string containing name of m-file

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 nag_glopt_multistart_start_points (e05ucz) may be used as the actual argument. nag_glopt_multistart_start_points (e05ucz) is supplied in the NAG Toolbox and uses the NAG quasi-random number generators to distribute starting points uniformly across the domain. It is affected by the value of repeat.

[quas, user, mode] = start(npts, quas, n, repeat, bl, bu, user, mode)

Input Parameters

1:     $\mathrm{npts}$ – int64int32nag_int scalar

Indicates the number of starting points.

2:     $\mathrm{quas}\left(\mathbf{n},\mathbf{npts}\right)$ – double array

All elements of quas will have been set to zero, so only nonzero values need be set subsequently.

3:     $\mathrm{n}$ – int64int32nag_int scalar

The number of variables.

4:     $\mathrm{repeat}$ – logical scalar

Specifies whether a repeatable or non-repeatable sequence of points are to be generated.

5:     $\mathrm{bl}\left(\mathbf{n}\right)$ – double array

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:     $\mathrm{bu}\left(\mathbf{n}\right)$ – double array

The upper bounds on the variables. (See bl.)

7:     $\mathrm{user}$ – Any MATLAB object

start is called from nag_glopt_nlp_multistart_sqp (e05uc) with the object supplied to nag_glopt_nlp_multistart_sqp (e05uc).

8:     $\mathrm{mode}$ – int64int32nag_int scalar

mode will contain $0$.

Output Parameters

1:     $\mathrm{quas}\left(\mathbf{n},\mathbf{npts}\right)$ – double array

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.

2:     $\mathrm{user}$ – Any MATLAB object

3:     $\mathrm{mode}$ – int64int32nag_int scalar

If you set mode to a negative value then nag_glopt_nlp_multistart_sqp (e05uc) will terminate immediately with $\mathbf{ifail}=\mathbf{9}$.

10:   $\mathrm{repeat}$ – logical scalar

Is passed as an argument to start and may be used to initialize a random number generator to a repeatable, or non-repeatable, sequence.

11:   $\mathrm{nb}$ – int64int32nag_int scalar

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}$.

12:   $\mathrm{iopts}\left(740\right)$ – int64int32nag_int array

13:   $\mathrm{opts}\left(485\right)$ – double array

The arrays iopts and opts must not be altered between calls to any of the functions nag_glopt_nlp_multistart_sqp (e05uc) and nag_glopt_optset (e05zk).

Optional Input Parameters

1:     $\mathrm{nclin}$ – int64int32nag_int scalar

Default: the first dimension of the array a.

$n_L$, the number of general linear constraints.

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

2:     $\mathrm{user}$ – Any MATLAB object

user is not used by nag_glopt_nlp_multistart_sqp (e05uc), but is passed to confun, objfun and start. Note that for large objects it may be more efficient to use a global variable which is accessible from the m-files than to use user.

Output Parameters

1:     $\mathrm{x}\left(\mathit{ldx},\mathbf{nb}\right)$ – double array

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

2:     $\mathrm{objf}\left(\mathbf{nb}\right)$ – double array

$\mathbf{objf}\left(i\right)$ contains the value of the objective function at the final iterate for the $i$th solution.

3:     $\mathrm{objgrd}\left(\mathit{ldobjd},\mathbf{nb}\right)$ – double array

$\mathbf{objgrd}\left(\mathit{j},i\right)$ contains the gradient of the objective function for the $i$th solution at the final iterate (or its finite difference approximation), for $\mathit{j}=1,2,\dots ,\mathbf{n}$.

4:     $\mathrm{iter}\left(\mathbf{nb}\right)$ – int64int32nag_int array

$\mathbf{iter}\left(i\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}\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.

5:     $\mathrm{c}\left(\mathit{ldc},\mathbf{nb}\right)$ – double array

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.

6:     $\mathrm{cjac}\left(\mathit{ldcjac},\mathit{sdcjac},\mathbf{nb}\right)$ – double array

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.

7:     $\mathrm{r}\left(\mathit{ldr},\mathit{sdr},\mathbf{nb}\right)$ – double array

$\mathit{sdr}=\mathbf{n}$.

For each of the nb solutions r will contain a form of the Hessian; for the $i$th returned solution $\mathbf{r}\left(\mathit{ldr},\mathit{sdr},i\right)$ contains the Hessian that would be returned from the local minimizer. If $\mathbf{Hessian}=\mathrm{NO}$, the default, each $\mathbf{r}\left(\mathit{ldr},\mathit{sdr},i\right)$ contains the upper triangular Cholesky factor $R$ of $Q^{\mathrm{T}}HQ$, an estimate of the transformed and reordered Hessian of the Lagrangian at $x$. If $\mathbf{Hessian}=\mathrm{YES}$, $\mathbf{r}\left(\mathit{ldr},\mathit{sdr},i\right)$ contains the upper triangular Cholesky factor $R$ of $H$, the approximate (untransformed) Hessian of the Lagrangian, with the variables in the natural order.

8:     $\mathrm{clamda}\left(\mathit{ldclda},\mathbf{nb}\right)$ – double array

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$.

9:     $\mathrm{istate}\left(\mathit{listat},\mathbf{nb}\right)$ – int64int32nag_int array

$\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\right)=\mathbf{bu}\left(j\right)$.

10:   $\mathrm{iopts}\left(740\right)$ – int64int32nag_int array

11:   $\mathrm{opts}\left(485\right)$ – double array

12:   $\mathrm{user}$ – Any MATLAB object

13:   $\mathrm{info}\left(\mathbf{nb}\right)$ – int64int32nag_int array

$\mathbf{info}\left(i\right)$ contains one of $0$, $1$ or $6$. Please see the description of each corresponding value of ifail on exit from nag_opt_nlp1_solve (e04uc) for detailed explanations of these exit values. As usual $0$ denotes success.

If $\mathbf{ifail}=\mathbf{8}$ on exit, then not all nb solutions have been found, and $\mathbf{info}\left(\mathbf{nb}\right)$ contains the number of solutions actually found.

14:   $\mathrm{ifail}$ – int64int32nag_int scalar

$\mathbf{ifail}=\mathbf{0}$ unless the function detects an error (see Error Indicators and Warnings).

Error Indicators and Warnings

Cases prefixed with W are classified as warnings and do not generate an error of type NAG:error_n. See nag_issue_warnings.

   $\mathbf{ifail}=1$

An input value is incorrect. One or more of the following constraints are violated.

• Constraint: $1\le \mathbf{nb}\le \mathbf{npts}$.
• Constraint: $\mathbf{bl}\left(i\right)\le \mathbf{bu}\left(i\right)$, for all $i$.
• Constraint: if $\mathbf{ncnln}>0$, $\mathit{sdcjac}\ge \mathbf{n}$.
• Constraint: $\mathit{lda}\ge \mathbf{nclin}$.
• Constraint: $\mathit{ldcjac}\ge \mathbf{ncnln}$.
• Constraint: $\mathit{ldclda}\ge \mathbf{n}+\mathbf{nclin}+\mathbf{ncnln}$.
• Constraint: $\mathit{ldc}\ge \mathbf{ncnln}$.
• Constraint: $\mathit{ldobjd}\ge \mathbf{n}$.
• Constraint: $\mathit{ldr}\ge \mathbf{n}$.
• Constraint: $\mathit{ldx}\ge \mathbf{n}$.
• Constraint: $\mathit{listat}\ge \mathbf{n}+\mathbf{nclin}+\mathbf{ncnln}$.
• Constraint: $\mathbf{n}>0$.
• Constraint: $\mathbf{nclin}\ge 0$.
• Constraint: $\mathbf{ncnln}\ge 0$.
• Constraint: $\mathit{sdr}\ge \mathbf{n}$.

   $\mathbf{ifail}=2$

No solution obtained. Linear constraints may be infeasible.

nag_glopt_nlp_multistart_sqp (e05uc) 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 parameter Linear Feasibility Tolerance (default value $\sqrt{\epsilon }$, where $\epsilon$ is the machine precision), or no feasible point could be found in the number of iterations specified by the optional parameter 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 parameter 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, Linear Feasibility Tolerance should be at least ${10}^{-3}$.

   $\mathbf{ifail}=3$

nag_glopt_nlp_multistart_sqp (e05uc) 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.)

No solution obtained. Nonlinear constraints may be infeasible.

   $\mathbf{ifail}=4$

No solution obtained. Many potential solutions reach iteration limit.

The Iteration Limit may be changed using nag_glopt_optset (e05zk).

   $\mathbf{ifail}=7$

User-supplied derivatives probably wrong.

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 ifail 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.

W  $\mathbf{ifail}=8$

Only $\_$ solutions obtained.

Not all nb solutions have been found. $\mathbf{info}\left(\mathbf{nb}\right)$ contains the number actually found.

   $\mathbf{ifail}=9$

User terminated computation from start procedure. $\mathbf{mode}=\_$.

If nag_glopt_multistart_start_points (e05ucz) has been used as an actual argument for start then the message displayed, when $\mathbf{ifail}=\mathbf{0}$ or $-\mathbf{1}$ on entry to nag_glopt_nlp_multistart_sqp (e05uc), will have the following meaning:

$998$	failure to allocate space, a smaller value of NPTS should be tried.
$997$	an internal error has occurred. Please contact NAG for assistance.

   $\mathbf{ifail}=10$

Failed to initialize optional parameter arrays.

   $\mathbf{ifail}=-99$

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

   $\mathbf{ifail}=-399$

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

   $\mathbf{ifail}=-999$

Dynamic memory allocation failed.

Accuracy

Further Comments

Description of the Printed Output

Example

Open in the MATLAB editor: e05uc_example

function e05uc_example


fprintf('e05uc example results\n\n');

npts   = int64(1000);
repeat = true;
nclin  = int64(1);
ncnln  = int64(2);
nb     = int64(10);
n      = int64(2);

bl = [-500; -500; -10000; -1;      -0.9];
bu = [ 500;  500;     10;  500000;  0.9];
a  = [3, -2];

% Initialise e05uc
iopts = zeros(740, 1, 'int64');
opts  = zeros(485, 1);
[iopts, opts, ifail] = e05zk(...
                             'Initialize = e05uc', iopts, opts);
[iopts, opts, ifail] = e05zk(...
                             'Derivative Level = 3', iopts, opts);

wstat = warning();
warning('OFF');
% Solve the problem
[x, objf, objgrd, iter, c, cjac, r, clamda, istate, ...
                          iopts, opts, user, info, ifail] = ...
  e05uc(...
        n, ncnln, a, bl, bu, @confun, @objfun, ...
        npts, 'e05ucz', repeat, nb, iopts, opts);

warning(wstat);

if ifail == 8
  l = double(info(10));
  fprintf('\nOnly %d solutions found\n', l);
else
  l = 10;
end

l = min(l,3);
% List details of first 3 solutions only
for i=1:l
  fprintf('\nSolution number %d\n\n', i);
  fprintf('e04uc returned with ifail = %d\n\n', info(i));
  fprintf(' Variable Istate           Value Lagrange Multiplier\n');
  for j=1:double(n)
    fprintf(' %3d%9d%19.6g%13.4g\n', j, istate(j,i), x(j,i), clamda(j,i));
  end

  if nclin > 0
    ax = a*x(:,i);
    fprintf('\n L Con    Istate           Value Lagrange Multiplier\n');
    for k=double(n+1):double(n+nclin)
      j=k-n;
      fprintf(' %3d%9d%19.6g%13.4g\n', j, istate(k,i), ax(j), clamda(k,i));
    end
  end

  if ncnln > 0
    fprintf('\n NL Con  Istate            Value Lagrange Multiplier\n');
    for k=double(n+nclin+1):double(n+nclin +ncnln)
      j=k-n-nclin;
      fprintf(' %3d%9d%19.6g%13.4g\n', j, istate(k,i), c(j,i), clamda(j,i));
    end
  end

  fprintf('\nFinal objective value = %15.7g\n', objf(i));
  fprintf('clamda: ');
  disp(transpose(clamda(1:double(n+nclin+ncnln),i)));
  fprintf('\n ------------------------------------------------------\n');
end



function [mode, objf, objgrd, user] = objfun(mode, n, x, objgrd, nstate, user)
  if mode==0 || mode==2
    % Evaluate the objective function.
    objf = x(1)*sin(sqrt(abs(x(1)))) + x(2)*sin(sqrt(abs(x(2))));
  else
    objf = 0;
  end

  if mode==1 || mode==2
    % Calculate the gradient of the objective function.
    t = sqrt(abs(x(1)));
    objgrd(1) = sin(t) + 0.5*t*cos(t);
    t = sqrt(abs(x(2)));
    objgrd(2) = sin(t) + 0.5*t*cos(t);
  end

function [mode, c, cjsl, user] = ...
    confun(mode, ncnln, n, ldcj1, needc, x, cjsl, nstate, user)
  c = zeros(ncnln, 1);
  dncnln = double(ncnln);

  if (mode==0 || mode==2)
    % Constraint values are required.
    % Only those for which needc is non-zero need be set.
    for k = 1:dncnln
      if (needc(k)>0)
        switch k
          case {1}
            c(k) = x(1)^2 - x(2)^2 + 3.0*x(1)*x(2);
          case {2}
            c(k) = cos((x(1)/200.0)^2+(x(2)/100.0));
        end
      end
    end
  end

  if (mode==1 || mode==2)
    % Constraint derivatives (cjsl) are required.
    for k = 1:dncnln
      switch k
        case {1}
          cjsl(k,1) = 2.0*x(1) + 3.0*x(2);
          cjsl(k,2) = -2.0*x(2) + 3.0*x(1);
        case {2}
          t1 = x(1)/200.0;
          t2 = x(2)/100.0;
          cjsl(k,1) = -sin(t1^2+t2)*2.0*t1/200.0;
          cjsl(k,2) = -sin(t1^2+t2)/100.0;
      end
    end
  end

e05uc example results


Solution number 1

e04uc returned with ifail = 0

 Variable Istate           Value Lagrange Multiplier
   1        0           -394.151            0
   2        0           -433.491            0

 L Con    Istate           Value Lagrange Multiplier
   1        0           -315.472            0

 NL Con  Istate            Value Lagrange Multiplier
   1        0             480024            0
   2        2                0.9            0

Final objective value =       -731.7064
clamda:          0         0         0         0 -718.9449


 ------------------------------------------------------

Solution number 2

e04uc returned with ifail = 0

 Variable Istate           Value Lagrange Multiplier
   1        0           -413.805            0
   2        0           -382.984            0

 L Con    Istate           Value Lagrange Multiplier
   1        0           -475.447            0

 NL Con  Istate            Value Lagrange Multiplier
   1        2             500000            0
   2        2                0.9            0

Final objective value =       -665.1962
clamda:    1.0e+03 *

         0         0         0   -0.0000   -1.1615


 ------------------------------------------------------

Solution number 3

e04uc returned with ifail = 1

 Variable Istate           Value Lagrange Multiplier
   1        0           -413.964            0
   2        0           -382.327            0

 L Con    Istate           Value Lagrange Multiplier
   1        0           -477.237            0

 NL Con  Istate            Value Lagrange Multiplier
   1        2             500000            0
   2        0           0.895662            0

Final objective value =       -660.1803
clamda:          0         0         0   -0.0018         0


 ------------------------------------------------------

Algorithmic Details

Optional Parameters

Description of the Optional Parameters

Description of Monitoring Information