NAG Toolbox: nag_opt_bounds_mod_deriv_comp (e04kd)

Purpose

Syntax

Description

References

Parameters

Compulsory Input Parameters

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

funct must evaluate the function $F\left(x\right)$ and its first derivatives $\frac{\partial F}{\partial x_j}$ at a specified point. (However, if you do not wish to calculate $F$ or its first derivatives at a particular $x$, there is the option of setting a argument to cause nag_opt_bounds_mod_deriv_comp (e04kd) to terminate immediately.)

[iflag, fc, gc, iw, w] = funct(iflag, n, xc, iw, w)

Input Parameters

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

Will have been set to $1$ or $2$. The value $1$ indicates that only the first derivatives of $F$ need be supplied, and the value $2$ indicates that both $F$ itself and its first derivatives must be calculated.

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

The number $n$ of variables.

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

The point $x$ at which the $\frac{\partial F}{\partial x_j}$, or $F$ and the $\frac{\partial F}{\partial x_j}$, are required.

4:     $\mathrm{iw}\left(\mathit{liw}\right)$ – int64int32nag_int array

5:     $\mathrm{w}\left(\mathit{lw}\right)$ – double array

funct is called with the same arguments iw, liw, w, lw as for nag_opt_bounds_mod_deriv_comp (e04kd). They are present so that, when other library functions require the solution of a minimization subproblem, constants needed for the function evaluation can be passed through iw and w. Similarly, you could use elements $3,4,\dots ,\mathit{liw}$ of iw and elements from $\max \left(8,7\times \mathbf{n}+\mathbf{n}\times \left(\mathbf{n}-1\right)/2\right)+1$ onwards of w for passing quantities to funct from the function which calls nag_opt_bounds_mod_deriv_comp (e04kd). However, because of the danger of mistakes in partitioning, it is recommended that you should pass information to funct via global variables and not use iw or w at all. In any case you must not change the first $2$ elements of iw or the first $\max \left(8,7\times \mathbf{n}+\mathbf{n}\times \left(\mathbf{n}-1\right)/2\right)$ elements of w.

Output Parameters

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

If it is not possible to evaluate $F$ or its first derivatives at the point given in xc (or if it is wished to stop the calculations for any other reason) you should reset iflag to a negative number and return control to nag_opt_bounds_mod_deriv_comp (e04kd). nag_opt_bounds_mod_deriv_comp (e04kd) will then terminate immediately, with ifail set to your setting of iflag.

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

Unless $\mathbf{iflag}=1$ on entry or iflag is reset, funct must set fc to the value of the objective function $F$ at the current point $x$.

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

Unless funct resets iflag, it must set $\mathbf{gc}\left(\mathit{j}\right)$ to the value of the first derivative $\frac{\partial F}{\partial x_{\mathit{j}}}$ at the point $x$, for $\mathit{j}=1,2,\dots ,n$.

4:     $\mathrm{iw}\left(\mathit{liw}\right)$ – int64int32nag_int array

5:     $\mathrm{w}\left(\mathit{lw}\right)$ – double array

Note:  funct should be tested separately before being used in conjunction with nag_opt_bounds_mod_deriv_comp (e04kd).

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

If $\mathbf{iprint}\ge 0$, you must supply monit which is suitable for monitoring the minimization process. monit must not change the values of any of its arguments.

If $\mathbf{iprint}<0$, a monit with the correct argument list must still be supplied, although it will not be called.

[iw, w] = monit(n, xc, fc, gc, istate, gpjnrm, cond, posdef, niter, nf, iw, w)

Input Parameters

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

The number $n$ of variables.

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

The coordinates of the current point $x$.

3:     $\mathrm{fc}$ – double scalar

The value of $F\left(x\right)$ at the current point $x$.

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

The value of $\frac{\partial F}{\partial x_{\mathit{j}}}$ at the current point $x$, for $\mathit{j}=1,2,\dots ,n$.

5:     $\mathrm{istate}\left(\mathbf{n}\right)$ – int64int32nag_int array

Information about which variables are currently fixed on their bounds and which are free.

If $\mathbf{istate}\left(j\right)$ is negative, $x_j$ is currently:

–	fixed on its upper bound if $\mathbf{istate}\left(j\right)=-1$
–	fixed on its lower bound if $\mathbf{istate}\left(j\right)=-2$
–	effectively a constant (i.e., $l_j=u_j$) if $\mathbf{istate}\left(j\right)=-3$

If $\mathbf{istate}\left(j\right)$ is positive, its value gives the position of $x_j$ in the sequence of free variables.

6:     $\mathrm{gpjnrm}$ – double scalar

The Euclidean norm of the current projected gradient vector $g_z$.

7:     $\mathrm{cond}$ – double scalar

The ratio of the largest to the smallest elements of the diagonal factor $D$ of the approximated projected Hessian matrix. This quantity is usually a good estimate of the condition number of the projected Hessian matrix. (If no variables are currently free, cond is set to zero.)

8:     $\mathrm{posdef}$ – logical scalar

Specifies true or false according to whether or not the approximation to the second derivative matrix for the current subspace, $H$, is positive definite.

9:     $\mathrm{niter}$ – int64int32nag_int scalar

The number of iterations (as outlined in Description) which have been performed by nag_opt_bounds_mod_deriv_comp (e04kd) so far.

10:   $\mathrm{nf}$ – int64int32nag_int scalar

The number of evaluations of $F\left(x\right)$ so far, i.e., the number of calls of funct with iflag set to $2$. Each such call of funct also calculates the first derivatives of $F$. (In addition to these calls monitored by nf, funct is called with iflag set to $1$ not more than n times per iteration.)

11:   $\mathrm{iw}\left(\mathit{liw}\right)$ – int64int32nag_int array

12:   $\mathrm{w}\left(\mathit{lw}\right)$ – double array

As in funct, these arguments correspond to the arguments iw, liw, w, lw of nag_opt_bounds_mod_deriv_comp (e04kd). They are included in monit's argument list primarily for when nag_opt_bounds_mod_deriv_comp (e04kd) is called by other library functions.

Output Parameters

1:     $\mathrm{iw}\left(\mathit{liw}\right)$ – int64int32nag_int array

2:     $\mathrm{w}\left(\mathit{lw}\right)$ – double array

You should normally print fc, gpjnrm and cond to be able to compare the quantities mentioned in Accuracy. It is usually helpful to examine xc, posdef and nf too.

3:     $\mathrm{eta}$ – double scalar

Suggested value:

• $\mathbf{eta}=0.5$ if $1<n<10$;
• $\mathbf{eta}=0.1$ if $10\le n\le 20$;
• $\mathbf{eta}=0.01$ if $n>20$.

If $\mathbf{n}=1$, eta should be set to $0.0$ (also when the problem is effectively one-dimensional even though $n>1$; i.e., if for all except one of the variables the lower and upper bounds are equal).

Every iteration of nag_opt_bounds_mod_deriv_comp (e04kd) involves a linear minimization (i.e., minimization of $F\left(x+\alpha p\right)$ with respect to $\alpha$). eta specifies how accurately these linear minimizations are to be performed. The minimum with respect to $\alpha$ will be located more accurately for small values of eta (say, $0.01$) than large values (say, $0.9$).

Although accurate linear minimizations will generally reduce the number of iterations (and hence the number of calls of funct to estimate the second derivatives), they will tend to increase the number of calls of funct needed for each linear minimization. On balance, it is usually more efficient to perform a low accuracy linear minimization when $n$ is small and a high accuracy minimization when $n$ is large.

Constraint: $0.0\le \mathbf{eta}<1.0$.

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

Indicates whether the problem is unconstrained or bounded. If there are bounds on the variables, ibound can be used to indicate whether the facility for dealing with bounds of special forms is to be used. It must be set to one of the following values:

$\mathbf{ibound}=0$

If the variables are bounded and you are supplying all the $l_j$ and $u_j$ individually.

$\mathbf{ibound}=1$

If the problem is unconstrained.

$\mathbf{ibound}=2$

If the variables are bounded, but all the bounds are of the form $0\le x_j$.

$\mathbf{ibound}=3$

If all the variables are bounded, and $l_1=l_2=\cdots =l_n$ and $u_1=u_2=\cdots =u_n$.

$\mathbf{ibound}=4$

If the problem is unconstrained. (The $\mathbf{ibound}=4$ option is provided for consistency with other functions. In nag_opt_bounds_mod_deriv_comp (e04kd) it produces the same effect as $\mathbf{ibound}=1\text{.}$)

Constraint: $0\le \mathbf{ibound}\le 4$.

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

The fixed lower bounds $l_j$.

If ibound is set to $0$, you must set $\mathbf{bl}\left(\mathit{j}\right)$ to $l_{\mathit{j}}$, for $\mathit{j}=1,2,\dots ,n$. (If a lower bound is not specified for any $x_j$, the corresponding $\mathbf{bl}\left(j\right)$ should be set to a large negative number, e.g., $-{10}^6$.)

If ibound is set to $3$, you must set $\mathbf{bl}\left(1\right)$ to $l_1$; nag_opt_bounds_mod_deriv_comp (e04kd) will then set the remaining elements of bl equal to $\mathbf{bl}\left(1\right)$.

If ibound is set to $1$, $2$ or $4$, bl will be initialized by nag_opt_bounds_mod_deriv_comp (e04kd).

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

The fixed upper bounds $u_j$.

If ibound is set to $0$, you must set $\mathbf{bu}\left(\mathit{j}\right)$ to $u_{\mathit{j}}$, for $\mathit{j}=1,2,\dots ,n$. (If an upper bound is not specified for any variable, the corresponding $\mathbf{bu}\left(j\right)$ should be set to a large positive number, e.g., ${10}^6$.)

If ibound is set to $3$, you must set $\mathbf{bu}\left(1\right)$ to $u_1$; nag_opt_bounds_mod_deriv_comp (e04kd) will then set the remaining elements of bu equal to $\mathbf{bu}\left(1\right)$.

If ibound is set to $1$, $2$ or $4$, bu will be initialized by nag_opt_bounds_mod_deriv_comp (e04kd).

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

$\mathbf{x}\left(\mathit{j}\right)$ must be set to a guess at the $\mathit{j}$th component of the position of the minimum, for $\mathit{j}=1,2,\dots ,n$.

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

The dimension of the array hesl.

Constraint: $\mathbf{lh}\ge \max \left(\mathbf{n}\times \left(\mathbf{n}-1\right)/2,1\right)$.

9:     $\mathrm{iw}\left(\mathit{liw}\right)$ – int64int32nag_int array

liw, the dimension of the array, must satisfy the constraint $\mathit{liw}\ge 2$.

Constraint: $\mathit{liw}\ge 2$.

10:   $\mathrm{w}\left(\mathit{lw}\right)$ – double array

lw, the dimension of the array, must satisfy the constraint $\mathit{lw}\ge \max \left(7\times \mathbf{n}+\mathbf{n}\times \left(\mathbf{n}-1\right)/2,8\right)$.

Constraint: $\mathit{lw}\ge \max \left(7\times \mathbf{n}+\mathbf{n}\times \left(\mathbf{n}-1\right)/2,8\right)$.

Optional Input Parameters

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

Default: the dimension of the arrays bl, bu, x. (An error is raised if these dimensions are not equal.)

The number $n$ of independent variables.

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

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

Default: $1$

The frequency with which monit is to be called.

$\mathbf{iprint}>0$

monit is called once every iprint iterations and just before exit from nag_opt_bounds_mod_deriv_comp (e04kd).

$\mathbf{iprint}=0$

monit is just called at the final point.

$\mathbf{iprint}<0$

monit is not called at all.

iprint should normally be set to a small positive number.

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

Default: $50\times \mathbf{n}$

The maximum permitted number of evaluations of $F\left(x\right)$, i.e., the maximum permitted number of calls of funct with iflag set to $2$. It should be borne in mind that, in addition to the calls of funct which are limited directly by maxcal, there will be calls of funct (with iflag set to $1$) to evaluate only first derivatives.

Constraint: $\mathbf{maxcal}\ge 1$.

4:     $\mathrm{xtol}$ – double scalar

Default: $0.0$

The accuracy in $x$ to which the solution is required.

If $x_{\mathrm{true}}$ is the true value of $x$ at the minimum, then $x_{\mathrm{sol}}$, the estimated position before a normal exit, is such that $‖x_{\mathrm{sol}}-x_{\mathrm{true}}‖<\mathbf{xtol}\times \left(1.0+‖x_{\mathrm{true}}‖\right)$ where $‖y‖=\sqrt{{\displaystyle \sum _{j=1}^n}{y}_j^2}$. For example, if the elements of $x_{\mathrm{sol}}$ are not much larger than $1.0$ in modulus, and if xtol is set to ${10}^{-5}$, then $x_{\mathrm{sol}}$ is usually accurate to about five decimal places. (For further details see Accuracy.)

If the problem is scaled as described in Scaling and $\epsilon$ is the machine precision, then $\sqrt{\epsilon }$ is probably the smallest reasonable choice for xtol. This is because, normally, to machine accuracy, $F\left(x+\sqrt{\epsilon }{e}_j\right)=F\left(x\right)$, for any $j$ where $e_j$ is the $j$th column of the identity matrix. If you set xtol to $0.0$ (or any positive value less than $\epsilon$), nag_opt_bounds_mod_deriv_comp (e04kd) will use $10.0\times \sqrt{\epsilon }$ instead of xtol.

Constraint: $\mathbf{xtol}\ge 0.0$.

5:     $\mathrm{delta}$ – double scalar

Default: $0.0$

The differencing interval to be used for approximating the second derivatives of $F\left(x\right)$. Thus, for the finite difference approximations, the first derivatives of $F\left(x\right)$ are evaluated at points which are delta apart. If $\epsilon$ is the machine precision, then $\sqrt{\epsilon }$ will usually be a suitable setting for delta. If you set delta to $0.0$ (or to any positive value less than $\epsilon$), nag_opt_bounds_mod_deriv_comp (e04kd) will automatically use $\sqrt{\epsilon }$ as the differencing interval.

Constraint: $\mathbf{delta}\ge 0.0$.

6:     $\mathrm{stepmx}$ – double scalar

Default: $100000.0$

An estimate of the Euclidean distance between the solution and the starting point supplied by you. (For maximum efficiency a slight overestimate is preferable.)

nag_opt_bounds_mod_deriv_comp (e04kd) will ensure that, for each iteration,

$$\sqrt{\sum _{j=1}^n{\left[x_j^{\left(k\right)}-x_j^{\left(k-1\right)}\right]}^2}\le \mathbf{stepmx}\text{,}$$

where $k$ is the iteration number. Thus, if the problem has more than one solution, nag_opt_bounds_mod_deriv_comp (e04kd) is most likely to find the one nearest to the starting point. On difficult problems, a realistic choice can prevent the sequence of $x^{\left(k\right)}$ entering a region where the problem is ill-behaved and can also help to avoid possible overflow in the evaluation of $F\left(x\right)$. However, an underestimate of stepmx can lead to inefficiency.

Constraint: $\mathbf{stepmx}\ge \mathbf{xtol}$.

Output Parameters

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

The lower bounds actually used by nag_opt_bounds_mod_deriv_comp (e04kd), e.g., if $\mathbf{ibound}=2$, $\mathbf{bl}\left(1\right)=\mathbf{bl}\left(2\right)=\cdots =\mathbf{bl}\left(n\right)=0.0$.

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

The upper bounds actually used by nag_opt_bounds_mod_deriv_comp (e04kd), e.g., if $\mathbf{ibound}=2$, $\mathbf{bu}\left(1\right)=\mathbf{bu}\left(2\right)=\cdots =\mathbf{bu}\left(n\right)={10}^6$.

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

The final point $x^{\left(k\right)}$. Thus, if $\mathbf{ifail}=\mathbf{0}$ on exit, $\mathbf{x}\left(j\right)$ is the $j$th component of the estimated position of the minimum.

4:     $\mathrm{hesl}\left(\mathbf{lh}\right)$ – double array

During the determination of a direction $p_z$ (see Description), $H+E$ is decomposed into the product $LD{L}^{\mathrm{T}}$, where $L$ is a unit lower triangular matrix and $D$ is a diagonal matrix. (The matrices $H$, $E$, $L$ and $D$ are all of dimension $n_z$, where $n_z$ is the number of variables free from their bounds. $H$ consists of those rows and columns of the full estimated second derivative matrix which relate to free variables. $E$ is chosen so that $H+E$ is positive definite.)

hesl and hesd are used to store the factors $L$ and $D$. The elements of the strict lower triangle of $L$ are stored row by row in the first $n_z\left(n_z-1\right)/2$ positions of hesl. The diagonal elements of $D$ are stored in the first $n_z$ positions of hesd. In the last factorization before a normal exit, the matrix $E$ will be zero, so that hesl and hesd will contain, on exit, the factors of the final estimated second derivative matrix $H$. The elements of hesd are useful for deciding whether to accept the results produced by nag_opt_bounds_mod_deriv_comp (e04kd) (see Accuracy).

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

During the determination of a direction $p_z$ (see Description), $H+E$ is decomposed into the product $LD{L}^{\mathrm{T}}$, where $L$ is a unit lower triangular matrix and $D$ is a diagonal matrix. (The matrices $H$, $E$, $L$ and $D$ are all of dimension $n_z$, where $n_z$ is the number of variables free from their bounds. $H$ consists of those rows and columns of the full estimated second derivative matrix which relate to free variables. $E$ is chosen so that $H+E$ is positive definite.)

hesl and hesd are used to store the factors $L$ and $D$. The elements of the strict lower triangle of $L$ are stored row by row in the first $n_z\left(n_z-1\right)/2$ positions of hesl. The diagonal elements of $D$ are stored in the first $n_z$ positions of hesd. In the last factorization before a normal exit, the matrix $E$ will be zero, so that hesl and hesd will contain, on exit, the factors of the final estimated second derivative matrix $H$. The elements of hesd are useful for deciding whether to accept the results produced by nag_opt_bounds_mod_deriv_comp (e04kd) (see Accuracy).

6:     $\mathrm{istate}\left(\mathbf{n}\right)$ – int64int32nag_int array

Information about which variables are currently on their bounds and which are free. If $\mathbf{istate}\left(j\right)$ is:

• – equal to $-1$, $x_j$ is fixed on its upper bound;
• – equal to $-2$, $x_j$ is fixed on its lower bound;
• – equal to $-3$, $x_j$ is effectively a constant (i.e., $l_j=u_j$);
• – positive, $\mathbf{istate}\left(j\right)$ gives the position of $x_j$ in the sequence of free variables.

7:     $\mathrm{f}$ – double scalar

The function value at the final point given in x.

8:     $\mathrm{g}\left(\mathbf{n}\right)$ – double array

The first derivative vector corresponding to the final point given in x. The components of g corresponding to free variables should normally be close to zero.

9:     $\mathrm{iw}\left(\mathit{liw}\right)$ – int64int32nag_int array

$\mathit{liw}=2$.

Communication array, used to store information between calls to nag_opt_bounds_mod_deriv_comp (e04kd).

10:   $\mathrm{w}\left(\mathit{lw}\right)$ – double array

$\mathit{lw}=\max \left(7\times \mathbf{n}+\mathbf{n}\times \left(\mathbf{n}-1\right)/2,8\right)$.

Communication array, used to store information between calls to nag_opt_bounds_mod_deriv_comp (e04kd).

11:   $\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.

W  $\mathbf{ifail}<0$

A negative value of ifail indicates an exit from nag_opt_bounds_mod_deriv_comp (e04kd) because you have set iflag negative in funct. The value of ifail will be the same as your setting of iflag.

   $\mathbf{ifail}=1$

On entry,	$\mathbf{n}<1$,
or	$\mathbf{maxcal}<1$,
or	$\mathbf{eta}<0.0$,
or	$\mathbf{eta}\ge 1.0$,
or	$\mathbf{xtol}<0.0$,
or	$\mathbf{delta}<0.0$,
or	$\mathbf{stepmx}<\mathbf{xtol}$,
or	$\mathbf{ibound}<0$,
or	$\mathbf{ibound}>4$,
or	$\mathbf{bl}\left(j\right)>\mathbf{bu}\left(j\right)$ for some $j$ if $\mathbf{ibound}=0$,
or	$\mathbf{bl}\left(1\right)>\mathbf{bu}\left(1\right)$ if $\mathbf{ibound}=3$,
or	$\mathbf{lh}<\max \left(1,\mathbf{n}\times \left(\mathbf{n}-1\right)/2\right)$,
or	$\mathit{liw}<2$,
or	$\mathit{lw}<\max \left(8,7\times \mathbf{n}+\mathbf{n}\times \left(\mathbf{n}-1\right)/2\right)$.

(Note that if you have set xtol or delta to $0.0$, nag_opt_bounds_mod_deriv_comp (e04kd) uses the default values and continues without failing.) When this exit occurs, no values will have been assigned to f or to the elements of hesl, hesd or g.

   $\mathbf{ifail}=2$

There have been maxcal function evaluations. If steady reductions in $F\left(x\right)$ were monitored up to the point where this exit occurred, then the exit probably occurred simply because maxcal was set too small, so the calculations should be restarted from the final point held in x. This exit may also indicate that $F\left(x\right)$ has no minimum.

W  $\mathbf{ifail}=3$

The conditions for a minimum have not all been met, but a lower point could not be found.

Provided that, on exit, the first derivatives of $F\left(x\right)$ with respect to the free variables are sufficiently small, and that the estimated condition number of the second derivative matrix is not too large, this error exit may simply mean that, although it has not been possible to satisfy the specified requirements, the algorithm has in fact found the minimum as far as the accuracy of the machine permits. Such a situation can arise, for instance, if xtol has been set so small that rounding errors in the evaluation of $F\left(x\right)$ or its derivatives make it impossible to satisfy the convergence conditions.

If the estimated condition number of the second derivative matrix at the final point is large, it could be that the final point is a minimum, but that the smallest eigenvalue of the Hessian matrix is so close to zero that it is not possible to recognize the point as a minimum.

   $\mathbf{ifail}=4$

Not used. (This is done to make the significance of $\mathbf{ifail}=\mathbf{5}$ similar for nag_opt_bounds_mod_deriv_comp (e04kd) and nag_opt_bounds_mod_deriv2_comp (e04lb).)

W  $\mathbf{ifail}=5$

All the Lagrange multiplier estimates which are not indisputably positive lie relatively close to zero, but it is impossible either to continue minimizing on the current subspace or to find a feasible lower point by releasing and perturbing any of the fixed variables. You should investigate as for $\mathbf{ifail}=\mathbf{3}$.

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

Timing

Scaling

Unconstrained Minimization

Example

Open in the MATLAB editor: e04kd_example

function e04kd_example


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

global monitoring;
monitoring = false;

eta     = 0.5;
ibound  = int64(0);
bl      = [1; -2;-1000000; 1];
bu      = [3;  0; 1000000; 3];
x       = [3; -1;       0; 1];
lh      = int64(6);
iw(1:2) = int64(0);
w       = zeros(34,1);

% Catch warnings and assume ifail=3,5 gives a good estimate
wstat = warning();
warning('OFF');
[bl, bu, x, hesl, hesd, istate, f, g, iw, w, ifail] = ...
  e04kd(...
        @funct, @monit, eta, ibound, bl, bu, x, lh, iw, w);
if (ifail == 0 || ifail == 5 | ifail == 3)
  fprintf('\nMinimum found at x: ');
  fprintf(' %9.4f',x);
  fprintf('\nMinimum value     :  %9.4f\n\n',f);
else   
  fprintf('\n Error: e04kd returns ifail = %d\n',ifail);
end
warning(wstat);



function [iflag, fc, gc] = funct(iflag, n, xc)
  gc = zeros(n, 1);
  fc = 0;
  x1 = xc(1) + 10*xc(2);
  x2 = xc(3) -    xc(4);
  x3 = xc(2) -  2*xc(3);
  x4 = xc(1) -    xc(4);
  if (iflag ~= 1)
    fc = x1^2 + 5*x2^2 + x3^4 + 10*x4^4;
  end
  gc(1) =   2*x1 + 40*x4^3;
  gc(2) =  20*x1 +  4*x3^3;
  gc(3) =  10*x2 -  8*x3^3;
  gc(4) = -10*x2 - 40*x4^3;


function [] = monit(n, xc, fc, gc, istate, gpjnrm, cond, posdef, niter, nf)

global monitoring;
if (monitoring)
  fprintf('\n Itn     Fn evals         Fn value     Norm of proj gradient\n');
  fprintf(' %3d      %5d    %15.4f      %13.4f\n', niter, nf, fc, gpjnrm);
  fprintf('\n J           X(J)           G(J)         Status\n');
  for j = 1:n
    isj = istate(j);
    if (isj > 0)
      fprintf('%2d %16.4f%15.4f   %s\n', j, xc(j), gc(j), '    Free');
    elseif (isj == -1)
      fprintf('%2d %16.4f%15.4f   %s\n', j, xc(j), gc(j), '    Upper Bound');
    elseif (isj == -2)
      fprintf('%2d %16.4f%15.4f   %s\n', j, xc(j), gc(j), '    Lower Bound');
    elseif (isj == -3)
      fprintf('%2d %16.4f%15.4f   %s\n', j, xc(j), gc(j), '    Constant');
    end
  end
  if (cond ~= 0)
    if (cond > 1.0d6)
      fprintf('\nEst. condition number of projected Hessian > 10^6\n');
    else
      fprintf('\nEst. condition number of projected Hessian = %10.2f\n', cond);
    end
    if ( not(posdef) )
      % The following statement is included so that this monit can be used
      % in conjunction with either of the functions e04kd or e04lb
      fprintf('\nProjected Hessian matrix is not positive definite\n');
    end
  end
end

e04kd example results


Minimum found at x:     1.0000   -0.0852    0.4093    1.0000
Minimum value     :     2.4338