naginterfaces.library.opt.handle_​solve_​ipopt

naginterfaces.library.opt.handle_solve_ipopt(handle, x, objfun=None, objgrd=None, confun=None, congrd=None, hess=None, monit=None, u=None, data=None, io_manager=None)

handle_solve_ipopt is a solver from the NAG optimization modelling suite for constrained large-scale Nonlinear Programming (NLP) problems. It is an interior point method optimization solver based on the IPOPT software package.

Note: this function uses optional algorithmic parameters, see also: handle_opt_set(), handle_opt_get().

For full information please refer to the NAG Library document for e04st

https://support.nag.com/numeric/nl/nagdoc_30.2/flhtml/e04/e04stf.html

Parameters

handleHandle

The handle to the problem. It needs to be initialized (e.g., by handle_init()) and to hold a problem formulation compatible with handle_solve_ipopt. It must not be changed between calls to the NAG optimization modelling suite.

xfloat, array-like, shape $\left(\text{nvar}\right)$

$x^0$, the initial estimates of the variables $x$.

objfunNone or callable (fx, inform) = objfun(x, inform, data=None), optional

Note: if this argument is None then a NAG-supplied facility will be used.

$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(), handle_set_qconstr() or handle_set_qconstr_fac() was called to define a linear or quadratic objective function), $objfun$ will never be called by handle_solve_ipopt and $objfun$ may be None.

Parameters

xfloat, ndarray, shape $\left(\text{nvar}\right)$

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

informint

A non-negative value.

dataarbitrary, optional, modifiable in place

User-communication data for callback functions.

Returns

fxfloat

The value of the objective function at $x$.

informint

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 $errno$ = 25; otherwise, the solver will proceed normally.

objgrdNone or callable inform = objgrd(x, fdx, inform, data=None), optional

Note: if this argument is None then a NAG-supplied facility will be used.

$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(), handle_set_qconstr() or handle_set_qconstr_fac() was called to define a linear or quadratic objective function), $objgrd$ will never be called by handle_solve_ipopt and $objgrd$ may be None.

Parameters

xfloat, ndarray, shape $\left(\text{nvar}\right)$

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

fdxfloat, ndarray, shape $\left(\text{nnzfd}\right)$, to be modified in place

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 $\text{idxfd}$ in a previous call to handle_set_nlnobj(). $fdx[\text{i}-1]$ will be the gradient $\frac{\partial f}{\partial x_{\text{idxfd}[\text{i}-1]}}$.

informint

A non-negative value.

dataarbitrary, optional, modifiable in place

User-communication data for callback functions.

Returns

informint

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 $errno$ = 25; otherwise, computations will continue.

confunNone or callable (gx, inform) = confun(x, ncnln, inform, data=None), optional

Note: if this argument is None then a NAG-supplied facility will be used.

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

Parameters

xfloat, ndarray, shape $\left(\text{nvar}\right)$

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

ncnlnint

$m_g$, the number of nonlinear constraints, as specified in an earlier call to handle_set_nlnconstr().

informint

A non-negative value.

dataarbitrary, optional, modifiable in place

User-communication data for callback functions.

Returns

gxfloat, array-like, shape $\left(ncnln\right)$

The $m_g$ values of the nonlinear constraint functions at $x$.

informint

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 $errno$ = 25; otherwise, the solver will proceed normally.

congrdNone or callable inform = congrd(x, gdx, inform, data=None), optional

Note: if this argument is None then a NAG-supplied facility will be used.

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

Parameters

xfloat, ndarray, shape $\left(\text{nvar}\right)$

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

gdxfloat, ndarray, shape $\left(\text{nnzgd}\right)$, to be modified in place

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 $\text{irowgd}$ and $\text{icolgd}$ in an earlier call to handle_set_nlnconstr(). $gdx[\text{i}-1]$ will be the gradient $\frac{\partial g_j}{\partial x_k}$, where $j=\text{irowgd}[\text{i}-1]$ and $k=\text{icolgd}[\text{i}-1]$.

informint

A non-negative value.

dataarbitrary, optional, modifiable in place

User-communication data for callback functions.

Returns

informint

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 $errno$ = 25; otherwise, computations will continue.

hessNone or callable inform = hess(x, idf, sigma, lamda, hx, inform, data=None), optional

Note: if this argument is None then a NAG-supplied facility will be used.

$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)+{\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 $errno$ = 6).

If there were no calls to handle_set_nlnhess(), $hess$ will never be called by handle_solve_ipopt and $hess$ may be None. In this case, the Hessian of the Lagrangian will be approximated by a limited-memory quasi-Newton method (L-BFGS).

Parameters

xfloat, ndarray, shape $\left(\text{nvar}\right)$

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

idfint

Specifies the quantities to be computed in $hx$.

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

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

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

sigmafloat

If $idf=-1$, the value of the $\sigma$ quantity in the definition of the Hessian of the Lagrangian. Otherwise, $sigma$ should not be referenced.

lamdafloat, ndarray, shape $\left(\text{ncnln}\right)$

If $idf=-1$, the values of the ${\lambda }_i$ quantities in the definition of the Hessian of the Lagrangian. Otherwise, $lamda$ should not be referenced.

hxfloat, ndarray, shape $\left(\text{nnzh}\right)$, to be modified in place

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 $\text{irowh}$ and $\text{icolh}$.

informint

A non-negative value.

dataarbitrary, optional, modifiable in place

User-communication data for callback functions.

Returns

informint

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 $errno$ = 25; otherwise, computations will continue.

monitNone or callable monit(x, u, rinfo, stats, data=None), optional

Note: if this argument is None then a NAG-supplied facility will be used.

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

$monit$ may be None.

Parameters

xfloat, ndarray, shape $\left(\text{nvar}\right)$

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

ufloat, ndarray, shape $\left(\text{nnzu}\right)$

If $\text{nnzu}>0$, $u$ holds the values of Lagrange multipliers (dual variables) for the constraints at the current iteration. See Structure of the Lagrange Multipliers for layout information.

rinfofloat, ndarray, shape $\left(100\right)$

Error measures and various indicators at the end of the current iteration as described in Description of the Printed Output.

statsfloat, ndarray, shape $\left(100\right)$

Solver statistics at the end of the current iteration. It reports only the iteration count and the number of backtracking trial steps taken. See Description of the Printed Output.

dataarbitrary, optional, modifiable in place

User-communication data for callback functions.

uNone or float, array-like, shape $\left(\text{nnzu}\right)$, optional

The input of $u$ is reserved for future releases of the NAG Library and it is ignored at the moment.

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

dataarbitrary, optional

User-communication data for callback functions.

io_managerFileObjManager, optional

Manager for I/O in this routine.

Returns

xfloat, ndarray, shape $\left(\text{nvar}\right)$

The final values of the variables $x$.

ufloat, ndarray, shape $\left(\text{nnzu}\right)$

The final value of Lagrange multipliers $(z,\lambda )$.

rinfofloat, ndarray, shape $\left(100\right)$

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 [equation].
$2$	Dual infeasibility, see [equation].
$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 Description of the Printed Output.
$6$	Step size for the dual variables. This value is only available in $monit$, see Iteration log in Description of the Printed Output.
$7$	Step size for the primal variables. This value is only available in $monit$, see Iteration log in Description of the Printed Output.
$8$–$99$	Reserved for future use.

statsfloat, ndarray, shape $\left(100\right)$

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.

Other Parameters

‘Defaults’valueless

This special keyword may be used to reset all options to their default values. Any value given with this keyword will be ignored.

‘Hessian Mode’str

Default $=\text{'AUTO'}$

This argument specifies whether the Hessian will be user-supplied (in $hx$) or approximated by handle_solve_ipopt using a limited-memory quasi-Newton L-BFGS method. In the ‘AUTO’ setting, if no Hessian structure has been registered in the problem with a call to handle_set_nlnhess() and there are general nonlinear objective or constraints, then the Hessian will be approximated. Otherwise $hess$ will be called if and only if any of handle_set_nlnobj() or handle_set_nlnconstr() have been used to define the problem. Approximating the Hessian is likely to require more iterations to achieve convergence but will reduce the time spent in user-supplied functions.

Constraint: $\text{‘Hessian Mode'}=\text{'AUTO'}$, $\text{'EXACT'}$ or $\text{'APPROXIMATE'}$.

‘Infinite Bound Size’float

Default $={10}^{20}$

This defines the ‘infinite’ bound $\text{bigbnd}$ in the definition of the problem constraints. Any upper bound greater than or equal to $\text{bigbnd}$ will be regarded as $+\infty$ (and similarly any lower bound less than or equal to $-\text{bigbnd}$ will be regarded as $-\infty$). Note that a modification of this option does not influence constraints which have already been defined; only the constraints formulated after the change will be affected.

It also serves as a limit for the objective function to be considered unbounded ($errno$ = 54).

Constraint: $\text{‘Infinite Bound Size'}\ge 1000$.

‘Monitoring File’int

Default $=-1$

If $i\ge 0$, the unit number for the secondary (monitoring) output. If set to $-1$, no secondary output is provided. The information output to this unit is controlled by ‘Monitoring Level’.

Constraint: $\text{‘Monitoring File'}\ge -1$.

‘Monitoring Level’int

Default $=4$

This argument sets the amount of information detail that will be printed by the solver to the secondary output. The meaning of the levels is the same as with ‘Print Level’.

Constraint: $0\le \text{‘Monitoring Level'}\le 5$.

‘Matrix Ordering’str

Default $=\text{'AUTO'}$

If ‘NLP Factorization Method’ is ‘MA97’, this argument specifies the ordering to be used by the internal sparse linear algebra solver. It affects the number of nonzeros in the factorized matrix and thus influences the cost per iteration.

$\text{‘Matrix Ordering'}=\text{'AUTO'}$

A heuristic is used to choose automatically between METIS and AMD orderings.

$\text{‘Matrix Ordering'}=\text{'BEST'}$

Both AMD and METIS orderings are computed at the beginning of the solve and the one with the fewest nonzeros in the factorized matrix is selected.

$\text{‘Matrix Ordering'}=\text{'AMD'}$

An approximate minimum degree (AMD) ordering is used.

$\text{‘Matrix Ordering'}=\text{'METIS'}$

METIS ordering is used.

Note: if ‘NLP Factorization Method’ is ‘MA86’, this parameter is ignored and AMD ordering will be used.

Constraint: $\text{‘Matrix Ordering'}=\text{'AUTO'}$, $\text{'BEST'}$, $\text{'AMD'}$ or $\text{'METIS'}$.

‘NLP Factorization Method’str

Default $=\text{'MA97'}$

This parameter controls whether Harwell package ‘MA97’ or ‘MA86’ is used for the sparse linear algebra factorization. To determine which best suits your application, it is recommended to try both ‘MA97’ and ‘MA86’.

Constraint: $\text{‘NLP Factorization Method'}=\text{'MA97'}$ or $\text{'MA86'}$.

‘Outer Iteration Limit’int

Default $=100$

The maximum number of iterations to be performed by handle_solve_ipopt. Setting the option too low might lead to $errno$ = 22.

Constraint: $\text{‘Outer Iteration Limit'}\ge 0$.

‘Print File’int

Default $=\text{advisory message unit number}$

If $i\ge 0$, the unit number for the primary output of the solver. If $\text{‘Print File'}=-1$, the primary output is completely turned off independently of other settings. The default value is the advisory message unit number at the time of the options initialization, e.g., at the initialization of the handle. The information output to this unit is controlled by ‘Print Level’.

Constraint: $\text{‘Print File'}\ge -1$.

‘Print Level’int

Default $=2$

This argument defines how detailed information should be printed by the solver to the primary output.

$i$	Output
$0$	No output from the solver
$1$	Additionally, derivative check information, the Header and Summary.
$2$	Additionally, the Iteration log.
$3$, $4$	Additionally, details of each iteration with scalar quantities printed.
$5$	Additionally, individual components of arrays are printed resulting in large output.

Constraint: $0\le \text{‘Print Level'}\le 5$.

‘Print Options’str

Default $=\text{'YES'}$

If $\text{‘Print Options'}=\text{'YES'}$, a listing of options will be printed to the primary output.

Constraint: $\text{‘Print Options'}=\text{'YES'}$ or $\text{'NO'}$.

‘Print Solution’str

Default $=\text{'NO'}$

If $\text{‘Print Solution'}=\text{'X'}$, the final values of the primal variables are printed on the primary and secondary outputs.

If $\text{‘Print Solution'}=\text{'YES'}$ or $\text{'ALL'}$, in addition to the primal variables, the final values of the dual variables are printed on the primary and secondary outputs.

Constraint: $\text{‘Print Solution'}=\text{'YES'}$, $\text{'NO'}$, $\text{'X'}$ or $\text{'ALL'}$.

‘Stats Time’str

Default $=\text{'NO'}$

This argument allows you to turn on timings of various parts of the algorithm to give a better overview of where most of the time is spent. This might be helpful for a choice of different solving approaches.

Constraint: $\text{‘Stats Time'}=\text{'YES'}$ or $\text{'NO'}$.

‘Stop Tolerance 1’float

Default $=max({10}^{-6},\sqrt{ϵ})$

This option sets the value ${ϵ}_{\text{tol}}$ of (5) which is used for optimality and complementarity tests from KKT conditions. See Stopping Criteria.

Constraint: $\text{‘Stop Tolerance 1'}>ϵ$.

‘Task’str

Default $=\text{'MINIMIZE'}$

This argument specifies the required direction of the optimization. If $\text{‘Task'}=\text{'FEASIBLE POINT'}$, the objective function (if set) is ignored and the algorithm stops as soon as a feasible point is found with respect to the given tolerance. If no objective function is set, ‘Task’ reverts to ‘FEASIBLE POINT’ automatically.

Constraint: $\text{‘Task'}=\text{'MINIMIZE'}$, $\text{'MAXIMIZE'}$ or $\text{'FEASIBLE POINT'}$.

‘Time Limit’float

Default $={10}^6$

A limit to the number of seconds that the solver can use to solve one problem. If during the convergence check this limit is exceeded, the solver will terminate with a corresponding error message.

Constraint: $\text{‘Time Limit'}>0$.

‘Verify Derivatives’str

Default $=\text{'NO'}$

This argument specifies whether the function should perform numerical checks on the consistency of the user-supplied functions. It is recommended that such checks are enabled when first developing the formulation of the problem, however, the derivative check results in a significant increase of the number of the function evaluations and thus it shouldn’t be used in production code.

Constraint: $\text{‘Verify Derivatives'}=\text{'YES'}$ or $\text{'NO'}$.

Raises

NagValueError

(errno $-199$)

handle_solve_ipopt is not available in this implementation.

(errno $1$)

$handle$ has not been initialized.

(errno $1$)

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

(errno $1$)

$handle$ has not been initialized properly or is corrupted.

(errno $2$)

The problem is already being solved.

(errno $2$)

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

(errno $4$)

On entry, $\text{nvar}=⟨value⟩$, expected $value=⟨value⟩$.

Constraint: $\text{nvar}$ must match the current number of variables of the model in the $handle$.

(errno $5$)

On entry, $\text{nnzu}=⟨value⟩$.

Constraint: $\text{nnzu}=⟨value⟩$ or $0$.

(errno $5$)

On entry, $\text{nnzu}=⟨value⟩$.

Constraint: no constraints present, so $\text{nnzu}$ must be $0$.

(errno $6$)

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

(errno $6$)

On entry, a nonlinear constraint function has been defined but no constraint Hessian sparsity structure has been defined through handle_set_nlnhess(), for constraint number $⟨value⟩$.

(errno $7$)

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

(errno $7$)

Please provide a proper $objfun$ function.

(errno $7$)

Please provide a proper $objgrd$ function.

(errno $7$)

Please provide a proper $confun$ function.

(errno $7$)

Please provide a proper $congrd$ function.

(errno $23$)

The solver terminated with not enough degrees of freedom.

(errno $23$)

The solver terminated due to an invalid problem definition.

(errno $23$)

The solver terminated due to an invalid option.

(errno $51$)

The solver detected an infeasible problem.

(errno $54$)

The solver terminated due to diverging iterates.

Warns

NagAlgorithmicWarning

(errno $22$)

Maximum number of iterations exceeded.

(errno $50$)

The solver reports NLP solved to acceptable level.

NagAlgorithmicMajorWarning

(errno $23$)

The solver terminated after failure in the restoration phase.

(errno $23$)

The solver terminated after an error in the step computation.

(errno $23$)

The solver terminated after the maximum time allowed was exceeded.

(errno $24$)

The solver terminated after the search direction became too small.

(errno $25$)

Invalid number detected in user function.

NagCallbackTerminateWarning

(errno $20$)

User requested termination during a monitoring step.

Notes

handle_solve_ipopt is typically used to solve the following nonlinear programming problem

$$\begin{array}{c}\begin{array}{ccc}{minimize}_{x\in R^n}& f\left(x\right)& \\ \text{subject to}& l_g\le g\left(x\right)\le u_g\text{,}& \\ & \frac{1}{2}{x}^T{Q}_{i}x+r_i^{T}x+s_i\le 0\text{,}1\le i\le m_Q\text{,}& \\ & l_B\le Bx\le u_B\text{,}& \\ & l_x\le x\le u_x\text{,}& \end{array}\end{array}$$

where

$n$ is the number of the decision variables,

$m_g$ is the number of the nonlinear constraints and $g\left(x\right)$, $l_g$ and $u_g$ are $m_g$-dimensional vectors,

$m_Q$ is the number of the quadratic constraints,

$m_B$ is the number of the linear constraints and $B$ is a $m_B\times n$ matrix, $l_B$ and $u_B$ are $m_B$-dimensional vectors,

there are $n$ box constraints and $l_x$ and $u_x$ are $n$-dimensional vectors.

The objective $f\left(x\right)$ can be specified in a number of ways: handle_set_linobj() for a dense linear function, handle_set_quadobj() (and handle_set_qconstr() or handle_set_qconstr_fac()) for a sparse linear or quadratic function, handle_set_qconstr_fac() is used to provide the quadratic function in factorized form, and handle_set_nlnobj() for a general nonlinear function. In the last case, $objfun$ and $objgrd$ will be used to compute values and gradients of the objective function. Variable box bounds $l_x,u_x$ can be specified with handle_set_simplebounds(). The special case of linear constraints $l_B,B,u_B$ is handled by handle_set_linconstr(), quadratic constraints are handled by handle_set_qconstr() and handle_set_qconstr_fac() while general nonlinear constraints $l_g,g\left(x\right),u_g$ are specified by handle_set_nlnconstr() (all can be specified). Again, in the last case, $confun$ and $congrd$ will be used to compute values and gradients of the nonlinear constraint functions.

Finally, if it is viable to calculate second derivatives, the sparsity structure of the second partial derivatives of a general nonlinear objective and/or of any general nonlinear constraints is specified by handle_set_nlnhess() and the values of these derivatives themselves will be computed by user-supplied $hess$. While there is an option (see ‘Hessian Mode’) that forces internal approximation of second derivatives, no such option exists for first derivatives which must be computed accurately. If handle_set_nlnhess() has been called and $hess$ is used to calculate values for second derivatives, both the nonlinear objective and all the nonlinear constraints must be included; it is not possible to provide a subset of these. If the problem has only linear or quadratic objective and constraints, then $hess$ is never called since the required Hessian information is already provided by the calls to handle_set_linobj(), handle_set_quadobj(), handle_set_linconstr(), handle_set_qconstr_fac() and handle_set_qconstr(). If handle_set_nlnhess() is not called, then internal approximation of second derivatives will take place.

See the E04 Introduction for more details about the NAG optimization modelling suite.

Structure of the Lagrange Multipliers

For a problem consisting of $n$ variable bounds, $m_B$ linear constraints, $m_Q$ quadratic constraints, and $m_g$ nonlinear constraints, the number of Lagrange multipliers, and consequently the correct value for $nnzu$, will be $q=2\ast n+2\ast m_B+2\ast m_Q+2\ast m_g$. The order these will be found in the $u$ array is

$\begin{array}{c}{z}_{1_L},z_{1_U},z_{2_L},z_{2_U}\dots z_{n_L},z_{n_U},\\ {\lambda }_{1_L},{\lambda }_{1_U},{\lambda }_{2_L},{\lambda }_{2_U}\dots {\lambda }_{{m_B}_L},{\lambda }_{{m_B}_U},\\ {\lambda }_{{(m_B+1)}_L},{\lambda }_{{(m_B+1)}_U},{\lambda }_{{(m_B+2)}_L},{\lambda }_{{(m_B+2)}_U}\dots {\lambda }_{{(m_B+m_Q)}_L},{\lambda }_{{(m_B+m_Q)}_U},\\ {\lambda }_{{(m_B+m_Q+1)}_L},{\lambda }_{{(m_B+m_Q+1)}_U},{\lambda }_{{(m_B+m_Q+2)}_L},{\lambda }_{{(m_B+m_Q+2)}_U}\dots {\lambda }_{{(m_B+m_Q+m_g)}_L},{\lambda }_{{(m_B+m_Q+m_g)}_U}.\end{array}$

where the $L$ and $U$ subscripts refer to lower and upper bounds, respectively, and the variable bound constraint multipliers come first (if present, i.e., if handle_set_simplebounds() was called), followed by the linear constraint multipliers (if present, i.e., if handle_set_linconstr() was called), followed by the quadratic constraint multipliers (if present, i.e., if handle_set_qconstr() or handle_set_qconstr_fac() were called), and the nonlinear constraint multipliers (if present, i.e., if handle_set_nlnconstr() was called).

Significantly nonzero values for any of these, after the solver has terminated, indicates that the corresponding constraint is active. Significance is judged in the first instance by the relative scale of any value compared to the smallest among them.

References

Byrd, R H, Gilbert, J Ch and Nocedal, J, 2000, A trust region method based on interior point techniques for nonlinear programming, Mathematical Programming (89), 149–185

Byrd, R H, Liu, G and Nocedal, J, 1997, On the local behavior of an interior point method for nonlinear programming, Numerical Analysis, (eds D F Griffiths and D J Higham), Addison–Wesley

Conn, A R, Gould, N I M, Orban, D and Toint, Ph L, 2000, A primal-dual trust-region algorithm for non-convex nonlinear programming, Mathematical Programming (87 (2)), 215–249

Conn, A R, Gould, N I M and Toint, Ph L, 2000, Trust Region Methods, SIAM, Philadephia

Fiacco, A V and McCormick, G P, 1990, Nonlinear Programming: Sequential Unconstrained Minimization Techniques, SIAM, Philadelphia

Gould, N I M, Orban, D, Sartenaer, A and Toint, Ph L, 2001, Superlinear convergence of primal-dual interior point algorithms for nonlinear programming, SIAM Journal on Optimization (11 (4)), 974–1002

Hock, W and Schittkowski, K, 1981, Test Examples for Nonlinear Programming Codes. Lecture Notes in Economics and Mathematical Systems (187), Springer–Verlag

Hogg, J D and Scott, J A, 2010, An indefinite sparse direct solver for large problems on multicore machines, RAL Technical Report. RAL-TR-2010-011

Hogg, J D and Scott, J A, 2011, HSL MA97: a bit-compatible multifrontal code for sparse symmetric systems, RAL Technical Report. RAL-TR-2011-024

Wächter, A and Biegler, L T, 2006, On the implementation of a primal-dual interior point filter line search algorithm for large-scale nonlinear programming, Mathematical Programming (106(1)), 25–57

Williams, P and Lang, B, 2013, A framework for the $M{R}^3$ Algorithm: theory and implementation, SIAM J. Sci. Comput. (35), 740–766

Yamashita, H, 1998, A globally convergent primal-dual interior-point method for constrained optimization, Optimization Methods and Software (10), 443–469

See also

naginterfaces.library.examples.opt.handle_solve_ipopt_ex.main()