NAG FL Interface
e04stf (handle_​solve_​ipopt)

1 Purpose

2 Specification

3 Description

3.1 Structure of the Lagrange Multipliers

4 References

5 Arguments

1: $\mathbf{handle}$ – Type (c_ptr) Input

On entry: the handle to the problem. It needs to be initialized by e04raf and the problem formulated by some of the routines e04ref, e04rff, e04rgf, e04rhf, e04rjf, e04rkf and e04rlf. It must not be changed between calls to the NAG optimization modelling suite.

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

objfun must calculate the value of the nonlinear objective function $f\left(x\right)$ at a specified value of the $n$-element vector of $x$ variables. If there is no nonlinear objective (e.g., e04ref or e04rff was called to define a linear or quadratic objective function), objfun will never be called by e04stf and objfun may be the dummy routine e04stv. (e04stv is included in the NAG Library.)

The specification of objfun is:

Fortran Interface

Subroutine objfun ( nvar, x, fx, inform, iuser, ruser, cpuser) Integer, Intent (In) :: nvar Integer, Intent (Inout) :: inform, iuser(*) Real (Kind=nag_wp), Intent (In) :: x(nvar) Real (Kind=nag_wp), Intent (Inout) :: ruser(*) Real (Kind=nag_wp), Intent (Out) :: fx Type (c_ptr), Intent (In) :: cpuser

C Header Interface

void  objfun_ (const Integer *nvar, const double x[], double *fx, Integer *inform, Integer iuser[], double ruser[], void **cpuser)

C++ Header Interface

#include <nag.h> extern "C" { void  objfun_ (const Integer &nvar, const double x[], double &fx, Integer &inform, Integer iuser[], double ruser[], void *&cpuser) }

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

On entry: $n$, the number of variables in the problem. It must be unchanged from the value set during the initialization of the handle by e04raf.

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

On entry: the vector $x$ of variable values at which the objective function is to be evaluated.

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

On exit: the value of the objective function at $x$.

4: $\mathbf{inform}$ – Integer Input/Output

On entry: a non-negative value.

On exit: must be set to a value describing the action to be taken by the solver on return from objfun. Specifically, if the value is negative, then the value of fx will be discarded and the solver will either attempt to find a different trial point or terminate immediately with $\mathbf{ifail}=\mathbf{25}$ (the same will happen if fx is Infinity or NaN); otherwise, the solver will proceed normally.

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

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

7: $\mathbf{cpuser}$ – Type (c_ptr) User Workspace

objfun is called with the arguments iuser, ruser and cpuser as supplied to e04stf. You should use the arrays iuser and ruser, and the data handle cpuser to supply information to objfun.

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

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

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

objgrd must calculate the values of the nonlinear objective function gradients $\frac{\partial f}{\partial x}$ at a specified value of the $n$-element vector of $x$ variables. If there is no nonlinear objective (e.g., e04ref or e04rff was called to define a linear or quadratic objective function), objgrd will never be called by e04stf and objgrd may be the dummy subroutine e04stw. (e04stw is included in the NAG Library.)

The specification of objgrd is:

Fortran Interface

Subroutine objgrd ( nvar, x, nnzfd, fdx, inform, iuser, ruser, cpuser) Integer, Intent (In) :: nvar, nnzfd Integer, Intent (Inout) :: inform, iuser(*) Real (Kind=nag_wp), Intent (In) :: x(nvar) Real (Kind=nag_wp), Intent (Inout) :: ruser(*) Real (Kind=nag_wp), Intent (Out) :: fdx(nnzfd) Type (c_ptr), Intent (In) :: cpuser

C Header Interface

void  objgrd_ (const Integer *nvar, const double x[], const Integer *nnzfd, double fdx[], Integer *inform, Integer iuser[], double ruser[], void **cpuser)

C++ Header Interface

#include <nag.h> extern "C" { void  objgrd_ (const Integer &nvar, const double x[], const Integer &nnzfd, double fdx[], Integer &inform, Integer iuser[], double ruser[], void *&cpuser) }

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

On entry: $n$, the number of variables in the problem. It must be unchanged from the value set during the initialization of the handle by e04raf.

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

On entry: the vector $x$ of variable values at which the objective function gradient is to be evaluated.

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

On entry: the number of nonzero elements in the sparse gradient vector of the objective function, as was set in a previous call to e04rgf.

4: $\mathbf{fdx}\left(\mathbf{nnzfd}\right)$ – Real (Kind=nag_wp) array Output

On exit: the values of the nonzero elements in the sparse gradient vector of the objective function, in the order specified by idxfd in a previous call to e04rgf. $\mathbf{fdx}\left(\mathit{i}\right)$ will be the gradient $\frac{\partial f}{\partial x_{\mathbf{idxfd}\left(\mathit{i}\right)}}$.

5: $\mathbf{inform}$ – Integer Input/Output

On entry: a non-negative value.

On exit: must be set to a value describing the action to be taken by the solver on return from objgrd. Specifically, if the value is negative the solution of the current problem will terminate immediately with $\mathbf{ifail}=\mathbf{25}$ (the same will happen if fdx contains Infinity or NaN); otherwise, computations will continue.

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

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

8: $\mathbf{cpuser}$ – Type (c_ptr) User Workspace

objgrd is called with the arguments iuser, ruser and cpuser as supplied to e04stf. You should use the arrays iuser and ruser, and the data handle cpuser to supply information to objgrd.

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

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

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

confun must calculate the values of the $m_g$-element vector $g_i\left(x\right)$ of nonlinear constraint functions at a specified value of the $n$-element vector of $x$ variables. If no nonlinear constraints were registered in this handle, confun will never be called by e04stf and confun may be the dummy subroutine e04stx. (e04stx is included in the NAG Library.)

The specification of confun is:

Fortran Interface

Subroutine confun ( nvar, x, ncnln, gx, inform, iuser, ruser, cpuser) Integer, Intent (In) :: nvar, ncnln Integer, Intent (Inout) :: inform, iuser(*) Real (Kind=nag_wp), Intent (In) :: x(nvar) Real (Kind=nag_wp), Intent (Inout) :: ruser(*) Real (Kind=nag_wp), Intent (Out) :: gx(ncnln) Type (c_ptr), Intent (In) :: cpuser

C Header Interface

void  confun_ (const Integer *nvar, const double x[], const Integer *ncnln, double gx[], Integer *inform, Integer iuser[], double ruser[], void **cpuser)

C++ Header Interface

#include <nag.h> extern "C" { void  confun_ (const Integer &nvar, const double x[], const Integer &ncnln, double gx[], Integer &inform, Integer iuser[], double ruser[], void *&cpuser) }

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

On entry: $n$, the number of variables in the problem. It must be unchanged from the value set during the initialization of the handle by e04raf.

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

On entry: the vector $x$ of variable values at which the constraint functions are to be evaluated.

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

On entry: $m_g$, the number of nonlinear constraints, as specified in an earlier call to e04rkf.

4: $\mathbf{gx}\left(\mathbf{ncnln}\right)$ – Real (Kind=nag_wp) array Output

On exit: the $m_g$ values of the nonlinear constraint functions at $x$.

5: $\mathbf{inform}$ – Integer Input/Output

On entry: a non-negative value.

On exit: must be set to a value describing the action to be taken by the solver on return from confun. Specifically, if the value is negative, then the value of gx will be discarded and the solver will either attempt to find a different trial point or terminate immediately with $\mathbf{ifail}=\mathbf{25}$ (the same will happen if gx contains Infinity or NaN); otherwise, the solver will proceed normally.

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

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

8: $\mathbf{cpuser}$ – Type (c_ptr) User Workspace

confun is called with the arguments iuser, ruser and cpuser as supplied to e04stf. You should use the arrays iuser and ruser, and the data handle cpuser to supply information to confun.

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

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

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

congrd must calculate the nonzero values of the sparse Jacobian of the nonlinear constraint functions $\frac{\partial g_i}{\partial x}$ at a specified value of the $n$-element vector of $x$ variables. If there are no nonlinear constraints (e.g., e04rkf was never called with the same handle or it was called with ncnln $=0$), congrd will never be called by e04stf and congrd may be the dummy subroutine e04sty. (e04sty is included in the NAG Library.)

The specification of congrd is:

Fortran Interface

Subroutine congrd ( nvar, x, nnzgd, gdx, inform, iuser, ruser, cpuser) Integer, Intent (In) :: nvar, nnzgd Integer, Intent (Inout) :: inform, iuser(*) Real (Kind=nag_wp), Intent (In) :: x(nvar) Real (Kind=nag_wp), Intent (Inout) :: ruser(*) Real (Kind=nag_wp), Intent (Out) :: gdx(nnzgd) Type (c_ptr), Intent (In) :: cpuser

C Header Interface

void  congrd_ (const Integer *nvar, const double x[], const Integer *nnzgd, double gdx[], Integer *inform, Integer iuser[], double ruser[], void **cpuser)

C++ Header Interface

#include <nag.h> extern "C" { void  congrd_ (const Integer &nvar, const double x[], const Integer &nnzgd, double gdx[], Integer &inform, Integer iuser[], double ruser[], void *&cpuser) }

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

On entry: $n$, the number of variables in the problem. It must be unchanged from the value set during the initialization of the handle by e04raf.

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

On entry: the vector $x$ of variable values at which the Jacobian of the constraint functions is to be evaluated.

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

On entry: is the number of nonzero elements in the sparse Jacobian of the constraint functions, as was set in a previous call to e04rkf.

4: $\mathbf{gdx}\left(\mathbf{nnzgd}\right)$ – Real (Kind=nag_wp) array Output

On exit: the nonzero values of the Jacobian of the nonlinear constraints, in the order specified by irowgd and icolgd in an earlier call to e04rkf. $\mathbf{gdx}\left(\mathit{i}\right)$ will be the gradient $\frac{\partial g_{\mathbf{irowgd}\left(\mathit{i}\right)}}{\partial x_{\mathbf{icolgd}\left(\mathit{i}\right)}}$.

5: $\mathbf{inform}$ – Integer Input/Output

On entry: a non-negative value.

On exit: must be set to a value describing the action to be taken by the solver on return from congrd. Specifically, if the value is negative the solution of the current problem will terminate immediately with $\mathbf{ifail}=\mathbf{25}$ (the same will happen if gdx contains Infinity or NaN); otherwise, computations will continue.

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

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

8: $\mathbf{cpuser}$ – Type (c_ptr) User Workspace

congrd is called with the arguments iuser, ruser and cpuser as supplied to e04stf. You should use the arrays iuser and ruser, and the data handle cpuser to supply information to congrd.

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

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

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

hess must calculate the nonzero values of one of a set of second derivative quantities:

• the Hessian of the Lagrangian function $\sigma {\nabla }^{2}f+{\displaystyle \sum _{i=1}^{m_g}}{\lambda }_i{\nabla }^2{g}_i$
• the Hessian of the objective function ${\nabla }^{2}f$
• the Hessian of the constraint functions ${\nabla }^2{g}_i$

The value of argument idf determines which one of these is to be computed and this, in turn, is determined by earlier calls to e04rlf, when the nonzero sparsity structure of these Hessians was registered. Please note that it is not possible to only supply a subset of the Hessians (see $\mathbf{ifail}=\mathbf{6}$). If there were no calls to e04rlf, hess will never be called by e04stf and hess may be the dummy subroutine e04stz (e04stz is included in the NAG Library). In this case, the Hessian of the Lagrangian will be approximated by a limited-memory quasi-Newton method (L-BFGS).

The specification of hess is:

Fortran Interface

Subroutine hess ( nvar, x, ncnln, idf, sigma, lambda, nnzh, hx, inform, iuser, ruser, cpuser) Integer, Intent (In) :: nvar, ncnln, idf, nnzh Integer, Intent (Inout) :: inform, iuser(*) Real (Kind=nag_wp), Intent (In) :: x(nvar), sigma, lambda(ncnln) Real (Kind=nag_wp), Intent (Inout) :: ruser(*) Real (Kind=nag_wp), Intent (Out) :: hx(nnzh) Type (c_ptr), Intent (In) :: cpuser

C Header Interface

void  hess_ (const Integer *nvar, const double x[], const Integer *ncnln, const Integer *idf, const double *sigma, const double lambda[], const Integer *nnzh, double hx[], Integer *inform, Integer iuser[], double ruser[], void **cpuser)

C++ Header Interface

#include <nag.h> extern "C" { void  hess_ (const Integer &nvar, const double x[], const Integer &ncnln, const Integer &idf, const double &sigma, const double lambda[], const Integer &nnzh, double hx[], Integer &inform, Integer iuser[], double ruser[], void *&cpuser) }

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

On entry: $n$, the number of variables in the problem. It must be unchanged from the value set during the initialization of the handle by e04raf.

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

On entry: the vector $x$ of variable values at which the Hessian functions are to be evaluated.

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

On entry: $m_g$, the number of nonlinear constraints, as specified in an earlier call to e04rkf.

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

On entry: specifies the quantities to be computed in hx.

$\mathbf{idf}=-1$

The values of the Hessian of the Lagrangian will be computed in hx. This will be the case if e04rlf has been called with idf of the same value.

$\mathbf{idf}=0$

The values of the Hessian of the objective function will be computed in hx. This will be the case if e04rlf has been called with idf of the same value.

$\mathbf{idf}>0$

The values of the Hessian of the idfth constraint function will be computed in hx. This will be the case if e04rlf has been called with idf of the same value.

5: $\mathbf{sigma}$ – Real (Kind=nag_wp) Input

On entry: if $\mathbf{idf}=-1$, the value of the $\sigma$ quantity in the definition of the Hessian of the Lagrangian. Otherwise, sigma should not be referenced.

6: $\mathbf{lambda}\left(\mathbf{ncnln}\right)$ – Real (Kind=nag_wp) array Input

On entry: if $\mathbf{idf}=-1$, the values of the ${\lambda }_i$ quantities in the definition of the Hessian of the Lagrangian. Otherwise, lambda should not be referenced.

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

On entry: the number of nonzero elements in the Hessian to be computed.

8: $\mathbf{hx}\left(\mathbf{nnzh}\right)$ – Real (Kind=nag_wp) array Output

On exit: the nonzero values of the requested Hessian evaluated at $x$. For each value of idf, the ordering of nonzeros must follow the sparsity structure registered in the handle by earlier calls to e04rlf through the arguments irowh and icolh.

9: $\mathbf{inform}$ – Integer Input/Output

On entry: a non-negative value.

On exit: must be set to a value describing the action to be taken by the solver on return from hess. Specifically, if the value is negative the solution of the current problem will terminate immediately with $\mathbf{ifail}=\mathbf{25}$ (the same will happen if hx contains Infinity or NaN); otherwise, computations will continue.

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

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

12: $\mathbf{cpuser}$ – Type (c_ptr) User Workspace

hess is called with the arguments iuser, ruser and cpuser as supplied to e04stf. You should use the arrays iuser and ruser, and the data handle cpuser to supply information to hess.

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

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

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

monit is provided to enable you to monitor the progress of the optimization.

monit may be the dummy subroutine e04stu (e04stu is included in the NAG Library).

The specification of monit is:

Fortran Interface

Subroutine monit ( nvar, x, nnzu, u, inform, rinfo, stats, iuser, ruser, cpuser) Integer, Intent (In) :: nvar, nnzu Integer, Intent (Inout) :: inform, iuser(*) Real (Kind=nag_wp), Intent (In) :: x(nvar), u(nnzu), rinfo(32), stats(32) Real (Kind=nag_wp), Intent (Inout) :: ruser(*) Type (c_ptr), Intent (In) :: cpuser

C Header Interface

void  monit_ (const Integer *nvar, const double x[], const Integer *nnzu, const double u[], Integer *inform, const double rinfo[], const double stats[], Integer iuser[], double ruser[], void **cpuser)

C++ Header Interface

#include <nag.h> extern "C" { void  monit_ (const Integer &nvar, const double x[], const Integer &nnzu, const double u[], Integer &inform, const double rinfo[], const double stats[], Integer iuser[], double ruser[], void *&cpuser) }

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

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

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

On entry: $x^i$, the values of the decision variables $x$ at the current iteration.

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

On entry: the dimension of array u.

4: $\mathbf{u}\left(\mathbf{nnzu}\right)$ – Real (Kind=nag_wp) array Input

On entry: if $\mathbf{nnzu}>0$, u holds the values at the current iteration of Lagrange multipliers (dual variables) for the constraints. See Section 3.1 for layout information.

5: $\mathbf{inform}$ – Integer Input/Output

On entry: a non-negative value.

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

6: $\mathbf{rinfo}\left(32\right)$ – Real (Kind=nag_wp) array Input

On entry: error measures and various indicators at the end of the current iteration as described in Section 9.1.

7: $\mathbf{stats}\left(32\right)$ – Real (Kind=nag_wp) array Input

On entry: solver statistics at the end of the current iteration as described in Section 9.1.

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

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

10: $\mathbf{cpuser}$ – Type (c_ptr) User Workspace

monit is called with the arguments iuser, ruser and cpuser as supplied to e04stf. You should use the arrays iuser and ruser, and the data handle cpuser to supply information to monit.

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

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

8: $\mathbf{nvar}$ – Integer Input

On entry: $n$, the number of variables in the problem. It must be unchanged from the value set during the initialization of the handle by e04raf.

9: $\mathbf{x}\left(\mathbf{nvar}\right)$ – Real (Kind=nag_wp) array Input/Output

On entry: $x^0$, the initial estimates of the variables $x$.

On exit: the final values of the variables $x$.

10: $\mathbf{nnzu}$ – Integer Input

On entry: the number of Lagrange multipliers that are to be returned in array u.

If $\mathbf{nnzu}=0$, u will not be referenced; otherwise it needs to match the dimension $q$ as explained in Section 3.1.

Constraints:

• $\mathbf{nnzu}\ge 0$;
• if $\mathbf{nnzu}>0$, $\mathbf{nnzu}=q$.

11: $\mathbf{u}\left(\mathbf{nnzu}\right)$ – Real (Kind=nag_wp) array Output

Note: if $\mathbf{nnzu}>0$, u holds Lagrange multipliers (dual variables) for the constraints. See Section 3.1 for layout information. If $\mathbf{nnzu}=0$, u will not be referenced.

On exit: the final value of Lagrange multipliers $z,\lambda$.

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

On exit: error measures and various indicators at the end of the final iteration as given in the table below:

$1$	Objective function value $f\left(x\right)$.
$2$	Constraint violation (primal infeasibility) (8).
$3$	Dual infeasibility (7).
$4$	Complementarity.
$5$	Karush–Kuhn–Tucker error.

13: $\mathbf{stats}\left(32\right)$ – Real (Kind=nag_wp) array Output

On exit: solver statistics at the end of the final iteration as given in the table below:

$1$	Number of the iterations.
$3$	Number of backtracking trial steps.
$4$	Number of Hessian evaluations.
$5$	Number of objective gradient evaluations.
$8$	Total wall clock time elapsed.
$19$	Number of objective function evaluations.
$20$	Number of constraint function evaluations.
$21$	Number of constraint Jacobian evaluations.

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

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

16: $\mathbf{cpuser}$ – Type (c_ptr) User Workspace

iuser, ruser and cpuser are not used by e04stf, but are passed directly to objfun, objgrd, confun, congrd, hess and monit and may be used to pass information to these routines. If you do not need to reference cpuser, it should be initialized to c_null_ptr.

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

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

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

If halting is not appropriate, the value $-1$ or $1$ is recommended. If message printing is undesirable, then the value $1$ is recommended. Otherwise, the value $-1$ is recommended since useful values can be provided in some output arguments even when $\mathbf{ifail}\ne \mathbf{0}$ on exit. When the value $-\mathbf{1}$ or $\mathbf{1}$ is used it is essential to test the value of ifail on exit.

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

6 Error Indicators and Warnings

$\mathbf{ifail}=1$

The supplied handle does not define a valid handle to the data structure for the NAG optimization modelling suite. It has not been initialized by e04raf or it has been corrupted.

$\mathbf{ifail}=2$

The problem is already being solved.

This solver does not support the model defined in the handle.

$\mathbf{ifail}=3$

A different solver from the suite has already been used. Initialize a new handle using e04raf.

$\mathbf{ifail}=4$

The information supplied does not match with that previously stored.
On entry, $\mathbf{nvar}=〈\mathit{\text{value}}〉$ must match that given during initialization of the handle, i.e., $〈\mathit{\text{value}}〉$.

$\mathbf{ifail}=5$

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

On entry, $\mathbf{nnzu}=〈\mathit{\text{value}}〉$.
Constraint: no constraints present, so $\mathbf{nnzu}$ must be $0$.

$\mathbf{ifail}=6$

Either all of the constraint and objective Hessian structures must be defined or none (in which case, the Hessians will be approximated by a limited-memory quasi-Newton L-BFGS method).
On entry, a nonlinear objective function has been defined but no objective Hessian sparsity structure has been defined through e04rlf.

On entry, a nonlinear constraint function has been defined but no constraint Hessian sparsity structure has been defined through e04rlf, for constraint number $〈\mathit{\text{value}}〉$.

$\mathbf{ifail}=7$

The dummy confun routine was called but the problem requires these values. Please provide a proper confun routine.

The dummy congrd routine was called but the problem requires these derivatives. Please provide a proper congrd routine.

The dummy hess routine was called but the problem requires these derivatives. Either change the optional parameter Hessian Mode or provide a proper hess routine.

The dummy objfun routine was called but the problem requires these values. Please provide a proper objfun routine.

The dummy objgrd routine was called but the problem requires these derivatives. Please provide a proper objgrd routine.

$\mathbf{ifail}=20$

User requested termination during a monitoring step. inform was set to a negative value in monit.

$\mathbf{ifail}=22$

Maximum number of iterations exceeded.

$\mathbf{ifail}=23$

The solver terminated after an error in the step computation. This message is printed if the solver is unable to compute a search direction, despite several attempts to modify the iteration matrix. Usually, the value of the regularization parameter then becomes too large. One situation where this can happen is when values in the Hessian are invalid (NaN or Infinity). You can check whether this is true by using the Verify Derivatives option.

The solver terminated after failure in the restoration phase. This indicates that the restoration phase failed to find a feasible point that was acceptable to the filter line search for the original problem. This could happen if the problem is highly degenerate, does not satisfy the constraint qualification, or if your NLP code provides incorrect derivative information.

The solver terminated after the maximum time allowed was exceeded. Maximum number of seconds exceeded. Use optional parameter Time Limit to reset the limit.

The solver terminated due to an invalid option. Please contact NAG with details of the call to e04stf.

The solver terminated due to an invalid problem definition. Please contact NAG with details of the call to e04stf.

The solver terminated with not enough degrees of freedom. This indicates that your problem, as specified, has too few degrees of freedom. This can happen if you have too many equality constraints, or if you fix too many variables.

$\mathbf{ifail}=24$

The solver terminated after the search direction became too small. This indicates that the solver is calculating very small step sizes and is making very little progress. This could happen if the problem has been solved to the best numerical accuracy possible given the current NLP scaling.

$\mathbf{ifail}=25$

Invalid number detected in user function. Either inform was set to a negative value within the user-supplied functions objfun, objgrd, confun, congrd or hess, or an Infinity or NaN was detected in values returned from them.

$\mathbf{ifail}=50$

The solver reports NLP solved to acceptable level. This indicates that the algorithm did not converge to the desired tolerances, but that it was able to obtain a point satisfying the acceptable tolerance level. This may happen if the desired tolerances are too small for the current problem.

$\mathbf{ifail}=51$

The solver detected an infeasible problem. The restoration phase converged to a point that is a minimizer for the constraint violation (in the ${\ell }_1$-norm), but is not feasible for the original problem. This indicates that the problem may be infeasible (or at least that the algorithm is stuck at a locally infeasible point). The returned point (the minimizer of the constraint violation) might help you to find which constraint is causing the problem. If you believe that the NLP is feasible, it might help to start the optimization from a different point.

$\mathbf{ifail}=54$

The solver terminated due to diverging iterates. The max-norm of the iterates has become larger than a preset value. This can happen if the problem is unbounded below and the iterates are diverging.

$\mathbf{ifail}=-199$

e04stf is not available in this implementation.

$\mathbf{ifail}=-99$

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

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

$\mathbf{ifail}=-399$

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

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

$\mathbf{ifail}=-999$

Dynamic memory allocation failed.

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

7 Accuracy

8 Parallelism and Performance

9 Further Comments

9.1 Description of the Printed Output

Starting derivative checker for first derivatives.

* grad_f[          1] = -2.000000E+00    ~  2.455000E+01  [ 1.081E+00]
* jac_g [    1,    4] =  4.700969E+01 v  ~  5.200968E+01  [ 9.614E-02]
Starting derivative checker for second derivatives.

*             obj_hess[    1,    1] =  1.881000E+03 v  ~  1.882000E+03  [ 5.314E-04]
*     1-th constr_hess[    1,    3] =  2.988964E+00 v  ~ -1.103543E-02  [ 3.000E+00]

Derivative checker detected 3 error(s).

Number of nonzeros in equality constraint Jacobian...:        4
Number of nonzeros in inequality constraint Jacobian.:        8
Number of nonzeros in Lagrangian Hessian.............:       10

Total number of variables............................:        4
                     variables with only lower bounds:        4
                variables with lower and upper bounds:        0
                     variables with only upper bounds:        0
Total number of equality constraints.................:        1
Total number of inequality constraints...............:        2
        inequality constraints with only lower bounds:        2
   inequality constraints with lower and upper bounds:        0
        inequality constraints with only upper bounds:        0

iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls
   0  2.6603500E+05 1.55E+02 3.21E+01  -1.0 0.00E+00    -  0.00E+00 0.00E+00   0
   1  1.5053889E+05 7.95E+01 1.43E+01  -1.0 1.16E+00    -  4.55E-01 1.00E+00f  1
   2  8.9745785E+04 3.91E+01 6.45E+00  -1.0 3.07E+01    -  5.78E-03 1.00E+00f  1
   3  3.9878595E+04 1.63E+01 3.47E+00  -1.0 5.19E+00   0.0 2.43E-01 1.00E+00f  1
   4  2.7780042E+04 1.08E+01 1.64E+00  -1.0 3.66E+01    -  7.24E-01 8.39E-01f  1
   5  2.6194274E+04 1.01E+01 1.49E+00  -1.0 1.07E+01    -  1.00E+00 1.05E-01f  1
   6  1.5422960E+04 4.75E+00 6.82E-01  -1.0 1.74E+01    -  1.00E+00 1.00E+00f  1
   7  1.1975453E+04 3.14E+00 7.26E-01  -1.0 2.83E+01    -  1.00E+00 5.06E-01f  1
   8  8.3508421E+03 1.34E+00 2.04E-01  -1.0 3.96E+01    -  9.27E-01 1.00E+00f  1
   9  7.0657495E+03 4.85E-01 9.22E-02  -1.0 5.32E+01    -  1.00E+00 1.00E+00f  1
iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls
  10  6.8359393E+03 1.17E-01 1.28E-01  -1.7 4.69E+01    -  8.21E-01 1.00E+00h  1
  11  6.6508917E+03 1.52E-02 1.52E-02  -2.5 1.87E+01    -  1.00E+00 1.00E+00h  1
  12  6.4123213E+03 8.77E-03 1.49E-01  -3.8 1.85E+01    -  7.49E-01 1.00E+00f  1
  13  6.3157361E+03 4.33E-03 1.90E-03  -3.8 2.07E+01    -  1.00E+00 1.00E+00f  1
  14  6.2989280E+03 1.12E-03 4.06E-04  -3.8 1.54E+01    -  1.00E+00 1.00E+00h  1
  15  6.2996264E+03 9.90E-05 2.05E-04  -5.7 5.35E+00    -  9.63E-01 1.00E+00h  1
  16  6.2998436E+03 0.00E+00 1.86E-07  -5.7 4.55E-01    -  1.00E+00 1.00E+00h  1
  17  6.2998424E+03 0.00E+00 6.18E-12  -8.2 2.62E-03    -  1.00E+00 1.00E+00h  1

Number of Iterations....: 6

                                   (scaled)                 (unscaled)
Objective...............:   7.8692659500479623E-01    6.2324586324379867E+00
Dual infeasibility......:   7.9744615766675617E-10    6.3157735687207093E-09
Constraint violation....:   8.3555384833289281E-12    8.3555384833289281E-12
Complementarity.........:   0.0000000000000000E+00    0.0000000000000000E+00
Overall NLP error.......:   7.9744615766675617E-10    6.3157735687207093E-09


Number of objective function evaluations             = 7
Number of objective gradient evaluations             = 7
Number of equality constraint evaluations            = 7
Number of inequality constraint evaluations          = 0
Number of equality constraint Jacobian evaluations   = 7
Number of inequality constraint Jacobian evaluations = 0
Number of Lagrangian Hessian evaluations             = 6
Total CPU secs in IPOPT (w/o function evaluations)   =      0.724
Total CPU secs in NLP function evaluations           =      0.343

EXIT: Optimal Solution Found.

9.2 Internal Changes

9.3 Additional Licensor

10 Example

10.1 Program Text

10.2 Program Results

11 Algorithmic Details

11.1 Stopping Criteria

11.2 Scaling the NLP

12 Optional Parameters

• Defaults
• Hessian Mode
• Infinite Bound Size
• Matrix Ordering
• Monitoring File
• Monitoring Level
• Outer Iteration Limit
• Print File
• Print Level
• Stats Time
• Stop Tolerance 1
• Task
• Time Limit
• Verify Derivatives

12.1 Description of the Optional Parameters

• the keywords, where the minimum abbreviation of each keyword is underlined;
• 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 x02ajf).