On entry: if  the argument settings in the call to nag_opt_nlp (e04ucc) will be printed.

On entry: the level of results printout produced by nag_opt_nlp (e04ucc) at each major iteration. The following values are available:

"Nag_NoPrint" No output.

"Nag_Soln" The final solution only.

"Nag_Iter" One line of output for each iteration.

"Nag_Iter_Long" A longer line of output for each iteration with more information (line exceeds 80 characters).

"Nag_Soln_Iter" The final solution and one line of output for each iteration.

"Nag_Soln_Iter_Long" The final solution and one long line of output for each iteration (line exceeds 80 characters).

"Nag_Soln_Iter_Const" As "Nag_Soln_Iter_Long" with the objective function, the values of the variables, the Euclidean norm of the nonlinear constraint violations, the nonlinear constraint values, , and the linear constraint values  also printed at each iteration.

"Nag_Soln_Iter_Full" As "Nag_Soln_Iter_Const" with the diagonal elements of the upper triangular matrix  associated with the  factorization (5) of the QP working set, and the diagonal elements of , the triangular factor of the transformed and re-ordered Hessian (6).

Details of each level of results printout are described in Section [Description of Printed Output ].

Constraint:   "Nag_NoPrint", "Nag_Soln", "Nag_Iter", "Nag_Soln_Iter", "Nag_Iter_Long", "Nag_Soln_Iter_Long", "Nag_Soln_Iter_Const" or "Nag_Soln_Iter_Full". .

On entry: the level of results printout produced by the minor iterations of nag_opt_nlp (e04ucc) (i.e., the iterations of the QP subproblem). The following values are available:

"Nag_NoPrint" No output.

"Nag_Soln" The final solution only.

"Nag_Iter" One line of output for each iteration.

"Nag_Iter_Long" A longer line of output for each iteration with more information (line exceeds 80 characters).

"Nag_Soln_Iter" The final solution and one line of output for each iteration.

"Nag_Soln_Iter_Long" The final solution and one long line of output for each iteration (line exceeds 80 characters).

"Nag_Soln_Iter_Const" As "Nag_Soln_Iter_Long" with the Lagrange multipliers, the variables , the constraint values  and the constraint status also printed at each iteration.

"Nag_Soln_Iter_Full" As "Nag_Soln_Iter_Const" with the diagonal elements of the upper triangular matrix  associated with the  factorization (4) of the working set, and the diagonal elements of the upper triangular matrix  printed at each iteration.

Details of each level of results printout are described in Section [Optional Arguments] of the document for e04ncc (nag_opt_lin_lsq). (minor_print_level in the present function is equivalent to optional_settings[print_level].)

Constraint:   "Nag_NoPrint", "Nag_Soln", "Nag_Iter", "Nag_Soln_Iter", "Nag_Iter_Long", "Nag_Soln_Iter_Long", "Nag_Soln_Iter_Const" or "Nag_Soln_Iter_Full". .

On entry: The name of a file to which intermediate or diagnostic output should be appended. If a value is not provided for this parameter then the behaviour of this routine is platform dependent. Usually all output will be suppressed, however on some platforms output will be produced and will be displayed in the Maple session.

On entry: this argument indicates whether all the derivatives of the objective function are provided by the user in function objfun. If none or only some of the derivatives are being supplied by objfun then obj_deriv should be set to false.

Whenever possible all derivatives should be supplied, since nag_opt_nlp (e04ucc) is more reliable and will usually be more efficient when all derivatives are exact.

If , nag_opt_nlp (e04ucc) will approximate the unspecified components of the objective gradient, using finite differences. The computation of finite-difference approximations usually increases the total run-time, since a call to objfun is required for each unspecified element. Furthermore, less accuracy can be attained in the solution (see Chapter 8 of Gill et al. (1986c), for a discussion of limiting accuracy).

At times, central differences are used rather than forward differences, in which case twice as many calls to objfun are needed. (The switch to central differences is not under the user's control.)

On entry: this argument indicates whether all derivatives for the constraint Jacobian are provided by the user in function confun. If none or only some of the derivatives are being supplied by confun then con_deriv should be set to false.

Whenever possible all derivatives should be supplied, since nag_opt_nlp (e04ucc) is more reliable and will usually be more efficient when all derivatives are exact.

If , nag_opt_nlp (e04ucc) will approximate unspecified elements of the Jacobian. One call to confun is needed for each variable for which partial derivatives are not available. For example, if the constraint Jacobian has the form

where "*" indicates an element provided by the user and "?" indicates an unspecified element, nag_opt_nlp (e04ucc) 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 confun are needed. (The switch to central differences is not under the user's control.)

On entry: specifies the level of derivative checking to be performed by nag_opt_nlp (e04ucc) on the gradient elements computed by the user supplied functions objfun and confun.

The following values are available:

"Nag_NoCheck" No derivative checking is performed.

"Nag_SimpleCheck" Perform a simple check of both the objective and constraint gradients.

"Nag_CheckObj" Perform a component check of the objective gradient elements.

"Nag_CheckCon" Perform a component check of the constraint gradient elements.

"Nag_CheckObjCon" Perform a component check of both the objective and constraint gradient elements.

"Nag_XSimpleCheck" Perform a simple check of both the objective and constraint gradients at the initial value of  specified in x.

"Nag_XCheckObj" Perform a component check of the objective gradient elements at the initial value of  specified in x.

"Nag_XCheckCon" Perform a component check of the constraint gradient elements at the initial value of  specified in x.

"Nag_XCheckObjCon" Perform a component check of both the objective and constraint gradient elements at the initial value of  specified in x.

If   "Nag_SimpleCheck" or "Nag_XSimpleCheck" then a simple "cheap" test is performed, which requires only one call to objfun and one call to confun. If   "Nag_CheckObj", "Nag_CheckCon" or "Nag_CheckObjCon" then a more reliable (but more expensive) test will be made on individual gradient components. This component check will be made in the range specified by the optional arguments optional_settings[obj_check_start] and optional_settings[obj_check_stop] for the objective gradient, with default values being  and n respectively. For the constraint gradient the range is specified by optional_settings[con_check_start] and optional_settings[con_check_stop], with default values being  and n.

The procedure for the derivative check is based on finding an interval that produces an acceptable estimate of the second derivative, and then using that estimate to compute an interval that should produce a reasonable forward-difference approximation. The gradient element is then compared with the difference approximation. (The method of finite difference interval estimation is based on Gill et al. (1983a).) The result of the test is printed out by nag_opt_nlp (e04ucc) if optional argument .

Constraint:   "Nag_NoCheck", "Nag_SimpleCheck", "Nag_CheckObj", "Nag_CheckCon", "Nag_CheckObjCon", "Nag_XSimpleCheck", "Nag_XCheckObj", "Nag_XCheckCon" or "Nag_XCheckObjCon". .

On entry: controls whether the results of any derivative checking are printed out (see optional argument optional_settings[verify_grad]).

If a component derivative check has been carried out, then full details will be printed if . For a printout summarising the results of a component derivative check set . If only a simple derivative check is requested then "Nag_D_Sum" and "Nag_D_Full" will give the same level of output. To prevent any printout from a derivative check set .

Constraint:   "Nag_D_NoPrint", "Nag_D_Sum" or "Nag_D_Full". .

These options take effect only when   "Nag_CheckObj", "Nag_CheckObjCon", "Nag_XCheckObj" or "Nag_XCheckObjCon".

On entry: they may be used to control the verification of gradient elements computed by the function objfun. For example, if the first 30 elements appeared to be correct in an earlier run, so that only element 31 remains questionable, it is reasonable to specify . If the first 30 variables appear linearly in the objective, so that the corresponding gradient elements are constant, the above choice would also be appropriate.

Constraint: . .

These options take effect only when   "Nag_CheckCon", "Nag_CheckObjCon", "Nag_XCheckCon" or "Nag_XCheckObjCon".

On entry: these arguments may be used to control the verification of the Jacobian elements computed by the function confun. For example, if the first 30 columns of the constraint Jacobian appeared to be correct in an earlier run, so that only column 31 remains questionable, it is reasonable to specify .

Constraint: . .

On entry: defines an interval used to estimate derivatives by finite differences in the following circumstances:

a. For verifying the objective and/or constraint gradients (see the description of the optional argument optional_settings[verify_grad]).

b. For estimating unspecified elements of the objective and/or constraint Jacobian matrix.

In general, using the notation , a derivative with respect to the th variable is approximated using the interval , where , with  the first point feasible with respect to the bounds and linear constraints. If the functions are well scaled, the resulting derivative approximation should be accurate to O. See Gill et al. (1981) for a discussion of the accuracy in finite difference approximations.

If a difference interval is not specified by the user, a finite difference interval will be computed automatically for each variable by a procedure that requires up to six calls of confun and objfun for each element. This option is recommended if the function is badly scaled or the user wishes to have nag_opt_nlp (e04ucc) determine constant elements in the objective and constraint gradients (see the descriptions of confun and objfun in Section [Parameters]).

Constraint: . .

On entry: if the algorithm switches to central differences because the forward-difference approximation is not sufficiently accurate the value of c_diff_int is used as the difference interval for every element of . The switch to central differences is indicated by C at the end of each line of intermediate printout produced by the major iterations (see Section [Description of Printed Output ]). The use of finite-differences is discussed under the option optional_settings[f_diff_int].

Constraint: . .

On entry: the maximum number of major iterations allowed before termination.

Constraint: . .

On entry: the maximum number of iterations for finding a feasible point with respect to the bounds and linear constraints (if any). The value also specifies the maximum number of minor iterations for the optimality phase of each QP subproblem.

Constraint: . .

On entry: this argument defines , which is intended to be a measure of the accuracy with which the problem functions  and  can be computed.

The value of  should reflect the relative precision of ; i.e.,  acts as a relative precision when  is large, and as an absolute precision when  is small. For example, if  is typically of order 1000 and the first six significant digits are known to be correct, an appropriate value for  would be . In contrast, if  is typically of order  and the first six significant digits are known to be correct, an appropriate value for  would be . The choice of  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. However, when the accuracy of the computed function values is known to be significantly worse than full precision, the value of  should be large enough so that nag_opt_nlp (e04ucc) will not attempt to distinguish between function values that differ by less than the error inherent in the calculation.

Constraint: . .

On entry: specifies the accuracy to which the user wishes the final iterate to approximate a solution of the problem. Broadly speaking, optim_tol indicates the number of correct figures desired in the objective function at the solution. For example, if optim_tol is  and nag_opt_nlp (e04ucc) terminates successfully, the final value of  should have approximately six correct figures.

nag_opt_nlp (e04ucc) will terminate successfully if the iterative sequence of -values is judged to have converged and the final point satisfies the first-order Kuhn–Tucker conditions (see Section [Overview ]). The sequence of iterates is considered to have converged at  if

(16)

where  is the search direction and  the step length from (3), and  is the value of optim_tol. An iterate is considered to satisfy the first-order conditions for a minimum if

(17)

and

(18)

where  is the projected gradient (see Section [Overview ]),  is the gradient of  with respect to the free variables,  is the violation of the th active nonlinear constraint, and  the value of the optional argument optional_settings[nonlin_feas_tol].

Constraint: . .

On entry: defines the maximum acceptable absolute violations in the linear constraints at a "feasible" point; i.e., a linear constraint is considered satisfied if its violation does not exceed lin_feas_tol.

On entry to nag_opt_nlp (e04ucc), an iterative procedure is executed in order to find a point that satisfies the linear constraints and bounds on the variables to within the tolerance specified by lin_feas_tol. All subsequent iterates will satisfy the constraints to within the same tolerance (unless lin_feas_tol is comparable to the finite difference interval).

This tolerance should reflect the precision of the linear constraints. For example, if the variables and the coefficients in the linear constraints are of order unity, and the latter are correct to about 6 decimal digits, it would be appropriate to specify lin_feas_tol as .

Constraint: . .

The default is  if , and  otherwise.

On entry: defines the maximum acceptable violations in the nonlinear constraints at a "feasible" point; i.e., a nonlinear constraint is considered satisfied if its violation does not exceed nonlin_feas_tol.

The tolerance defines the largest constraint violation that is acceptable at an optimal point. Since nonlinear constraints are generally not satisfied until the final iterate, the value of nonlin_feas_tol acts as a partial termination criteria for the iterative sequence generated by nag_opt_nlp (e04ucc) (see the discussion of optional_settings[optim_tol] ).

This tolerance should reflect the precision of the nonlinear constraint functions calculated by confun.

Constraint: . .

On entry: controls the accuracy with which the step  taken during each iteration approximates a minimum of the merit function along the search direction (the smaller the value of linesearch_tol, the more accurate the line search). The default value requests an inaccurate search, and is appropriate for most problems, particularly those with any nonlinear constraints.

If there are no nonlinear constraints, a more accurate search may be appropriate when it is desirable to reduce the number of major iterations – for example, if the objective function is cheap to evaluate, or if a substantial number of derivatives are unspecified.

Constraint: . .

On entry: specifies the maximum change in the variables at the first step of the line search. In some cases, such as  or , even a moderate change in the elements of  can lead to floating-point overflow. The argument step_limit is therefore used to encourage evaluation of the problem functions at meaningful points. Given any major iterate , the first point  at which  and  are evaluated during the line search is restricted so that

where  is the value of step_limit.

The line search may go on and evaluate  and  at points further from  if this will result in a lower value of the merit function. In this case, the character L is printed at the end of each line of output produced by the major iterations (see Section [Description of Printed Output ]). If L is printed for most of the iterations, step_limit should be set to a larger value.

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

Constraint: . .

On entry: crash_tol is used during a "cold start" when nag_opt_nlp (e04ucc) selects an initial working set (). The initial working set will include (if possible) bounds or general inequality constraints that lie within crash_tol of their bounds. In particular, a constraint of the form  will be included in the initial working set if .

Constraint: . .

On entry: inf_bound defines the "infinite" bound in the definition of the problem constraints. Any upper bound greater than or equal to inf_bound will be regarded as plus infinity (and similarly any lower bound less than or equal to  will be regarded as minus infinity).

Constraint: . .

On entry: inf_step specifies the magnitude of the change in variables that will be considered a step to an unbounded solution. If the change in  during an iteration would exceed the value of inf_step, the objective function is considered to be unbounded below in the feasible region.

Constraint: . .

Note: On exit the variable conf will have a value of type float.

On entry: ncnlin values of memory will be automatically allocated by nag_opt_nlp (e04ucc) and this is the recommended method of use of conf. However a user may supply memory from the calling program.

On exit: if ,  contains the value of the th nonlinear constraint function  at the final iterate.

If  then conf will not be referenced.

Note: On exit the variable conjac will have a value of type float.

On entry: ncnlin*n values of memory will be automatically allocated by nag_opt_nlp (e04ucc) and this is the recommended method of use of conjac. However a user may supply memory from the calling program.

On exit: if , conjac contains the Jacobian matrix of the nonlinear constraint functions at the final iterate, i.e.,  contains the partial derivative of the th constraint function with respect to the th variable, for ; . (See the discussion of the argument conjac under confun.)

If  then conjac will not be referenced.

Note: On exit the variable state will have a value of type integer.

On entry: state need not be set if the default option of  is used as  values of memory will be automatically allocated by nag_opt_nlp (e04ucc).

If the option  has been chosen, state must point to a minimum of  elements of memory. This memory will already be available if the optional_settings structure has been used in a previous call to nag_opt_nlp (e04ucc) from the calling program, with  and the same values of n, nclin and ncnlin. If a previous call has not been made, sufficient memory must be allocated by the user.

When a "warm start" is chosen state should specify the status of the bounds and linear constraints at the start of the feasibility phase. More precisely, the first n elements of state refer to the upper and lower bounds on the variables, the next nclin elements refer to the general linear constraints and the following ncnlin elements refer to the nonlinear constraints. Possible values for  are as follows:

The values ,  and 4 are also acceptable but will be reset to zero by the function, as will any elements which are set to 3 when the corresponding elements of bl and bu are not equal. If nag_opt_nlp (e04ucc) has been called previously with the same values of n, nclin and ncnlin, then state already contains satisfactory information. (See also the description of the optional argument optional_settings[start].) The function also adjusts (if necessary) the values supplied in x to be consistent with the values supplied in state.

Constraint: , for . .

On exit: the status of the constraints in the QP working set at the point returned in x. The significance of each possible value of  is as follows:

Note: On exit the variable lambda will have a value of type float.

On entry: lambda need not be set if the default option of  is used as  values of memory will be automatically allocated by nag_opt_nlp (e04ucc).

If the option  has been chosen, lambda must point to a minimum of  elements of memory. This memory will already be available if the optional_settings structure has been used in a previous call to nag_opt_nlp (e04ucc) from the calling program, with  and the same values of n, nclin and ncnlin. If a previous call has not been made with sufficient memory must be allocated by the user.

When a "warm start" is chosen  must contain a multiplier estimate for each nonlinear constraint with a sign that matches the status of the constraint specified by optional_settings[state], for , ,, . The remaining elements need not be set.

Note that if the th constraint is defined as "inactive" by the initial value of the optional_settings[state] array (i.e., ),  should be zero; if the th constraint is an inequality active at its lower bound (i.e., ),  should be non-negative; if the th constraint is an inequality active at its upper bound (i.e., ),  should be non-positive. If necessary, the function will modify lambda to match these rules.

On exit: the values of the Lagrange multipliers from the last QP subproblem.  should be non-negative if  and non-positive if .

Note: On exit the variable h will have a value of type float.

On entry: h need not be set if the default option of  is used, as  values of memory will be automatically allocated by nag_opt_nlp (e04ucc).

If the option  has been chosen, h must point to a minimum of  elements of memory. This memory will already be available if the calling program has used the optional_settings structure in a previous call to nag_opt_nlp (e04ucc) with  and the same value of n. If a previous call has not been made sufficient memory must be allocated by the user.

When  is chosen, the memory pointed to by h must contain the upper triangular Cholesky factor  of the initial approximation of the Hessian of the Lagrangian function, with the variables in the natural order. Elements not in the upper triangular part of  are assumed to be zero and need not be assigned. If a previous call has been made, with , then h will already have been set correctly.

On exit: if , h contains the upper triangular Cholesky factor  of , an estimate of the transformed and re-ordered Hessian of the Lagrangian at  (see (6) in Section [Overview ]).

If , h contains the upper triangular Cholesky factor  of , the approximate (untransformed) Hessian of the Lagrangian, with the variables in the natural order.

On entry: controls the contents of the optional argument optional_settings[h] on return from nag_opt_nlp (e04ucc). nag_opt_nlp (e04ucc) works exclusively with the transformed and re-ordered Hessian , and hence extra computation is required to form the Hessian itself. If , optional_settings[h] contains the Cholesky factor of the transformed and re-ordered Hessian. If , the Cholesky factor of the approximate Hessian itself is formed and stored in optional_settings[h]. This information is required by nag_opt_nlp (e04ucc) if the next call to nag_opt_nlp (e04ucc) will be made with optional argument .

Note: On exit the variable iter will have a value of type integer.

On exit: the number of major iterations which have been performed in nag_opt_nlp (e04ucc).

Note: On exit the variable nf will have a value of type integer.

On exit: the number of times the objective function has been evaluated (i.e., number of calls of objfun). The total excludes any calls made to objfun for purposes of derivative checking.

x[i] the element of .

dx[i] the optimal finite difference interval.

g[i] or Jacobian value the gradient/Jacobian element.

Difference approxn. the finite difference approximation.

Itns the number of trials performed to find a suitable difference interval.

Maj is the major iteration count.

Mnr is the number of minor iterations required by the feasibility and optimality phases of the QP subproblem. Generally, Mnr will be 1 in the later iterations, since theoretical analysis predicts that the correct active set will be identified near the solution (see Section [Further Description ]).

Note that Mnr may be greater than the optional argument optional_settings[minor_max_iter] (default value ; see Section [The optional-settings Parameter]) if some iterations are required for the feasibility phase.

Step is the step taken along the computed search direction. On reasonably well-behaved problems, the unit step will be taken as the solution is approached.

Merit function is the value of the augmented Lagrangian merit function (12) at the current iterate. This function will decrease at each iteration unless it was necessary to increase the penalty arguments (see Section [The Merit Function ]). As the solution is approached, Merit function will converge to the value of the objective function at the solution.

If the QP subproblem does not have a feasible point (signified by I at the end of the current output line), the merit function is a large multiple of the constraint violations, weighted by the penalty arguments. During a sequence of major iterations with infeasible subproblems, the sequence of Merit Function values will decrease monotonically until either a feasible subproblem is obtained or nag_opt_nlp (e04ucc) terminates with the error "NW_NONLIN_NOT_FEASIBLE" is raised (no feasible point could be found for the nonlinear constraints).

If no nonlinear constraints are present (i.e., ), this entry contains Objective, the value of the objective function . The objective function will decrease monotonically to its optimal value when there are no nonlinear constraints.

Violtn is the Euclidean norm of the residuals of constraints that are violated or in the predicted active set (not printed if ncnlin is zero). Violtn will be approximately zero in the neighbourhood of a solution.

Norm Gz is , the Euclidean norm of the projected gradient (see Section [Overview ]). Norm Gz will be approximately zero in the neighbourhood of a solution.

Cond Hz is a lower bound on the condition number of the projected Hessian approximation   ; see (6) in Section [Overview ] and (11) in Section [Solution of the Quadratic Programming Subproblem ]). The larger this number, the more difficult the problem.

M is printed if the quasi-Newton update was modified to ensure that the Hessian approximation is positive-definite (see Section [The Quasi-Newton Update ]).

I is printed if the QP subproblem has no feasible point.

C is printed if central differences were used to compute the unspecified objective and constraint gradients. If the value of Step is zero, the switch to central differences was made because no lower point could be found in the line search. (In this case, the QP subproblem is re-solved with the central difference gradient and Jacobian.) If the value of Step is non-zero, central differences were computed because Norm Gz and Violtn imply that  is close to a Kuhn–Tucker point (see Section [Overview ]).

L is printed if the line search has produced a relative change in  greater than the value defined by the optional argument optional_settings[step_limit] (default value ; see Section [The optional-settings Parameter]). If this output occurs frequently during later iterations of the run, optional_settings[step_limit] should be set to a larger value.

R is printed if the approximate Hessian has been refactorized. If the diagonal condition estimator of  indicates that the approximate Hessian is badly conditioned, the approximate Hessian is refactorized using column interchanges. If necessary,  is modified so that its diagonal condition estimator is bounded.

Nfun is the cumulative number of evaluations of the objective function needed for the line search. Evaluations needed for the estimation of the gradients by finite differences are not included. Nfun is printed as a guide to the amount of work required for the linesearch.

Nz is the number of columns of  (see Section [Overview ]). The value of Nz is the number of variables minus the number of constraints in the predicted active set; i.e., .

Bnd is the number of simple bound constraints in the predicted active set.

Lin is the number of general linear constraints in the predicted active set.

Nln is the number of nonlinear constraints in the predicted active set (not printed if ncnlin is zero).

Penalty is the Euclidean norm of the vector of penalty arguments used in the augmented Lagrangian merit function (not printed if ncnlin is zero).

Norm Gf is the Euclidean norm of , the gradient of the objective function with respect to the free variables.

Cond H is a lower bound on the condition number of the Hessian approximation .

Cond T is a lower bound on the condition number of the matrix of predicted active constraints.

Conv is a three-letter indication of the status of the three convergence tests (16)  (18) defined in the description of the optional argument optional_settings[optim_tol] in Section [The optional-settings Parameter]. Each letter is T if the test is satisfied, and F otherwise. The three tests indicate whether:

a. the sequence of iterates has converged;

b. the projected gradient (Norm Gz) is sufficiently small; and

c. the norm of the residuals of constraints in the predicted active set (Violtn) is small enough.

If any of these indicators is F when nag_opt_nlp (e04ucc) terminates with the error indicator no error raised , the user should check the solution carefully.

Varbl gives the name (V) and index , for  of the variable.

State gives the state of the variable (FR if neither bound is in the active set, EQ if a fixed variable, LL if on its lower bound, UL if on its upper bound). If Value lies outside the upper or lower bounds by more than the feasibility tolerances specified by the optional arguments optional_settings[lin_feas_tol] and optional_settings[nonlin_feas_tol] (see Section [The optional-settings Parameter]), State will be ++ or -- respectively.

A key is sometimes printed before State to give some additional information about the state of a variable.

    A Alternative optimum possible. The variable is active at one of its bounds, but its Lagrange Multiplier is essentially zero. This means that if the variable were allowed to start moving away from its bound, there would be no change to the objective function. The values of the other free variables might change, giving a genuine alternative solution. However, if there are any degenerate variables (labelled D), the actual change might prove to be zero, since one of them could encounter a bound immediately. In either case, the values of the Lagrange multipliers might also change.

    D Degenerate. The variable is free, but it is equal to (or very close to) one of its bounds.

    I Infeasible. The variable is currently violating one of its bounds by more than optional_settings[lin_feas_tol].

Value is the value of the variable at the final iteration.

Lower bound is the lower bound specified for the variable . (None indicates that , where optional_settings[inf_bound] is the optional argument.)

Upper bound is the upper bound specified for the variable . (None indicates that , where optional_settings[inf_bound] is the optional argument.)

Lagr Mult is the value of the Lagrange multiplier for the associated bound constraint. This will be zero if State is FR unless  and , in which case the entry will be blank. If  is optimal, the multiplier should be non-negative if State is LL, and non-positive if State is UL.

Residual is the difference between the variable Value and the nearer of its (finite) bounds  and . A blank entry indicates that the associated variable is not bounded (i.e.,  and ).

L Con gives the name (L) and index , for  of the linear constraint.

N Con gives the name (N) and index , for  of the nonlinear constraint.