NAG CPP Interface
nagcpp::opt::handle_solve_ipopt (e04st)

1 Purpose

2 Specification

#include "e04/nagcpp_e04st.hpp"
#include "e04/nagcpp_class_CommE04RA.hpp"

template <typename COMM, typename OBJFUN, typename OBJGRD, typename CONFUN, typename CONGRD, typename HESS, typename MONIT, typename X, typename U, typename RINFO, typename STATS>

void function handle_solve_ipopt(COMM &comm, OBJFUN &&objfun, OBJGRD &&objgrd, CONFUN &&confun, CONGRD &&congrd, HESS &&hess, MONIT &&monit, X &&x, U &&u, RINFO &&rinfo, STATS &&stats, OptionalE04ST opt)

template <typename COMM, typename OBJFUN, typename OBJGRD, typename CONFUN, typename CONGRD, typename HESS, typename MONIT, typename X, typename U, typename RINFO, typename STATS>

void function handle_solve_ipopt(COMM &comm, OBJFUN &&objfun, OBJGRD &&objgrd, CONFUN &&confun, CONGRD &&congrd, HESS &&hess, MONIT &&monit, X &&x, U &&u, RINFO &&rinfo, STATS &&stats)

3 Description

3.1 Structure of the Lagrange Multipliers

4 References

5 Arguments

1: $\mathbf{comm}$ – CommE04RA Input/Output

Communication structure. An object of either the derived class CommE04RA or its base class NoneCopyableComm can be supplied. It is recommended that the derived class is used. If the base class is supplied it must first be initialized via a call to opt::handle_init (e04ra).

2: $\mathbf{objfun}$ – void function 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., handle_​set_​linobj, handle_​set_​quadobj, e04rsf (no CPP interface) and e04rtf (no CPP interface) was called to define a linear or quadratic objective function), objfun will never be called by handle_solve_ipopt and objfun may be the dummy function ipopt_​dummy_​objfun. (ipopt_​dummy_​objfun is included in the NAG Library.)

void function objfun(const utility::array1D<double,data_handling::ArgIntent::IntentIN> &x, double &fx, types::f77_integer &inform)

1: $\mathbf{x}\left(\mathbf{nvar}\right)$ – double array Input

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

2: $\mathbf{fx}$ – double Output

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

3: $\mathbf{inform}$ – types::f77_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{errorid}=\mathbf{25}$; otherwise, the solver will proceed normally.

4: $\mathbf{nvar}$ – types::f77_integer Input

On entry: $n$, the current number of decision variables $x$ in the model.

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

3: $\mathbf{objgrd}$ – void function 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., handle_​set_​linobj, handle_​set_​quadobj, e04rsf (no CPP interface) and e04rtf (no CPP interface) was called to define a linear or quadratic objective function), objgrd will never be called by handle_solve_ipopt and objgrd may be the dummy function ipopt_​dummy_​objgrd included in the NAG Library.

void function objgrd(const utility::array1D<double,data_handling::ArgIntent::IntentIN> &x, utility::array1D<double,data_handling::ArgIntent::IntentINOUT> &fdx, types::f77_integer &inform)

1: $\mathbf{x}\left(\mathbf{nvar}\right)$ – double array Input

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

2: $\mathbf{fdx}\left(\mathbf{nnzfd}\right)$ – double array Input/Output

On entry: the elements should only be assigned and not referenced.

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 handle_​set_​nlnobj. $\mathbf{fdx}\left(\mathit{i}-1\right)$ will be the gradient $\frac{\partial f}{\partial x_{\mathbf{idxfd}\left(\mathit{i}-1\right)}}$.

3: $\mathbf{inform}$ – types::f77_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 then the value of fdx will be discarded and the solver will either attempt to find a different trial point or will terminate immediately with $\mathbf{errorid}=\mathbf{25}$; otherwise, computations will continue.

4: $\mathbf{nvar}$ – types::f77_integer Input

On entry: $n$, the current number of decision variables $x$ in the model.

5: $\mathbf{nnzfd}$ – types::f77_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 handle_​set_​nlnobj.

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

4: $\mathbf{confun}$ – void function 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 there are no nonlinear constraints then confun will never be called by handle_solve_ipopt and it may be the dummy function ipopt_​dummy_​confun included in the NAG Library.

void function confun(const utility::array1D<double,data_handling::ArgIntent::IntentIN> &x, const types::f77_integer ncnln, utility::array1D<double,data_handling::ArgIntent::IntentOUT> &gx, types::f77_integer &inform)

1: $\mathbf{x}\left(\mathbf{nvar}\right)$ – double array Input

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

2: $\mathbf{ncnln}$ – types::f77_integer Input

On entry: $m_g$, the number of nonlinear constraints, as specified in an earlier call to handle_​set_​nlnconstr.

3: $\mathbf{gx}\left(\mathbf{ncnln}\right)$ – double array Output

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

4: $\mathbf{inform}$ – types::f77_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{errorid}=\mathbf{25}$; otherwise, the solver will proceed normally.

5: $\mathbf{nvar}$ – types::f77_integer Input

On entry: $n$, the current number of decision variables $x$ in the model.

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

5: $\mathbf{congrd}$ – void function 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, congrd will never be called by handle_solve_ipopt and congrd may be the dummy function ipopt_​dummy_​congrd included in the NAG Library.)

void function congrd(const utility::array1D<double,data_handling::ArgIntent::IntentIN> &x, utility::array1D<double,data_handling::ArgIntent::IntentINOUT> &gdx, types::f77_integer &inform)

1: $\mathbf{x}\left(\mathbf{nvar}\right)$ – double array Input

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

2: $\mathbf{gdx}\left(\mathbf{nnzgd}\right)$ – double array Input/Output

On entry: the elements should only be assigned and not referenced.

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 handle_​set_​nlnconstr. $\mathbf{gdx}\left(\mathit{i}-1\right)$ will be the gradient $\frac{\partial g_j}{\partial x_k}$, where $j=\mathbf{irowgd}\left(\mathit{i}-1\right)$ and $k=\mathbf{icolgd}\left(\mathit{i}-1\right)$.

3: $\mathbf{inform}$ – types::f77_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{errorid}=\mathbf{25}$; otherwise, computations will continue.

4: $\mathbf{nvar}$ – types::f77_integer Input

On entry: $n$, the current number of decision variables $x$ in the model.

5: $\mathbf{nnzgd}$ – types::f77_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 handle_​set_​nlnconstr.

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

6: $\mathbf{hess}$ – void function 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\left(x\right)+{\displaystyle \sum _{i=1}^{m_g}}{\lambda }_i{\nabla }^2{g}_i\left(x\right)$,
• the Hessian of the objective function ${\nabla }^{2}f\left(x\right)$,
• the Hessian of the $i$th constraint function ${\nabla }^2{g}_i\left(x\right)$.

The value of argument idf determines which one of these is to be computed and this, in turn, is determined by earlier calls to handle_​set_​nlnhess, 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{errorid}=\mathbf{6}$). If there were no calls to handle_​set_​nlnhess, hess will never be called by handle_solve_ipopt and hess may be the dummy function ipopt_​dummy_​hess (ipopt_​dummy_​hess 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).

void function hess(const utility::array1D<double,data_handling::ArgIntent::IntentIN> &x, const types::f77_integer idf, const double sigma, const utility::array1D<double,data_handling::ArgIntent::IntentIN> &lamda, utility::array1D<double,data_handling::ArgIntent::IntentINOUT> &hx, types::f77_integer &inform)

1: $\mathbf{x}\left(\mathbf{nvar}\right)$ – double array Input

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

2: $\mathbf{idf}$ – types::f77_integer Input

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

$\mathbf{idf}=\mathrm{-1}$

The values of the Hessian of the Lagrangian will be computed in hx. This will be the case if handle_​set_​nlnhess 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 handle_​set_​nlnhess has been called with idf of the same value.

$\mathbf{idf}>0$

The values of the Hessian of the constraint function with index idf will be computed in hx. This will be the case if handle_​set_​nlnhess has been called with idf of the same value.

3: $\mathbf{sigma}$ – double Input

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

4: $\mathbf{lamda}\left(\mathbf{ncnln}\right)$ – double array Input

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

5: $\mathbf{hx}\left(\mathbf{nnzh}\right)$ – double array Input/Output

On entry: the elements should only be assigned and not referenced.

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 handle_​set_​nlnhess through the arguments irowh and icolh.

6: $\mathbf{inform}$ – types::f77_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{errorid}=\mathbf{25}$; otherwise, computations will continue.

7: $\mathbf{nvar}$ – types::f77_integer Input

On entry: $n$, the current number of decision variables $x$ in the model.

8: $\mathbf{ncnln}$ – types::f77_integer Input

On entry: $m_g$, the number of nonlinear constraints, as specified in an earlier call to handle_​set_​nlnconstr.

9: $\mathbf{nnzh}$ – types::f77_integer Input

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

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

7: $\mathbf{monit}$ – void function Function

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

monit may be the dummy function ipopt_​dummy_​monit included in the NAG Library.

void function monit(const utility::array1D<double,data_handling::ArgIntent::IntentIN> &x, const utility::array1D<double,data_handling::ArgIntent::IntentIN> &u, const utility::array1D<double,data_handling::ArgIntent::IntentIN> &rinfo, const utility::array1D<double,data_handling::ArgIntent::IntentIN> &stats)

1: $\mathbf{x}\left(\mathbf{nvar}\right)$ – double array Input

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

2: $\mathbf{u}\left(\mathbf{nnzu}\right)$ – double array Input

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

3: $\mathbf{rinfo}\left(100\right)$ – double array Input

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

4: $\mathbf{stats}\left(100\right)$ – double array Input

On entry: solver statistics at the end of the current iteration. It reports only the iteration count and the number of backtracking trial steps taken. See Section 9.1.

5: $\mathbf{nvar}$ – types::f77_integer Input

On entry: $n$, the current number of decision variables $x$ in the model.

6: $\mathbf{nnzu}$ – types::f77_integer Input

On entry: the dimension of array u.

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

8: $\mathbf{x}\left(\mathbf{nvar}\right)$ – double array Input/Output

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

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

9: $\mathbf{u}\left(\mathbf{nnzu}\right)$ – double array Input/Output

On entry: the input of u is reserved for future releases of the NAG Library and it is ignored at the moment.

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

10: $\mathbf{rinfo}\left(100\right)$ – double array Output

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

$0$	Objective function value $f\left(x\right)$.
$1$	Constraint violation (primal infeasibility), see (7).
$2$	Dual infeasibility, see (6).
$3$	Complementarity.
$4$	Karush–Kuhn–Tucker error.
$5$	Regularization term for the Hessian of the Lagrangian. This value is only available in monit, see Iteration log in Section 9.1.
$6$	Step size for the dual variables. This value is only available in monit, see Iteration log in Section 9.1.
$7$	Step size for the primal variables. This value is only available in monit, see Iteration log in Section 9.1.
$8$–$99$	Reserved for future use.

11: $\mathbf{stats}\left(100\right)$ – double array Output

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

$0$	Number of the iterations.
$1$	Reserved for future use.
$2$	Number of backtracking trial steps.
$3$	Number of Hessian evaluations.
$4$	Number of objective gradient evaluations.
$5$, $6$	Reserved for future use.
$7$	Total wall clock time elapsed.
$8$–$17$	Reserved for future use.
$18$	Number of objective function evaluations.
$19$	Number of constraint function evaluations.
$20$	Number of constraint Jacobian evaluations.
$21$–$99$	Reserved for future use.

12: $\mathbf{opt}$ – OptionalE04ST Input/Output

Optional parameter container, derived from Optional.

6 Exceptions and Warnings

Raises: ErrorException

$\mathbf{errorid}=\mathrm{-199}$

function is not available in this implementation.

$\mathbf{errorid}=1$

comm::handle has not been initialized.

$\mathbf{errorid}=1$

comm::handle does not belong to the NAG optimization modelling suite,
has not been initialized properly or is corrupted.

$\mathbf{errorid}=1$

comm::handle has not been initialized properly or is corrupted.

$\mathbf{errorid}=2$

The problem is already being solved.

$\mathbf{errorid}=2$

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

$\mathbf{errorid}=4$

On entry, $\mathbf{nvar}=⟨\mathit{value}⟩$,
expected $\mathrm{value}=⟨\mathit{value}⟩$.
Constraint: $\mathbf{nvar}$ must match the current number of variables
of the model in the comm::handle.

$\mathbf{errorid}=5$

On entry, $\mathbf{nnzu}=⟨\mathit{value}⟩$.
Constraint: $\mathbf{nnzu}=⟨\mathit{value}⟩$ or $0$.

$\mathbf{errorid}=5$

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

$\mathbf{errorid}=6$

On entry, a nonlinear objective function has been defined
but no objective Hessian sparsity structure has been defined
through function.

$\mathbf{errorid}=6$

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

$\mathbf{errorid}=7$

Either change the option ‘Hessian Mode’ or
provide a proper hess function.

$\mathbf{errorid}=7$

Please provide a proper objfun function.

$\mathbf{errorid}=7$

Please provide a proper objgrd function.

$\mathbf{errorid}=7$

Please provide a proper confun function.

$\mathbf{errorid}=7$

Please provide a proper congrd function.

$\mathbf{errorid}=23$

The solver terminated with not enough degrees of freedom.

$\mathbf{errorid}=23$

The solver terminated due to an invalid problem definition.

$\mathbf{errorid}=23$

The solver terminated due to an invalid option.

$\mathbf{errorid}=51$

The solver detected an infeasible problem.

$\mathbf{errorid}=54$

The solver terminated due to diverging iterates.

$\mathbf{errorid}=10601$

On entry, argument $⟨\mathit{\text{value}}⟩$ must be a vector of size $⟨\mathit{\text{value}}⟩$ array.
Supplied argument has $⟨\mathit{\text{value}}⟩$ dimensions.

$\mathbf{errorid}=10601$

On entry, argument $⟨\mathit{\text{value}}⟩$ must be a vector of size $⟨\mathit{\text{value}}⟩$ array.
Supplied argument was a vector of size $⟨\mathit{\text{value}}⟩$.

$\mathbf{errorid}=10601$

On entry, argument $⟨\mathit{\text{value}}⟩$ must be a vector of size $⟨\mathit{\text{value}}⟩$ array.
The size for the supplied array could not be ascertained.

$\mathbf{errorid}=10602$

On entry, the raw data component of $⟨\mathit{\text{value}}⟩$ is null.

$\mathbf{errorid}=10603$

On entry, unable to ascertain a value for $⟨\mathit{\text{value}}⟩$.

$\mathbf{errorid}=10605$

On entry, the communication class $⟨\mathit{\text{value}}⟩$ has not been initialized correctly.

$\mathbf{errorid}=10703$

An exception was thrown during IO (writing).

$\mathbf{errorid}=\mathrm{-99}$

An unexpected error has been triggered by this routine.

$\mathbf{errorid}=\mathrm{-399}$

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

$\mathbf{errorid}=\mathrm{-999}$

Dynamic memory allocation failed.

Raises: CallbackEarlyTermination

$\mathbf{errorid}=20$

User requested termination during a monitoring step.

Raises: WarningException

$\mathbf{errorid}=22$

Maximum number of iterations exceeded.

$\mathbf{errorid}=23$

The solver terminated after failure in the restoration phase.

$\mathbf{errorid}=23$

The solver terminated after an error in the step computation.

$\mathbf{errorid}=23$

The solver terminated after the maximum time allowed was exceeded.

$\mathbf{errorid}=24$

The solver terminated after the search direction became too small.

$\mathbf{errorid}=25$

Invalid number detected in user function.

$\mathbf{errorid}=50$

The solver reports NLP solved to acceptable level.

Raises: CallbackException

$\mathbf{errorid}=10701$

An exception was thrown in a callback.

$\mathbf{errorid}=10702$

The memory address for an array in a callback has changed.

7 Accuracy

8 Parallelism and Performance

9 Further Comments

9.1 Description of the Printed Output

 ------------------------------------------------------------------------------
  E04ST, Interior point method for large-scale nonlinear optimization problems
 ------------------------------------------------------------------------------
 
 Begin of Options
     Print File                    =                   6     * d
     Print Level                   =                   2     * U
     Monitoring File               =                  67     * U
     Monitoring Level              =                   2     * U
 
     Infinite Bound Size           =         1.00000E+20     * d
     Task                          =            Minimize     * d
     Stats Time                    =                  No     * d
     Time Limit                    =         1.00000E+01     * U
     Verify Derivatives            =                  No     * d
 
     Hessian Mode                  =                Auto     * d
     Nlp Factorization Method      =                Ma97     * d
     Matrix Ordering               =                Auto     * d
     Outer Iteration Limit         =                  26     * U
     Stop Tolerance 1              =         2.50000E-08     * U
 End of Options

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

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

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 Additional Licensor

10 Example

10.1 Example Program

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
• NLP Factorization Method
• Outer Iteration Limit
• Print File
• Print Level
• Print Options
• Print Solution
• 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 precision).