naginterfaces.library.opt.nlp1_​sparse_​solve

naginterfaces.library.opt.nlp1_sparse_solve(m, ncnln, nonln, njnln, iobj, a, ha, ka, bl, bu, start, names, ns, xs, istate, clamda, comm, confun=None, objfun=None, leniz=None, lenz=500, data=None, io_manager=None)

nlp1_sparse_solve solves sparse nonlinear programming problems.

Note: this function uses optional algorithmic parameters, see also: nlp1_sparse_option_file(), nlp1_sparse_option_string(), nlp1_init().

Deprecated since version 28.3.0.0: nlp1_sparse_solve is deprecated. Please use handle_solve_ssqp() instead. See also the Replacement Calls document.

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

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

Parameters

mint

$m$, the number of general constraints (or slacks). This is the number of rows in $A$, including the free row (if any; see $iobj$). Note that $A$ must contain at least one row. If your problem has no constraints, or only upper and lower bounds on the variables, then you must include a dummy ‘free’ row consisting of a single (zero) element subject to ‘infinite’ upper and lower bounds. Further details can be found under the descriptions for $iobj$, $\text{nnz}$, $a$, $ha$, $ka$, $bl$ and $bu$.

ncnlnint

$n_N$, the number of nonlinear constraints.

nonlnint

$n_1^{\prime }$, the number of nonlinear objective variables. If the objective function is nonlinear, the leading $n_1^{\prime }$ columns of $A$ belong to the nonlinear objective variables. (See also the description for $njnln$.)

njnlnint

$n_1^{\prime \prime }$, the number of nonlinear Jacobian variables. If there are any nonlinear constraints, the leading $n_1^{\prime \prime }$ columns of $A$ belong to the nonlinear Jacobian variables. If $n_1^{\prime }>0$ and $n_1^{\prime \prime }>0$, the nonlinear objective and Jacobian variables overlap. The total number of nonlinear variables is given by $\overline{n}=max(n_1^{\prime },n_1^{\prime \prime })$.

iobjint

If $iobj>ncnln$, row $iobj$ of $A$ is a free row containing the nonzero elements of the linear part of the objective function.

$iobj=0$

There is no free row.

$iobj=-1$

There is a dummy ‘free’ row.

afloat, array-like, shape $\left(\text{nnz}\right)$

The nonzero elements of the Jacobian matrix $A$, ordered by increasing column index. Since the constraint Jacobian matrix $J\left(x^{\prime \prime }\right)$ must always appear in the top left-hand corner of $A$, those elements in a column associated with any nonlinear constraints must come before any elements belonging to the linear constraint matrix $G$ and the free row (if any; see $iobj$).

In general, $a$ is partitioned into a nonlinear part and a linear part corresponding to the nonlinear variables and linear variables in the problem.

Elements in the nonlinear part may be set to any value (e.g., zero) because they are initialized at the first point that satisfies the linear constraints and the upper and lower bounds.

If $\text{‘Derivative Level'}=2$ or $3$, the nonlinear part may also be used to store any constant Jacobian elements.

Note that if $confun$ does not define the constant Jacobian element $fjac[i-1]$, then the missing value will be obtained directly from $a\left[j\right]$ for some $j\ge i$.

If $\text{‘Derivative Level'}=0$ or $1$, unassigned elements of $fjac$ are not treated as constant; they are estimated by finite differences, at nontrivial expense.

The linear part must contain the nonzero elements of $G$ and the free row (if any).

If $iobj=-1$, set $a\left[0\right]=0$.

Elements with the same row and column indices are not allowed. (See also the descriptions for $ha$ and $ka$.)

haint, array-like, shape $\left(\text{nnz}\right)$

$ha[\text{i}-1]$ must contain the row index of the nonzero element stored in $a[\text{i}-1]$, for $\text{i}=1,2,\dots ,\text{nnz}$. The row indices for a column may be supplied in any order subject to the condition that those elements in a column associated with any nonlinear constraints must appear before those elements associated with any linear constraints (including the free row, if any). Note that $confun$ must define the Jacobian elements in the same order. If $iobj=-1$, set $ha\left[0\right]=1$.

kaint, array-like, shape $(n+1)$

$ka[\text{j}-1]$ must contain the index in $a$ of the start of the $\text{j}$th column, for $\text{j}=1,2,\dots ,n$. To specify the $\text{j}$th column as empty, set $ka[\text{j}-1]=ka\left[\text{j}\right]$. Note that the first and last elements of $ka$ must be such that $ka\left[0\right]=1$ and $ka\left[n\right]=\text{nnz}+1$. If $iobj=-1$, set $ka[\text{j}-1]=2$, for $\text{j}=2,3,\dots ,n$.

blfloat, array-like, shape $(n+m)$

$l$, the lower bounds for all the variables and general constraints, in the following order. The first $\text{n}$ elements of $bl$ must contain the bounds on the variables $x$, the next $ncnln$ elements the bounds for the nonlinear constraints $F\left(x\right)$ (if any) and the next ($m-ncnln$) elements the bounds for the linear constraints $Gx$ and the free row (if any). To specify a nonexistent lower bound (i.e., $l_j=-\infty$), set $bl[j-1]\le -\text{bigbnd}$. To specify the $j$th constraint as an equality, set $bl[j-1]=bu[j-1]=\beta$, say, where $\left|\beta \right|<\text{bigbnd}$. If $iobj=-1$, set $bl[n+abs\left(iobj\right)-1]\le -\text{bigbnd}$.

bufloat, array-like, shape $(n+m)$

$u$, the upper bounds for all the variables and general constraints, in the following order. The first $\text{n}$ elements of $bu$ must contain the bounds on the variables $x$, the next $ncnln$ elements the bounds for the nonlinear constraints $F\left(x\right)$ (if any) and the next ($m-ncnln$) elements the bounds for the linear constraints $Gx$ and the free row (if any). To specify a nonexistent upper bound (i.e., $u_j=+\infty$), set $bu[j-1]\ge \text{bigbnd}$. To specify the $j$th constraint as an equality, set $bu[j-1]=bl[j-1]=\beta$, say, where $\left|\beta \right|<\text{bigbnd}$. If $iobj=-1$, set $bu[n+abs\left(iobj\right)-1]\ge \text{bigbnd}$.

startstr, length 1

Indicates how a starting basis is to be obtained.

$start=\text{'C'}$

An internal Crash procedure will be used to choose an initial basis.

$start=\text{'W'}$

A basis is already defined in $istate$ and $ns$ (probably from a previous call).

namesstr, length 8, array-like, shape $\left(\text{nname}\right)$

Specifies the column and row names to be used in the printed output.

If $\text{nname}=1$, $names$ is not referenced and the printed output will use default names for the columns and rows.

If $\text{nname}=n+m$, the first $\text{n}$ elements must contain the names for the columns, the next $ncnln$ elements must contain the names for the nonlinear rows (if any) and the next $(m-ncnln)$ elements must contain the names for the linear rows (if any) to be used in the printed output.

Note that the name for the free row or dummy ‘free’ row must be stored in $names[n+abs\left(iobj\right)-1]$.

nsint

$n_S$, the number of superbasics. It need not be specified if $start=\text{'C'}$, but must retain its value from a previous call when $start=\text{'W'}$.

xsfloat, array-like, shape $(n+m)$

The initial values of the variables and slacks $(x,s)$. (See the description for $istate$.)

istateint, array-like, shape $(n+m)$

If $start=\text{'C'}$, the first $\text{n}$ elements of $istate$ and $xs$ must specify the initial states and values, respectively, of the variables $x$. (The slacks $s$ need not be initialized.) An internal Crash procedure is then used to select an initial basis matrix $B$. The initial basis matrix will be triangular (neglecting certain small elements in each column). It is chosen from various rows and columns of $\left(\begin{array}{cc}A& -I\end{array}\right)$. Possible values for $istate[j-1]$ are as follows:

$istate[j-1]$	State of $xs[j-1]$ during Crash procedure
$0$ or $1$	Eligible for the basis
$2$	Ignored
$3$	Eligible for the basis (given preference over $0$ or $1$)
$4$ or $5$	Ignored

If nothing special is known about the problem, or there is no wish to provide special information, you may set $istate[\text{j}-1]=0$ and $xs[\text{j}-1]=0.0$, for $\text{j}=1,2,\dots ,n$.

All variables will then be eligible for the initial basis.

Less trivially, to say that the $j$th variable will probably be equal to one of its bounds, set $istate[j-1]=4$ and $xs[j-1]=bl[j-1]$ or $istate[j-1]=5$ and $xs[j-1]=bu[j-1]$ as appropriate.

Following the Crash procedure, variables for which $istate[j-1]=2$ are made superbasic.

Other variables not selected for the basis are then made nonbasic at the value $xs[j-1]$ if $bl[j-1]\le xs[j-1]\le bu[j-1]$, or at the value $bl[j-1]$ or $bu[j-1]$ closest to $xs[j-1]$.

If $start=\text{'W'}$, $istate$ and $xs$ must specify the initial states and values, respectively, of the variables and slacks $(x,s)$.

If the function has been called previously with the same values of $\text{n}$ and $m$, $istate$ already contains satisfactory information.

clamdafloat, array-like, shape $(n+m)$

If $ncnln>0$, $clamda[\text{j}-1]$ must contain a Lagrange multiplier estimate for the $\text{j}$th nonlinear constraint $F_{\text{j}}\left(x\right)$, for $\text{j}=n+1,\dots ,n+ncnln$. If nothing special is known about the problem, or there is no wish to provide special information, you may set $clamda[j-1]=0.0$. The remaining elements need not be set.

commdict, communication object, modified in place

Communication structure.

This argument must have been initialized by a prior call to nlp1_init().

confunNone or callable (mode, f, fjac) = confun(mode, ncnln, x, fjac, nstate, data=None), optional

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

$confun$ must calculate the vector $F\left(x\right)$ of nonlinear constraint functions and (optionally) its Jacobian $(=\frac{\partial F}{\partial x})$ for a specified $n_1^{\prime \prime }$ ($\le n$) element vector $x$.

If there are no nonlinear constraints (i.e., $ncnln=0$), $confun$ will never be called by nlp1_sparse_solve and $confun$ may be None. If there are nonlinear constraints, the first call to $confun$ will occur before the first call to $objfun$.

Parameters

modeint

Indicates which values must be assigned during each call of $confun$. Only the following values need be assigned:

$mode=0$

$f$.

$mode=1$

All available elements of $fjac$.

$mode=2$

$f$ and all available elements of $fjac$.

ncnlnint

$n_N$, the number of nonlinear constraints. These must be the first $ncnln$ constraints in the problem.

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

$x$, the vector of nonlinear Jacobian variables at which the nonlinear constraint functions and/or the available elements of the constraint Jacobian are to be evaluated.

fjacfloat, ndarray, shape $\left(\text{nnzjac}\right)$

The elements of $fjac$ are set to special values which enable nlp1_sparse_solve to detect whether they are changed by $confun$.

nstateint

If $nstate=1$, then nlp1_sparse_solve is calling $confun$ for the first time. This argument setting allows you to save computation time if certain data must be read or calculated only once.

If $nstate\ge 2$, nlp1_sparse_solve is calling $confun$ for the last time.

This argument setting allows you to perform some additional computation on the final solution.

In general, the last call to $confun$ is made with $nstate=2+\text{errno}$ (see Exceptions).

Otherwise, $nstate=0$.

dataarbitrary, optional, modifiable in place

User-communication data for callback functions.

Returns

modeint

You may set to a negative value as follows:

$mode\le -2$

The solution to the current problem is terminated and in this case nlp1_sparse_solve will terminate with $\text{errno}$ set to $mode$.

$mode=-1$

The nonlinear constraint functions cannot be calculated at the current $x$. nlp1_sparse_solve will then terminate with $errno$ = -1 unless this occurs during the linesearch; in this case, the linesearch will shorten the step and try again.

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

If $mode=0$ or $2$, $f[i-1]$ must contain the value of the $i$th nonlinear constraint function at $x$.

fjacfloat, array-like, shape $\left(\text{nnzjac}\right)$

If $mode=1$ or $2$, $fjac$ must return the available elements of the constraint Jacobian evaluated at $x$. These elements must be stored in exactly the same positions as implied by the definitions of the arrays $a$, $ha$ and $ka$. If option $\text{‘Derivative Level'}=2$ or $3$, the value of any constant Jacobian element not defined by $confun$ will be obtained directly from $a$. Note that the function does not perform any internal checks for consistency (except indirectly via the option ‘Verify Level’), so great care is essential.

objfunNone or callable (mode, objf, objgrd) = objfun(mode, x, objgrd, nstate, data=None), optional

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

$objfun$ must calculate the nonlinear part of the objective function $f\left(x\right)$ and (optionally) its gradient $(=\frac{\partial f}{\partial x})$ for a specified $n_1^{\prime }$ ($\le n$) element vector $x$.

If there are no nonlinear objective variables (i.e., $nonln=0$), $objfun$ will never be called by nlp1_sparse_solve and $objfun$ may be None.

Parameters

modeint

Indicates which values must be assigned during each call of $objfun$. Only the following values need be assigned:

$mode=0$

$objf$.

$mode=1$

All available elements of $objgrd$.

$mode=2$

$objf$ and all available elements of $objgrd$.

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

$x$, the vector of nonlinear variables at which the nonlinear part of the objective function and/or all available elements of its gradient are to be evaluated.

objgrdfloat, ndarray, shape $\left(\text{nonln}\right)$

The elements of $objgrd$ are set to special values which enable nlp1_sparse_solve to detect whether they are changed by $objfun$.

nstateint

If $nstate=1$, nlp1_sparse_solve is calling $objfun$ for the first time. This argument setting allows you to save computation time if certain data must be read or calculated only once.

If $nstate\ge 2$, nlp1_sparse_solve is calling $objfun$ for the last time.

This argument setting allows you to perform some additional computation on the final solution.

In general, the last call to $objfun$ is made with $nstate=2+\text{errno}$ (see Exceptions).

Otherwise, $nstate=0$.

dataarbitrary, optional, modifiable in place

User-communication data for callback functions.

Returns

modeint

You may set to a negative value as follows:

$mode\le -2$

The solution to the current problem is terminated and in this case nlp1_sparse_solve will terminate with $\text{errno}$ set to $mode$.

$mode=-1$

The nonlinear part of the objective function cannot be calculated at the current $x$. nlp1_sparse_solve will then terminate with $errno$ = -1 unless this occurs during the linesearch; in this case, the linesearch will shorten the step and try again.

objffloat

If $mode=0$ or $2$, $objf$ must be set to the value of the objective function at $x$.

objgrdfloat, array-like, shape $\left(\text{nonln}\right)$

If $mode=1$ or $2$, $objgrd$ must return the available elements of the gradient evaluated at $x$.

lenizNone or int, optional

Note: if this argument is None then a default value will be used, determined as follows: $max(500,n+m)$.

The dimension of the internal workspace array $\text{iz}$.

lenzint, optional

The dimension of the internal workspace array $\text{z}$.

dataarbitrary, optional

User-communication data for callback functions.

io_managerFileObjManager, optional

Manager for I/O in this routine.

Returns

afloat, ndarray, shape $\left(\text{nnz}\right)$

Elements in the nonlinear part corresponding to nonlinear Jacobian variables are overwritten.

nsint

The final number of superbasics.

xsfloat, ndarray, shape $(n+m)$

The final values of the variables and slacks $(x,s)$.

istateint, ndarray, shape $(n+m)$

The final states of the variables and slacks $(x,s)$. The significance of each possible value of $istate[j-1]$ is as follows:

$istate[j-1]$	State of variable $j$	Normal value of $xs[j-1]$
$0$	Nonbasic	$bl[j-1]$
$1$	Nonbasic	$bu[j-1]$
$2$	Superbasic	Between $bl[j-1]$ and $bu[j-1]$
$3$	Basic	Between $bl[j-1]$ and $bu[j-1]$

If $ninf=0$, basic and superbasic variables may be outside their bounds by as much as the value of the option ‘Minor Feasibility Tolerance’.

Note that if scaling is specified, the option ‘Minor Feasibility Tolerance’ applies to the variables of the scaled problem.

In this case, the variables of the original problem may be as much as $0.1$ outside their bounds, but this is unlikely unless the problem is very badly scaled.

Very occasionally some nonbasic variables may be outside their bounds by as much as the option ‘Minor Feasibility Tolerance’ and there may be some nonbasic variables for which $xs[j-1]$ lies strictly between its bounds.

If $ninf>0$, some basic and superbasic variables may be outside their bounds by an arbitrary amount (bounded by $sinf$ if scaling was not used).

clamdafloat, ndarray, shape $(n+m)$

A set of Lagrange multipliers for the bounds on the variables (reduced costs) and the general constraints (shadow costs). More precisely, the first $\text{n}$ elements contain the multipliers for the bounds on the variables, the next $ncnln$ elements contain the multipliers for the nonlinear constraints $F\left(x\right)$ (if any) and the next ($m-ncnln$) elements contain the multipliers for the linear constraints $Gx$ and the free row (if any).

minizint

The minimum value of $leniz$ required to start solving the problem. If $errno$ = 12, nlp1_sparse_solve may be called again with $leniz$ suitably larger than $miniz$. (The bigger the better, since it is not certain how much workspace the basis factors need.)

minzint

The minimum value of $lenz$ required to start solving the problem. If $errno$ = 13, nlp1_sparse_solve may be called again with $lenz$ suitably larger than $minz$. (The bigger the better, since it is not certain how much workspace the basis factors need.)

ninfint

The number of constraints that lie outside their bounds by more than the value of the option ‘Minor Feasibility Tolerance’.

If the linear constraints are infeasible, the sum of the infeasibilities of the linear constraints is minimized subject to the upper and lower bounds being satisfied.

In this case, $ninf$ contains the number of elements of $Gx$ that lie outside their upper or lower bounds.

Note that the nonlinear constraints are not evaluated.

Otherwise, the sum of the infeasibilities of the nonlinear constraints is minimized subject to the linear constraints and the upper and lower bounds being satisfied.

In this case, $ninf$ contains the number of elements of $F\left(x\right)$ that lie outside their upper or lower bounds.

sinffloat

The sum of the infeasibilities of constraints that lie outside their bounds by more than the value of the option ‘Minor Feasibility Tolerance’.

objfloat

The value of the objective function.

Other Parameters

‘Central Difference Interval’float

Default $=\sqrt[3]{3\text{‘Function Precision'}}$

Note that this option does not apply when $\text{‘Derivative Level'}=3$.

The value of $r$ is used near an optimal solution in order to obtain more accurate (but more expensive) estimates of gradients. This requires twice as many function evaluations as compared to using forward differences (see option ‘Forward Difference Interval’). The interval used for the $j$th variable is $h_j=r(1+\left|x_j\right|)$. The resulting gradient estimates should be accurate to $O\left(r^2\right)$, unless the functions are badly scaled. The switch to central differences is indicated by c at the end of each line of intermediate printout produced by the major iterations (see Major Iteration Printout). See Gill et al. (1981) for a discussion of the accuracy in finite difference approximations.

If $r\le 0$, the default value is used.

‘Check Frequency’int

Default $=60$

Every $i$th minor iteration after the most recent basis factorization, a numerical test is made to see if the current solution $(x,s)$ satisfies the general linear constraints (including any linearized nonlinear constraints). The constraints are of the form $Ax-s=b$, where $s$ is the set of slack variables. If the largest element of the residual vector $r=b-Ax+s$ is judged to be too large, the current basis is refactorized and the basic variables recomputed to satisfy the general constraints more accurately.

If $i<0$, the default value is used. If $i=0$, the value $i=99999999$ is used and effectively no checks are made.

‘Crash Option’int

Default $=0\text{or}3$

The default value of $i$ is $0$ if there are any nonlinear constraints and $3$ otherwise. Note that this option does not apply when $start=\text{'W'}$ (see Parameters).

If $start=\text{'C'}$, an internal Crash procedure is used to select an initial basis from various rows and columns of the constraint matrix $\left(\begin{array}{cc}A& -I\end{array}\right)$. The value of $i$ determines which rows and columns of $A$ are initially eligible for the basis and how many times the Crash procedure is called. Columns of $-I$ are used to pad the basis where necessary. The possible choices for $i$ are the following.

$i$	Meaning
0	The initial basis contains only slack variables: $B=I$.
1	The Crash procedure is called once (looking for a triangular basis in all rows and columns of $A$).
2	The Crash procedure is called twice (if there are any 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 the Crash procedure is called again to find a triangular basis in the nonlinear rows (whilst retaining the current basis for linear rows).
3	The Crash procedure is called up to three times (if there are any nonlinear constraints). The first two calls treat linear equality constraints and linear inequality constraints separately. The Jacobian is then evaluated for the first major iteration and the Crash procedure is called again to find a triangular basis in the nonlinear rows (whilst retaining the current basis for linear rows).

If $i<0$ or $i>3$, the default value is used.

If $i\ge 1$, certain slacks on inequality rows are selected for the basis first. (If $i\ge 2$, numerical values are used to exclude slacks that are close to a bound.) The Crash procedure 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.

‘Crash Tolerance’float

Default $=0.1$

The value $r$ ($0\le r<1$) allows the Crash procedure to ignore certain ‘small’ nonzero elements in the columns of $A$ while searching for a triangular basis. If $a_{max}$ is the largest element in the $j$th column, other nonzeros $a_{ij}$ in the column are ignored if $\left|a_{ij}\right|\le a_{max}\times r$.

When $r>0$, the basis obtained by the Crash procedure 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. A feasible solution may be reached earlier on some problems.

If $r<0$ or $r\ge 1$, the default value is used.

‘Defaults’valueless

This special keyword may be used to reset all options to their default values.

‘Derivative Level’int

Default $=3$

This argument indicates which nonlinear function gradients are provided in functions $objfun$ and $confun$. The possible choices for $i$ are the following.

$i$	Meaning
3	All elements of the objective gradient and the constraint Jacobian are provided.
2	All elements of the constraint Jacobian are provided, but some (or all) elements of the objective gradient are not specified.
1	All elements of the objective gradient are provided, but some (or all) elements of the constraint Jacobian are not specified.
0	Some (or all) elements of both the objective gradient and the constraint Jacobian are not specified.

The default value $i=3$ should be used whenever possible. It is the most reliable and will usually be the most efficient.

If $i=0$ or $2$, nlp1_sparse_solve will estimate the unspecified elements of the objective gradient, using finite differences. This may simplify the coding of $objfun$. However, the computation of finite difference approximations usually increases the total run-time substantially (since a call to $objfun$ is required for each unspecified element) and there is less assurance that an acceptable solution will be found.

If $i=0$ or $1$, nlp1_sparse_solve will approximate unspecified elements of the constraint Jacobian. For each column of the Jacobian, one call to $confun$ is needed to estimate all unspecified elements in that column (if any). For example, if the sparsity pattern of the Jacobian has the form

$$\begin{array}{c}\left(\begin{array}{cccc}\text{*}& \text{*}& & \text{*}\\ & \text{?}& \text{?}& \\ \text{*}& & \text{?}& \\ & \text{*}& & \text{*}\end{array}\right)\end{array}$$

where ‘$\ast$’ indicates an element provided and ‘?’ indicates an unspecified element, nlp1_sparse_solve will call $confun$ twice: once to estimate the missing element in column $2$ and again to estimate the two missing elements in column $3$. (Since columns $1$ and $4$ are known, they require no calls to $confun$.)

At times, central differences are used rather than forward differences, in which case twice as many calls to $objfun$ and $confun$ are needed. (The switch to central differences is not under your control.)

If $i<0$ or $i>3$, the default value is used.

‘Derivative Linesearch’valueless

Default

At each major iteration, a linesearch is used to improve the value of the Lagrangian merit function [equation]. The default linesearch uses safeguarded cubic interpolation and requires both function and gradient values in order to compute estimates of the step ${\alpha }_k$. If some analytic derivatives are not provided or option ‘Nonderivative Linesearch’ is specified, a linesearch based upon safeguarded quadratic interpolation (which does not require the evaluation or approximation of any gradients) is used instead.

A nonderivative linesearch can be slightly less robust on difficult problems and it is recommended that the default be used if the functions and their derivatives can be computed at approximately the same cost. If the gradients are very expensive to compute relative to the functions however, a nonderivative linesearch may result in a significant decrease in the total run-time.

If option ‘Nonderivative Linesearch’ is selected, nlp1_sparse_solve signals the evaluation of the linesearch by calling $objfun$ and $confun$ with $mode=0$. Once the linesearch is complete, the nonlinear functions are re-evaluated with $mode=2$. If the potential savings offered by a nonderivative linesearch are to be fully realised, it is essential that $objfun$ and $confun$ be coded so that no derivatives are computed when $mode=0$.

‘Nonderivative Linesearch’valueless

At each major iteration, a linesearch is used to improve the value of the Lagrangian merit function [equation]. The default linesearch uses safeguarded cubic interpolation and requires both function and gradient values in order to compute estimates of the step ${\alpha }_k$. If some analytic derivatives are not provided or option ‘Nonderivative Linesearch’ is specified, a linesearch based upon safeguarded quadratic interpolation (which does not require the evaluation or approximation of any gradients) is used instead.

A nonderivative linesearch can be slightly less robust on difficult problems and it is recommended that the default be used if the functions and their derivatives can be computed at approximately the same cost. If the gradients are very expensive to compute relative to the functions however, a nonderivative linesearch may result in a significant decrease in the total run-time.

If option ‘Nonderivative Linesearch’ is selected, nlp1_sparse_solve signals the evaluation of the linesearch by calling $objfun$ and $confun$ with $mode=0$. Once the linesearch is complete, the nonlinear functions are re-evaluated with $mode=2$. If the potential savings offered by a nonderivative linesearch are to be fully realised, it is essential that $objfun$ and $confun$ be coded so that no derivatives are computed when $mode=0$.

‘Elastic Weight’float

Default $=1.0$ or $100.0$

The default value of $r$ is $100.0$ if there are any nonlinear constraints and $1.0$ otherwise.

This option defines the initial weight $\gamma$ associated with problem [equation].

At any given major iteration $k$, elastic mode is entered if the QP subproblem is infeasible or the QP dual variables (Lagrange multipliers) are larger in magnitude than $r\times (1+{\parallel g\left(x_k\right)\parallel }_2)$, where $g$ is the objective gradient. In either case, the QP subproblem is resolved in elastic mode with $\gamma =r\times (1+{\parallel g\left(x_k\right)\parallel }_2)$.

Thereafter, $\gamma$ is increased (subject to a maximum allowable value) at any point that is optimal for problem [equation], but not feasible for problem (1). After the $p$th increase, $\gamma =r\times {10}^p\times (1+{\Vert g\left(x_{k_1}\right)\Vert }_2)$, where $x_{k_1}$ is the iterate at which $\gamma$ was first needed.

If $r<0$, the default value is used.

‘Expand Frequency’int

Default $=10000$

This option is part of the EXPAND anti-cycling procedure due to Gill et al. (1989), which is designed to make progress even on highly degenerate problems.

For linear models, the strategy is to force a positive step at every iteration, at the expense of violating the constraints by a small amount. Suppose that the value of option ‘Minor Feasibility Tolerance’ is $\delta$. Over a period of $i$ iterations, the feasibility tolerance actually used by nlp1_sparse_solve (i.e., the working feasibility tolerance) increases from $0.5\delta$ to $\delta$ (in steps of $0.5\delta /i$).

For nonlinear models, the same procedure is used for iterations in which there is only one superbasic variable. (Cycling can only occur when the current solution is at a vertex of the feasible region.) Thus, zero steps are allowed if there is more than one superbasic variable, but otherwise positive steps are enforced.

Increasing the value of $i$ helps reduce the number of slightly infeasible nonbasic basic variables (most of which are eliminated during the resetting procedure). However, it also diminishes the freedom to choose a large pivot element (see option ‘Pivot Tolerance’).

If $i<0$, the default value is used. If $i=0$, the value $i=99999999$ is used and effectively no anti-cycling procedure is invoked.

‘Factorization Frequency’int

Default $=50\text{or}100$

The default value of $i$ is $50$ if there are any nonlinear constraints and $100$ otherwise.

If $i>0$, at most $i$ basis changes will occur between factorizations of the basis matrix.

For linear problems, the basis factors are usually updated at every iteration. The default value $i=100$ is reasonable for typical problems, particularly those that are extremely sparse and well-scaled.

When the objective function is nonlinear, fewer basis updates will occur as the solution is approached. The number of iterations between basis factorizations will, therefore, increase. During these iterations a test is made regularly according to the value of option ‘Check Frequency’ to ensure that the general constraints are satisfied. If necessary, the basis will be refactorized before the limit of $i$ updates is reached.

If $i\le 0$, the default value is used.

‘Infeasible Exit’valueless

Default

Note that this option is ignored if the value of option ‘Major Iteration Limit’ is exceeded, or the linear constraints are infeasible.

If termination is about to occur at a point that does not satisfy the nonlinear constraints and option ‘Feasible Exit’ is selected, this option requests that additional iterations be performed in order to find a feasible point (if any) for the nonlinear constraints. This involves solving a feasible point problem in which the objective function is omitted.

Otherwise, this option requests no additional iterations be performed.

‘Feasible Exit’valueless

Note that this option is ignored if the value of option ‘Major Iteration Limit’ is exceeded, or the linear constraints are infeasible.

If termination is about to occur at a point that does not satisfy the nonlinear constraints and option ‘Feasible Exit’ is selected, this option requests that additional iterations be performed in order to find a feasible point (if any) for the nonlinear constraints. This involves solving a feasible point problem in which the objective function is omitted.

Otherwise, this option requests no additional iterations be performed.

‘Minimize’valueless

Default

If option ‘Feasible Point’ is selected, this option attempts to find a feasible point (if any) for the nonlinear constraints by omitting the objective function. It can also be used to check whether the nonlinear constraints are feasible.

Otherwise, this option specifies the required direction of the optimization. It applies to both linear and nonlinear terms (if any) in the objective function. Note that if two problems are the same except that one minimizes $f\left(x\right)$ and the other maximizes $-f\left(x\right)$, their solutions will be the same but the signs of the dual variables ${\pi }_i$ and the reduced gradients $d_j$ will be reversed.

‘Maximize’valueless

If option ‘Feasible Point’ is selected, this option attempts to find a feasible point (if any) for the nonlinear constraints by omitting the objective function. It can also be used to check whether the nonlinear constraints are feasible.

Otherwise, this option specifies the required direction of the optimization. It applies to both linear and nonlinear terms (if any) in the objective function. Note that if two problems are the same except that one minimizes $f\left(x\right)$ and the other maximizes $-f\left(x\right)$, their solutions will be the same but the signs of the dual variables ${\pi }_i$ and the reduced gradients $d_j$ will be reversed.

‘Feasible Point’valueless

If option ‘Feasible Point’ is selected, this option attempts to find a feasible point (if any) for the nonlinear constraints by omitting the objective function. It can also be used to check whether the nonlinear constraints are feasible.

Otherwise, this option specifies the required direction of the optimization. It applies to both linear and nonlinear terms (if any) in the objective function. Note that if two problems are the same except that one minimizes $f\left(x\right)$ and the other maximizes $-f\left(x\right)$, their solutions will be the same but the signs of the dual variables ${\pi }_i$ and the reduced gradients $d_j$ will be reversed.

‘Forward Difference Interval’float

Default $=\sqrt{\text{‘Function Precision'}}$

This option defines an interval used to estimate derivatives by forward differences in the following circumstances:

1. For verifying the objective and/or constraint gradients (see the description of the option ‘Verify Level’).

2. For estimating unspecified elements of the objective gradient and/or the constraint Jacobian.

A derivative with respect to $x_j$ is estimated by perturbing that element of $x$ to the value $x_j+r(1+\left|x_j\right|)$ and then evaluating $f\left(x\right)$ and/or $F\left(x\right)$ (as appropriate) 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. See Gill et al. (1981) for a discussion of the accuracy in finite difference approximations.

If $r\le 0$, the default value is used.

‘Function Precision’float

Default $={ϵ}^{0.8}$

This argument defines the relative function precision ${ϵ}_r$, which 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)$ (or $F_i\left(x\right)$) is computed as $1000.56789$ for some relevant $x$ and the first $6$ significant digits are known to be correct, then the appropriate value for ${ϵ}_r$ would be ${10}^{-6}$.

Ideally the functions $f\left(x\right)$ or $F_i\left(x\right)$ should have 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)$ (or $F_i\left(x\right)$) is computed as $1.23456789\times {10}^{-4}$ for some relevant $x$ and the first $6$ significant digits are known to be correct, then the appropriate value for ${ϵ}_r$ would be ${10}^{-10}$.

The choice of ${ϵ}_r$ can be quite complicated for badly scaled problems; see Module 8 of Gill et al. (1981) for a discussion of scaling techniques. The default value is appropriate for most simple functions that are computed with full accuracy.

In some cases the function values will be the result of extensive computation, possibly involving an iterative procedure that can provide few digits of precision at reasonable cost. Specifying an appropriate value of $r$ may, therefore, 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.

If $r<ϵ$ or $r\ge 1$, the default value is used.

‘Hessian Frequency’int

Default $=99999999$

This option forces the approximate Hessian formed from $i$ BFGS updates to be reset to the identity matrix upon completion of a major iteration. It is intended to be used in conjunction with option ‘Hessian Full Memory’.

If $i\le 0$, the default value is used and effectively no resets occur.

‘Hessian Full Memory’valueless

Default when $\overline{n}<75$

These options specify the method for storing and updating the quasi-Newton approximation to the Hessian of the Lagrangian function.

If ‘Hessian Full Memory’ is specified, the approximate Hessian is treated as a dense matrix and BFGS quasi-Newton updates are applied explicitly. This is most efficient when the total number of nonlinear variables is not too large (say, $\overline{n}<75$). In this case, the storage requirement is fixed and you can expect $1$-step Q-superlinear convergence to the solution.

‘Hessian Limited Memory’ should only be specified when $\overline{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.)

Note that if $\text{‘Hessian Frequency'}=20$ is used in conjunction with ‘Hessian Full Memory’, the effect will be similar to using ‘Hessian Limited Memory’ in conjunction with $\text{‘Hessian Updates'}=20$, except that the latter will retain the current diagonal during resets.

‘Hessian Limited Memory’valueless

Default when $\overline{n}\ge 75$

These options specify the method for storing and updating the quasi-Newton approximation to the Hessian of the Lagrangian function.

If ‘Hessian Full Memory’ is specified, the approximate Hessian is treated as a dense matrix and BFGS quasi-Newton updates are applied explicitly. This is most efficient when the total number of nonlinear variables is not too large (say, $\overline{n}<75$). In this case, the storage requirement is fixed and you can expect $1$-step Q-superlinear convergence to the solution.

‘Hessian Limited Memory’ should only be specified when $\overline{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.)

Note that if $\text{‘Hessian Frequency'}=20$ is used in conjunction with ‘Hessian Full Memory’, the effect will be similar to using ‘Hessian Limited Memory’ in conjunction with $\text{‘Hessian Updates'}=20$, except that the latter will retain the current diagonal during resets.

‘Hessian Updates’int

Default $=20$ or $99999999$

The default value of $i$ is $20$ when ‘Hessian Limited Memory’ is in effect and $99999999$ when ‘Hessian Full Memory’ is in effect, in which case no updates are performed.

If ‘Hessian Limited Memory’ is in effect, this option defines the maximum number of pairs of Hessian update vectors that are to be used to define the quasi-Newton approximate Hessian. Once the limit of $i$ updates is reached, all but the diagonal elements of the accumulated updates are discarded and the process starts again. Broadly speaking, the more updates that are stored, the better the quality of the approximate Hessian. On the other hand, the more vectors that are stored, the greater the cost of each QP iteration.

The default value of $i$ is likely to give a robust algorithm without significant expense, but faster convergence may be obtained with far fewer updates (e.g., $i=5$).

If $i<0$, the default value is used.

‘Infinite Bound Size’float

Default $={10}^{20}$

If $r>0$, $r$ 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$).

If $r\le 0$, the default value is used.

‘Iteration Limit’int

Default $=10000$

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 options ‘Major Iteration Limit’ and ‘Minor Iteration Limit’.)

If $i<0$, the default value is used.

‘Linesearch Tolerance’float

Default $=0.9$

This option controls the accuracy with which a step length will be located along the direction of search at each iteration. At the start of each linesearch a target directional derivative for the Lagrangian merit function is identified. The value of $r$, therefore, determines the accuracy to which this target value is approximated.

The default value $r=0.9$ requests an inaccurate search and is appropriate for most problems, particularly those with any nonlinear constraints.

If the nonlinear functions are cheap to evaluate, a more accurate search may be appropriate; try $r=0.1,0.01$ or $0.001$. The number of major iterations required to solve the problem might decrease.

If the nonlinear functions are expensive to evaluate, a less accurate search may be appropriate. If $\text{‘Derivative Level'}=3$, try $r=0.99$. (The number of major iterations required to solve the problem might increase, but the total number of function evaluations may decrease enough to compensate.)

If $\text{‘Derivative Level'}<3$, a moderately accurate search may be appropriate; try $r=0.5$. Each search will (typically) require only $1-5$ function values, but many function calls will then be needed to estimate the missing gradients for the next iteration.

If $r<0$ or $r\ge 1$, the default value is used.

‘List’valueless

Option ‘List’ enables printing of each option specification as it is supplied. ‘Nolist’ suppresses this printing.

‘Nolist’valueless

Default $=\text{‘Nolist'}$

Option ‘List’ enables printing of each option specification as it is supplied. ‘Nolist’ suppresses this printing.

‘LU Density Tolerance’float

Default $=0.6$

If $r_1>0$, $r_1$ defines the density tolerance used during the $LU$ factorization of the basis matrix. Columns of $L$ and rows of $U$ are formed one at a time and the remaining rows and columns of the basis are altered appropriately. At any stage, if the density of the remaining matrix exceeds $r_1$, the Markowitz strategy for choosing pivots is terminated. The remaining matrix is then factorized using a dense $LU$ procedure. Increasing the value of $r_1$ towards unity may give slightly sparser $LU$ factors, with a slight increase in factorization time. If $r_1\le 0$, the default value is used.

If $r_2>0$, $r_2$ defines the singularity tolerance used to guard against ill-conditioned basis matrices. Whenever the basis is refactorized, the diagonal elements of $U$ are tested as follows. If $\left|u_{jj}\right|\le r_2$ or $\left|u_{jj}\right|<r_2\times {max}_i\left|u_{ij}\right|$, the $j$th column of the basis is replaced by the corresponding slack variable. This is most likely to occur when $start=\text{'W'}$ (see Parameters), or at the start of a major iteration. If $r_2\le 0$, the default value is used.

In some cases, the Jacobian matrix may converge to values that make the basis exactly singular (e.g., a whole row of the Jacobian matrix could be zero at an optimal solution). Before exact singularity occurs, the basis could become very ill-conditioned and the optimization could progress very slowly (if at all). Setting $r_2=0.00001$ (say) may, therefore, help cause a judicious change of basis in such situations.

‘LU Singularity Tolerance’float

Default $={ϵ}^{0.67}$

If $r_1>0$, $r_1$ defines the density tolerance used during the $LU$ factorization of the basis matrix. Columns of $L$ and rows of $U$ are formed one at a time and the remaining rows and columns of the basis are altered appropriately. At any stage, if the density of the remaining matrix exceeds $r_1$, the Markowitz strategy for choosing pivots is terminated. The remaining matrix is then factorized using a dense $LU$ procedure. Increasing the value of $r_1$ towards unity may give slightly sparser $LU$ factors, with a slight increase in factorization time. If $r_1\le 0$, the default value is used.

If $r_2>0$, $r_2$ defines the singularity tolerance used to guard against ill-conditioned basis matrices. Whenever the basis is refactorized, the diagonal elements of $U$ are tested as follows. If $\left|u_{jj}\right|\le r_2$ or $\left|u_{jj}\right|<r_2\times {max}_i\left|u_{ij}\right|$, the $j$th column of the basis is replaced by the corresponding slack variable. This is most likely to occur when $start=\text{'W'}$ (see Parameters), or at the start of a major iteration. If $r_2\le 0$, the default value is used.

In some cases, the Jacobian matrix may converge to values that make the basis exactly singular (e.g., a whole row of the Jacobian matrix could be zero at an optimal solution). Before exact singularity occurs, the basis could become very ill-conditioned and the optimization could progress very slowly (if at all). Setting $r_2=0.00001$ (say) may, therefore, help cause a judicious change of basis in such situations.

‘LU Factor Tolerance’float

Default $=5.0$ or $100.0$

The default value of $r_1$ is $5.0$ if there are any nonlinear constraints and $100.0$ otherwise. The default value of $r_2$ is $5.0$ if there are any nonlinear constraints and $10.0$ otherwise.

If $r_1\ge 1$ and $r_2\ge 1$, the values of $r_1$ and $r_2$ affect the stability and sparsity of the basis factorization $B=LU$, during refactorization and updating, respectively. The lower triangular matrix $L$ is a product of matrices of the form

$$\begin{array}{c}\left(\begin{array}{cc}1& \\ \mu & 1\end{array}\right)\text{,}\end{array}$$

where the multipliers $\mu$ satisfy $\left|\mu \right|\le r_i$. Smaller values of $r_i$ favour stability, while larger values favour sparsity. The default values of $r_1$ and $r_2$ usually strike a good compromise. For large and relatively dense problems, setting $r_1=10.0$ or $5.0$ (say) may give a marked improvement in sparsity without impairing stability to a serious degree. Note that for problems involving band matrices, it may be necessary to reduce $r_1$ and/or $r_2$ in order to achieve stability.

If $r_1<1$ or $r_2<1$, the appropriate default value is used.

‘LU Update Tolerance’float

Default $=5.0$ or $10.0$

The default value of $r_1$ is $5.0$ if there are any nonlinear constraints and $100.0$ otherwise. The default value of $r_2$ is $5.0$ if there are any nonlinear constraints and $10.0$ otherwise.

If $r_1\ge 1$ and $r_2\ge 1$, the values of $r_1$ and $r_2$ affect the stability and sparsity of the basis factorization $B=LU$, during refactorization and updating, respectively. The lower triangular matrix $L$ is a product of matrices of the form

$$\begin{array}{c}\left(\begin{array}{cc}1& \\ \mu & 1\end{array}\right)\text{,}\end{array}$$

where the multipliers $\mu$ satisfy $\left|\mu \right|\le r_i$. Smaller values of $r_i$ favour stability, while larger values favour sparsity. The default values of $r_1$ and $r_2$ usually strike a good compromise. For large and relatively dense problems, setting $r_1=10.0$ or $5.0$ (say) may give a marked improvement in sparsity without impairing stability to a serious degree. Note that for problems involving band matrices, it may be necessary to reduce $r_1$ and/or $r_2$ in order to achieve stability.

If $r_1<1$ or $r_2<1$, the appropriate default value is used.

‘Major Feasibility Tolerance’float

Default $=\sqrt{ϵ}$

This option specifies how accurately the nonlinear constraints should be satisfied. The default value is appropriate when the linear and nonlinear constraints contain data to approximately that accuracy. A larger value may be appropriate if some of the problem functions are known to be of low accuracy.

Let rowerr be defined as the maximum nonlinear constraint violation normalized by the size of the solution. It is required to satisfy

$$\text{rowerr}={max}_i\frac{{\text{viol}}_i}{\parallel (x,s)\parallel }\le r\text{,}$$

where ${\text{viol}}_i$ is the violation of the $i$th nonlinear constraint.

If $r\le ϵ$, the default value is used.

‘Major Iteration Limit’int

Default $=1000$

The value of $i$ specifies the maximum number of major iterations allowed before termination. It is intended to guard against an excessive number of linearizations of the nonlinear constraints. Setting $i=0$ and $\text{‘Major Print Level'}>0$ means that the objective and constraint gradients will be checked if $\text{‘Verify Level'}>0$ and the workspace needed to start solving the problem will be computed and printed, but no iterations will be performed.

If $i<0$, the default value is used.

‘Major Optimality Tolerance’float

Default $=\sqrt{ϵ}$

This option specifies the final accuracy of the dual variables. If nlp1_sparse_solve terminates with no exception or warning is raised, a primal and dual solution ($x,s,\pi$) will have been computed such that

$$\text{maxgap}={max}_j\frac{{\text{gap}}_j}{\parallel \pi \parallel }\le r\text{,}$$

where ${\text{gap}}_j$ is an estimate of the complementarity gap for the $j$th variable and $\parallel \pi \parallel$ is a measure of the size of the QP dual variables (or Lagrange multipliers) given by

$$\parallel \pi \parallel =max(\frac{\sigma }{\sqrt{m}},1)\text{, where}\sigma =\sum _{i=1}^m\left|{\pi }_i\right|\text{.}$$

It is included to make the tests independent of a scale factor on the objective function. Specifically, ${\text{gap}}_j$ is 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 element of the objective gradient and $a_j$ is the associated column of the constraint matrix $\left(\begin{array}{cc}A& -I\end{array}\right)$:

$$\begin{array}{c}{\text{gap}}_j=\{\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}\end{array}$$

If $r\le 0$, the default value is used.

‘Optimality Tolerance’float

Default $=\sqrt{ϵ}$

This option specifies the final accuracy of the dual variables. If nlp1_sparse_solve terminates with no exception or warning is raised, a primal and dual solution ($x,s,\pi$) will have been computed such that

$$\text{maxgap}={max}_j\frac{{\text{gap}}_j}{\parallel \pi \parallel }\le r\text{,}$$

where ${\text{gap}}_j$ is an estimate of the complementarity gap for the $j$th variable and $\parallel \pi \parallel$ is a measure of the size of the QP dual variables (or Lagrange multipliers) given by

$$\parallel \pi \parallel =max(\frac{\sigma }{\sqrt{m}},1)\text{, where}\sigma =\sum _{i=1}^m\left|{\pi }_i\right|\text{.}$$

It is included to make the tests independent of a scale factor on the objective function. Specifically, ${\text{gap}}_j$ is 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 element of the objective gradient and $a_j$ is the associated column of the constraint matrix $\left(\begin{array}{cc}A& -I\end{array}\right)$:

$$\begin{array}{c}{\text{gap}}_j=\{\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}\end{array}$$

If $r\le 0$, the default value is used.

‘Major Print Level’int

Default $=0$

The value of $i$ controls the amount of printout produced by the major iterations of nlp1_sparse_solve, as indicated below. A detailed description of the printed output is given in Major Iteration Printout (summary output at each major iteration and the final solution) and Monitoring Information (monitoring information at each major iteration). (See also the description of the option ‘Minor Print Level’.)

The following printout is sent to the file object associated with the advisory I/O unit (see FileObjManager):

$i$	Output
$0$	No output.
$1$	The final solution only.
$5$	One line of summary output ($<80$ characters; see Major Iteration Printout) for each major iteration (no printout of the final solution).
$\ge 10$	The final solution and one line of summary output for each major iteration.

The following printout is sent to the unit number given by the option ‘Monitoring File’:

$i$	Output
$0$	No output.
$1$	The final solution only.
$5$	One long line of output ($<120$ characters; see Monitoring Information) for each major iteration (no printout of the final solution).
$\ge 10$	The final solution and one long line of output for each major iteration.
$\ge 20$	The final solution, one long line of output for each major iteration, matrix statistics (initial status of rows and columns, number of elements, density, biggest and smallest elements, etc.), details of the scale factors resulting from the scaling procedure (if $\text{‘Scale Option'}=1$ or $2$), basis factorization statistics and details of the initial basis resulting from the Crash procedure (if $start=\text{'C'}$; see Parameters).

If $\text{‘Major Print Level'}\ge 5$ and the unit number defined by the option ‘Monitoring File’ is the advisory unit number, the summary output for each major iteration is suppressed.

‘Print Level’int

The value of $i$ controls the amount of printout produced by the major iterations of nlp1_sparse_solve, as indicated below. A detailed description of the printed output is given in Major Iteration Printout (summary output at each major iteration and the final solution) and Monitoring Information (monitoring information at each major iteration). (See also the description of the option ‘Minor Print Level’.)

The following printout is sent to the file object associated with the advisory I/O unit (see FileObjManager):

$i$	Output
$0$	No output.
$1$	The final solution only.
$5$	One line of summary output ($<80$ characters; see Major Iteration Printout) for each major iteration (no printout of the final solution).
$\ge 10$	The final solution and one line of summary output for each major iteration.

The following printout is sent to the unit number given by the option ‘Monitoring File’:

$i$	Output
$0$	No output.
$1$	The final solution only.
$5$	One long line of output ($<120$ characters; see Monitoring Information) for each major iteration (no printout of the final solution).
$\ge 10$	The final solution and one long line of output for each major iteration.
$\ge 20$	The final solution, one long line of output for each major iteration, matrix statistics (initial status of rows and columns, number of elements, density, biggest and smallest elements, etc.), details of the scale factors resulting from the scaling procedure (if $\text{‘Scale Option'}=1$ or $2$), basis factorization statistics and details of the initial basis resulting from the Crash procedure (if $start=\text{'C'}$; see Parameters).

If $\text{‘Major Print Level'}\ge 5$ and the unit number defined by the option ‘Monitoring File’ is the advisory unit number, the summary output for each major iteration is suppressed.

‘Major Step Limit’float

Default $=2.0$

If $r>0,r$ limits the change in $x$ during a linesearch. It applies to all nonlinear problems once a ‘feasible solution’ or ‘feasible subproblem’ has been found.

A linesearch determines a step $\alpha$ in the interval $0<\alpha \le \beta$, where $\beta =1$ if there are any nonlinear constraints, or the step to the nearest upper or lower bound on $x$ if all the constraints are linear. Normally, the first step attempted is ${\alpha }_1=min(1,\beta )$.

In some cases, such as $f\left(x\right)=a{e}^{bx}$ or $f\left(x\right)=a{x}^b$, even a moderate change in the elements of $x$ can lead to floating-point overflow. The argument $r$ is, therefore, used to define a step limit $\overline{\beta }$ given by

$$\overline{\beta }=\frac{r(1+{\parallel x\parallel }_2)}{{\parallel p\parallel }_2}\text{,}$$

where $p$ is the search direction and the first evaluation of $f\left(x\right)$ is made at the (potentially) smaller step length ${\alpha }_1=min(1,\overline{\beta },\beta )$.

Wherever possible, upper and lower bounds on $x$ should be used to prevent evaluation of nonlinear functions at meaningless points. The default value $r=2.0$ should not affect progress on well-behaved functions, but values such as $r=0.1$ or $0.01$ may be helpful when rapidly varying functions are present. If a small value of $r$ is selected, a ‘good’ starting point may be required. An important application is to the class of nonlinear least squares problems.

If $r\le 0$, the default value is used.

‘Minor Feasibility Tolerance’float

Default $=\sqrt{ϵ}$

This option attempts to ensure that all variables eventually satisfy their upper and lower bounds to within the tolerance $r$. Since this includes slack variables, general linear constraints should also be satisfied to within $r$. Note that feasibility with respect to nonlinear constraints is judged by the value of option ‘Major Feasibility Tolerance’ and not by $r$.

If the bounds and linear constraints cannot be satisfied to within $r$, the problem is declared infeasible. Let Sinf be the corresponding sum of infeasibilities. If Sinf 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.

If $\text{‘Scale Option'}\ge 1$, feasibility is defined in terms of the scaled problem (since it is more likely to be meaningful).

Nonlinear functions will only be evaluated at points that satisfy the bounds and linear constraints. If there are regions where a function is undefined, every effort should be made to eliminate these regions from the problem. For example, if $f(x_1,x_2)=\sqrt{x_1}+\log \left(x_2\right)$, it is essential to place lower bounds on both $x_1$ and $x_2$. If the value $r={10}^{-6}$ is used, the bounds $x_1\ge {10}^{-5}$ and $x_2\ge {10}^{-4}$ might be appropriate. (The log singularity is more serious; in general, you should attempt to keep $x$ as far away from singularities as possible.)

In reality, $r$ is used 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 and the function is, then in elastic mode thereafter (with only the linearized nonlinear constraints defined to be elastic). (See also the description of ‘Elastic Weight’.)

If $r\le ϵ$, the default value is used.

‘Feasibility Tolerance’float

Default $=\sqrt{ϵ}$

This option attempts to ensure that all variables eventually satisfy their upper and lower bounds to within the tolerance $r$. Since this includes slack variables, general linear constraints should also be satisfied to within $r$. Note that feasibility with respect to nonlinear constraints is judged by the value of option ‘Major Feasibility Tolerance’ and not by $r$.

If the bounds and linear constraints cannot be satisfied to within $r$, the problem is declared infeasible. Let Sinf be the corresponding sum of infeasibilities. If Sinf 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.

If $\text{‘Scale Option'}\ge 1$, feasibility is defined in terms of the scaled problem (since it is more likely to be meaningful).

Nonlinear functions will only be evaluated at points that satisfy the bounds and linear constraints. If there are regions where a function is undefined, every effort should be made to eliminate these regions from the problem. For example, if $f(x_1,x_2)=\sqrt{x_1}+\log \left(x_2\right)$, it is essential to place lower bounds on both $x_1$ and $x_2$. If the value $r={10}^{-6}$ is used, the bounds $x_1\ge {10}^{-5}$ and $x_2\ge {10}^{-4}$ might be appropriate. (The log singularity is more serious; in general, you should attempt to keep $x$ as far away from singularities as possible.)

In reality, $r$ is used 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 and the function is, then in elastic mode thereafter (with only the linearized nonlinear constraints defined to be elastic). (See also the description of ‘Elastic Weight’.)

If $r\le ϵ$, the default value is used.

‘Minor Iteration Limit’int

Default $=500$

The value of $i$ specifies the maximum number of iterations allowed between successive linearizations of the nonlinear constraints. A value in the range $10\le i\le 50$ prevents excessive effort being expended on early major iterations, but allows later QP subproblems to be solved to completion. Note that an extra $m$ minor iterations are allowed if the first QP subproblem to be solved starts with the all-slack basis $B=I$. (See the description of the option ‘Crash Option’.)

In general, it is unsafe to specify values as small as $i=1$ or $2$ (because even when an optimal solution has been reached, a few minor iterations may be needed for the corresponding QP subproblem to be recognized as optimal).

If $i\le 0$, the default value is used.

‘Minor Optimality Tolerance’float

Default $=\sqrt{ϵ}$

This option is used to judge optimality for each QP subproblem. Let the QP reduced gradients be $d_j=g_j-{\pi }^T{a}_j$, where $g_j$ is the $j$th element of the QP gradient, $a_j$ is the associated column of the QP constraint matrix and $\pi$ is the set of QP dual variables.

By construction, the reduced gradients for basic variables are always zero. The QP subproblem will be declared optimal if the reduced gradients for nonbasic variables at their upper or lower bounds satisfy

$$\frac{d_j}{\parallel \pi \parallel }\ge -r\text{or}\frac{d_j}{\parallel \pi \parallel }\le r$$

respectively, and if $\frac{\left|d_j\right|}{\parallel \pi \parallel }\le r$ for superbasic variables.

Note that $\parallel \pi \parallel$ is a measure of the size of the dual variables. It is included to make the tests independent of a scale factor on the objective function. (The value of $\parallel \pi \parallel$ actually used is defined in the description for option ‘Major Optimality Tolerance’.)

If the objective is scaled down to be very small, the optimality test reduces to comparing $d_j$ against $r$.

If $r\le 0$, the default value is used.

‘Minor Print Level’int

Default $=0$

The value of $i$ controls the amount of printout produced by the minor iterations of nlp1_sparse_solve (i.e., the iterations of the quadratic programming algorithm), as indicated below. A detailed description of the printed output is given in Minor Iteration Printout (summary output at each minor iteration) and Monitoring Information (monitoring information at each minor iteration). (See also the description of the option ‘Major Print Level’.)

The following printout is sent to the file object associated with the advisory I/O unit (see FileObjManager):

$i$	Output
$0$	No output.
$\ge 1$	One line of summary output ($<80$ characters; see Minor Iteration Printout) for each minor iteration.

The following printout is sent to the unit number given by the option ‘Monitoring File’:

$i$	Output
$0$	No output.
$\ge 1$	One long line of output ($<120$ characters; see Monitoring Information) for each minor iteration.

If $\text{‘Major Print Level'}\ge 5$ and the unit number defined by the option ‘Monitoring File’ is the advisory unit number, the summary output for each major iteration is suppressed.

‘Monitoring File’int

Default $=-1$

If $i\ge 0$ and $\text{‘Major Print Level'}\ge 5$ or $i\ge 0$ and $\text{‘Minor Print Level'}\ge 1$, then monitoring information is produced by nlp1_sparse_solve at every iteration is sent to a file with logical unit number $i$. If $i<0$ and/or $\text{‘Major Print Level'}<5$ and $\text{‘Minor Print Level'}<1$, then no monitoring information is produced.

‘Partial Price’int

Default $=1$ or $10$

The default value of $i$ is $1$ if there are any nonlinear constraints and $10$ otherwise.

This option is recommended for large problems that have significantly more variables than constraints (i.e., $n\gg m$). It reduces the work required for each ‘pricing’ operation (i.e., when a nonbasic variable is selected to become superbasic). The possible choices for $i$ are the following.

$i$	Meaning
$1$	All columns of the constraint matrix $\left(\begin{array}{cc}A& -I\end{array}\right)$ are searched.
$\ge 2$	Both $A$ and $I$ are partitioned to give $i$ roughly equal segments $A_{\text{j}},I_{\text{j}}$, for $\text{j}=1,2,\dots ,p$ (modulo $p$). If the previous pricing search was successful on $A_j,I_j$, the next search begins on the segments $A_{j+1},I_{j+1}$. If a reduced gradient is found that is larger than some dynamic tolerance, the variable with the largest such reduced gradient (of appropriate sign) is selected to enter the basis. If nothing is found, the search continues on the next segments $A_{j+2},I_{j+2}$ and so on.

If $i\le 0$, the default value is used.

‘Pivot Tolerance’float

Default $={ϵ}^{0.67}$

If $r>0$, $r$ is used during the solution of QP subproblems to prevent columns entering the basis if they would cause the basis to become almost singular.

When $x$ changes to $x+\alpha p$ for some specified search direction $p$, a ‘ratio test’ is used to determine which element of $x$ reaches an upper or lower bound first. The corresponding element of $p$ is called the pivot element. Elements of $p$ are ignored (and, therefore, cannot be pivot elements) if they are smaller than $r$.

It is common in practice for two (or more) variables to reach a bound at essentially the same time. In such cases, the ‘Minor Feasibility Tolerance’ provides some freedom to maximize the pivot element and thereby improve numerical stability. Excessively small values of ‘Minor Feasibility Tolerance’ should, therefore, not be specified. To a lesser extent, the ‘Expand Frequency’ also provides some freedom to maximize the pivot element. Excessively large values of ‘Expand Frequency’ should, therefore, not be specified.

If $r\le 0$, the default value is used.

‘Scale Option’int

Default $=1$ or $2$

The default value of $i$ is $1$ if there are any nonlinear constraints and $2$ otherwise.

This option enables you to scale the variables and constraints using an iterative procedure due to Fourer (1982), which attempts to compute row scales $r_i$ and column scales $c_j$ such that the scaled matrix coefficients ${\overline{a}}_{ij}=a_{ij}\times \left(c_j/r_i\right)$ are as close as possible to unity. (The lower and upper bounds on the variables and slacks for the scaled problem are redefined as ${\overline{l}}_j=l_j/c_j$ and ${\overline{u}}_j=u_j/c_j$ respectively, where $c_j\equiv r_{j-n}$ if $j>n$.) The possible choices for $i$ are the following.

$i$	Meaning
0	No scaling is performed. This is recommended if it is known that the elements of $x$ and the constraint matrix $A$ (along with its Jacobian) never become large (say, $>1000$).
1	All linear constraints and variables are scaled. This may improve the overall efficiency of the function on some problems.
2	All constraints and variables are scaled. Also, an additional scaling is performed that 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.

If there are any nonlinear constraints present, the scale factors depend on the Jacobian at the first point that satisfies the linear constraints and the upper and lower bounds. The setting $i=2$ should, therefore, be used only if a ‘good’ starting point is available and the problem is not highly nonlinear.

If $i<0$ or $i>2$, the default value is used.

‘Scale Tolerance’float

Default $=0.9$

Note that this option does not apply when $\text{‘Scale Option'}=0$.

The value $r$ ($0<r<1$) is used to control the number of scaling passes to be made through the constraint matrix $A$. At least $3$ (and at most $10$) passes will be made. More precisely, let $a_p$ denote the largest column ratio (i.e., $\frac{\text{‘biggest'}\text{element}}{\text{‘smallest'}\text{element}}$ in some sense) after the $p$th scaling pass through $A$. The scaling procedure is terminated if $a_p\ge a_{p-1}\times r$ for some $p\ge 3$. Thus, increasing the value of $r$ from $0.9$ to $0.99$ (say) will probably increase the number of passes through $A$.

If $r\le 0$ or $r\ge 1$, the default value is used.

‘Start Objective Check At Column’int

Default $=1$

These keywords take effect only if $\text{‘Verify Level'}>0$. They may be used to control the verification of gradient elements computed by $objfun$ and/or Jacobian elements computed by $confun$. For example, if the first $30$ elements of the objective gradient appeared to be correct in an earlier run, so that only element $31$ remains questionable, then it is reasonable to specify $\text{‘Start Objective Check At Column'}=31$. Similarly for columns of the Jacobian. If the first $30$ variables occur nonlinearly in the constraints but the remaining variables are nonlinear only in the objective, then $objfun$ must set the first $30$ elements of the array $objgrd$ to zero, but these hardly need to be verified. Again it is reasonable to specify $\text{‘Start Objective Check At Column'}=31$.

If $i_2\le 0$ or $i_2>n_1^{\prime }$, the default value is used.

If $i_1\le 0$ or $i_1>min(n_1^{\prime },i_2)$, the default value is used.

If $i_4\le 0$ or $i_4>n_1^{\prime \prime }$, the default value is used.

If $i_3\le 0$ or $i_3>min(n_1^{\prime \prime },i_4)$, the default value is used.

‘Stop Objective Check At Column’int

Default $=n_1^{\prime }$

These keywords take effect only if $\text{‘Verify Level'}>0$. They may be used to control the verification of gradient elements computed by $objfun$ and/or Jacobian elements computed by $confun$. For example, if the first $30$ elements of the objective gradient appeared to be correct in an earlier run, so that only element $31$ remains questionable, then it is reasonable to specify $\text{‘Start Objective Check At Column'}=31$. Similarly for columns of the Jacobian. If the first $30$ variables occur nonlinearly in the constraints but the remaining variables are nonlinear only in the objective, then $objfun$ must set the first $30$ elements of the array $objgrd$ to zero, but these hardly need to be verified. Again it is reasonable to specify $\text{‘Start Objective Check At Column'}=31$.

If $i_2\le 0$ or $i_2>n_1^{\prime }$, the default value is used.

If $i_1\le 0$ or $i_1>min(n_1^{\prime },i_2)$, the default value is used.

If $i_4\le 0$ or $i_4>n_1^{\prime \prime }$, the default value is used.

If $i_3\le 0$ or $i_3>min(n_1^{\prime \prime },i_4)$, the default value is used.

‘Start Constraint Check At Column’int

Default $=1$

These keywords take effect only if $\text{‘Verify Level'}>0$. They may be used to control the verification of gradient elements computed by $objfun$ and/or Jacobian elements computed by $confun$. For example, if the first $30$ elements of the objective gradient appeared to be correct in an earlier run, so that only element $31$ remains questionable, then it is reasonable to specify $\text{‘Start Objective Check At Column'}=31$. Similarly for columns of the Jacobian. If the first $30$ variables occur nonlinearly in the constraints but the remaining variables are nonlinear only in the objective, then $objfun$ must set the first $30$ elements of the array $objgrd$ to zero, but these hardly need to be verified. Again it is reasonable to specify $\text{‘Start Objective Check At Column'}=31$.

If $i_2\le 0$ or $i_2>n_1^{\prime }$, the default value is used.

If $i_1\le 0$ or $i_1>min(n_1^{\prime },i_2)$, the default value is used.

If $i_4\le 0$ or $i_4>n_1^{\prime \prime }$, the default value is used.

If $i_3\le 0$ or $i_3>min(n_1^{\prime \prime },i_4)$, the default value is used.

‘Stop Constraint Check At Column’int

Default $=n_1^{\prime \prime }$

These keywords take effect only if $\text{‘Verify Level'}>0$. They may be used to control the verification of gradient elements computed by $objfun$ and/or Jacobian elements computed by $confun$. For example, if the first $30$ elements of the objective gradient appeared to be correct in an earlier run, so that only element $31$ remains questionable, then it is reasonable to specify $\text{‘Start Objective Check At Column'}=31$. Similarly for columns of the Jacobian. If the first $30$ variables occur nonlinearly in the constraints but the remaining variables are nonlinear only in the objective, then $objfun$ must set the first $30$ elements of the array $objgrd$ to zero, but these hardly need to be verified. Again it is reasonable to specify $\text{‘Start Objective Check At Column'}=31$.

If $i_2\le 0$ or $i_2>n_1^{\prime }$, the default value is used.

If $i_1\le 0$ or $i_1>min(n_1^{\prime },i_2)$, the default value is used.

If $i_4\le 0$ or $i_4>n_1^{\prime \prime }$, the default value is used.

If $i_3\le 0$ or $i_3>min(n_1^{\prime \prime },i_4)$, the default value is used.

‘Superbasics Limit’int

Default $=min(500,\overline{n}+1)$

Note that this option does not apply to linear problems.

It places a limit on the storage allocated for superbasic variables. Ideally, the value of $i$ should be set slightly larger than the ‘number of degrees of freedom’ expected at the solution.

For nonlinear problems, the number of degrees of freedom is often called the ‘number of independent variables’. Normally, the value of $i$ need not be greater than $\overline{n}+1$, but for many problems it may be considerably smaller. (This will save storage if $\overline{n}$ is very large.)

If $i\le 0$, the default value is used.

‘Unbounded Objective’float

Default $={10}^{15}$

These options are intended to detect unboundedness in nonlinear problems. During the linesearch, the objective function $f$ is evaluated at points of the form $x+\alpha p$, where $x$ and $p$ are fixed and $\alpha$ varies. If $\left|f\right|$ exceeds $r_1$ or $\alpha$ exceeds $r_2$, the iterations are terminated and the function returns with $errno$ = 3.

If singularities are present, unboundedness in $f\left(x\right)$ may manifest itself by a floating-point overflow during the evaluation of $f(x+\alpha p)$, before the test against $r_1$ can be made.

Unboundedness in $x$ is best avoided by placing finite upper and lower bounds on the variables.

If $r_1\le 0$ or $r_2\le 0$, the appropriate default value is used.

‘Unbounded Step Size’float

Default $=max(\text{bigbnd},{10}^{20})$

These options are intended to detect unboundedness in nonlinear problems. During the linesearch, the objective function $f$ is evaluated at points of the form $x+\alpha p$, where $x$ and $p$ are fixed and $\alpha$ varies. If $\left|f\right|$ exceeds $r_1$ or $\alpha$ exceeds $r_2$, the iterations are terminated and the function returns with $errno$ = 3.

If singularities are present, unboundedness in $f\left(x\right)$ may manifest itself by a floating-point overflow during the evaluation of $f(x+\alpha p)$, before the test against $r_1$ can be made.

Unboundedness in $x$ is best avoided by placing finite upper and lower bounds on the variables.

If $r_1\le 0$ or $r_2\le 0$, the appropriate default value is used.

‘Verify Level’int

Default $=0$

This option refers to finite difference checks on the gradient elements computed by $objfun$ and $confun$. Gradients are verified at the first point that satisfies the linear constraints and the upper and lower bounds. Unspecified gradient elements are not checked and hence they result in no overhead. The possible choices for $i$ are the following.

$i$	Meaning
$-1$	No checks are performed.
$0$	Only a ‘cheap’ test will be performed, requiring three calls to $objfun$ and two calls to $confun$. Note that no checks are carried out if every column of the constraint gradients (Jacobian) contains a missing element.
$1$	Individual objective gradient elements will be checked using a reliable (but more expensive) test. If $\text{‘Major Print Level'}>0$, a key of the form OK or BAD? indicates whether or not each element appears to be correct. If a gradient element is determined to be extremely poor (i.e., if it appears to have no significant digits of accuracy at all), then nlp1_sparse_solve will also exit with an error indicator in argument $\text{errno}$.
$2$	Individual columns of the constraint gradients (Jacobian) will be checked using a reliable (but more expensive) test. If $\text{‘Major Print Level'}>0$, a key of the form OK or BAD? indicates whether or not each element appears to be correct.
$3$	Check both constraint and objective gradients (in that order) as described above for $i=2$ and $i=1$ respectively.

The value $i=3$ should be used whenever a new function function is being developed. The ‘Start Objective Check At Column’ and ‘Stop Objective Check At Column’ keywords may be used to limit the number of nonlinear variables to be checked.

If $i<-1$ or $i>3$, the default value is used.

‘Violation Limit’float

Default $=10.0$

This option defines an absolute limit on the magnitude of the maximum constraint violation after the linesearch. Upon completion of the linesearch, the new iterate $x_{k+1}$ satisfies the condition

$$v_i\left(x_{k+1}\right)\le r\times max(1,v_i\left(x_0\right))\text{,}$$

where $x_0$ is the point at which the nonlinear constraints are first evaluated and $v_i\left(x\right)$ is the $i$th nonlinear constraint violation $v_i\left(x\right)=max(0,l_i-F_i\left(x\right),F_i\left(x\right)-u_i)$.

The effect of the violation limit is to restrict the iterates to lie in an expanded feasible region whose size depends on the magnitude of $r$. This makes it possible to keep the iterates within a region where the objective function is expected to be well-defined and bounded below (or above in the case of maximization). If the objective function is bounded below (or above in the case of maximization) for all values of the variables, then $r$ may be any large positive value.

If $r\le 0$, the default value is used.

Raises

NagValueError

(errno $7$)

On entry, $start=⟨value⟩$.

Constraint: $start=\text{'C'}$ or $\text{'W'}$.

(errno $7$)

On entry, $n=⟨value⟩$.

Constraint: $n\ge 1$.

(errno $7$)

On entry, $m=⟨value⟩$.

Constraint: $m\ge 1$.

(errno $7$)

On entry, $\text{nnz}=⟨value⟩$, $n=⟨value⟩$ and $m=⟨value⟩$.

Constraint: $1\le \text{nnz}\le n\times m$.

(errno $7$)

On entry, $ncnln=⟨value⟩$ and $m=⟨value⟩$.

Constraint: $0\le ncnln\le m$.

(errno $7$)

On entry, $nonln=⟨value⟩$ and $n=⟨value⟩$.

Constraint: $0\le nonln\le n$.

(errno $7$)

On entry, $ncnln=0$ and $njnln=⟨value⟩$.

Constraint: if $ncnln=0$ then $nonln=0$.

(errno $7$)

On entry, $njnln=⟨value⟩$, $n=⟨value⟩$ and $ncnln=⟨value⟩$.

Constraint: if $ncnln>0$ then $1\le njnln\le n$.

(errno $7$)

On entry, $iobj=⟨value⟩$.

Constraint: $iobj\ge -1$.

(errno $7$)

On entry, $iobj=⟨value⟩$, $ncnln=⟨value⟩$ and $m=⟨value⟩$.

Constraint: $ncnln<iobj\le m$.

(errno $7$)

On entry, $\text{nname}=⟨value⟩$, $n=⟨value⟩$ and $m=⟨value⟩$.

Constraint: $\text{nname}=1$ or $\text{nname}=n+m$.

(errno $7$)

On entry, $leniz=⟨value⟩$, $n=⟨value⟩$ and $m=⟨value⟩$.

Constraint: $leniz\ge max(500,m+n)$.

(errno $7$)

On entry, $lenz=⟨value⟩$.

Constraint: $lenz\ge 500$.

(errno $7$)

On entry, $m=⟨value⟩$ and $ha[⟨value⟩]=⟨value⟩$.

Constraint: $1\le ha\left[j\right]\le m$ for all $j$.

(errno $7$)

On entry, $ka\left[0\right]=⟨value⟩$.

Constraint: $ka\left[0\right]=1$.

(errno $7$)

On entry, $n+1=⟨value⟩$, $ka\left[n\right]=⟨value⟩$ and $\text{nnz}+1=⟨value⟩$.

Constraint: $ka\left[n\right]=\text{nnz}+1$.

(errno $7$)

On entry, $ka[⟨value⟩]=⟨value⟩$.

Constraint: $ka\left[j\right]\ge 1$ for all $j$.

(errno $7$)

On entry, $m=⟨value⟩$, $ka\left[j\right]=⟨value⟩$ and $ka[j-1]=⟨value⟩$, for $j=⟨value⟩$.

Constraint: $0\le ka[j+1]-ka\left[j\right]\le m$ for all $j$.

(errno $7$)

On entry, duplicate element found in row $⟨value⟩$, column $⟨value⟩$.

(errno $7$)

On entry, $start=\text{'C'}$ and $istate[⟨value⟩]=⟨value⟩$.

Constraint: if $start=\text{'C'}$ then $istate\left[i\right]\ge 0$ for all $i$.

(errno $7$)

On entry, $start=\text{'C'}$ and $istate[⟨value⟩]=⟨value⟩$.

Constraint: if $start=\text{'C'}$ then $istate\left[i\right]\le 5$ for all $i$.

(errno $7$)

On entry, $start=\text{'W'}$ and $istate[⟨value⟩]=⟨value⟩$.

Constraint: if $start=\text{'W'}$ then $istate\left[i\right]\ge 0$ for all $i$.

(errno $7$)

On entry, $start=\text{'W'}$ and $istate[⟨value⟩]=⟨value⟩$.

Constraint: if $start=\text{'W'}$ then $istate\left[i\right]\le 3$ for all $i$.

(errno $7$)

On entry, $n=⟨value⟩$, $iobj=⟨value⟩$, $bl[n+\left|iobj\right|-1]=⟨value⟩$ and $\text{bigbnd}=⟨value⟩$.

Constraint: $bl[n+\left|iobj\right|-1]\le -\text{bigbnd}$.

(errno $7$)

On entry, $n=⟨value⟩$, $iobj=⟨value⟩$, $bu[n+\left|iobj\right|-1]=⟨value⟩$ and $\text{bigbnd}=⟨value⟩$.

Constraint: $bu[n+\left|iobj\right|-1]\ge \text{bigbnd}$.

(errno $7$)

On entry, the equal bounds on $⟨value⟩$ are infinite, because $bl[⟨value⟩]=\text{beta}$ and $bu[⟨value⟩]=\text{beta}$, but $\left|\text{beta}\right|\ge \text{bigbnd}$: $\text{beta}=⟨value⟩$ and $\text{bigbnd}=⟨value⟩$.

(errno $7$)

On entry, the bounds on $⟨value⟩$ are inconsistent: $bl[⟨value⟩]=⟨value⟩$ and $bu[⟨value⟩]=⟨value⟩$.

(errno $8$)

Function $objfun$ appears to be giving incorrect gradients.

(errno $9$)

Function $confun$ appears to be giving incorrect gradients.

(errno $11$)

Numerical error in trying to satisfy the linear constraints.

(errno $12$)

Not enough integer workspace for the basis factors.

(errno $13$)

Not enough real workspace for the basis factors.

Warns

NagAlgorithmicWarning

(errno $-1$)

Constraint and objective values could not be calculated.

(errno $i<0$)

User requested termination by setting $mode$ negative in $objfun$ or $confun$.

(errno $1$)

Infeasible problem, nonlinear infeasibilities minimized.

(errno $1$)

No feasible point for the nonlinear constraints.

(errno $1$)

No feasible point for the linear constraints.

(errno $2$)

The problem is unbounded (or badly scaled).

(errno $3$)

Violation Limit exceeded. The problem may be unbounded.

(errno $5$)

Feasible solution, but requested accuracy could not be achieved.

(errno $10$)

Current point cannot be improved upon.

(errno $14$)

The basis is singular after $15$ factorization attempts.

(errno $15$)

Not enough integer workspace to start solving the problem.

(errno $16$)

Not enough real workspace to start solving the problem.

NagAlgorithmicMajorWarning

(errno $4$)

Major Iteration Limit exceeded.

(errno $4$)

Minor Iteration Limit exceeded.

(errno $4$)

Iteration Limit exceeded.

(errno $6$)

The value of the option ‘Superbasics Limit’ is too small.

Notes

In the NAG Library the traditional C interface for this routine uses a different algorithmic base. Please contact NAG if you have any questions about compatibility.

nlp1_sparse_solve is designed to solve a class of nonlinear programming problems that are assumed to be stated in the following general form:

$$\begin{array}{c}{minimize}_{x\in R^n}f\left(x\right)\text{subject to}l\le \left\{\begin{array}{c}x\\ F\left(x\right)\\ Gx\end{array}\right\}\le u\text{,}\end{array}$$

where $x={(x_1,x_2,\dots ,x_n)}^T$ is a set of variables, $f\left(x\right)$ is a smooth scalar objective function, $l$ and $u$ are constant lower and upper bounds, $F\left(x\right)$ is a vector of smooth nonlinear constraint functions $\left\{F_i\left(x\right)\right\}$ and $G$ is a sparse matrix.

The constraints involving $F$ and $Gx$ are called the general constraints. Note that upper and lower bounds are specified for all variables and constraints. This form allows full generality in specifying various types of constraint. In particular, the $j$th constraint can be defined as an equality by setting $l_j=u_j$. If certain bounds are not present, the associated elements of $l$ or $u$ can be set to special values that will be treated as $-\infty$ or $+\infty$. (See the description of the option ‘Infinite Bound Size’.)

nlp1_sparse_solve converts the upper and lower bounds on the $m$ elements of $F$ and $Gx$ to equalities by introducing a set of slack variables $s$, where $s={(s_1,s_2,\dots ,s_m)}^T$. For example, the linear constraint $5\le 2x_1+3x_2\le +\infty$ is replaced by $2x_1+3x_2-s_1=0$, together with the bounded slack $5\le s_1\le +\infty$. The problem defined by (1) can, therefore, be re-written in the following equivalent form:

$$\begin{array}{c}{minimize}_{x\in R^n,s\in R^m}f\left(x\right)\text{subject to}\left\{\begin{array}{c}Gx\end{array}\right\}-s=0\text{,}l\le \left\{\begin{array}{c}x\\ s\end{array}\right\}\le u\text{.}\end{array}$$

Since the slack variables $s$ are subject to the same upper and lower bounds as the elements of $F$ and $Gx$, the bounds on $F$ and $Gx$ can simply be thought of as bounds on the combined vector $(x,s)$. The elements of $x$ and $s$ are partitioned into basic, nonbasic and superbasic variables defined as follows:

• a basic variable ($x_j$ say) is the $j$th variable associated with the $j$th column of the basis matrix $B$;

• a nonbasic variable is a variable that is temporarily fixed at its current value (usually its upper or lower bound);

• a superbasic variable is a nonbasic variable which is not at one of its bounds that is free to move in any desired direction (namely one that will improve the value of the objective function or reduce the sum of infeasibilities).

For example, in the simplex method (see Gill et al. (1981)) the elements of $x$ can be partitioned at each vertex into a set of $m$ basic variables (all non-negative) and a set of $(n-m)$ nonbasic variables (all zero). This is equivalent to partitioning the columns of the constraint matrix as $\left(\begin{array}{cc}B& N\end{array}\right)$, where $B$ contains the $m$ columns that correspond to the basic variables and $N$ contains the $(n-m)$ columns that correspond to the nonbasic variables. Note that $B$ is square and nonsingular.

The option ‘Maximize’ may be used to specify an alternative problem in which $f\left(x\right)$ is maximized. If the objective function is nonlinear and all the constraints are linear, $F$ is absent and the problem is said to be linearly constrained. In general, the objective and constraint functions are structured in the sense that they are formed from sums of linear and nonlinear functions. This structure can be exploited by the function during the solution process as follows.

Consider the following nonlinear optimization problem with four variables ($u,v,z,w$):

$${minimize}_{u,v,z,w}{(u+v+z)}^2+3z+5w$$

subject to the constraints

$$\begin{array}{c}\begin{array}{c}{u}^2+v^2+z=2\\ u^4+v^4+w=4\\ 2u+4v\ge 0\end{array}\end{array}$$

and to the bounds

$$\begin{array}{c}\begin{array}{c}z\ge 0\\ w\ge 0\text{.}\end{array}\end{array}$$

This problem has several characteristics that can be exploited by the function:

• the objective function is nonlinear. It is the sum of a nonlinear function of the variables ($u,v,z$) and a linear function of the variables ($z,w$);

• the first two constraints are nonlinear. The third is linear;

• each nonlinear constraint function is the sum of a nonlinear function of the variables ($u,v$) and a linear function of the variables ($z,w$).

The nonlinear terms are defined by $objfun$ and $confun$ (see Parameters), which involve only the appropriate subset of variables.

For the objective, we define the function $f(u,v,z)={(u+v+z)}^2$ to include only the nonlinear part of the objective. The three variables ($u,v,z$) associated with this function are known as the nonlinear objective variables. The number of them is given by $nonln$ (see Parameters) and they are the only variables needed in $objfun$. The linear part $3z+5w$ of the objective is stored in row $iobj$ (see Parameters) of the (constraint) Jacobian matrix $A$ (see below).

Thus, if $x^{\prime }$ and $y^{\prime }$ denote the nonlinear and linear objective variables, respectively, the objective may be re-written in the form

$$f\left(x^{\prime }\right)+c^T{x}^{\prime }+d^T{y}^{\prime }\text{,}$$

where $f\left(x^{\prime }\right)$ is the nonlinear part of the objective and $c$ and $d$ are constant vectors that form a row of $A$. In this example, $x^{\prime }=(u,v,z)$ and $y^{\prime }=w$.

Similarly for the constraints, we define a vector function $F(u,v)$ to include just the nonlinear terms. In this example, $F_1(u,v)=u^2+v^2$ and $F_2(u,v)=u^4+v^4$, where the two variables ($u,v$) are known as the nonlinear Jacobian variables. The number of them is given by $njnln$ (see Parameters) and they are the only variables needed in $confun$. Thus, if $x^{\prime \prime }$ and $y^{\prime \prime }$ denote the nonlinear and linear Jacobian variables, respectively, the constraint functions and the linear part of the objective have the form

$$\begin{array}{c}\left(\begin{array}{c}F\left(x^{\prime \prime }\right)+A_2{y}^{\prime \prime }\\ A_3{x}^{\prime \prime }+A_4{y}^{\prime \prime }\end{array}\right)\text{,}\end{array}$$

where $x^{\prime \prime }=(u,v)$ and $y^{\prime \prime }=(z,w)$ in this example. This ensures that the Jacobian is of the form

$$\begin{array}{c}A=\left(\begin{array}{cc}J\left(x^{\prime \prime }\right)& A_2\\ A_3& A_4\end{array}\right)\text{,}\end{array}$$

where $J\left(x^{\prime \prime }\right)=\frac{\partial F\left(x^{\prime \prime }\right)}{\partial x}$. Note that $J\left(x^{\prime \prime }\right)$ always appears in the top left-hand corner of $A$.

The inequalities $l_1\le F\left(x^{\prime \prime }\right)+A_2{y}^{\prime \prime }\le u_1$ and $l_2\le A_3{x}^{\prime \prime }+A_4{y}^{\prime \prime }\le u_2$ implied by the constraint functions in (3) are known as the nonlinear and linear constraints, respectively. The nonlinear constraint vector $F\left(x^{\prime \prime }\right)$ in (3) and (optionally) its partial derivative matrix $J\left(x^{\prime \prime }\right)$ are set in $confun$. The matrices $A_2$, $A_3$ and $A_4$ contain any (constant) linear terms. Along with the sparsity pattern of $J\left(x^{\prime \prime }\right)$ they are stored in the arrays $a$, $ha$ and $ka$ (see Parameters).

In general, the vectors $x^{\prime }$ and $x^{\prime \prime }$ have different dimensions, but they always overlap, in the sense that the shorter vector is always the beginning of the other. In the above example, the nonlinear Jacobian variables $(u,v)$ are an ordered subset of the nonlinear objective variables $(u,v,z)$. In other cases it could be the other way round (whichever is the most convenient), but the first way keeps $J\left(x^{\prime \prime }\right)$ as small as possible.

Note that the nonlinear objective function $f\left(x^{\prime }\right)$ may involve either a subset or superset of the variables appearing in the nonlinear constraint functions $F\left(x^{\prime \prime }\right)$. Thus, $nonln\le njnln$ (or vice-versa). Sometimes the objective and constraints really involve disjoint sets of nonlinear variables. In such cases the variables should be ordered so that $nonln>njnln$ and $x^{\prime }=(x^{\prime \prime },x^{\prime \prime \prime })$, where the objective is nonlinear in just the last vector $x^{\prime \prime \prime }$. The first $njnln$ elements of the gradient array $objgrd$ should also be set to zero in $objfun$.

If all elements of the constraint Jacobian are known (i.e., the option $\text{‘Derivative Level'}=2$ or $3$), any constant elements may be assigned their correct values in $a$, $ha$ and $ka$. The corresponding elements of the constraint Jacobian array $fjac$ need not be reset in $confun$. This includes values that are identically zero as constraint Jacobian elements are assumed to be zero unless specified otherwise. It must be emphasized that, if $\text{‘Derivative Level'}=0$ or $1$, unassigned elements of $fjac$ are not treated as constant; they are estimated by finite differences, at nontrivial expense.

If there are no nonlinear constraints in (1) and $f\left(x\right)$ is linear or quadratic, then it may be more efficient to use qpconvex2_sparse_solve() to solve the resulting linear or quadratic programming problem, or one of lp_solve(), lsq_lincon_solve() or qp_dense_solve() if $G$ is a dense matrix. If the problem is dense and does have nonlinear constraints then one of nlp2_solve(), nlp1_rcomm() or lsq_gencon_deriv() (as appropriate) should be used instead.

You must supply an initial estimate of the solution to (1), together with versions of $objfun$ and $confun$ that define $f\left(x^{\prime }\right)$ and $F\left(x^{\prime \prime }\right)$, respectively, and as many first partial derivatives as possible. Note that if there are any nonlinear constraints, then the first call to $confun$ will precede the first call to $objfun$.

nlp1_sparse_solve is based on the SNOPT package described in Gill et al. (2002), which in turn utilizes functions from the MINOS package (see Murtagh and Saunders (1995)). It incorporates a Sequential Quadratic Programming (SQP) method that obtains search directions from a sequence of Quadratic Programming (QP) subproblems. Each QP subproblem minimizes a quadratic model of a certain Lagrangian function subject to a linearization of the constraints. An augmented Lagrangian merit function is reduced along each search direction to ensure convergence from any starting point. Further details can be found in Algorithmic Details.

Throughout this document the symbol $ϵ$ is used to represent the machine precision (see machine.precision).

References

Conn, A R, 1973, Constrained optimization using a nondifferentiable penalty function, SIAM J. Numer. Anal. (10), 760–779

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

Fletcher, R, 1984, An $l_1$ penalty method for nonlinear constraints, Numerical Optimization 1984, (eds P T Boggs, R H Byrd and R B Schnabel), 26–40, SIAM Philadelphia

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, 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, 1989, A practical anti-cycling procedure for linearly constrained optimization, Math. Programming (45), 437–474

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

Gill, P E, Murray, W and Wright, M H, 1981, Practical Optimization, Academic Press

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, 1995, MINOS 5.4 users’ guide, Report SOL 83-20R, Department of Operations Research, Stanford University

Ortega, J M and Rheinboldt, W C, 1970, Iterative Solution of Nonlinear Equations in Several Variables, Academic Press

Powell, M J D, 1974, Introduction to constrained optimization, Numerical Methods for Constrained Optimization, (eds P E Gill and W Murray), 1–28, Academic Press

See also

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