naginterfaces.library.opt.handle_​solve_​ssqp

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

handle_solve_ssqp is a solver from the NAG optimization modelling suite for large-scale Nonlinear Programming (NLP) problems based on an active-set Sequential Quadratic Programming (SQP) method, using limited-memory quasi-Newton approximations to the Hessian of the Lagrangian.

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

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

https://support.nag.com/numeric/nl/nagdoc_30.2/flhtml/e04/e04srf.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_ssqp. 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 point $x$.

If there is no nonlinear objective (i.e., handle_set_nlnobj() was not called), $objfun$ will never be called by handle_solve_ssqp 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

May be used to indicate that the function cannot be evaluated at the requested point $x$ by setting $inform<0$. The algorithm will try to recover if the objective cannot be evaluated; if recovery is not possible it will stop with $errno$ = 21 or $errno$ = 25.

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 gradient $\frac{\partial f}{\partial x}$ at a specified point $x$.

If there is no nonlinear objective (i.e., handle_set_nlnobj() was not called), $objgrd$ will never be called by handle_solve_ssqp and $objgrd$ may be None.

If the option $\text{‘SSQP Estimate Derivatives'}=\text{'YES'}$ or $\text{'ONLYOBJ'}$, then after returning from $objgrd$ the gradient vector is checked for missing entries which you have not supplied.

Missing entries will be estimated using a finite difference method, see option ‘SSQP Estimate Derivatives’ description for more details.

Note: $objgrd$ should not return floating-point NaN (Not a Number) or infinity values, if your code inadvertently returns any NaNs or infinities, handle_solve_ssqp is likely to terminate with $errno$ = 21, 24 or 25.

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 store the gradient element $\frac{\partial f}{\partial x_j}$, where $j=\text{idxfd}[\text{i}-1]$.

informint

A non-negative value.

If $inform=100$, then this is a special presolve call.

This call is used to fill-in the constant elements of the objective gradient, e.g., when there are linear variables in the model.

Note that this call may occur with an iterate $x$ that may not be feasible with respect to the linear constraints but it will always be feasible with respect to the variable bounds.

Furthermore, this call only requires to return the constant elements of the gradient, $\frac{\partial f}{\partial x_{\text{i}}}$, where $f\left(x\right)$ is linear in $x_{\text{i}}$.

If you do not provide these elements, subsequent calls to $objfun$ with $inform$$=0$ may occur in the vicinity of $x$ with the purpose of estimating the missing derivatives using finite differences.

dataarbitrary, optional, modifiable in place

User-communication data for callback functions.

Returns

informint

May be used to inform that the gradient cannot be evaluated at the requested point $x$ by setting $inform<0$. The algorithm will try to recover if the gradient cannot be evaluated; if recovery is not possible it will stop with $errno$ = 21 or $errno$ = 25.

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 nonlinear constraints $g\left(x\right)$ at a specified point $x$.

If there are no nonlinear constraints then $confun$ will never be called by handle_solve_ssqp and it may be None.

Note: $confun$ should not return floating-point NaN (Not a Number) or infinity values, if your code inadvertently returns any NaNs or infinities, handle_solve_ssqp is likely to terminate with $errno$ = 21, 24 or 25.

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.

If $inform=100$, then this is a special presolve call.

This call is used to quickly identify if the problem is infeasible, e.g., due to fixed variables.

Note that this call can occur with an iterate $x$ that may not be feasible with respect to the linear constraints but it will always be feasible with respect to the variable bounds.

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

May be used to inform that the constraint values cannot be evaluated at the requested point $x$ by setting $inform<0$. The algorithm will try to recover if the gradient cannot be evaluated; if recovery is not possible it will stop with $errno$ = 21 or $errno$ = 25.

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 Jacobian of the nonlinear constraints $\frac{\partial g}{\partial x}$ at a specified point $x$.

If there are no nonlinear constraints, $congrd$ will never be called by handle_solve_ssqp and $congrd$ may be None.

If the option $\text{‘SSQP Estimate Derivatives'}=\text{'YES'}$ or $\text{'ONLYCON'}$, then after returning from $congrd$ the Jacobian is checked for missing entries which you have not supplied.

Missing entries will be estimated using a finite difference method, see option ‘SSQP Estimate Derivatives’ description for more details.

Note: $congrd$ should not return floating-point NaN (Not a Number) or infinity values, if your code inadvertently returns any NaNs or infinities, handle_solve_ssqp is likely to terminate with $errno$ = 21, 24 or 25.

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.

If $inform=100$, then this is a special presolve call.

This call is used to fill-in the constant elements of the Jacobian, e.g., when there are linear variables in the model.

Note that this call may occur with an iterate $x$ that may not be feasible with respect to the linear constraints but it will always be feasible with respect to the variable bounds.

Furthermore, this call only requires to return the constant elements of the Jacobian, $\frac{\partial g_{\text{j}}}{\partial x_{\text{i}}}$, where $g_{\text{j}}\left(x\right)$ is linear in $x_{\text{i}}$.

If the user does not provide these elements, subsequent calls to $confun$ with $inform$$=0$ may occur in the vicinity of $x$ with the purpose of estimating the missing derivatives using finite differences.

dataarbitrary, optional, modifiable in place

User-communication data for callback functions.

Returns

informint

May be used to inform that the Jacobian of the constraints cannot be evaluated at the requested point $x$ by setting $inform<0$. The algorithm will try to recover if the gradient cannot be evaluated; if recovery is not possible it will stop with $errno$ = 21 or $errno$ = 25.

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$ is reserved for future releases of the NAG Library which will allow calculation of the second derivatives.

It will never be called in the current implementation and $hess$ may be None.

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$ = 21 or $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 and optionally to terminate the solver early if necessary.

It is invoked at the end of every $i$th major iteration where $i$ is given by the ‘SSQP Monitor Frequency’ (the default is $0$, $monit$ is not called).

$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, see Minor Iterations) for the constraints at the current iteration. See Lagrangian 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 $rinfo$.

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

Solver statistics at the end of the current iteration as described in $stats$.

dataarbitrary, optional, modifiable in place

User-communication data for callback functions.

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

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

Optionally provides the initial estimates of Lagrange multipliers, $(z_0,{\pi }_0)$. These values are only referenced if a warm start is requested (Warm Starting). If there are no initial estimates available, then set to zero.

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

uNone or float, ndarray, shape $\left(\text{nnzu}\right)$

The final value of Lagrange multipliers $(z^{\ast },{\pi }^{\ast })$, see Minor Iterations.

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

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), see Accuracy.
$2$	Dual infeasibility.
$3$–$6$	Reserved for future use.
$7$	Step size for the primal variables, see Iteration log in Description of the Printed Output.
$8$	Estimate of the condition number of $R^{T}R$, itself an estimate of $Z^{T}HZ$, the reduced Hessian of the Lagrangian. See Description of the Printed Output.
$9$	Largest nonlinear constraint violation.
$10$	Largest nonlinear constraint violation, normalized using $1+\parallel x_k\parallel$, with $x_k$ the latest iterate. See (2).
$11$	Sum of the infeasibilities of constraints that lie outside one of their bounds by more than the option ‘SSQP Minor Feasibility Tol’ before the solution is unscaled.
$12$	$j$ Description 0 none of the conditions are satisfied; 1 condition on primal infeasibility satisfied, $rinfo$$\left(2\right)$ is within ‘SSQP Major Feasibility Tol’ tolerance; 2 condition on dual infeasibility satisfied, $rinfo$$\left(3\right)$ is within ‘SSQP Minor Feasibility Tol’ tolerance; and 3 both conditions are satisfied.
$13$	The size of the penalty parameter $D$ of (8). See The Merit Function.
$14$	Flag indicating whether the current iterate is feasible with respect to the linear constraints, if any. A nonzero value indicates feasibility.
$15$–$99$	Reserved for future use.

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

Solver statistics at the end of the final iteration as given in the table below:

$0$	Number of major iterations.
$1$	Total number of minor iterations.
$2$	Number of minor iterations performed on the last major iteration.
$3$	Number of Hessian evaluations.
$4$	Number of gradient evaluations.
$5$	Number of infeasibilities of constraints that lie outside one of their bounds by more than the option ‘SSQP Minor Feasibility Tol’ before the solution is unscaled. If any linear constraints are infeasible, it contains the number of variables and linear constraints lying outside their upper or lower bounds. The nonlinear constraints are not evaluated. Otherwise, it contains the number of components of $g\left(x\right)$ lying outside their bounds by more than the option ‘SSQP Minor Feasibility Tol’. Again this is before the solution is unscaled.
$6$	Total time spent in presolver (including user-supplied function calls).
$7$	Total time spent in solver (including user-supplied function calls).
$8$	Total time spent evaluating constraint function.
$9$	Total time spent evaluating constraint Jacobian.
$10$	Total time spent evaluating objective function.
$11$	Total time spent evaluating objective gradient.
$12$	Total time spent evaluating Hessian.
$13$–$17$	Reserved for future use.
$18$	Number of function evaluations.
$19$	Number of constraint function evaluations.
$20$	Number of constraint Jacobian evaluations.
$21$–$23$	Reserved for future use.
$24$	Number of superbasic variables.
$25$	Number of column swaps between $B$ and $S$.
$26$	Number of elements in the $LU$ factorization of $B$.
$27$–$28$	Reserved for future use.
$29$	Number of slack variables. See Algorithmic Details.
$30$–$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.

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

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 following information is output to the unit:

• a listing of the options;

• problem statistics, the iteration log and the final status as set by ‘Monitoring Level’;

• the solution if set by ‘Print Solution’.

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

‘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 following information is output to the unit:

• a listing of options if set by ‘Print Options’;

• problem statistics, the iteration log and the final status from the solver as set by ‘Print Level’;

• the solution if set by ‘Print Solution’.

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$	Only the final status and the objective value
$2$	Problem statistics, one line per iteration showing the progress of the solution with respect to the convergence measures, final status and statistics
$3$	As level $2$ and additionally inner QP iteration log is reported every ‘SSQP Print Frequency’
$4,5$	As level $3$ but further details of each minor and major iteration are presented

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{'YES'}$, the final values of the solution vector are printed on the primary and secondary outputs.

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

‘SSQP Crash Option’str

Default $=\text{'TRIPLE-PASS'}$

Except on restarts $\text{‘SSQP Start Type'}=\text{'COLD'}$, a crash procedure is used to select an initial basis $B$ (see (7) in Minor Iterations) from certain rows and columns of the constraint matrix $\left(\begin{array}{cc}A& -I\end{array}\right)$. The ‘SSQP Crash Option’ determines which rows and columns of $A$ (see (5) in Major Iterations) are eligible initially, and how many times crash is called. Columns of $-I$ are used to pad the basis where necessary.

$a$	Meaning
‘ONLY-SLACKS’	The initial basis contains only slack variables: $B=I$ (see (7) in Minor Iterations).
‘SINGLE-PASS’	crash is called once, looking for a triangular basis in all rows and columns of $A$.
‘DOUBLE-PASS’	crash is called twice (if there are nonlinear constraints). The first call looks for a triangular basis in linear rows, and the iteration proceeds with simplex iterations until the linear constraints are satisfied. The Jacobian is then evaluated for the first major iteration and crash is called again to find a triangular basis in the nonlinear rows (retaining the current basis for linear rows).
‘TRIPLE-PASS’	crash is called up to three times (if there are nonlinear constraints). The first two calls treat linear equalities and linear inequalities separately. As before, the last call treats nonlinear rows before the first major iteration.

If $\text{‘SSQP Crash Option'}\ne \text{'ONLY-SLACKS'}$, certain slacks on inequality rows are selected for the basis first, furthermore if $\text{‘SSQP Crash Option'}=\text{'DOUBLE-PASS'}$ or $\text{'TRIPLE-PASS'}$, numerical values are used to exclude slacks that are close to a bound. crash then makes several passes through the columns of $A$, searching for a basis matrix that is essentially triangular. A column is assigned to pivot on a particular row if the column contains a suitably large element in a row that has not yet been assigned (the pivot elements ultimately form the diagonals of the triangular basis. For remaining unassigned rows, slack variables are inserted to complete the basis.

Note: Each crash pass is counted as a minor iteration..

Constraint: $\text{‘SSQP Crash Option'}=\text{'ONLY-SLACKS'}$, $\text{'SINGLE-PASS'}$, $\text{'DOUBLE-PASS'}$ or $\text{'TRIPLE-PASS'}$.

‘SSQP Crash Tolerance’float

Default $=0.1$

The ‘SSQP Crash Tolerance’ $r$ allows the starting procedure crash to ignore certain small nonzeros in each column of $A$ (see (5) in Major Iterations). If $a_{max}$ is the largest element in column $j$, other nonzeros $a_{ij}$ in the column are ignored if $\left|a_{ij}\right|\le a_{max}\times r$. To be meaningful, $r$ needs to be in the range $0\le r\le 1$.)

When $r>0$, the basis obtained by crash may not be strictly triangular, but it is likely to be nonsingular and almost triangular. The intention is to obtain a starting basis containing more columns of $A$ and fewer (arbitrary) slacks (columns of $-I$). A feasible solution may be reached sooner on some problems.

When $r=-1$ (or $r<0$) the solver will automatically choose an appropriate tolerance.

Constraint: ‘SSQP Crash Tolerance’$\ge 0$ or ‘SSQP Crash Tolerance’$=-1.0$.

‘SSQP Estimate Derivatives’str

Default $=\text{'NO'}$

This option specifies which nonlinear function gradients (objective and nonlinear constraints) are known analytically and will be supplied to the solver by you functions $objgrd$ and $congrd$. This option has the following alternatives:

$a$	Meaning
‘NO’ (default)	Indicates to the solver that you are providing full derivative information, that is, all objective and constraint gradients are known.
‘ONLYOBJ’	Indicates that some or all components of the objective gradient will be missing but all constraint gradients are known.
‘ONLYCON’	Conversely to ‘ONLYOBJ’, this indicated that some or all of the constraint gradients will be missing but the objective gradient is known.
‘YES’	Indicates that the user is not providing derivatives.

The value $\text{‘SSQP Estimate Derivatives'}=\text{'NO'}$ should be used whenever possible. It is the most reliable and will usually be the most efficient.

If $\text{‘SSQP Estimate Derivatives'}=\text{'YES'}$ or $\text{'ONLYOBJ'}$, handle_solve_ssqp will estimate the missing components of the objective gradient, using finite differences. This may simplify the coding of function $objgrd$. However, it could increase the total run-time substantially (since a special call to $objfun$ is required for each missing element), and there is less assurance that an acceptable solution will be located. If the nonlinear variables are not well scaled, it may be necessary to specify a nonstandard difference interval changing ‘SSQP Finite Diff Ctrl Interval’ or ‘SSQP Finite Diff Interval’.

Conversely, if $\text{‘SSQP Estimate Derivatives'}=\text{'YES'}$ or $\text{'ONLYCON'}$, handle_solve_ssqp will estimate missing elements of the Jacobian. For each column of the Jacobian, one call to $confun$ is needed to estimate all missing elements in that column, if any.

At times, central differences are used rather than forward differences. Twice as many calls to $objfun$ and $confun$ are then needed. (This is not under your control.)

Note: If $\text{‘SSQP Estimate Derivatives'}=\text{'NO'}$, $\text{'ONLYCON'}$ or $\text{'ONLYOBJ'}$ and the user does not provide one or more of the required gradient (or Jacobian) elements then these will be assumed to be constant, this might not be the desired behaviour. Under this circumstance, handle_solve_ssqp will inform the user with a message.

Constraint: $\text{‘SSQP Estimate Derivatives'}=\text{'NO'}$, $\text{'ONLYOBJ'}$, $\text{'ONLYCON'}$ or $\text{'YES'}$.

‘SSQP Finite Diff Ctrl Interval’float

Default $\approx 1.7\times {ϵ}^{0.27}$

When $\text{‘SSQP Estimate Derivatives'}=\text{'YES'}$, $\text{'ONLYOBJ'}$ or $\text{'ONLYCON'}$, the central-difference interval $r$ is used near an optimal solution to obtain more accurate (but more expensive) estimates of gradients. Twice as many function evaluations are required compared to forward differencing. The interval used for the $j$th variable is $h_j=r(1+\left|x_j\right|)$. The resulting derivative estimates should be accurate to $O\left(r^2\right)$, unless the functions are badly scaled.

Constraint: $0<r<0.1$.

‘SSQP Finite Diff Interval’float

Default $\approx 1.7\times {ϵ}^{0.4}$

This alters the interval $r$ used to estimate gradients by forward differences. It does so in the following circumstances:

• in the ‘cheap’ phase of verifying the problem derivatives, when $\text{‘Verify Derivatives'}=\text{'CHEAP'}$;

• for verifying the problem derivatives ($\text{‘Verify Derivatives'}=\text{'YES'}$);

• for estimating missing derivatives.

In all cases, a derivative with respect to $x_j$ is estimated by perturbing that component of $x$ to the value $x_j+r(1+\left|x_j\right|)$, and then evaluating the objective or constraint functions at the perturbed point. The resulting gradient estimates should be accurate to $O\left(r\right)$ unless the functions are badly scaled. Judicious alteration of $r$ may sometimes lead to greater accuracy.

Constraint: $0<r<0.1$.

‘SSQP Function Precision’float

Default $\approx 1.7\times {ϵ}^{0.8}$

The relative function precision ${ϵ}_r$ is intended to be a measure of the relative accuracy with which the nonlinear functions can be computed. For example, if $f\left(x\right)$ is computed as $1000.56789$ for some relevant $x$ and if the first $6$ significant digits are known to be correct, the appropriate value for ${ϵ}_r$ would be $1.0e-6$.

Ideally, the functions $f\left(x\right)$ and $g_i\left(x\right)$ should have a magnitude of order $1$. If all functions are substantially less than $1$ in magnitude, ${ϵ}_r$ should be the absolute precision. For example, if $f\left(x\right)=1.23456789e-4$ at some point and if the first $6$ significant digits are known to be correct, the appropriate value for ${ϵ}_r$ would be $1.0e-10$.)

The default value of ${ϵ}_r$ is appropriate for simple analytic functions.

In some cases the function values will be the result of extensive computation, possibly involving a costly iterative procedure that can provide few digits of precision. Specifying an appropriate ‘SSQP Function Precision’ may lead to savings, by allowing the linesearch procedure to terminate when the difference between function values along the search direction becomes as small as the absolute error in the values.

Constraint: $0<{ϵ}_r<0.1$.

‘SSQP Hessian’str

Default $=\text{'AUTO'}$

This option selects the method for storing and updating the approximate Hessian. (handle_solve_ssqp uses a quasi-Newton approximation to the Hessian of the Lagrangian. A BFGS update is applied after each major iteration.)

If $\text{‘SSQP Hessian'}=\text{'FULL-MEMORY'}$ is specified, the approximate Hessian is treated as a dense matrix and the BFGS updates are applied explicitly. This option is most efficient when the number of variables $n$ is not too large (say, less than $75$). In this case, the storage requirement is fixed and one can expect $1$-step Q-superlinear convergence to the solution.

$\text{‘SSQP Hessian'}=\text{'LIMITED-MEMORY'}$ should be used on problems where $n$ is very large. In this case, a limited-memory procedure is used to update a diagonal Hessian approximation $H_r$ a limited number of times. Updates are accumulated as a list of vector pairs. They are discarded at regular intervals after $H_r$ has been reset to their diagonal, see option ‘SSQP Hessian Updates’.

If $\text{‘SSQP Hessian'}=\text{'AUTO'}$ is specified, then the quasi-Newton method used is chosen based on a heuristic involving the number of nonlinear variables (see Note regarding nonlinear functions) in the problem.

Constraint: $\text{‘SSQP Hessian'}=\text{'AUTO'}$, $\text{'FULL-MEMORY'}$ or $\text{'LIMITED-MEMORY'}$.

‘SSQP Hessian Updates’int

Default $=10$

If option $\text{‘SSQP Hessian'}=\text{'LIMITED-MEMORY'}$ is in effect and $i$ BFGS updates have already been carried out, all but the diagonal elements of the accumulated updates are discarded and the updating process starts again.

Broadly speaking, the more updates stored, the better the quality of the approximate Hessian. However, the more vectors stored, the greater the cost of each QP iteration. The default value is likely to give a robust algorithm without significant expense, but faster convergence can sometimes be obtained with significantly fewer updates (e.g., $i=5$).

Constraint: $0<\text{‘SSQP Hessian Updates'}$.

‘SSQP Iteration Limit’int

Default $=max(10000,10max(\text{nvar},m))$

The value of $i$ specifies the maximum number of minor iterations allowed (i.e., iterations of the simplex method or the QP algorithm), summed over all major iterations. (See also the description of the option ‘SSQP Minor Iteration Limit’.) For the default value, $m$ is the number of linear, quadratic and nonlinear constraints defined in the model.

Constraint: $0<\text{‘SSQP Iteration Limit'}$.

‘SSQP Major Feasibility Tol’float

Default $\approx {ϵ}^{0.38}$

This tolerance, $r$, specifies how accurately the nonlinear constraints should be satisfied. The default value is appropriate when the linear and nonlinear constraints contain data to about that accuracy.

Let $v_{max}$ be the maximum nonlinear constraint violation, normalized by the size of the solution, which is required to satisfy

$$v_{max}={max}_i{v}_i/\parallel x\parallel \le r\text{,}$$

where $v_{\text{i}}$ is the violation of the $\text{i}$th nonlinear constraint, for $\text{i}=1,2,\dots ,ncnln$.

In the major iteration log (see Description of the Printed Output), $v_{max}$ appears as the quantity labelled ‘Feasible’. If some of the problem functions are known to be of low accuracy, a larger ‘SSQP Major Feasibility Tol’ may be appropriate.

Constraint: $0<r\le 0.1$.

‘SSQP Major Iteration Limit’int

Default $=max(1000,3max(\text{nvar},m))$

This is the maximum number of major iterations allowed. It is intended to guard against an excessive number of linearizations of the constraints. For the default value, $m$ is the number of linear, quadratic and nonlinear constraints defined in the model.

Constraint: $0<\text{‘SSQP Major Iteration Limit'}$.

‘SSQP Major Optimality Tol’float

Default $\approx {ϵ}^{0.38}$

This tolerance, $r$, specifies the final accuracy of the dual variables. On successful termination, handle_solve_ssqp will have computed a solution $(x,s,\pi )$ such that

$$c_{max}={max}_j{c}_j/\parallel \pi \parallel \le r\text{,}$$

where $c_{\text{j}}$ is an estimate of the complementarity slackness for variable $\text{j}$, for $\text{j}=1,2,\dots ,n+m$. Here $m$ represents the number of constraints. The values $c_i$ are computed from the final QP solution using the reduced gradients $d_j=g_j-{\pi }^T{a}_j$ (where $g_j$ is the $j$th component of the objective gradient, $a_j$ is the associated column of the constraint matrix $\left(\begin{array}{cc}A& -I\end{array}\right)$, and $\pi$ is the set of QP dual variables):

$$\begin{array}{c}{c}_j=\left\{\begin{array}{cc}{d}_{j}min(x_j-l_j,1)& \text{if}{d}_j\ge 0\text{;}\\ -d_{j}min(u_j-x_j,1)& \text{if}{d}_j<0\text{.}\end{array}\right)\end{array}$$

In the major iteration log, $c_{max}$ appears as the quantity labelled ‘Optimal’, See section Major Iteration Log.

Constraint: $0<r\le 0.1$.

‘SSQP Minor Feasibility Tol’float

Default $\approx {ϵ}^{0.38}$

handle_solve_ssqp tries to ensure that all variables eventually satisfy their upper and lower bounds to within this tolerance, $r$. This includes slack variables. Hence, general linear constraints should also be satisfied to within $r$.

Feasibility with respect to nonlinear constraints is judged by the option ‘SSQP Major Feasibility Tol’ (not by ‘SSQP Minor Feasibility Tol’).

If the bounds and linear constraints cannot be satisfied to within $r$, the problem is declared infeasible. If $rinfo$$\left(12\right)$ is quite small, it may be appropriate to raise $r$ by a factor of $10$ or $100$. Otherwise, some error in the data should be suspected.

Nonlinear functions will be evaluated only at points that satisfy the bounds and linear constraints, except perhaps in presolve where the solver may require to evaluate $confun$, $objgrd$ or $congrd$ at a bound-feasible point. If there are regions where a function is undefined, every attempt should be made to eliminate these regions from the problem.

For example, if $f\left(x\right)=\sqrt{x_1}+\log \left(x_2\right)$, it is essential to place lower bounds on both variables. If $r=1.0e-6$, the bounds $x_1\ge {10}^{-5}$ and $x_2\ge {10}^{-4}$ might be appropriate. (The log singularity is more serious. In general, keep $x$ as far away from singularities as possible.)

If $\text{‘SSQP Scale Option'}=\text{'ALL'}$ or $\text{'VARS AND LC'}$, feasibility is defined in terms of the scaled problem (since it is then more likely to be meaningful).

In reality, handle_solve_ssqp uses $r$ as a feasibility tolerance for satisfying the bounds on $x$ and $s$ in each QP subproblem. If the sum of infeasibilities cannot be reduced to zero, the QP subproblem is declared infeasible. handle_solve_ssqp then activates elastic mode for the rest of the solving process (with only the linearized nonlinear constraints defined to be elastic). For further details see Treatment of Constraint Infeasibilities.

Constraint: $0<r\le 0.1$.

‘SSQP Minor Iteration Limit’int

Default $=500$

If the number of minor iterations for the optimality phase of the QP subproblem exceeds $i$, then all nonbasic QP variables that have not yet moved are frozen at their current values and the reduced QP is solved to optimality.

Note that more than $i$ minor iterations may be necessary to solve the reduced QP to optimality. These extra iterations are necessary to ensure that the terminated point gives a suitable direction for the linesearch.

In the major iteration log (see Description of the Printed Output) the flag t at the end of a line indicates that the corresponding QP was artificially terminated using the limit $i$.

Compare with the option ‘SSQP Iteration Limit’, which defines an independent absolute limit on the total number of minor iterations (summed over all QP subproblems).

Constraint: $0<\text{‘SSQP Minor Iteration Limit'}$.

‘SSQP Monitor Frequency’int

Default $=0$

This argument specifies the frequency on which to call the monitor function $monit$. If zero, the monitor function will not be called.

Constraint: $\text{‘SSQP Monitor Frequency'}\ge 0$.

‘SSQP Penalty Parameter’float

Default $=0.0$

Defines the initial value of the penalty parameter and sets $D=\text{diag}\left(r\right)$ in (8).

Constraint: $0.0\le \text{‘SSQP Penalty Parameter'}$.

‘SSQP Print Frequency’int

Default $=1$

Defines how frequently to print log information for the inner iterations. Only relevant if ‘Print Level’$\ge 3$ (with ‘Print File’$\ne -1$) or ‘Monitoring Level’$\ge 3$ (with ‘Monitoring File’$\ne -1$)

Constraint: $0\le \text{‘SSQP Print Frequency'}$.

‘SSQP Scale Option’str

Default $=\text{'NONE'}$

Three scale options are available as follows:

$a$	Meaning
‘NONE’	No scaling. This is recommended if it is known that $x$ and the constraint matrix never have very large elements (say, larger than $100$).
‘VARS AND LC’	The constraints and variables are scaled by an iterative procedure that attempts to make the matrix coefficients as close as possible to $1.0$ (see Fourer (1982)). This will sometimes improve the performance of the solution procedures.
‘ALL’	The constraints and variables are scaled by the iterative procedure. Also, a certain additional scaling is performed that may be helpful if the right-hand side $b$ or the solution $x$ is large. This takes into account columns of $\left(\begin{array}{cc}A& -I\end{array}\right)$ that are fixed or have positive lower bounds or negative upper bounds.

Constraint: $\text{‘SSQP Scale Option'}=\text{'NONE'}$, $\text{'VARS AND LC'}$ or $\text{'ALL'}$.

‘SSQP Scale Print’str

Default $=\text{'NO'}$

Defines whether to print the row scales $r\left(i\right)$ and column scales $c\left(j\right)$. The scaled matrix coefficients are ${\overline{a}}_{ij}=a_{ij}c\left(j\right)/r\left(i\right)$ and the scaled bounds on the variables and slacks are ${\overline{l}}_j=l_j/c\left(j\right)$, ${\overline{u}}_j=u_j/r(j-n)$ if $j>n$.

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

‘SSQP Scale Tolerance’float

Default $=0.9$

This argument affects how many passes might be needed through the constraint matrix. On each pass, the scaling procedure computes the ratio of the largest and smallest nonzero coefficients in each column:

$${\rho }_j={max}_j\left|a_{ij}\right|/{min}_i\left|a_{ij}\right|(a_{ij}\ne 0)\text{.}$$

If ${max}_j{\rho }_j$ is less than $r$ times its previous value, another scaling pass is performed to adjust the row and column scales. Raising $r$ from $0.9$ to $0.99$ (say) usually increases the number of scaling passes through $A$. At most $10$ passes are made. The value of $r$ should lie in the range $0<r<1$.

Constraint: $ϵ\le \text{‘SSQP Scale Tolerance'}$.

‘SSQP Start Type’str

Default $=\text{'COLD'}$

Defines whether to perform a cold or warm start. If warm start data is not provided or is considered to have an unexpected size or content, then the solver will revert to perform a cold start on the problem. See Warm Starting on how to correctly warm start a problem.

Constraint: $\text{‘SSQP Start Type'}=\text{'COLD'}$ or $\text{'WARM'}$.

‘SSQP Superbasics Limit’int

Default $=-1$

This option places a limit on the storage allocated for superbasic variables. Ideally, $i$ should be set slightly larger than the ‘number of degrees of freedom’ expected at an optimal solution. For nonlinear problems, the number of degrees of freedom is often called the ‘number of independent variables’. Normally, $i$ need not be greater than $n+1$.

If $i=-1$ (the default), then handle_solve_ssqp automatically sets the limit to the number of nonlinear variables. For many problems, $i$ may be considerably smaller than $n$. This will save storage if $n$ is very large.

If the limit set is too low then the solver will terminate with $errno$ = 27 error message.

Constraint: $-1\le \text{‘SSQP Superbasics Limit'}$.

‘Stats Time’str

Default $=\text{'NO'}$

This argument allows you to turn on the 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. It is possible to choose between CPU and wall clock time. Choice ‘YES’ is equivalent to ‘WALL CLOCK’.

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

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

This argument specifies a limit in seconds that the solver can use to solve one problem. If during the convergence check this limit is exceeded, the solver will terminate with $errno$ = 23 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 gradient functions $objgrd$ and $congrd$. If any discrepancies are found, $errno$ = 26 is returned. It is recommended that such checks are enabled when first developing the formulation of the problem, however, the verification process results in a significant increase in the number of the function evaluations and thus it shouldn’t be used in production code.

a	Meaning
$\text{'CHEAP'}$	Only a ‘cheap’ test will be performed.
$\text{'YES'}$	Individual columns of the problem Jacobian, as well as individual gradient elements, will be checked (with a more reliable test). A key of the form OK or Bad? indicates whether or not each component appears to be correct.
$\text{'NO'}$	Derivative checking is disabled.

$\text{‘Verify Derivatives'}=\text{'YES'}$ should be specified whenever a new $objgrd$ or $congrd$ is being developed.

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

Raises

NagValueError

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

Please provide a proper $hess$ function.

Warns

NagAlgorithmicWarning

(errno $20$)

User requested termination during a monitoring step.

(errno $50$)

Problem was solved to an acceptable level, full accuracy was not achieved.

(errno $51$)

The problem was found to be infeasible during preprocessing.

(errno $53$)

The problem seems to be infeasible, the algorithm was stopped.

(errno $54$)

The problem seems to be unbounded and the algorithm was stopped.

NagAlgorithmicMajorWarning

(errno $21$)

The current starting point is unusable.

(errno $22$)

Maximum number of iterations reached.

(errno $23$)

The solver terminated after the maximum time allowed was exhausted.

(errno $24$)

The solver was terminated because no further progress could be achieved.

(errno $25$)

Invalid value detected in user function and recovery failed.

(errno $26$)

User-provided derivatives are likely to be incorrect.

(errno $27$)

Maximum number of superbasic variables reached. Increase value of the option ‘SSQP Superbasics Limit’.

(errno $90$)

Memory limit is too small.

Notes

handle_solve_ssqp is designed to minimize (maximize) a linear or nonlinear function possibly subject to a set of constraints including bounds on the variables and sparse linear and nonlinear constraints. It is suitable for large-scale general nonlinear programming (NLP) problems, as well as for linearly constrained optimization. It is particularly efficient if only some of the variables enter nonlinearly, or there are relatively few degrees of freedom at a solution (i.e., many constraints are active). However, there is no limit on the number of degrees of freedom.

handle_solve_ssqp solves a nonlinear programming problem in the following form

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

handle_solve_ssqp serves as a solver for problems stored as a handle. The handle points to an internal data structure which defines the problem and serves as a means of communication for functions in the NAG optimization modelling suite. First, the problem handle is initialized, typically by calling handle_init(). Then some of the components of the model need to be defined by calling one or more of the following routines based on the component type:

the objective function $f\left(x\right)$: linear (handle_set_linobj() or handle_set_quadobj()), quadratic (handle_set_quadobj(), handle_set_qconstr() or handle_set_qconstr_fac()) or nonlinear (handle_set_nlnobj()),

bound constraints on the variables $l_x,u_x$ (handle_set_simplebounds()),

one or more blocks of linear constraints $l_B,B,u_B$ (handle_set_linconstr()),

quadratic constraints (handle_set_qconstr() and handle_set_qconstr_fac() for quadratics in a factorized form),

general nonlinear constraints $l_g,g\left(x\right),u_g$ (handle_set_nlnconstr()).

Once the problem is fully described, the handle may be passed to the solver handle_solve_ssqp. When the handle is no longer needed, handle_free() should be called to destroy it and deallocate the memory held within. There are other ways that the problem model can be defined and/or updated, see the E04 Introduction for more details about the NAG optimization modelling suite.

The algorithm behaviour can be modified by various options (see Other Parameters) which can be set by handle_opt_set() and handle_opt_set_file() anytime between the initialization of the handle and a call to the solver. Once the solver has finished, options or the model may be modified for the next solve. The solver may be called repeatedly with various starting points and/or options. Option getter handle_opt_get() can be called to retrieve the current value of any option.

The option ‘Task’ may be used to switch the problem to maximization.

In certain situations the solver can be sped up by warm starting, see Warm Starting and option ‘SSQP Start Type’ for details.

Several options may have a significant impact on the performance of the solver. Even if the defaults were chosen to suit the majority of problems, it is recommended that you experiment in order to find the most suitable set of options for a particular problem, see Algorithmic Details and Other Parameters for further details.

Note regarding nonlinear functions

In the presence of a nonlinear objective function or constraint function, the structure (sparsity pattern) of these functions are defined by handle_set_nlnobj() and handle_set_nlnconstr() respectively; the function values and the first derivatives (gradients) are computed at requested points by the corresponding supplied functions $objfun$, $objgrd$, $confun$ and $congrd$. Ideally, the first derivatives should be known and coded but handle_solve_ssqp estimates any missing ones by finite differences, see ‘SSQP Estimate Derivatives’.

The solver can strongly benefit from the correct identification of linear variables; these are the variables which appear only in linear expressions in the whole optimization model. The solver cannot autodetect if any variable present in nonlinear constraints or the nonlinear objective is linear thus there is a mechanism to declare the variable as linear by handle_set_property() and it is highly recommended to do so whenever possible. See Linearity of the Variables for handle_set_property for a detailed explanation and examples. The main advantage is that linear variables have constant first partial derivatives and must be zero in second derivatives, thus the internal approximation of the Hessian doesn’t need to take them into account which speeds up the solver.

Alternative solvers

handle_solve_ssqp is a generic solver which can solve a great variety of problems, however, a dedicated solver might work better in the following cases. See the E04 Introduction.

If $f\left(x\right)$ is linear, $m_Q=0$, and $g\left(x\right)$ is absent, (1) is a linear program (LP) and handle_solve_lp_ipm() is recommended.

If the problem is a convex quadratic or quadratically constrained problem, try handle_solve_socp_ipm().

If the problem is unconstrained or only box-constrained, see handle_solve_bounds_foas(), or handle_solve_dfno() if the problem is small and derivatives cannot be provided.

A general nonlinear problem lacking the sparse structure (which is typically the case for problems with a relatively small number of variables and constraints) might be better handled by nlp1_solve() or nlp2_solve().

An alternative solver for the same class of problems but based on a different algorithm (interior point method) is handle_solve_ipopt(), see the E04 Introduction for a discussion of the advantages of each approach.

References

Dantzig, G B, 1963, Linear Programming and Extensions, Princeton University Press

Eldersveld, S K, 1991, Large-scale sequential quadratic programming algorithms, PhD Thesis, Department of Operations Research, Stanford University, Stanford

Fourer, R, 1982, Solving staircase linear programs by the simplex method, Math. Programming (23), 274–313

Gill, P E, Murray, W and Saunders, M A, 2002, SNOPT: An SQP Algorithm for Large-scale Constrained Optimization (12), 979–1006, SIAM J. Optim.

Gill, P E, Murray, W and Saunders, M A, 2015, Users’ guide for SNOPT 7.5: Software for large-scale linear nonlinear programming, Report SNOPT, Department of Mathematics, University of California, San Diego, https://www.ccom.ucsd.edu/~peg/papers/sndoc7.pdf

Gill, P E, Murray, W and Saunders, M A, 2016, Users’ guide for SQOPT 7.5: Software for large-scale linear and quadratic programming, Report SQOPT, Department of Mathematics, University of California, San Diego, https://www.ccom.ucsd.edu/~peg/papers/sqdoc7.pdf

Gill, P E, Murray, W, Saunders, M A and Wright, M H, 1986, Users’ guide for NPSOL (Version 4.0): a Fortran package for nonlinear programming, Report SOL 86-2, Department of Operations Research, Stanford University

Gill, P E, Murray, W, Saunders, M A and Wright, M H, 1987, Maintaining $LU$ factors of a general sparse matrix, Linear Algebra and its Applics. (88/89), 239–270

Gill, P E, Murray, W, Saunders, M A and Wright, M H, 1992, Some theoretical properties of an augmented Lagrangian merit function, Advances in Optimization and Parallel Computing, (ed P M Pardalos), 101–128, North Holland

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

Murtagh, B A and Saunders, M A, 1978, Large-scale linearly constrained optimization, 14, 41–72, Math. Programming

Murtagh, B A and Saunders, M A, 1982, A projected Lagrangian algorithm and its implementation for sparse nonlinear constraints, Math. Program. Stud. (16), 84–118

Murtagh, B A and Saunders, M A, 1995, MINOS 5.4 users’ guide, Report SOL 83-20R, Department of Operations Research, Stanford University

See also

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