NAG CL Interface
e04stc (handle_​solve_​ipopt)

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 e04rac and the problem formulated by some of the functions e04rec, e04rfc, e04rgc, e04rhc, e04rjc, e04rkc and e04rlc. It must not be changed between calls to the NAG optimization modelling suite.

2: $\mathbf{objfun}$ – function, supplied by the user External 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., e04rec or e04rfc was called to define a linear or quadratic objective function), objfun will never be called by 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}$ – 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 e04rac.

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

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 e04stc you may allocate memory and initialize these pointers with various quantities for use by objfun when called from e04stc (see Section 3.1.1 in the Introduction to the NAG Library CL Interface).

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

3: $\mathbf{objgrd}$ – function, supplied by the user External 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., e04rec or e04rfc was called to define a linear or quadratic objective function), objgrd will never be called by 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}$ – 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 e04rac.

2: $\mathbf{x}\left[\mathbf{nvar}\right]$ – const double 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 e04rgc.

4: $\mathbf{fdx}\left[\mathit{dim}\right]$ – double 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 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 e04stc you may allocate memory and initialize these pointers with various quantities for use by objgrd when called from e04stc (see Section 3.1.1 in the Introduction to the NAG Library CL Interface).

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

4: $\mathbf{confun}$ – function, supplied by the user External 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 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}$ – 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 e04rac.

2: $\mathbf{x}\left[\mathbf{nvar}\right]$ – const double 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 e04rkc.

4: $\mathbf{gx}\left[\mathit{dim}\right]$ – double 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{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 e04stc you may allocate memory and initialize these pointers with various quantities for use by confun when called from e04stc (see Section 3.1.1 in the Introduction to the NAG Library CL Interface).

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

5: $\mathbf{congrd}$ – function, supplied by the user External 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., e04rkc was never called with the same handle or it was called with ncnln $=0$), congrd will never be called by 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}$ – 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 e04rac.

2: $\mathbf{x}\left[\mathbf{nvar}\right]$ – const double 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 e04rkc.

4: $\mathbf{gdx}\left[\mathit{dim}\right]$ – double 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 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 e04stc you may allocate memory and initialize these pointers with various quantities for use by congrd when called from e04stc (see Section 3.1.1 in the Introduction to the NAG Library CL Interface).

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

6: $\mathbf{hess}$ – function, supplied by the user External 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 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 e04rlc, hess will never be called by e04stc 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}$ – 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 e04rac.

2: $\mathbf{x}\left[\mathbf{nvar}\right]$ – const double 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 e04rkc.

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

5: $\mathbf{sigma}$ – double 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[\mathit{dim}\right]$ – const double 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[\mathit{dim}\right]$ – double 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 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 e04stc you may allocate memory and initialize these pointers with various quantities for use by hess when called from e04stc (see Section 3.1.1 in the Introduction to the NAG Library CL Interface).

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

7: $\mathbf{monit}$ – function, supplied by the user External Function

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

monit may be specified as NULLFN.

The specification of monit is:

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

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

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

2: $\mathbf{x}\left[\mathbf{nvar}\right]$ – const double 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]$ – const double 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{fail}\mathbf{.}\mathbf{code}=$ NE_USER_STOP; otherwise, computations will continue.

6: $\mathbf{rinfo}\left[32\right]$ – const double 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]$ – const double Input

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

user – double *

iuser – Integer *

p – Pointer 

The type Pointer will be void *. Before calling e04stc you may allocate memory and initialize these pointers with various quantities for use by monit when called from e04stc (see Section 3.1.1 in the Introduction to the NAG Library CL Interface).

Note: monit should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by e04stc. If your code inadvertently does return any NaNs or infinities, e04stc 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 e04rac.

9: $\mathbf{x}\left[\mathbf{nvar}\right]$ – double 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]$ – double 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 and may be NULL.

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

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

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]$ – double Output

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.1.1 in the Introduction to the NAG Library CL Interface).

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

The NAG error argument (see Section 7 in the Introduction to the NAG Library CL Interface).

6 Error Indicators and Warnings

NE_ALLOC_FAIL

Dynamic memory allocation failed.
See Section 3.1.2 in the Introduction to the NAG Library CL Interface for further information.

NE_ALREADY_DEFINED

A different solver from the suite has already been used. Initialize a new handle using 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 e04rlc.

On entry, a nonlinear constraint function has been defined but no constraint Hessian sparsity structure has been defined through 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 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 7.5 in the Introduction to the NAG Library CL Interface 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 8 in the Introduction to the NAG Library CL Interface 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 optional parameter $\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 the model defined in the handle.

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

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

The solver terminated due to an invalid problem definition. Please contact NAG with details of the call to 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 monit.

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

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