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, const types::f77_integer nnzu, 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, const types::f77_integer nnzu, 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 and handle_​set_​quadobj 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::IN> &x, double &fx)

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{nvar}$ – types::f77_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 handle_​init.

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 and handle_​set_​quadobj 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. (ipopt_​dummy_​objgrd is included in the NAG Library.)

void function objgrd(const utility::array1D<double,data_handling::ArgIntent::IN> &x, const types::f77_integer nnzfd, utility::array1D<double,data_handling::ArgIntent::OUT> &fdx)

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

3: $\mathbf{fdx}\left(\mathbf{nnzfd}\right)$ – double 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 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)}}$.

4: $\mathbf{nvar}$ – types::f77_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 handle_​init.

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 no nonlinear constraints were registered in this handle, confun will never be called by handle_solve_ipopt and confun may be the dummy function ipopt_​dummy_​confun. (ipopt_​dummy_​confun is included in the NAG Library.)

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

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{nvar}$ – types::f77_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 handle_​init.

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 (e.g., handle_​set_​nlnconstr was never called with the same handle or it was called with ncnln $=0$), congrd will never be called by handle_solve_ipopt and congrd may be the dummy function ipopt_​dummy_​congrd. (ipopt_​dummy_​congrd is included in the NAG Library.)

void function congrd(const utility::array1D<double,data_handling::ArgIntent::IN> &x, const types::f77_integer nnzgd, utility::array1D<double,data_handling::ArgIntent::OUT> &gdx)

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

3: $\mathbf{gdx}\left(\mathbf{nnzgd}\right)$ – double 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 handle_​set_​nlnconstr. $\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)}}$.

4: $\mathbf{nvar}$ – types::f77_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 handle_​init.

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+{\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 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::IN> &x, const types::f77_integer idf, const double sigma, const utility::array1D<double,data_handling::ArgIntent::IN> &lamda, const types::f77_integer nnzh, utility::array1D<double,data_handling::ArgIntent::OUT> &hx)

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}=-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 idfth constraint function 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}=-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}=-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{nnzh}$ – types::f77_integer Input

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

6: $\mathbf{hx}\left(\mathbf{nnzh}\right)$ – double 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 handle_​set_​nlnhess through the arguments irowh and icolh.

7: $\mathbf{nvar}$ – types::f77_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 handle_​init.

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.

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 (ipopt_​dummy_​monit is included in the NAG Library).

void function monit(const utility::array1D<double,data_handling::ArgIntent::IN> &x, const utility::array1D<double,data_handling::ArgIntent::IN> &u, const utility::array1D<double,data_handling::ArgIntent::IN> &rinfo, const utility::array1D<double,data_handling::ArgIntent::IN> &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 at the current iteration of Lagrange multipliers (dual variables) for the constraints. See Section 3.1 for layout information.

3: $\mathbf{rinfo}\left(32\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(32\right)$ – double array Input

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

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

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

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{nnzu}$ – types::f77_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$.

10: $\mathbf{u}\left(\mathbf{nnzu}\right)$ – double 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$.

11: $\mathbf{rinfo}\left(32\right)$ – double array 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.

12: $\mathbf{stats}\left(32\right)$ – double array 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.

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

Optional parameter container, derived from Optional.

6 Exceptions and Warnings

Raises: ErrorException

$\mathbf{errorid}=-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}=3$

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

$\mathbf{errorid}=4$

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

$\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}=-99$

An unexpected error has been triggered by this routine.

$\mathbf{errorid}=-399$

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

$\mathbf{errorid}=-999$

Dynamic memory allocation failed.

Raises: WarningException

$\mathbf{errorid}=20$

User requested termination during a monitoring step.

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

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

10 Example

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