NAG C Library Function Document

nag_opt_handle_solve_ipopt (e04stc)

1

Purpose

2

Specification

3

Description

3.1

Structure of the Lagrange Multipliers

4

References

5

Arguments

1:    $\mathbf{handle}$ – void *Input

On entry: the handle to the problem. It needs to be initialized by nag_opt_handle_init (e04rac) and the problem formulated by some of the functions nag_opt_handle_set_linobj (e04rec), nag_opt_handle_set_quadobj (e04rfc), nag_opt_handle_set_nlnobj (e04rgc), nag_opt_handle_set_simplebounds (e04rhc), nag_opt_handle_set_linconstr (e04rjc), nag_opt_handle_set_nlnconstr (e04rkc) and nag_opt_handle_set_nlnhess (e04rlc). It must not be changed between calls to the NAG optimization modelling suite.

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

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., nag_opt_handle_set_linobj (e04rec) or nag_opt_handle_set_quadobj (e04rfc) was called to define a linear or quadratic objective function), objfun will never be called by nag_opt_handle_solve_ipopt (e04stc) and may be NULLFN.

The specification of objfun is:

void  objfun (Integer nvar, const double x[], double *fx, Integer *inform, Nag_Comm *comm)

1:    $\mathbf{nvar}$ – IntegerInput

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 nag_opt_handle_init (e04rac).

2:    $\mathbf{x}\left[\mathbf{nvar}\right]$ – const doubleInput

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

3:    $\mathbf{fx}$ – double *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{fail}\mathbf{.}\mathbf{code}=$ NE_USER_NAN (the same will happen if fx is Infinity or NaN); otherwise, the solver will proceed normally.

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

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

user – double *

iuser – Integer *

p – Pointer 

The type Pointer will be void *. Before calling nag_opt_handle_solve_ipopt (e04stc) you may allocate memory and initialize these pointers with various quantities for use by objfun when called from nag_opt_handle_solve_ipopt (e04stc) (see Section 3.3.1.1 in How to Use the NAG Library and its Documentation).

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

3:    $\mathbf{objgrd}$ – function, supplied by the userExternal Function

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., nag_opt_handle_set_linobj (e04rec) or nag_opt_handle_set_quadobj (e04rfc) was called to define a linear or quadratic objective function), objgrd will never be called by nag_opt_handle_solve_ipopt (e04stc) and may be NULLFN.

The specification of objgrd is:

void  objgrd (Integer nvar, const double x[], Integer nnzfd, double fdx[], Integer *inform, Nag_Comm *comm)

1:    $\mathbf{nvar}$ – IntegerInput

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 nag_opt_handle_init (e04rac).

2:    $\mathbf{x}\left[\mathbf{nvar}\right]$ – const doubleInput

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

3:    $\mathbf{nnzfd}$ – IntegerInput

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

4:    $\mathbf{fdx}\left[\mathit{dim}\right]$ – doubleOutput

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 nag_opt_handle_set_nlnobj (e04rgc). $\mathbf{fdx}\left[\mathit{i}-1\right]$ will be the gradient $\frac{\partial f}{\partial x_{\mathbf{idxfd}\left[\mathit{i}-1\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{fail}\mathbf{.}\mathbf{code}=$ NE_USER_NAN (the same will happen if fdx contains Infinity or NaN); otherwise, computations will continue.

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

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

user – double *

iuser – Integer *

p – Pointer 

The type Pointer will be void *. Before calling nag_opt_handle_solve_ipopt (e04stc) you may allocate memory and initialize these pointers with various quantities for use by objgrd when called from nag_opt_handle_solve_ipopt (e04stc) (see Section 3.3.1.1 in How to Use the NAG Library and its Documentation).

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

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

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 nag_opt_handle_solve_ipopt (e04stc) and may be specified as NULLFN.

The specification of confun is:

void  confun (Integer nvar, const double x[], Integer ncnln, double gx[], Integer *inform, Nag_Comm *comm)

1:    $\mathbf{nvar}$ – IntegerInput

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 nag_opt_handle_init (e04rac).

2:    $\mathbf{x}\left[\mathbf{nvar}\right]$ – const doubleInput

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

3:    $\mathbf{ncnln}$ – IntegerInput

On entry: $m_g$, the number of nonlinear constraints, as specified in an earlier call to nag_opt_handle_set_nlnconstr (e04rkc).

4:    $\mathbf{gx}\left[\mathit{dim}\right]$ – doubleOutput

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{fail}\mathbf{.}\mathbf{code}=$ NE_USER_NAN (the same will happen if gx contains Infinity or NaN); otherwise, the solver will proceed normally.

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

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

user – double *

iuser – Integer *

p – Pointer 

The type Pointer will be void *. Before calling nag_opt_handle_solve_ipopt (e04stc) you may allocate memory and initialize these pointers with various quantities for use by confun when called from nag_opt_handle_solve_ipopt (e04stc) (see Section 3.3.1.1 in How to Use the NAG Library and its Documentation).

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

5:    $\mathbf{congrd}$ – function, supplied by the userExternal Function

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., nag_opt_handle_set_nlnconstr (e04rkc) was never called with the same handle or it was called with ncnln $=0$), congrd will never be called by nag_opt_handle_solve_ipopt (e04stc) and may be specified as NULLFN.

The specification of congrd is:

void  congrd (Integer nvar, const double x[], Integer nnzgd, double gdx[], Integer *inform, Nag_Comm *comm)

1:    $\mathbf{nvar}$ – IntegerInput

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 nag_opt_handle_init (e04rac).

2:    $\mathbf{x}\left[\mathbf{nvar}\right]$ – const doubleInput

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

3:    $\mathbf{nnzgd}$ – IntegerInput

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

4:    $\mathbf{gdx}\left[\mathit{dim}\right]$ – doubleOutput

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 nag_opt_handle_set_nlnconstr (e04rkc). $\mathbf{gdx}\left[\mathit{i}-1\right]$ will be the gradient $\frac{\partial g_{\mathbf{irowgd}\left[\mathit{i}-1\right]}}{\partial x_{\mathbf{icolgd}\left[\mathit{i}-1\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{fail}\mathbf{.}\mathbf{code}=$ NE_USER_NAN (the same will happen if gdx contains Infinity or NaN); otherwise, computations will continue.

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

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

user – double *

iuser – Integer *

p – Pointer 

The type Pointer will be void *. Before calling nag_opt_handle_solve_ipopt (e04stc) you may allocate memory and initialize these pointers with various quantities for use by congrd when called from nag_opt_handle_solve_ipopt (e04stc) (see Section 3.3.1.1 in How to Use the NAG Library and its Documentation).

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

6:    $\mathbf{hess}$ – function, supplied by the userExternal Function

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 nag_opt_handle_set_nlnhess (e04rlc), 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{fail}\mathbf{.}\mathbf{code}=$ NE_DERIV_ERRORS or NE_NULL_ARGUMENT). If there were no calls to nag_opt_handle_set_nlnhess (e04rlc), hess will never be called by nag_opt_handle_solve_ipopt (e04stc) and may be specified as NULLFN. 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:

void  hess (Integer nvar, const double x[], Integer ncnln, Integer idf, double sigma, const double lambda[], Integer nnzh, double hx[], Integer *inform, Nag_Comm *comm)

1:    $\mathbf{nvar}$ – IntegerInput

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 nag_opt_handle_init (e04rac).

2:    $\mathbf{x}\left[\mathbf{nvar}\right]$ – const doubleInput

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

3:    $\mathbf{ncnln}$ – IntegerInput

On entry: $m_g$, the number of nonlinear constraints, as specified in an earlier call to nag_opt_handle_set_nlnconstr (e04rkc).

4:    $\mathbf{idf}$ – IntegerInput

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 nag_opt_handle_set_nlnhess (e04rlc) 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 nag_opt_handle_set_nlnhess (e04rlc) 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 nag_opt_handle_set_nlnhess (e04rlc) has been called with idf of the same value.

5:    $\mathbf{sigma}$ – doubleInput

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[\mathit{dim}\right]$ – const doubleInput

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}$ – IntegerInput

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

8:    $\mathbf{hx}\left[\mathit{dim}\right]$ – doubleOutput

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 nag_opt_handle_set_nlnhess (e04rlc) 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{fail}\mathbf{.}\mathbf{code}=$ NE_USER_NAN (the same will happen if hx contains Infinity or NaN); otherwise, computations will continue.

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

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

user – double *

iuser – Integer *

p – Pointer 

The type Pointer will be void *. Before calling nag_opt_handle_solve_ipopt (e04stc) you may allocate memory and initialize these pointers with various quantities for use by hess when called from nag_opt_handle_solve_ipopt (e04stc) (see Section 3.3.1.1 in How to Use the NAG Library and its Documentation).

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

7:    $\mathbf{mon}$ – function, supplied by the userExternal Function

mon is provided to enable you to monitor the progress of the optimization. A facility is provided to halt the optimization process if necessary, using parameter inform.

mon may be specified as NULLFN.

The specification of mon is:

void  mon (Integer nvar, const double x[], Integer nnzu, const double u[], Integer *inform, const double rinfo[], const double stats[], Nag_Comm *comm)

1:    $\mathbf{nvar}$ – IntegerInput

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

2:    $\mathbf{x}\left[\mathbf{nvar}\right]$ – const doubleInput

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

3:    $\mathbf{nnzu}$ – IntegerInput

On entry: the dimension of array u.

4:    $\mathbf{u}\left[\mathbf{nnzu}\right]$ – const doubleInput

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 mon. Specifically, if the value is negative the solution of the current problem will terminate immediately with $\mathbf{fail}\mathbf{.}\mathbf{code}=$ NE_USER_STOP; otherwise, computations will continue.

6:    $\mathbf{rinfo}\left[32\right]$ – const doubleInput

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]$ – const doubleInput

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

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

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

user – double *

iuser – Integer *

p – Pointer 

The type Pointer will be void *. Before calling nag_opt_handle_solve_ipopt (e04stc) you may allocate memory and initialize these pointers with various quantities for use by mon when called from nag_opt_handle_solve_ipopt (e04stc) (see Section 3.3.1.1 in How to Use the NAG Library and its Documentation).

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

8:    $\mathbf{nvar}$ – IntegerInput

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 nag_opt_handle_init (e04rac).

9:    $\mathbf{x}\left[\mathbf{nvar}\right]$ – doubleInput/Output

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

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

10:  $\mathbf{nnzu}$ – IntegerInput

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]$ – doubleOutput

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 and may be NULL.

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

12:  $\mathbf{rinfo}\left[32\right]$ – doubleOutput

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

$0$	objective function value $f\left(x\right)$
$1$	constraint violation (primal infeasibility) (8)
$2$	dual infeasibility (7)
$3$	complementarity
$4$	Karush–Kuhn–Tucker error

13:  $\mathbf{stats}\left[32\right]$ – doubleOutput

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

$0$	number of the iterations
$2$	number of backtracking trial steps
$3$	number of Hessian evaluations
$4$	number of objective gradient evaluations
$7$	total wall clock time elapsed
$18$	number of objective function evaluations
$19$	number of constraint function evaluations
$20$	number of constraint Jacobian evaluations

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

The NAG communication argument (see Section 3.3.1.1 in How to Use the NAG Library and its Documentation).

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

The NAG error argument (see Section 3.7 in How to Use the NAG Library and its Documentation).

6

Error Indicators and Warnings

NE_ALLOC_FAIL

Dynamic memory allocation failed.
See Section 2.3.1.2 in How to Use the NAG Library and its Documentation for further information.

NE_ALREADY_DEFINED

A different solver from the suite has already been used. Initialize a new handle using nag_opt_handle_init (e04rac).

NE_BAD_PARAM

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

NE_DERIV_ERRORS

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 nag_opt_handle_set_nlnhess (e04rlc).

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

NE_HANDLE

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 nag_opt_handle_init (e04rac) or it has been corrupted.

NE_INT

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

NE_INTERNAL_ERROR

An internal error has occurred in this function. Check the function call and any array sizes. If the call is correct then please contact NAG for assistance.
See Section 2.7.6 in How to Use the NAG Library and its Documentation for further information.

NE_MAYBE_INFEASIBLE

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.

NE_MAYBE_UNBOUNDED

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.

NE_NO_IMPROVEMENT

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.

NE_NO_LICENCE

Your licence key may have expired or may not have been installed correctly.
See Section 2.7.5 in How to Use the NAG Library and its Documentation for further information.

NE_NOT_IMPLEMENTED

This function is not available in this implementation.

NE_NULL_ARGUMENT

The problem requires the confun values. Please provide a proper confun function.

The problem requires the congrd derivatives. Please provide a proper congrd function.

The problem requires the hess derivatives. Either change the option $\mathbf{Hessian\; Mode}$ or provide a proper hess function.

The problem requires the objfun values. Please provide a proper objfun function.

The problem requires the objgrd derivatives. Please provide a proper objgrd function.

NE_PHASE

The problem is already being solved.

NE_REF_MATCH

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

NE_SETUP_ERROR

This solver does not support matrix inequality constraints.

NE_SUBPROBLEM

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 $\mathbf{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 option $\mathbf{Time\; Limit}$ to reset the limit.

The solver terminated due to an invalid option. Please contact NAG with details of the call to nag_opt_handle_solve_ipopt (e04stc).

The solver terminated due to an invalid problem definition. Please contact NAG with details of the call to nag_opt_handle_solve_ipopt (e04stc).

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.

NE_TOO_MANY_ITER

Maximum number of iterations exceeded.

NE_USER_NAN

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.

NE_USER_STOP

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

NW_NOT_CONVERGED

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.

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

Program Text (e04stce.c)

10.2

Program Results

Program Results (e04stce.r)

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 nag_machine_precision (X02AJC)).