For each option, we give a summary line, a description of the optional parameter and details of constraints.

The summary line contains:

Keywords and character values are case and white space insensitive.

Note that this option does not apply when $\mathbf{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 optional parameter Forward Difference Interval). The interval used for the $j$th variable is $h_j=r\left(1+\left|x_j\right|\right)$. The resulting gradient estimates should be accurate to $\mathit{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.

Every $i$th minor iteration after the most recent basis factorization, a numerical test is made to see if the current solution $\left(x,s\right)$ 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.

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

If $\mathbf{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.

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.

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.

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

This parameter indicates which nonlinear function gradients are provided in user-supplied delegates objfun and confun. The possible choices for $i$ are the following.

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\text{ or }2$, e04ug 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\text{ or }1$, e04ug 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 where ‘$*$’ indicates an element provided and ‘?’ indicates an unspecified element, e04ug 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.

At each major iteration, a linesearch is used to improve the value of the Lagrangian merit function (6). 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 optional parameter 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 optional parameter Nonderivative Linesearch is selected, e04ug signals the evaluation of the linesearch by calling objfun and confun with $\mathbf{mode}=0$. Once the linesearch is complete, the nonlinear functions are re-evaluated with $\mathbf{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 $\mathbf{mode}=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 (8).

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 \left(1+{‖g\left(x_k\right)‖}_2\right)$, where $g$ is the objective gradient. In either case, the QP subproblem is resolved in elastic mode with $\gamma =r\times \left(1+{‖g\left(x_k\right)‖}_2\right)$.

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

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

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 optional parameter Minor Feasibility Tolerance is $\delta$. Over a period of $i$ iterations, the feasibility tolerance actually used by e04ug (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 optional parameter 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.

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 optional parameter 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.

Note that this option is ignored if the value of optional parameter 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 optional parameter 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.

If optional parameter 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.

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

(a)	For verifying the objective and/or constraint gradients (see the description of the optional parameter Verify Level).
(b)	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\left(1+\left|x_j\right|\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 $\mathit{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.

This parameter defines the relative function precision ${\epsilon }_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 ${\epsilon }_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, ${\epsilon }_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 ${\epsilon }_r$ would be ${10}^{-10}$.

The choice of ${\epsilon }_r$ can be quite complicated for badly scaled problems; see Chapter 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<\epsilon$ or $r\ge 1$, the default value is used.

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 optional parameter Hessian Full Memory.

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

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, $\stackrel{-}{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 $\stackrel{-}{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 $\mathbf{Hessian\; Frequency}=20$ is used in conjunction with Hessian Full Memory, the effect will be similar to using Hessian Limited Memory in conjunction with $\mathbf{Hessian\; Updates}=20$, except that the latter will retain the current diagonal during resets.

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.

If $r>0$, $r$ defines the ‘infinite’ bound $\mathit{bigbnd}$ in the definition of the problem constraints. Any upper bound greater than or equal to $\mathit{bigbnd}$ will be regarded as $+\infty$ (and similarly any lower bound less than or equal to $-\mathit{bigbnd}$ will be regarded as $-\infty$).

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

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 optional parameters Major Iteration Limit and Minor Iteration Limit.)

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

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\text{ 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 $\mathbf{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 $\mathbf{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.

Normally each optional parameter specification is printed as it is supplied. Optional parameter Nolist may be used to suppress the printing and optional parameter List may be used to restore printing.

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 {\displaystyle \underset{i}{\max }}\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 $\mathbf{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.

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

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 where ${\mathit{viol}}_i$ is the violation of the $i$th nonlinear constraint.

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

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 $\mathbf{Major\; Print\; Level}>0$ means that the objective and constraint gradients will be checked if $\mathbf{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.

This option specifies the final accuracy of the dual variables. If e04ug terminates with $\mathbf{ifail}=0$, a primal and dual solution ($x,s,\pi$) will have been computed such that where ${\mathit{gap}}_j$ is an estimate of the complementarity gap for the $j$th variable and $‖\pi ‖$ is a measure of the size of the QP dual variables (or Lagrange multipliers) given by It is included to make the tests independent of a scale factor on the objective function. Specifically, ${\mathit{gap}}_j$ is computed from the final QP solution using the reduced gradients $d_j=g_j-{\pi }^{\mathrm{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)$:

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

The value of $i$ controls the amount of printout produced by the major iterations of e04ug, 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 [Description of Monitoring Information] (monitoring information at each major iteration). (See also the description of Minor Print Level.)

The following printout is sent to the current advisory message unit (as defined by (X04ABF not in this release)):

The following printout is sent to the logical unit number defined by the optional parameter Monitoring File:

If $\mathbf{Major\; Print\; Level}\ge 5$ and the unit number defined by the optional parameter Monitoring File is the same as that defined by (X04ABF not in this release) then the summary output for each major iteration is suppressed.

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 \left(1,\beta \right)$.

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 parameter $r$ is therefore used to define a step limit $\stackrel{-}{\beta }$ given by 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 \left(1,\stackrel{-}{\beta },\beta \right)$.

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

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 optional parameter 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 $\mathbf{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\left(x_1,x_2\right)=\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 method 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 \epsilon$, the default value is used.

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 optional parameter Crash Option.)

In general, it is unsafe to specify values as small as $i=1\text{ 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.

This option is used to judge optimality for each QP subproblem. Let the QP reduced gradients be $d_j=g_j-{\pi }^{\mathrm{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 respectively, and if $\frac{\left|d_j\right|}{‖\pi ‖}\le r$ for superbasic variables.

Note that $‖\pi ‖$ 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 $‖\pi ‖$ actually used is defined in the description for optional parameter 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.

The value of $i$ controls the amount of printout produced by the minor iterations of e04ug (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 [Description of Monitoring Information] (monitoring information at each minor iteration). (See also the description of the optional parameter Major Print Level.)

The following printout is sent to the current advisory message unit (as defined by (X04ABF not in this release)):

The following printout is sent to the logical unit number defined by the optional parameter Monitoring File:

If $\mathbf{Minor\; Print\; Level}\ge 1$ and the unit number defined by the optional parameter Monitoring File is the same as that defined by (X04ABF not in this release) then the summary output for each minor iteration is suppressed.

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

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.

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

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.

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 ${\stackrel{-}{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 ${\stackrel{-}{l}}_j=l_j/c_j$ and ${\stackrel{-}{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.

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.

Note that this option does not apply when $\mathbf{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.

These keywords take effect only if $\mathbf{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 $\mathbf{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 $\mathbf{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 \left(n_1^{\prime },i_2\right)$, 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 \left(n_1^{\prime \prime },i_4\right)$, the default value is used.

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 $\stackrel{-}{n}+1$, but for many problems it may be considerably smaller. (This will save storage if $\stackrel{-}{n}$ is very large.)

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

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 method returns with $\mathbf{ifail}=3$.

If singularities are present, unboundedness in $f\left(x\right)$ may manifest itself by a floating-point overflow during the evaluation of $f\left(x+\alpha p\right)$, 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.

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.

The value $i=3$ should be used whenever a new function method 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.

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 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 \left(0,l_i-F_i\left(x\right),F_i\left(x\right)-u_i\right)$.

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.