NAG CL Interface
e04ugc (nlp1_sparse_solve)
1
Purpose
e04ugc solves sparse nonlinear programming problems.
2
Specification
void |
e04ugc (
Integer n,
Integer m,
Integer ncnln,
Integer nonln,
Integer njnln,
Integer iobj,
Integer nnz,
double a[],
const Integer ha[],
const Integer ka[],
double bl[],
double bu[],
double xs[],
Integer *ninf,
double *sinf,
double *objf,
Nag_Comm *comm,
Nag_E04_Opt *options,
NagError *fail) |
|
The function may be called by the names: e04ugc, nag_opt_nlp1_sparse_solve or nag_opt_nlp_sparse.
3
Description
e04ugc is designed to solve a class of nonlinear programming problems that are assumed to be stated in the following general form:
where
is a set of variables,
is a smooth scalar objective function,
and
are constant lower and upper bounds,
is a vector of smooth nonlinear constraint functions
and
is a
sparse matrix.
The constraints involving
and
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
th constraint can be defined as an
equality by setting
. If certain bounds are not present, the associated elements of
or
can be set to special values that will be treated as
or
. (See the description of the optional parameter
in
Section 12.2).
e04ugc converts the upper and lower bounds on the
elements of
and
to equalities by introducing a set of
slack variables , where
. For example, the linear constraint
is replaced by
, together with the bounded slack
. The problem defined by
(1) can therefore be re-written in the following equivalent form:
Since the slack variables
are subject to the same upper and lower bounds as the elements of
and
, the bounds on
and
can simply be thought of as bounds on the combined vector
. The elements of
and
are partitioned into
basic,
nonbasic and
superbasic variables defined as follows (see
Section 11 for more details):
- A basic variable is a variable associated with a column of a square nonsingular basis matrix .
- 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 non basic variable which is not at one of its bounds and which 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). At each step, basic variables are adjusted depending on the values of superbasic variables.
For example, in the simplex method (see
Gill et al. (1981)) the elements of
can be partitioned at each vertex into a set of
basic variables (all non-negative) and a set of
nonbasic variables (all zero). This is equivalent to partitioning the columns of the constraint matrix as
, where
contains the
columns that correspond to the basic variables and
contains the
columns that correspond to the nonbasic variables.
The optional parameter (default value ) may be used to specify an alternative problem in which is maximized (setting ), or to only find a feasible point (setting ). If the objective function is nonlinear and all the constraints are linear, 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
:
subject to the constraints
and to the bounds
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 and a linear function of the variables ;
- the first two constraints are nonlinear. The third is linear;
- each nonlinear constraint function is the sum of a nonlinear function of the variables and a linear function of the variables .
The nonlinear terms are defined by the user-supplied subroutines
objfun and
confun (see
Section 5), which involve only the appropriate subset of variables.
For the objective, we define the function
to include only the nonlinear part of the objective. The three variables
associated with this function are known as the
nonlinear objective variables. The number of them is given by
nonln (see
Section 5), and they are the only variables needed in
objfun. The linear part
of the objective is stored in row
iobj (see
Section 5) of the (constraint) Jacobian matrix
(see below).
Thus, if
and
denote the nonlinear and linear objective variables, respectively, the objective may be re-written in the form
where
is the nonlinear part of the objective and
and
are constant vectors that form a row of
. In this example,
and
.
Similarly for the constraints, we define a vector function
to include just the nonlinear terms. In this example,
and
, where the two variables
are known as the
nonlinear Jacobian variables. The number of them is given by
njnln (see
Section 5), and they are the only variables needed in
confun. Thus, if
and
denote the nonlinear and linear Jacobian variables, respectively, the constraint functions and the linear part of the objective have the form
where
and
in this example. This ensures that the Jacobian is of the form
where
. Note that
always appears in the
top left-hand corner of
.
The inequalities
and
implied by the constraint functions in
(3) are known as the
nonlinear and
linear constraints, respectively. The nonlinear constraint vector
in
(3) and (optionally) its partial derivative matrix
are set in
confun. The matrices
,
and
contain any (constant) linear terms. Along with the sparsity pattern of
they are stored in the arrays
a,
ha and
ka (see
Section 5).
In general, the vectors
and
have different dimensions, but they
must always overlap, in the sense that the shorter vector should always be the beginning of the other. In the above example, the nonlinear Jacobian variables
are an ordered subset of the nonlinear objective variables
. In other cases it could be the other way round. Note that in some cases it might be necessary to add variables to
or
(whichever is the most convenient), but the first way keeps
as small as possible. Thus, the nonlinear objective function
may involve either a subset or superset of the variables appearing in the nonlinear constraint functions
, and
(or vice-versa). Sometimes the objective and constraints may really involve
disjoint sets of nonlinear variables. In such cases the variables should be ordered so that
and
, where the objective is nonlinear in just the last vector
. The first
njnln elements of the gradient array
objgrad (corresponding to
) should then be set to zero in
objfun. This is illustrated in
Section 10.
If there are no nonlinear constraints in
(1) and
is linear or quadratic, then it may be simpler and/or more efficient to use
e04nkc to solve the resulting linear or quadratic programming problem, or one of
e04mfc,
e04ncc or
e04nfc if
is a
dense matrix. If the problem is dense and does have nonlinear constraints, then
e04ucc should be used instead.
You must supply an initial estimate of the solution to
(1), together with versions of
objfun and
confun that define
and
, 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.
e04ugc is based on the SNOPT package described in
Gill et al. (1997), which in turn utilizes routines 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
Section 11.
Throughout this document the symbol
is used to represent the
machine precision (see
X02AJC).
4
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 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 (1997) SNOPT: an SQP algorithm for large-scale constrained optimization Numerical Analysis Report 97–2 Department of Mathematics, University of California, San Diego
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
5
Arguments
-
1:
– function, supplied by the user
External Function
-
confun must calculate the vector
of nonlinear constraint functions and (optionally) its Jacobian (
) for a specified
njnln element vector
. If there are no nonlinear constraints (i.e.,
),
confun will never be called by
e04ugc and the NAG defined null void function pointer,
NULLFN, can be supplied in the call to
e04ugc. If there are nonlinear constraints, the first call to
confun will occur before the first call to
objfun.
The specification of
confun is:
-
1:
– Integer
Input
-
On entry: the number of nonlinear constraints. These must be the first
ncnln constraints in the problem.
-
2:
– Integer
Input
-
On entry: the number of nonlinear variables. These must be the first
njnln variables in the problem.
-
3:
– Integer
Input
-
On entry: the number of nonzero elements in the constraint Jacobian. Note that
nnzjac will always be less than, or equal to,
.
-
4:
– const double
Input
-
On entry: , the vector of nonlinear Jacobian variables at which the nonlinear constraint functions and/or all available elements of the constraint Jacobian are to be evaluated.
-
5:
– double
Output
-
On exit: if or , must contain the value of , the th nonlinear constraint at .
-
6:
– double
Output
-
On exit: if
or
,
conjac must return the available elements of
, the constraint Jacobian evaluated at
. These elements must be stored in
conjac in exactly the same positions as implied by the definitions of the arrays
a,
ha and
ka described below, remembering that
always appears in the top left-hand corner of
. Note that the function does not perform any internal checks for consistency (except indirectly via the optional parameter
), so great care is essential.
If all elements of the constraint Jacobian are known, i.e., the optional parameter
(the default), any constant elements of the Jacobian may be assigned to
a at the start of the optimization if desired. If an element of
conjac is not assigned in
confun, the corresponding value from
a is used. See also the description for
a.
If
, then any available partial derivatives of
must be assigned to the elements of
conjac; the remaining elements
must remain unchanged. It must be emphasized that, in that case, unassigned elements of
conjac are not treated as constant; they are estimated by finite differences, at non-trivial expense.
-
7:
– Nag_Comm *
-
Pointer to a structure of type Nag_Comm; the following members are relevant to
confun.
- flag – IntegerInput/Output
-
On entry:
confun is called with
set to
, 1 or 2.
If
, only
conf has to be referenced.
If
, only
conjac has to be referenced.
If
, both
conf and
conjac are referenced.
On exit: if
confun resets
to
,
e04ugc will terminate with the error indicator
NE_CANNOT_CALCULATE, unless this occurs during the linesearch; in this case, the linesearch will shorten the step and try again. If
confun resets
to a value smaller or equal to
,,
e04ugc will terminate immediately with the error indicator
NE_USER_STOP. In both cases, if
fail is supplied to
e04ugc,
will be set to your setting of
.
- first – Nag_BooleanInput
-
On entry: will be set to Nag_TRUE on the first call to
confun and Nag_FALSE for all subsequent calls. This argument setting allows you to save computation time if certain data must be read or calculated only once.
- last – Nag_BooleanInput
-
On entry: will be set to Nag_TRUE on the last call to
confun and Nag_FALSE for all other calls. This argument setting allows you to perform some additional computation on the final solution.
- user – double *
- iuser – Integer *
- p – Pointer
-
The type Pointer is void *.
Before calling
e04ugc these pointers may be allocated memory and initialized with various quantities for use by
confun when called from
e04ugc.
Note: confun should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by
e04ugc. If your code inadvertently
does return any NaNs or infinities,
e04ugc is likely to produce unexpected results.
Note: confun should be tested separately before being used in conjunction with
e04ugc. The optional parameters
and
can be used to assist this process (see
Section 12.2). The array
x must
not be changed by
confun.
If
confun does not calculate all of the Jacobian constraint elements then the optional parameter
should be set to Nag_FALSE.
-
2:
– function, supplied by the user
External Function
-
objfun must calculate the nonlinear part of the objective
and (optionally) its gradient (
) for a specified
nonln element vector
. If there are no nonlinear objective variables (i.e.,
),
objfun will never be called by
e04ugc and the NAG defined null void function pointer,
NULLFN, can be supplied in the call to
e04ugc.
The specification of
objfun is:
-
1:
– Integer
Input
-
On entry: the number of nonlinear objective variables. These must be the first
nonln variables in the problem.
-
2:
– const double
Input
-
On entry: 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.
-
3:
– double *
Output
-
On exit: if
or
,
objfun must set
objf to the value of the nonlinear part of the objective function at
. If it is not possible to evaluate the objective function at
, then
objfun should assign
to
;
e04ugc will then terminate, unless this occurs during the linesearch; in this case, the linesearch will shorten the step and try again.
-
4:
– double
Output
-
On exit: if
or
,
objgrad must return the available elements of the gradient
evaluated at the current point
.
If the optional parameter
(the default), all elements of
objgrad must be set; if
, any available elements of the Jacobian matrix must be assigned to the elements of
objgrad; the remaining elements
must remain unchanged.
-
5:
– Nag_Comm *
-
Pointer to structure of type Nag_Comm; the following members are relevant to
objfun.
- flag – IntegerInput/Output
-
On entry:
objfun is called with
set to
, 1 or 2.
If
then only
objf has to be referenced.
If
then only
objgrad has to be referenced.
If
then both
objf and
objgrad are referenced.
On exit: if
objfun resets
to
, then
e04ugc will terminate with the error indicator
NE_CANNOT_CALCULATE, unless this occurs during the linesearch; in this case, the linesearch will shorten the step and try again. If
objfun resets
to a value smaller or equal to
, then
e04ugc will terminate immediately with the error indicator
NE_USER_STOP. In both cases, if
fail is supplied to
e04ugc will then be set to your setting of
.
- first – Nag_BooleanInput
-
On entry: will be set to Nag_TRUE on the first call to
objfun and Nag_FALSE for all subsequent calls. This argument setting allows you to save computation time if certain data must be read or calculated only once.
- last – Nag_BooleanInput
-
On entry: will be set to Nag_TRUE on the last call to
objfun and Nag_FALSE for all other calls. This argument setting allows you to perform some additional computation on the final solution.
- nf – IntegerInput
-
On entry: the number of evaluations of the objective function; this value will be equal to the number of calls made to
objfun including the current one.
- user – double *
- iuser – Integer *
- p – Pointer
-
The type Pointer is void *.
Before calling
e04ugc these pointers may be allocated memory and initialized with various quantities for use by
objfun when called from
e04ugc.
Note: objfun should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by
e04ugc. If your code inadvertently
does return any NaNs or infinities,
e04ugc is likely to produce unexpected results.
Note: objfun should be tested separately before being used in conjunction with
e04ugc. The optional parameters
and
can be used to assist this process (see
Section 12.2). The array
x must
not be changed by
objfun.
If the function
objfun does not calculate all of the Jacobian elements then the optional parameter
should be set to Nag_FALSE.
-
3:
– Integer
Input
-
On entry: , the number of variables (excluding slacks). This is the number of columns in the full Jacobian matrix .
Constraint:
.
-
4:
– Integer
Input
-
On entry:
, the number of general constraints (or slacks). This is the number of rows in
, including the free row (if any; see
iobj). Note that
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,
nnz,
a,
ha,
ka,
bl and
bu.
Constraint:
.
-
5:
– Integer
Input
-
On entry: the number of nonlinear constraints. These correspond to the leading
ncnln rows of
.
Constraint:
.
-
6:
– Integer
Input
-
On entry: the number of nonlinear objective variables. If the objective function is nonlinear, the leading
nonln columns of
belong to the nonlinear objective variables. (See also the description for
njnln.)
Constraint:
.
-
7:
– Integer
Input
-
On entry: the number of nonlinear Jacobian variables. If there are any nonlinear constraints, the leading
njnln columns of
belong to the nonlinear Jacobian variables. If
and
, the nonlinear objective and Jacobian variables overlap. The total number of nonlinear variables is given by
.
Constraints:
- if , ;
- if , .
-
8:
– Integer
Input
-
On entry: if
, row
iobj of
is a free row containing the nonzero elements of the linear part of the objective function.
- There is no free row.
- There is a dummy ‘free’ row.
Constraints:
- if , ;
- otherwise .
-
9:
– Integer
Input
-
On entry: the number of nonzero elements in (including the Jacobian for any nonlinear constraints, ). If , set .
Constraint:
.
-
10:
– double
Input/Output
-
On entry: the nonzero elements of the Jacobian matrix
, ordered by increasing column index. Note that elements with the same row and column index are not allowed. Since the constraint Jacobian matrix
must always appear in the top left-hand corner of
, those elements in a column associated with any nonlinear constraints must come before any elements belonging to the linear constraint matrix
and the free row (if any; see
iobj).
In general,
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 the optional parameter
(the default), the nonlinear part may also be used to store any constant Jacobian elements. Note that if
confun does not define the constant Jacobian element
, the missing value will be obtained directly from the corresponding element of
a. The linear part must contain the nonzero elements of
and the free row (if any). If
, set
, say, where
and
is the value of the optional parameter
(default value
). Elements with the same row and column indices are not allowed. (See also the descriptions for
ha and
ka.)
On exit: elements in the nonlinear part corresponding to nonlinear Jacobian variables are overwritten.
-
11:
– const Integer
Input
-
On entry:
must contain the row index of the nonzero element stored in
, for
. 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
, set
.
Constraint:
, for .
-
12:
– const Integer
Input
-
On entry:
must contain the index in
a of the start of the
th column, for
. To specify the
th column as empty, set
. Note that the first and last elements of
ka must be such that
and
. If
, set
, for
.
Constraints:
- ;
- , for ;
- ;
- , for .
-
13:
– double
Input/Output
-
14:
– double
Input/Output
-
On entry:
bl must contain the lower bounds
and
bu the upper bounds
, for all the variables and general constraints, in the following order. The first
n elements of
bl must contain the bounds on the variables
x, the next
ncnln elements the bounds for the nonlinear constraints
(if any) and the next
elements the bounds for the linear constraints
and the free row (if any). To specify a nonexistent lower bound (i.e.,
), set
, and to specify a nonexistent upper bound (i.e.,
), set
, where
is one of the optional parameters (default value
, see
Section 12.2). To specify the
th constraint as an
equality, set
, say, where
. Note that the lower bound corresponding to
must be set to
and stored in
; similarly, the upper bound must be set to
and stored in
.
On exit: the elements of
bl and
bu may have been modified internally, but they are restored on exit.
Constraints:
- , for ;
- if , ;
- if or , and .
-
15:
– double
Input/Output
-
On entry:
, for
, must contain the initial values of the variables,
. In addition, if a ‘warm start’ is specified by means of the optional parameter
(see
Section 12.2) the elements
, for
, must contain the initial values of the slack variables,
.
On exit: the final values of the variables and slacks .
-
16:
– Integer *
Output
-
On exit: the number of constraints that lie outside their bounds by more than the value of the optional parameter
(default value
).
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
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
that lie outside their upper or lower bounds.
-
17:
– double *
Output
-
On exit: the sum of the infeasibilities of constraints that lie outside their bounds by more than the value of the optional parameter
(default value
).
If the
linear constraints are infeasible,
sinf contains the sum of the infeasibilities of the linear constraints. Otherwise,
sinf contains the sum of the infeasibilities of the
nonlinear constraints.
-
18:
– double *
Output
-
On exit: the value of the objective function at the final iterate.
-
19:
– Nag_Comm *
Input/Output
-
Note: comm is a NAG defined type (see
Section 3.1.1 in the Introduction to the NAG Library CL Interface).
On entry/exit: structure containing pointers for communication to the user-supplied functions
objfun and
confun; see the description of
objfun and
confun for details. If you do not need to make use of this communication feature the null pointer
NAGCOMM_NULL may be used in the call to
e04ugc;
comm will then be declared internally for use in calls to user-supplied functions.
-
20:
– Nag_E04_Opt *
Input/Output
-
On entry/exit: a pointer to a structure of type Nag_E04_Opt whose members are optional parameters for
e04ugc. These structure members offer the means of adjusting some of the argument values of the algorithm and on output will supply further details of the results. A description of the members of
options is given below in
Section 12. Some of the results returned in
options can be used by
e04ugc to perform a ‘warm start’ (see the optional parameter
in
Section 12.2).
If any of these optional parameters are required then the structure
options should be declared and initialized by a call to
e04xxc and supplied as an argument to
e04ugc. However, if the optional parameters are not required the NAG defined null pointer,
E04_DEFAULT, can be used in the function call.
-
21:
– NagError *
Input/Output
-
The NAG error argument (see
Section 7 in the Introduction to the NAG Library CL Interface).
6
Error Indicators and Warnings
- NE_2_INT_ARG_CONS
-
On entry, while . These arguments must satisfy when .
- NE_2_INT_OPT_ARG_CONS
-
On entry, while . These arguments must satisfy .
(Note that this error may only occur when or .)
On entry, while . These arguments must satisfy .
(Note that this error may only occur when or .)
- NE_3_INT_ARG_CONS
-
On entry, , and . These arguments must satisfy when .
- NE_ALLOC_FAIL
-
Dynamic memory allocation failed.
- NE_ARRAY_CONS
-
The contents of array
ka are not valid.
Constraint:
, for
.
The contents of array
ka are not valid.
Constraint:
.
The contents of array
ka are not valid.
Constraint:
.
- NE_BAD_PARAM
-
On entry, argument had an illegal value.
On entry, argument had an illegal value.
On entry, argument had an illegal value.
On entry, argument had an illegal value.
On entry, argument had an illegal value.
On entry, argument had an illegal value.
On entry, argument had an illegal value.
On entry, argument had an illegal value.
- NE_BASIS_SINGULAR
-
The basis is singular after 15 attempts to factorize it (and adding slacks when necessary). Either the problem is badly scaled or the value of the optional parameter (default value or 100.0) is too large.
- NE_BOUND
-
The lower bound for variable (array element ) is greater than the upper bound.
- NE_BOUND_EQ
-
The lower bound and upper bound for variable (array elements and ) are equal but they are greater than or equal to .
- NE_BOUND_EQ_LCON
-
The lower bound and upper bound for linear constraint (array element and ) are equal but they are greater than or equal to .
- NE_BOUND_EQ_NLCON
-
The lower bound and upper bound for nonlinear constraint (array element and ) are equal but they are greater than or equal to .
- NE_BOUND_LCON
-
The lower bound for linear constraint (array element ) is greater than the upper bound.
- NE_BOUND_NLCON
-
The lower bound for nonlinear constraint (array element ) is greater than the upper bound.
- NE_CANNOT_CALCULATE
-
The objective and/or constraint functions could not be calculated.
- NE_CON_DERIV_ERRORS
-
Subroutine
confun appears to be giving incorrect gradients.
The user-provided derivatives of the nonlinear constraint functions computed by
confun appear to be incorrect. Check that
confun has been coded correctly and that all relevant elements of the nonlinear constraint Jacobian have been assigned their correct values.
- NE_DUPLICATE_ELEMENT
-
Duplicate sparse matrix element found in row , column .
- NE_INT_ARG_LT
-
On entry, .
Constraint: .
On entry, .
Constraint: .
On entry, .
Constraint: .
- NE_INT_ARRAY_1
-
Value
given to
not valid. Correct range for elements of
ka is
.
- NE_INT_ARRAY_2
-
Value
given to
is not valid. Correct range for elements of
ha is 1 to
m.
- NE_INT_OPT_ARG_GT
-
On entry, .
Constraint: .
(Note that this error may only occur when or .)
On entry, .
Constraint: .
(Note that this error may only occur when or .)
On entry, .
Constraint: .
(Note that this error may only occur when or .)
On entry, .
Constraint: .
(Note that this error may only occur when or .)
- NE_INT_OPT_ARG_LT
-
On entry, .
Constraint: .
(Note that this error may only occur when or .)
On entry, .
Constraint: .
(Note that this error may only occur when or .)
On entry, .
Constraint: .
On entry, .
Constraint: .
On entry, .
Constraint: .
On entry, .
Constraint: .
(Note that this error may only occur when or .)
On entry, .
Constraint: .
(Note that this error may only occur when or .)
- NE_INTERNAL_ERROR
-
An internal error has occurred in this function. Check the function call
and any array sizes. If the call is correct then please contact
NAG for
assistance.
- NE_INVALID_INT_RANGE_1
-
Value
given to
ncnln is not valid. Correct range is 0 to
m.
Value
given to
njnln is not valid. Correct range is (when
) 1 to
n.
Value
given to
nnz is not valid. Correct range is 1 to
.
Value
given to
nonln is not valid. Correct range is 0 to
n.
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is: if , then .
Value given to is not valid. Correct range is .
- NE_INVALID_INT_RANGE_2
-
Value given to is not valid. Correct range is .
- NE_INVALID_REAL_RANGE_E
-
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
- NE_INVALID_REAL_RANGE_EE
-
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
Value given to is not valid. Correct range is .
- NE_LIN_NOT_FEASIBLE
-
No feasible point was found for the linear constraints. Sum of infeasibilities: .
The problem is infeasible. The linear constraints cannot all be satisfied to within the values of the optional parameter (default value ).
- NE_MAYBE_UNBOUNDED
-
Violation limit exceeded. The problem may be unbounded.
Check the values of the optional parameters (default value ) and (default value ) are not too small. This exit also implies that the objective function is not bounded below (or above in the case of maximization) in the feasible region defined by expanding the bounds by the value of the optional parameter (default value ).
- NE_NAME_TOO_LONG
-
The string pointed to by is too long. It should be no longer than 8 characters.
- NE_NO_IMPROVE
-
The current point cannot be improved on.
Check that
objfun and
confun have been coded correctly and that they are consistent with the values of the optional parameters
and
(default value
).
- NE_NONLIN_NOT_FEASIBLE
-
No feasible point was found for the nonlinear constraints. Sum of infeasibilities: .
The problem is infeasible. The nonlinear constraints cannot all be satisfied to within the values of the optional parameter (default value ).
- NE_NOT_APPEND_FILE
-
Cannot open file for appending.
- NE_NOT_CLOSE_FILE
-
Cannot close file .
- NE_NOT_REQUIRED_ACC
-
Feasible solution, but required accuracy could not be achieved.
Check that the value of the optional parameter (default value ) is not too small.
- NE_OBJ_BOUND
-
Invalid lower bound for objective row. Bound should be .
Invalid upper bound for objective row. Bound should be .
- NE_OBJ_DERIV_ERRORS
-
Subroutine
objfun appears to be giving incorrect gradients.
The user-provided derivatives of the objective function computed by
objfun appear to be incorrect. Check that
objfun has been coded correctly and that all relevant elements of the objective gradient have been assigned their correct values.
- NE_OPT_NOT_INIT
-
Options structure not initialized.
- NE_OUT_OF_WORKSPACE
-
There is insufficient workspace for the basis factors, and
the maximum allowed number of reallocation attempts, as
specified by
max_restart, has been reached.
- NE_STATE_VAL
-
is out of range. .
- NE_SUPERBASICS_LIMIT
-
Too many superbasic variables (
).
The value of the optional parameter
(default value
(500,
,
n)) is too small and should be increased.
- NE_TOO_MANY_ITER
-
Iteration limit () exceeded.
- NE_TOO_MANY_MAJOR_ITER
-
Major iteration limit () exceeded.
- NE_TOO_MANY_MINOR_ITER
-
Minor iteration limit () exceeded.
- NE_UNBOUNDED
-
Solution appears to be unbounded.
The problem is unbounded (or badly scaled). The objective function is not bounded below (or above in the case of maximization) in the feasible region because a nonbasic variable can apparently be increased or decreased by an arbitrary amount without causing a basic variable to violate a bound. Add an upper or lower bound to the variable (whose index is printed by default) and rerun e04ugc.
- NE_USER_STOP
-
User requested termination, user flag value
.
This exit occurs if you set
to a negative value in
objfun or
confun. If
fail is supplied the value of
will be the same as your setting of
.
7
Accuracy
If is set to (default value ) and on exit, then the final value of should have approximatively correct digits.
8
Parallelism and Performance
e04ugc is not threaded in any implementation.
If
e04ugc returns with
, the iterates have converged to a point
that satisfies the first-order Kuhn–Karesh–Tucker conditions (see
Section 11.1) to the accuracy requested by the optional parameters
(default value
) and
(default value
).
10
Example
This example is a reformulation of Problem 74 from
Hock and Schittkowski (1981) and involves minimization of the nonlinear function
subject to the bounds
to the nonlinear constraints
and to the linear constraints
The initial point, which is infeasible, is
and
.
The optimal solution (to five figures) is
and
. All the nonlinear constraints are active at the solution.
The use of the interface to e04ugc for this particular example is briefly illustrated below. First, note that because of the constraints on the definitions of nonlinear Jacobian variables and nonlinear objective variables in the interface to e04ugc, the first objective variables and are considered as nonlinear objective variables. Thus, , and there are nonlinear Jacobian variables ( and ). (The alternative would have consisted in reordering the problem to have nonlinear objective variables and nonlinear constraint variables, but, as mentioned earlier, it is preferable to keep the size of the nonlinear Jacobian small, having .)
The Jacobian matrix
is the
by
matrix below
where zeros are not stored, each column represents a variable, each row a constraint (except the free row), and the
entries reflect the structure of the Jacobian
corresponding to the nonlinear constraints. The first 3 rows correspond to the
nonlinear constraints, rows 4 and 5 define the 2 linear constraints and there is finally an
th free row defining the linear part of the objective function,
.
contains
nonzero elements of which six entries define the structure of
. In this case all entries in
are defined in the supplied function
confun and there is no constant value that we want to pass only once via
, so all entries in the corresponding array
a corresponding to
can just be initialized to dummy values (here
). Effective Jacobian values will be provided in the argument
, for
,
, in the function
confun. Note also that in this simple example,
is indeed full; otherwise, the structure of
should reflect the sparsity of
.
This example includes source code to store the matrix
in the arrays
a,
ha,
ka, based on the simple format from the data file.
Finally, the lower and upper bounds are defined by , and
The first
elements of
bl and
bu are simple bounds on the variables; the next 3 elements are bounds on the nonlinear constraints; the next 2 elements are bounds on the linear constraints; and finally, the last (unbounded) element corresponds to the free row.
The
options structure is declared and initialized by
e04xxc. The
member is assigned to the array of character strings into which the column and row names were read and the
member is assigned a value of
. Two options are read from the data file by use of
e04xyc. Note that, unlike for some other optimization functions, optional parameters to
e04ugc are not checked inside
e04xyc; they are checked inside the main call to
e04ugc.
On return from
e04ugc, the solution is perturbed slightly and some further options set, selecting a warm start and a reduced level of printout.
e04ugc is then called for a second time. Finally, the memory freeing function
e04xzc is used to free the memory assigned by
e04ugc to the pointers in the options structure. You must
not use the standard C function
free() for this purpose.
10.1
Program Text
10.2
Program Data
10.3
Program Results
11
Further Description
e04ugc implements a sequential quadratic programming (SQP) method that obtains search directions from a sequence of quadratic programming (QP) subproblems. This section gives a detailed description of the algorithms used by
e04ugc. This, and possibly the next section,
Section 12, may be omitted if the more sophisticated features of the algorithm and software are not currently of interest.
11.1
Overview
Here we briefly summarise the main features of the method and introduce some terminology. Where possible, explicit reference is made to the names of variables that are arguments of the function or appear in the printed output. Further details can be found in
Gill et al. (2002).
At a solution of
(1), some of the constraints will be
active, i.e., satisfied exactly. Let
and
denote the set of indices of
corresponding to active constraints at an arbitrary point
. Let
denote the usual
derivative of
, which is the row vector of first partial derivatives of
(see
Ortega and Rheinboldt (1970)). The vector
comprises the
th row of
so that
where
is the Jacobian of
.
A point
is a
first-order Kuhn–Karesh–Tucker (KKT) point for
(1) (see, e.g.,
Powell (1974)) if the following conditions hold:
-
(a) is feasible;
-
(b)there exists a vector (the Lagrange multiplier vector for the bound and general constraints) such that
where is the gradient of evaluated at ;
-
(c)the Lagrange multiplier associated with the th constraint satisfies if ; if ; if ; and can have any value if .
An equivalent statement of the condition
(4) is
where
is a matrix defined as follows. Consider the set
of vectors orthogonal to the gradients of the active constraints, i.e.,
The columns of
may then be taken as any basis for the vector space
. The vector
is termed the
reduced gradient of
at
. Certain additional conditions must be satisfied in order for a first-order KKT point to be a solution of
(1) (see, e.g.,
Powell (1974)).
The basic structure of
e04ugc involves
major and
minor iterations. The major iterations generate a sequence of iterates
that satisfy the linear constraints and converge to a point
that satisfies the first-order KKT optimality conditions. At each iterate a QP subproblem is used to generate a search direction towards the next iterate
. The constraints of the subproblem are formed from the linear constraints
and the nonlinear constraint linearization
where
denotes the
Jacobian matrix, whose rows are the first partial derivatives of
evaluated at the point
. The QP constraints therefore comprise the
linear constraints
where
and
are bounded above and below by
and
as before. If the
by
matrix
and
element vector
are defined as
then the QP subproblem can be written as
where
is a quadratic approximation to a modified Lagrangian function (see
Gill et al. (2002)).
The linear constraint matrix
is stored in the arrays
a,
ha and
ka (see
Section 5). This allows you to specify the sparsity pattern of nonzero elements in
and
, and identify any nonzero elements that remain constant throughout the minimization.
Solving the QP subproblem is itself an iterative procedure, with the
minor iterations of an SQP method being the iterations of the QP method. At each minor iteration, the constraints
are (conceptually) partitioned into the form
where the
basis matrix is square and nonsingular. The elements of
,
and
are called the
basic,
superbasic and
nonbasic variables respectively; they are a permutation of the elements of
and
. At a QP solution, the basic and superbasic variables will lie somewhere between their bounds, while the nonbasic variables will be equal to one of their upper or lower bounds. At each minor iteration,
is regarded as a set of independent variables that are free to move in any desired direction, namely one that will improve the value of the QP objective function
or sum of infeasibilities (as appropriate). The basic variables are then adjusted in order to ensure that
continues to satisfy
. The number of superbasic variables (
say) therefore indicates the number of degrees of freedom remaining after the constraints have been satisfied. In broad terms,
is a measure of
how nonlinear the problem is. In particular,
will always be zero if there are no nonlinear constraints in
(1) and
is linear.
If it appears that no improvement can be made with the current definition of , and , a nonbasic variable is selected to be added to , and the process is repeated with the value of increased by one. At all stages, if a basic or superbasic variable encounters one of its bounds, the variable is made nonbasic and the value of decreased by one.
Associated with each of the
equality constraints
is a
dual variable . Similarly, each variable in
has an associated
reduced gradient (also known as a
reduced cost). The reduced gradients for the variables
are the quantities
, where
is the gradient of the QP objective function
; and the reduced gradients for the slack variables
are the dual variables
. The QP subproblem
(5) is optimal if
for all nonbasic variables at their lower bounds,
for all nonbasic variables at their upper bounds and
for other variables (including superbasics). In practice, an
approximate QP solution is found by slightly relaxing these conditions on
(see the description of the optional parameter
).
After a QP subproblem has been solved, new estimates of the solution to
(1) are computed using a linesearch on the augmented Lagrangian merit function
where
is a diagonal matrix of penalty parameters. If
denotes the current estimate of the solution and
denotes the optimal QP solution, the linesearch determines a step
(where
) such that the new point
produces a
sufficient decrease in the merit function
(6). When necessary, the penalties in
are increased by the minimum-norm perturbation that ensures descent for
(see
Gill et al. (1992)). As in
e04ucc,
is adjusted to minimize the merit function as a function of
prior to the solution of the QP subproblem. Further details can be found in
Eldersveld (1991) and
Gill et al. (1986).
11.2
Treatment of Constraint Infeasibilities
e04ugc makes explicit allowance for infeasible constraints. Infeasible linear constraints are detected first by solving a problem of the form
where
. This is equivalent to minimizing the sum of the general linear constraint violations subject to the simple bounds. (In the linear programming literature, the approach is often called
elastic programming.)
If the linear constraints are infeasible (i.e., or ), the function terminates without computing the nonlinear functions.
If the linear constraints are feasible, all subsequent iterates will satisfy the linear constraints. (Such a strategy allows linear constraints to be used to define a region in which
and
can be safely evaluated.) The function proceeds to solve
(1) as given, using search directions obtained from a sequence of QP subproblems
(5). Each QP subproblem minimizes a quadratic model of a certain Lagrangian function subject to linearized constraints. An augmented Lagrangian merit function
(6) is reduced along each search direction to ensure convergence from any starting point.
The function enters ‘elastic’ mode if the QP subproblem proves to be infeasible or unbounded (or if the dual variables
for the nonlinear constraints become ‘large’) by solving a problem of the form
where
is called a
composite objective and
is a non-negative argument (the
elastic weight). If
is sufficiently large, this is equivalent to minimizing the sum of the nonlinear constraint violations subject to the linear constraints and bounds. A similar
formulation of
(1) is fundamental to the S
QP algorithm of
Fletcher (1984). See also
Conn (1973).
12
Optional Parameters
A number of optional input and output arguments to
e04ugc are available through the structure argument
options, type Nag_E04_Opt. An argument may be selected by assigning an appropriate value to the relevant structure member; those arguments not selected will be assigned default values. If no use is to be made of any of the optional parameters you should use the NAG defined null pointer,
E04_DEFAULT, in place of
options when calling
e04ugc; the default settings will then be used for all arguments.
Before assigning values to
options directly the structure
must be initialized by a call to the function
e04xxc. Values may then be assigned to the structure members in the normal C manner.
After return from
e04ugc, the
options structure may only be re-used for future calls of
e04ugc if the dimensions of the new problem are the same. Otherwise, the structure must be cleared by a call of
e04xzc) and re-initialized by a call of
e04xxc before future calls. Failure to do this will result in unpredictable behaviour.
Option settings may also be read from a text file using the function
e04xyc in which case initialization of the
options structure will be performed automatically if not already done. Any subsequent direct assignment to the
options structure must
not be preceded by initialization.
If assignment of memory to pointers in the
options structure is required, then this must be done directly in the calling program; they cannot be assigned using
e04xyc.
12.1
Optional Parameter Checklist and Default Values
For easy reference, the following list shows the members of
options which are valid for
e04ugc together with their default values where relevant. The number
is a generic notation for
machine precision (see
X02AJC).
Nag_Start start |
|
Boolean list |
Nag_TRUE |
Boolean print_80ch |
Nag_TRUE |
Nag_PrintType print_level |
|
Nag_PrintType minor_print_level |
|
Nag_DPrintType print_deriv |
|
char outfile[512] |
stdout |
char **crnames |
NULL |
Boolean obj_deriv |
Nag_TRUE |
Boolean con_deriv |
Nag_TRUE |
Nag_GradChk verify_grad |
|
Integer obj_check_start |
1 |
Integer obj_check_stop |
nonln |
Integer con_check_start |
1 |
Integer con_check_stop |
njnln |
double f_diff_int |
|
double c_diff_int |
|
Nag_CrashType crash |
or |
Integer expand_freq |
10000 |
Integer factor_freq |
50 or 100 |
Integer fcheck |
60 |
Integer hess_freq |
99999999 |
Integer hess_update |
20 |
Integer iter_lim |
10000 |
Integer major_iter_lim |
1000 |
Integer minor_iter_lim |
500 |
Integer part_price |
1 or 10 |
Integer scale_opt |
1 or 2 |
Integer max_sb |
|
double crash_tol |
0.1 |
double elastic_wt |
or 100.0 |
double f_prec |
|
double inf_bound |
|
double linesearch_tol |
0.9 |
double lu_den_tol |
0.6 |
double lu_sing_tol |
|
double lu_factor_tol |
or 100.0 |
double lu_update_tol |
or 10.0 |
double major_feas_tol |
|
double major_opt_tol |
|
double major_step_lim |
2.0 |
double minor_feas_tol |
|
double minor_opt_tol |
|
double nz_coef |
5.0 |
double pivot_tol |
|
double scale_tol |
0.9 |
double unbounded_obj |
|
double inf_step |
|
double violation_limit |
10.0 |
Boolean deriv_linesearch |
Nag_TRUE |
Boolean feas_exit |
Nag_FALSE |
Nag_HessianType hess_storage |
or |
Nag_DirectionType direction |
|
Integer *state |
size |
double *lambda |
size |
Integer iter |
|
Integer major_iter |
|
Integer nsb |
|
Integer nf |
|
12.2
Description of the Optional Parameters
start – Nag_Start | | Default |
On entry: indicates how a starting basis is to be obtained.
If , then an initial Crash procedure will be used to choose an initial basis.
If , then you must provide a valid definition of the optional parameters and . (These may be the output of a previous call.)
A warm start will be advantageous if a good estimate of the initial working set is available – for example, when e04ugc is called repeatedly to solve related problems.
Constraint:
or .
list – Nag_Boolean | | Default |
On entry: if the argument settings in the call to e04ugc will be printed. The actual options printed can vary depending on the problem type being solved.
print_80ch – Nag_Boolean | | Default |
On entry: controls the maximum length of each line of output produced by major and minor iterations and by the printing of the solution.
If (the default), then a maximum of 80 characters per line is printed.
If , then a maximum of 120 characters per line is printed.
(See also and below.)
print_level – Nag_PrintType | | Default |
On entry: the level of results printout produced by
e04ugc at each major iteration, as indicated below. A detailed description of the printed output is given in
Section 12.3. (See also
, below.)
|
No output. |
|
The final solution only. |
|
One line of output for each major iteration (no printout of the final solution). |
|
The final solution and one line of output for each iteration. |
|
The final solution, one 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 or 2; see below), basis factorization statistics and details of the initial basis resulting from the Crash procedure (if and ). |
Note that the output for each line of major iteration and for the solution printout contains a maximum of 80 characters if , and a maximum of 120 characters otherwise. However, if , some printout may exceed 80 characters even when .
Constraint:
, , , or .
minor_print_level – Nag_PrintType | | Default |
On entry: controls the amount of printout produced by the minor iterations of
e04ugc (i.e., the iterations of the quadratic programming algorithm), as indicated below. A detailed description of the printed output is given in
Section 9.1 (default output at each iteration) and in
Section 12.3. (See also
.)
If , no output is produced.
If
, the following output is produced for each minor iteration:
- if , one line of summary output ( characters);
- if , one long line of output ( characters).
Constraint:
or .
print_deriv – Nag_DPrintType | | Default |
On entry: controls whether the results of any derivative checking are printed out (see also the optional parameter
).
If a component derivative check has been carried out, then full details will be printed if . If only a simple derivative check is requested, will produce a statement indicating failure or success. To prevent any printout from a derivative check, set .
Constraint:
or .
outfile – const char[512] | | Default |
On entry: the name of the file to which results should be printed. If then the stdout stream is used.
crnames – char ** | | Default NULL |
On entry: if
is not
NULL then it must point to an array of
character strings with maximum string length
, containing the names of the columns and rows (i.e., variables and constraints) of the problem. Thus,
contains the name of the
th column (variable), for
, and
contains the names of the
th row (constraint), for
. If supplied, the names are used in the solution output (see
Section 9.1 and
Section 12.3).
Constraint:
, for .
obj_deriv – Nag_Boolean | | Default |
On entry: this argument indicates whether all elements of the objective gradient are provided in function
objfun. If none or only some of the elements are being supplied by
objfun then
should be set to Nag_FALSE.
Whenever possible all elements should be supplied, since e04ugc is more reliable and will usually be more efficient when all derivatives are exact.
If
,
e04ugc will approximate unspecified elements 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. (2002), 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 your control.)
con_deriv – Nag_Boolean | | Default |
On entry: this argument indicates whether all elements of the constraint Jacobian are provided in function
confun (or possibly directly in
a for constant elements). If none or only some of the derivatives are being supplied then
should be set to Nag_FALSE.
Whenever possible all elements should be supplied, since e04ugc is more reliable and will usually be more efficient when all derivatives are exact.
If
,
e04ugc will approximate unspecified elements of the constraint Jacobian. One call to
confun will be needed for each variable for which partial derivatives are not available. For example, if the sparsity of the constraint Jacobian has the form
where ‘
’ indicates a provided element and ‘? ’ indicates an unspecified element,
e04ugc will call
confun twice: once to estimate the missing element in column
, and again once to estimate the two missing elements in column
. (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 your control.)
verify_grad – Nag_GradChk | | Default |
On entry: specifies the level of derivative checking to be performed by
e04ugc on the gradient elements computed by the user-supplied functions
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 following values are available:
|
No derivative checking is performed. |
|
Only a cheap test is 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. |
|
Individual objective gradient elements will be checked using a reliable (but more expensive) test. If , a key of the form OK or BAD? indicates whether or not each element appears to be correct. |
|
Individual columns or the constraint gradient (Jacobian) will be checked using a reliable (but more expensive) test. If , a key of the form OK or BAD? indicates whether or not each element appears to be correct. |
|
Check both constraint and objective gradients (in that order) as described for and (respectively). |
This component check will be made in the range specified by the optional parameters
and
for the objective gradient, with default values
and
nonln, respectively. For the constraint gradient the range is specified by
and
, with default values
and
njnln.
Constraint:
, , , or .
obj_check_start – Integer | | Default |
obj_check_stop – Integer | | Default |
These options take effect only when or .
On entry: these arguments may be used to control the verification of gradient elements computed by the function
objfun. For example, if the first 30 elements of the objective gradient appear to be correct in an earlier run, so that only element 31 remains questionable, it is reasonable to specify
.
Constraint:
.
con_check_start – Integer | | Default |
con_check_stop – Integer | | Default |
These options take effect only when or .
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:
.
f_diff_int – double | | Default |
This option does not apply when both and are true.
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 parameter ).
-
(b)For estimating unspecified elements of the objective and/or the constraint Jacobian matrix.
Using the notation
, a derivative with respect to
is estimated by perturbing that element of
to the value
, and then evaluating
and/or
(as appropriate) at the perturbed point. If the functions are well scaled, the resulting derivative approximation should be accurate to O
. Judicious alteration of
may sometimes lead to greater accuracy. See
Gill et al. (1981) for a discussion of the accuracy in finite difference approximations.
Constraint:
.
c_diff_int – double | | Default |
This option does not apply when both and are true.
On entry:
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 difference (see the optional parameter
). Using the notation
, the interval used for the
th variable is
. If the functions are well scaled, the resultant gradient estimates should be accurate to O
. The switch to central differences (not under user-control) is indicated by
C at the end of each line of intermediate printout produced by the major iterations (see
Section 12.3). The use of finite differences is discussed under the option
.
Constraint:
.
crash – Nag_CrashType | | Default or |
This option does not apply when .
On entry: the default value of
if there are any nonlinear constraints, and
otherwise.
If
, an internal Crash procedure is used to select an initial basis from the various rows and columns of the constraint matrix
. The value of
determines which rows and columns of
are initially eligible for the basis, and how many times the Crash procedure is called. Columns of
are used to pad the basis where necessary. The possible choices for
are as follows:
|
The initial basis contains only slack variables: . |
|
The Crash procedure is called once (looking for a triangular basis in all rows and columns of ). |
|
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). |
|
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 , certain slacks on inequality rows are selected for the basis first. (If or , numerical values are used to exclude slacks that are close to a bound.) The Crash procedure then makes several passes through the columns of , 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.
Constraint:
, , or .
expand_freq – Integer | | Default |
On entry: 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 (see below) is . Over a period of iterations, the feasibility tolerance actually used by e04ugc (i.e., the working feasibility tolerance) increases from to (in steps of ).
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 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 below).
If , the value is used and effectively no anti-cycling procedure is invoked.
Constraint:
.
factor_freq – Integer | | Default or 100 |
On entry:
specifies the maximum number of basis changes that will occur between factorizations of the basis matrix. The default value of
is 50 if there are any nonlinear constraints, and 100 otherwise.
For linear problems, the basis factors are usually updated at every iteration. The default value 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 the optional parameter (see below) to ensure that the general constraints are satisfied. If necessary, the basis will be refactorized before the limit of updates is reached.
Constraint:
.
fcheck – Integer | | Default |
On entry: every th iteration after the most recent basis iteration, a numerical test is made to see if the current solution satisfies the general linear constraints (including any linearized nonlinear constraints). The constraints are of the form , where is the set of slack variables. If the largest element of the residual vector is judged to be too large, the current basis is refactorized and the basic variables recomputed to satisfy the general constraints more accurately. If , the value is used and effectively no checks are made.
Constraint:
.
hess_freq – Integer | | Default |
This option only takes effect when .
On entry: this option forces the approximate Hessian formed from BFGS updates to be reset to the identity matrix upon completion of a major iteration.
Constraint:
.
hess_update – Integer | | Default |
This option only takes effect when .
On entry: if
(see below), 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
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 is likely to give a robust algorithm without significant expense, but faster convergence may often be obtained with far fewer updates (e.g., ).
Constraint:
.
iter_lim – Integer | | Default |
On entry: 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 and below.)
Constraint:
.
major_iter_lim – Integer | | Default |
On entry: 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 and means that the objective and constraint gradients will be checked if , but no iterations will be performed.
Constraint:
.
minor_iter_lim – Integer | | Default |
On entry: specifies the maximum number of iterations allowed between successive linearizations of the nonlinear constraints. A value in the range
prevents excessive effort being expended on early major iterations, but allows later QP subproblems to be solved to completion. Note that an extra
minor iterations are allowed if the first QP subproblem to be solved starts with the all-slack basis
. (See
.)
In general, it is unsafe to specify values as small as 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 recognised as optimal).
Constraint:
.
part_price – Integer | | Default or 10 |
On entry: this option is recommended for large problems that have significantly more variables than constraints (i.e.,
). The default value of
is 1 if there are any nonlinear constraints, and 10 otherwise. It reduces the work required for each ‘pricing’ operation (i.e., when a nonbasic variable is selected to become superbasic). The possible choices for
are the following.
|
Meaning |
|
All columns of the constraint matrix are searched. |
|
Both and are partitioned to give roughly equal segments , for (modulo ). If the previous pricing search was successful on , the next search begins on the segments . 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 , and so on. |
Constraint:
.
scale_opt – Integer | | Default or 2 |
On entry: the default value of
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
and column scales
such that the scaled matrix coefficients
are as close as possible to unity. (The lower and upper bounds on the variables and slacks for the scaled problem are redefined as
and
respectively, where
if
.) The possible choices for
are the following.
|
Meaning |
0 |
No scaling is performed. This is recommended if it is known that the elements of and the constraint matrix (along with its Jacobian) never become large (say, ). |
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 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 should therefore be used only if a ‘good’ starting point is available and the problem is not highly nonlinear.
|
Constraint:
, or .
max_sb – Integer | | Default |
This option does not apply to linear problems.
On entry:
places a limit on the storage allocated for superbasic variables. Ideally, the value of
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 need not be greater than (where ), but for many problems it may be considerably smaller. (This will save storage if is very large.)
Constraint:
.
crash_tol – double | | Default |
On entry: this option allows the Crash procedure to ignore certain ‘small’ nonzero elements in the columns of
while searching for a triangular basis. If
is the largest element in the
th column, other nonzeros
in the column are ignored if
.
When , 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 and fewer (arbitrary) slacks. A feasible solution may be reached earlier on some problems.
Constraint:
.
elastic_wt – double | | Default or 100.0 |
On entry: this option defines the initial weight
associated with problem
(8). The default value of
is
if there are any nonlinear constraints, and
otherwise.
At any given major iteration , elastic mode is entered if the QP subproblem is infeasible or the QP dual variables (Lagrange multipliers) are larger in magnitude than , where is the objective gradient. In either case, the QP subproblem is re-solved in elastic mode with .
Constraint:
.
f_prec – double | | Default |
On entry: this option defines the
relative function precision , which is intended to be a measure of the relative accuracy with which the nonlinear functions can be computed. For example, if
(or
) is computed as
for some relevant
and the first 6 significant digits are known to be correct, the appropriate value for
would be
.
Ideally the functions or should have magnitude of order . If all functions are substantially less than 1 in magnitude, should be the absolute precision. For example, if (or ) is computed as for some relevant and the first 6 significant digits are known to be correct, the 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.
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 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.
Constraint:
.
inf_bound – double | | Default |
On entry: defines the ‘infinite’ bound in the definition of the problem constraints. Any upper bound greater than or equal to will be regarded as (and similarly any lower bound less than or equal to will be regarded as ).
Constraint:
.
linesearch_tol – double | | Default |
On entry: this option controls the accuracy with which a steplength 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
therefore determines the accuracy to which this target value is approximated.
The default value 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 , or . 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 all derivatives are available ( and are both true), try . (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 some derivatives are not available (at least one of or is false), a moderately accurate search may be appropriate; try . Each search will (typically) require only function values, but many function calls will then be needed to estimate the missing gradients for the next iteration.
Constraint:
.
lu_den_tol – double | | Default |
On entry: this option defines the density tolerance used during the factorization of the basis matrix. Columns of and rows of 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 , the Markowitz strategy for choosing pivots is terminated. The remaining matrix is then factorized using a dense procedure. Increasing the value of towards unity may give slightly sparser factors, with a slight increase in factorization time.
Constraint:
.
lu_sing_tol – double | | Default |
On entry: this option defines the singularity tolerance used to guard against ill-conditioned basis matrices. Whenever the basis is refactorized, the diagonal elements of
are tested as follows. If
or
, the
th column of the basis is replaced by the corresponding slack variable. This is most likely to occur when
, or at the start of a major iteration.
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 (say) may therefore help cause a judicious change of basis in such situations.
Constraint:
.
lu_factor_tol – double | | Default or 100.0 |
lu_update_tol – double | | Default or 10.0 |
On entry:
and
affect the stability and sparsity of the basis factorization
, during refactorization and updates respectively. The default values are
if there are any nonlinear constraints, and
and
otherwise.
The lower triangular matrix
can be seen as a product of matrices of the form
where the multipliers
satisfy
during refactorization or
during update. The default values of
and
usually strike a good compromise between stability and sparsity. Smaller values of
and
favour stability, while larger values favour sparsity. For large and relatively dense problems, setting
to
or
(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
and/or
in order to achieve stability.
Constraints:
- ;
- .
major_feas_tol – double | | Default |
On entry: 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
is the violation of the
th nonlinear constraint.
Constraint:
.
major_opt_tol – double | | Default |
On entry: this option specifies the final accuracy of the dual variables. If
e04ugc terminates with
, a primal and dual solution
will have been computed such that
where
is an estimate of the complementarity gap for the
th variable and
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,
is computed from the final QP solution using the reduced gradients
, where
is the
th element of the objective gradient and
is the associated column of the constraint matrix
:
Constraint:
.
major_step_lim – double | | Default |
On entry: this option limits the change in
during a linesearch. It applies to all nonlinear problems once a ‘feasible solution’ or ‘feasible subproblem’ has been found.
A linesearch determines a step in the interval , where if there are any nonlinear constraints, or the step to the nearest upper or lower bound on if all the constraints are linear. Normally, the first step attempted is .
In some cases, such as
or
, even a moderate change in the elements of
can lead to floating-point overflow. The optional parameter
is therefore used to define a step limit
given by
where
is the search direction and the first evaluation of
is made at the (potentially) smaller step length
.
Wherever possible, upper and lower bounds on should be used to prevent evaluation of nonlinear functions at meaningless points. provides an additional safeguard. The default value should not affect progress on well-behaved functions, but values such as or may be helpful when rapidly varying functions are present. If a small value of is selected, a ‘good’ starting point may be required. An important application is to the class of nonlinear least squares problems.
Constraint:
.
minor_feas_tol – double | | Default |
On entry: this option attempts to ensure that all variables eventually satisfy their upper and lower bounds to within the tolerance
. Since this includes slack variables, general linear constraints should also be satisfied to within
. Note that feasibility with respect to nonlinear constraints is judged by the value of
and not by
.
If the bounds and linear constraints cannot be satisfied to within , the problem is declared infeasible. Let Sinf be the corresponding sum of infeasibilities. If Sinf is quite small, it may be appropriate to raise by a factor of 10 or . Otherwise, some error in the data should be suspected.
If , 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 , it is essential to place lower bounds on both and . If the value is used, the bounds and might be appropriate. (The log singularity is more serious; in general, you should attempt to keep as far away from singularities as possible.)
In reality, is used as a feasibility tolerance for satisfying the bounds on and 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 .)
Constraint:
.
minor_opt_tol – double | | Default |
On entry: this option is used to judge optimality for each QP subproblem. Let the QP reduced gradients be
, where
is the
th element of the QP gradient,
is the associated column of the QP constraint matrix and
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
for superbasic variables.
Note that 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 actually used is defined in the description of the optional parameter .)
If the objective is scaled down to be very small, the optimality test reduces to comparing against .
Constraint:
.
nz_coef – double | | Default |
This option is ignored if .
On entry:
defines how much memory is initially allocated for the basis factors: by default,
e04ugc allocates approximatively
reals and
integers in order to compute and store the basis factors. If at some point this appears not to be enough, an internal warm restart with more memory is automatically attempted, so that
e04ugc should complete anyway. Thus this option generally does not need to be modified.
However, if a lot of memory is available, it is possible to increase the value of such as to limit the number of compressions of the work space and possibly avoid internal restarts. On the other hand, for large problems where memory might be critical, decreasing the value of can sometimes save some memory.
Constraint:
.
pivot_tol – double | | Default |
On entry: this option 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 changes to for some specified search direction , a ‘ratio test’ is used to determine which element of reaches an upper or lower bound first. The corresponding element of is called the pivot element. Elements of are ignored (and therefore cannot be pivot elements) if they are smaller than .
It is common in practice for two (or more) variables to reach a bound at essentially the same time. In such cases, the optional parameter provides some freedom to maximize the pivot element and thereby improve numerical stability. Excessively small values of should therefore not be specified. To a lesser extent, the optional parameter also provides some freedom to maximize the pivot element. Excessively large values of should therefore not be specified.
Constraint:
.
scale_tol – double | | Default |
On entry: this option is used to control the number of scaling passes to be made through the constraint matrix . At least 3 (and at most 10) passes will be made. More precisely, let denote the largest column ratio (i.e., in some sense) after the th scaling pass through . The scaling procedure is terminated if for some . Thus, increasing the value of from to (say) will probably increase the number of passes through .
Constraint:
.
unbounded_obj – double | | Default |
inf_step – double | | Default |
On entry: these options are intended to detect unboundedness in nonlinear problems. During the linesearch, the objective function
is evaluated at points of the form
, where
and
are fixed and
varies. If
exceeds
or
exceeds
, the iterations are terminated and the function returns with
.
If singularities are present, unboundedness in may manifest itself by a floating-point overflow during the evaluation of , before the test against can be made.
Unboundedness in is best avoided by placing finite upper and lower bounds on the variables.
Constraints:
- ;
- .
violation_limit – double | | Default |
On entry: 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
satisfies the condition
where
is the point at which the nonlinear constraints are first evaluated and
is the
th nonlinear constraint violation
.
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 . 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 may be any large positive value.
Constraint:
.
deriv_linesearch – Nag_Boolean | | Default |
On entry: 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
. If some analytic derivatives are not provided or
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
is selected,
e04ugc signals the evaluation of the linesearch by calling
objfun and
confun with
. Once the linesearch is complete, the nonlinear functions are re-evaluated with
. 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
.
Constraint:
.
feas_exit – Nag_Boolean | | Default |
This option is ignored if the value of is exceeded, or the linear constraints are infeasible.
On entry: if termination is about to occur at a point that does not satisfy the nonlinear constraints and
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.
Constraint:
.
hess_storage – Nag_HessianType | | Default or |
On entry: this option specifies the method for storing and updating the quasi-Newton approximation to the Hessian of the Lagrangian function. The default is
if the number of nonlinear variables
(
)
, and
otherwise.
If , 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, ). In this case, the storage requirement is fixed and you can expect one-step Q-superlinear convergence to the solution.
should only be specified when is very large. In this case a limited memory procedure is used to update a diagonal Hessian approximation a limited number of times. (Updates are accumulated as a list of vector pairs. They are discarded at regular intervals after has been reset to their diagonal.)
Note that if is used in conjunction with , the effect will be similar to using in conjunction with , except that the latter will retain the current diagonal during resets.
Constraint:
or .
direction – Nag_DirectionType | | Default |
On entry: if
,
e04ugc 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, specifies the direction of 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 and the other maximizes , their solutions will be the same but the signs of the dual variables and the reduced gradients will be reversed.
Constraint:
, or .
state – Integer * | | Default memory |
On entry:
need not be set if the default option of
is used as
values of memory will be automatically allocated by
e04ugc.
If the optional parameter
has been chosen,
must point to a minimum of
elements of memory. This memory will already be available if the
options structure has been used in a previous call to
e04ugc from the calling program, with
and the same values of
n and
m. If a previous call has not been made you must allocate sufficient memory.
If you supply a
vector and
, then the first
n elements of
must specify the initial states of the problem variables. (The slacks
need not be initialized.) An internal Crash procedure is then used to select an initial basis matrix
. The initial basis matrix will be triangular (neglecting certain small elements in each column). It is chosen from various rows and columns of
. Possible values for
, for
, are:
|
State of 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 (and ), for . All variables will then be eligible for the initial basis. Less trivially, to say that the th variable will probably be equal to one of its bounds, you should set and or and as appropriate.
Following the Crash procedure, variables for which are made superbasic. Other variables not selected for the basis are then made nonbasic at the value if , or at the value or closest to .
When
,
and
xs must specify the initial states and values, respectively, of the variables and slacks
. If
e04ugc has been called previously with the same values of
n and
m,
already contains satisfactory information.
Constraints:
- if ,
, for ;
- if ,
, for .
On exit: the final states of the variables and slacks
. The significance of each possible value of
is as follows:
|
State of variable |
Normal value of
|
0 |
Nonbasic |
|
1 |
Nonbasic |
|
2 |
Superbasic |
Between and |
3 |
Basic |
Between and |
If the problem is feasible (i.e., ), basic and superbasic variables may be outside their bounds by as much as the optional parameter . Note that unless the optional parameter , applies to the variables of the scaled problem. In this case, the variables of the original problem may be as much as 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 , and there may be some nonbasic variables for which lies strictly between its bounds.
If the problem is infeasible (i.e.,
), some basic and superbasic variables may be outside their bounds by an arbitrary amount (bounded by
sinf if scaling was not used
.
lambda – double * | | Default memory |
On entry: if
, you do not need to provide memory for
, as
values of memory will be automatically allocated by
e04ugc. This is the recommended method of use of
. However you may supply memory from the calling program.
If the option
has been chosen,
must point to a minimum of
elements of memory. This memory will already be available if the
options structure has been used in a previous call to
e04ugc from the calling program, with
and the same values of
n and
m. If a previous call has not been made, you must allocate sufficient memory.
When a ‘warm start’ is chosen must contain a multiplier estimate for each nonlinear constraint for . The remaining elements need not be set. If nothing is known about the problem, or there is no wish to provide special information, you may set for .
On exit: a set of Lagrange multipliers for the bound constraints on the variables (
reduced costs) and the general constraints (
shadow costs). More precisely, the first
n elements contain the multipliers for the bound constraints on the variables, the next
ncnln elements contain the multipliers for the nonlinear constraints
(if any) and the next
elements contain the multipliers for the linear constraints
and the free row (if any).
On exit: the total number of minor iterations (summed over all major iterations).
On exit: the number of major iterations that have been performed in e04ugc.
On entry: the number of superbasic variables. It need not be specified if but must retain its value from a previous call when .
Constraint:
if , .
On exit: the final number of superbasic variables.
On exit: the number of calls to
objfun.
On exit: the number of calls to
confun.
12.3
Description of Printed Output
This section describes the intermediate printout and final printout produced by
e04ugc. The level of printed output can be controlled with the structure members
,
,
,
,
, and
(see
Section 12.2). If
then the argument values to
e04ugc are listed, followed by the result of any derivative check when
. The printout of results is then governed by the values of
,
and
. The default of
,
, and
produces a single line of output at each major iteration and the final result.
The following line of summary output (
characters) is produced at every major iteration. In all cases, the values of the quantities printed are those in effect
on completion of the given iteration.
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 11). |
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 (6) at the current iterate. This function will decrease at each iteration unless it was necessary to increase the penalty parameters (see Section 11.2). As the solution is approached, Merit function will converge to the value of the objective function at the solution.
In elastic mode (see Section 11.2), the merit function is a composite function involving the constraint violations weighted by the value of the optional parameter (default value or 100.0).
If there are no nonlinear constraints present, this entry contains Objective, the value of the objective function . In this case, will decrease monotonically to its optimal value. |
Feasibl |
is the value of rowerr, the largest element of the scaled nonlinear constraint residual vector defined in the description of the optional parameter . The solution is regarded as ‘feasible’ if Feasibl is less than (or equal to) the (default value ). Feasibl will be approximately zero in the neighbourhood of a solution.
If there are no nonlinear constraints present, all iterates are feasible and this entry is not printed. |
Optimal |
is the value of maxgap, the largest element of the maximum complementarity gap vector defined in the description of the optional parameter . The Lagrange multipliers are regarded as ‘optimal’ if Optimal is less than (or equal to) the optional parameter (default value ). Optimal will be approximately zero in the neighbourhood of a solution. |
Cond Hz |
is an estimate of the condition number of the reduced Hessian of the Lagrangian (not printed if ncnln and nonln are both zero). It is the square of the ratio between the largest and smallest diagonal elements of an upper triangular matrix . This constitutes a lower bound on the condition number of the matrix that approximates the reduced Hessian. The larger this number, the more difficult the problem. |
PD |
is a two-letter indication of the status of the convergence tests involving the feasibility and optimality of the iterates defined in the descriptions of the optional parameters and . Each letter is T if the test is satisfied, and F otherwise. The tests indicate whether the values of Feasibl and Optimal are sufficiently small. For example, TF or TT is printed if there are no nonlinear constraints present (since all iterates are feasible). |
M |
is printed if an extra evaluation of objfun and confun was needed in order to define an acceptable positive definite quasi-Newton update to the Hessian of the Lagrangian. This modification is only performed when there are nonlinear constraints present. |
m |
is printed if, in addition, it was also necessary to modify the update to include an augmented Lagrangian term. |
s |
is printed if a self-scaled BFGS (Broyden–Fletcher–Goldfarb–Shanno) update was performed. This update is always used when the Hessian approximation is diagonal, and hence always follows a Hessian reset. |
S |
is printed if, in addition, it was also necessary to modify the self-scaled update in order to maintain positive-definiteness. |
n |
is printed if no positive definite BFGS update could be found, in which case the approximate Hessian is unchanged from the previous iteration. |
r |
is printed if the approximate Hessian was reset after 10 consecutive major iterations in which no BFGS update could be made. The diagonal elements of the approximate Hessian are retained if at least one update has been performed since the last reset. Otherwise, the approximate Hessian is reset to the identity matrix. |
R |
is printed if the approximate Hessian has been reset by discarding all but its diagonal elements. This reset will be forced periodically by the values of the optional parameters (default value ) and (default value ). However, it may also be necessary to reset an ill-conditioned Hessian from time to time. |
l |
is printed if the change in the variables was limited by the value of the optional parameter (default value ). If this output occurs frequently during later iterations, it may be worthwhile increasing the value of . |
c |
is printed if central differences have been used to compute the unknown elements of the objective and constraint gradients. A switch to central differences is made if either the linesearch gives a small step, or is close to being optimal. In some cases, it may be necessary to re-solve the QP subproblem with the central difference gradient and Jacobian. |
u |
is printed if the QP subproblem was unbounded. |
t |
is printed if the minor iterations were terminated because the number of iterations specified by the value of the optional parameter (default value ) was reached. |
i |
is printed if the QP subproblem was infeasible when the function was not in elastic mode. This event triggers the start of nonlinear elastic mode, which remains in effect for all subsequent iterations. Once in elastic mode, the QP subproblems are associated with the elastic problem (8) (see Section 11.2). It is also printed if the minimizer of the elastic subproblem does not satisfy the linearized constraints when the function is already in elastic mode. (In this case, a feasible point for the usual QP subproblem may or may not exist.) |
w |
is printed if a weak solution of the QP subproblem was found. |
The final printout includes a listing of the status of every variable and constraint.
The following describes the printout for each variable.
Variable |
gives the name of the variable. If the optional parameter NULL, a default name is assigned to the th variable, for . Otherwise, the name supplied in is assigned to the th variable. |
State |
gives the state of the variable (LL if nonbasic on its lower bound, UL if nonbasic on its upper bound, EQ if nonbasic and fixed, FR if nonbasic and strictly between its bounds, BS if basic and SBS if superbasic).
A key is sometimes printed before State to give some additional information about the state of a variable. Note that unless the optional parameter (default value or 2) is specified, the tests for assigning a key are applied to the variables of the scaled problem.
A |
Alternative optimum possible. The variable is nonbasic, but its reduced gradient is essentially zero. This means that if the variable were allowed to start moving away from its current value, there would be no change in the value of the objective function. The values of the basic and superbasic variables might change, giving a genuine alternative solution. The values of the Lagrange multipliers might also change. |
D |
Degenerate. The variable is basic, but it is equal to (or very close to) one of its bounds. |
I |
Infeasible. The variable is basic and is currently violating one of its bounds by more than the value of the optional parameter (default value ). |
N |
Not precisely optimal. The variable is nonbasic. Its reduced gradient is larger than the value of the optional parameter (default value ). |
|
Value |
is the value of the variable at the final iterate. |
Lower Bound |
is the lower bound specified for the variable. None indicates that . |
Upper Bound |
is the upper bound specified for the variable. None indicates that . |
Lagr Mult |
is the Lagrange multiplier for the associated bound. This will be zero if State is FR. If is optimal, the multiplier should be non-negative if State is LL, non-positive if State is UL, and zero if State is BS or SBS. |
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 ). |
The meaning of the printout for general constraints is the same as that given above for variables, with ‘variable’ replaced by ‘constraint’,
replaced by
,
) replaced by
,
and
replaced by
and
respectively, and with the following change in the heading:
Constrnt |
gives the name of the general constraint. |
Numerical values are output with a fixed number of digits; they are not guaranteed to be accurate to this precision.
The following describes all of the possible other levels of results printout available from e04ugc.
If a simple derivative check, , is requested then a statement indicating success or failure is given. The largest error found in the objective and the constraint Jacobian are also output.
When a component derivative check (see the optional parameter
in
Section 12.2) is selected, the element with the largest relative error is identified for the objective and the constraint Jacobian.
If
then the following results are printed for each component:
x[j-1] |
the element of . |
dx[j-1] |
the finite difference interval. |
Jacobian value |
the nonlinear Jacobian element. |
g[j-1] |
the objective gradient element. |
Difference approx. |
the finite difference approximation. |
The indicator,
OK or
BAD?, states whether the derivative provided and the finite difference approximation are in agreement. If the derivatives are believed to be in error
e04ugc will exit with
fail set to either
NE_CON_DERIV_ERRORS or
NE_OBJ_DERIV_ERRORS, depending on whether the error was detected in the constraint Jacobian or in the objective gradient.
When
,
or
, and
, the following line of intermediate printout (
characters) is sent at every major iteration to
. Unless stated otherwise, the values of the quantities printed are those in effect
on completion of the given iteration.
Major |
is the major iteration count. |
Minor |
is the number of minor iterations required by the feasibility and optimality phases of the QP subproblem. Generally, Minor will be 1 in the later iterations, since theoretical analysis predicts that the correct active set will be identified near the solution (see Section 11). |
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. |
nObj |
is the number of times objfun has been called to evaluate the nonlinear part of the objective function. Evaluations needed for the estimation of the gradients by finite differences are not included. nObj is printed as a guide to the amount of work required for the linesearch. |
nCon |
is the number of times confun has been called to evaluate the nonlinear constraint functions (not printed if ncnln is zero). |
Merit |
is the value of the augmented Lagrangian merit function (6) at the current iterate. This function will decrease at each iteration unless it was necessary to increase the penalty parameters (see Section 11.1). As the solution is approached, Merit will converge to the value of the objective function at the solution.
In elastic mode (see Section 11.2), the merit function is a composite function involving the constraint violations weighted by the value of the optional parameter (default value or 100.0).
If there are no nonlinear constraints present, this entry contains Objective, the value of the objective function . In this case, will decrease monotonically to its optimal value. |
Feasibl |
is the value of rowerr, the largest element of the scaled nonlinear constraint residual vector defined in the description of the optional parameter . The solution is regarded as ‘feasible’ if Feasibl is less than (or equal to) (default value ). Feasibl will be approximately zero in the neighbourhood of a solution.
If there are no nonlinear constraints present, all iterates are feasible and this entry is not printed. |
Optimal |
is the value of maxgap, the largest element of the maximum complementarity gap vector defined in the description of the optional parameter . The Lagrange multipliers are regarded as ‘optimal’ if Optimal is less than (or equal to) (default value ). Optimal will be approximately zero in the neighbourhood of a solution. |
nS |
is the current number of superbasic variables. |
Penalty |
is the Euclidean norm of the vector of penalty parameters used in the augmented Lagrangian function (not printed if ncnln is zero). |
LU |
is the number of nonzeros representing the basis factors and on completion of the QP subproblem.
If there are nonlinear constraints present, the basis factorization is computed at the start of the first minor iteration. At this stage, , where lenL is the number of subdiagonal elements in the columns of a lower triangular matrix and lenU is the number of diagonal and superdiagonal elements in the rows of an upper triangular matrix. As columns of are replaced during the minor iterations, the value of LU may fluctuate up or down (but in general will tend to increase). As the solution is approached and the number of minor iterations required to solve each QP subproblem decreases towards zero, LU will reflect the number of nonzeros in the factors at the start of each QP subproblem.
If there are no nonlinear constraints present, refactorization is subject only to the value of the optional parameter (default value or 100) and hence LU will tend to increase between factorizations. |
Swp |
is the number of columns of the basis matrix that were swapped with columns of in order to improve the condition number of (not printed if ncnln is zero). The swaps are determined by an factorization of the rectangular matrix , with stability being favoured more than sparsity. |
Cond Hz |
is an estimate of the condition number of the reduced Hessian of the Lagrangian (not printed if ncnln and nonln are both zero). It is the square of the ratio between the largest and smallest diagonal elements of the upper triangular matrix . This constitutes a lower bound on the condition number of the matrix that approximates the reduced Hessian. The larger this number, the more difficult the problem. |
PD |
is a two-letter indication of the status of the convergence tests involving the feasibility and optimality of the iterates defined in the descriptions of the optional parameters and . Each letter is T if the test is satisfied, and F otherwise. The tests indicate whether the values of Feasibl and Optimal are sufficiently small. For example, TF or TT is printed if there are no nonlinear constraints present (since all iterates are feasible). |
M |
is printed if an extra evaluation of objfun and confun was needed in order to define an acceptable positive definite quasi-Newton update to the Hessian of the Lagrangian. This modification is only performed when there are nonlinear constraints present. |
m |
is printed if, in addition, it was also necessary to modify the update to include an augmented Lagrangian term. |
s |
is printed if a self-scaled BFGS (Broyden–Fletcher–Goldfarb–Shanno) update was performed. This update is always used when the Hessian approximation is diagonal, and hence always follows a Hessian reset. |
S |
is printed if, in addition, it was also necessary to modify the self-scaled update in order to maintain positive-definiteness. |
n |
is printed if no positive definite BFGS update could be found, in which case the approximate Hessian is unchanged from the previous iteration. |
r |
is printed if the approximate Hessian was reset after 10 consecutive major iterations in which no BFGS update could be made. The diagonal elements of the approximate Hessian are retained if at least one update has been performed since the last reset. Otherwise, the approximate Hessian is reset to the identity matrix. |
R |
is printed if the approximate Hessian has been reset by discarding all but its diagonal elements. This reset will be forced periodically by the values of the optional parameters (default value ) and (default value ). However, it may also be necessary to reset an ill-conditioned Hessian from time to time. |
l |
is printed if the change in the variables was limited by the value of the optional parameter (default value ). If this output occurs frequently during later iterations, it may be worthwhile increasing the value of . |
c |
is printed if central differences have been used to compute the unknown elements of the objective and constraint gradients. A switch to central differences is made if either the linesearch gives a small step, or is close to being optimal. In some cases, it may be necessary to re-solve the QP subproblem with the central difference gradient and Jacobian. |
u |
is printed if the QP subproblem was unbounded. |
t |
is printed if the minor iterations were terminated because the number of iterations specified by the value of the optional parameter (default value ) was reached. |
i |
is printed if the QP subproblem was infeasible when the function was not in elastic mode. This event triggers the start of nonlinear elastic mode, which remains in effect for all subsequent iterations. Once in elastic mode, the QP subproblems are associated with the elastic problem (8) (see Section 11.2). It is also printed if the minimizer of the elastic subproblem does not satisfy the linearized constraints when the function is already in elastic mode. (In this case, a feasible point for the usual QP subproblem may or may not exist.) |
w |
is printed if a weak solution of the QP subproblem was found. |
When
and
, the following line of intermediate printout (
characters) is sent at every minor iteration to
. Unless stated otherwise, the values of the quantities printed are those in effect
on completion of the given iteration.
Itn |
is the iteration count. |
Step |
is the step taken along the computed search direction. |
Ninf |
is the number of infeasibilities. This will not increase unless the iterations are in elastic mode. Ninf will be zero during the optimality phase. |
Sinf |
is the value of the sum of infeasibilities if Ninf is nonzero. This will be zero during the optimality phase. |
Objective |
is the value of the current QP objective function when Ninf is zero and the iterations are not in elastic mode. The switch to elastic mode is indicated by a change in the heading to Composite Obj (see below). |
Composite Obj |
is the value of the composite objective function (9) when the iterations are in elastic mode. This function will decrease monotonically at each iteration. |
Norm rg |
is the Euclidean norm of the reduced gradient of the QP objective function. During the optimality phase, this norm will be approximately zero after a unit step. |
When and , the following line of intermediate printout ( characters) is sent at every minor iteration to . Unless stated otherwise, the values of the quantities printed are those in effect on completion of the given iteration.
In the description below, a ‘pricing’ operation is defined to be the process by which a nonbasic variable is selected to become superbasic (in addition to those already in the superbasic set). If the problem is purely linear, the variable selected will usually become basic immediately (unless it happens to reach its opposite bound and return to the nonbasic set).
Itn |
is the iteration count. |
pp |
is the partial price indicator. The variable selected by the last pricing operation came from the ppth partition of and . Note that pp is reset to zero whenever the basis is refactorized. |
dj |
is the value of the reduced gradient (or reduced cost) for the variable selected by the pricing operation at the start of the current iteration. |
+SBS |
is the variable selected by the pricing operation to be added to the superbasic set. |
-SBS |
is the variable chosen to leave the superbasic set. It has become basic if the entry under -B is nonzero; otherwise it has become nonbasic. |
-BS |
is the variable removed from the basis (if any) to become nonbasic. |
-B |
is the variable removed from the basis (if any) to swap with a slack variable made superbasic by the latest pricing operation. The swap is done to ensure that there are no superbasic slacks. |
Step |
is the value of the step length taken along the current search direction . The variables have just been changed to . If a variable is made superbasic during the current iteration (i.e., +SBS is positive), Step will be the step to the nearest bound. During the optimality phase, the step can be greater than unity only if the reduced Hessian is not positive definite. |
Pivot |
is the th element of a vector satisfying whenever (the th column of the constraint matrix ) replaces the th column of the basis matrix . Wherever possible, Step is chosen so as to avoid extremely small values of Pivot (since they may cause the basis to be nearly singular). In extreme cases, it may be necessary to increase the value of the optional parameter (default value ) to exclude very small elements of from consideration during the computation of Step. |
Ninf |
is the number of infeasibilities. This will not increase unless the iterations are in elastic mode. Ninf will be zero during the optimality phase. |
Sinf/Objective |
is the value of the current objective function. If is infeasible, Sinf gives the value of the sum of infeasibilities at the start of the current iteration. It will usually decrease at each nonzero value of Step, but may occasionally increase if the value of Ninf decreases by a factor of 2 or more. However, in elastic mode this entry gives the value of the composite objective function (9), which will decrease monotonically at each iteration. If is feasible, Objective is the value of the current QP objective function. |
L |
is the number of nonzeros in the basis factor . Immediately after a basis factorization , this entry contains lenL. Further nonzeros are added to L when various columns of are later replaced. (Thus, L increases monotonically.) |
U |
is the number of nonzeros in the basis factor . Immediately after a basis factorization , this entry contains lenU. As columns of are replaced, the matrix is maintained explicitly (in sparse form). The value of U may fluctuate up or down; in general, it will tend to increase. |
Ncp |
is the number of compressions required to recover workspace in the data structure for . This includes the number of compressions needed during the previous basis factorization. Normally, Ncp should increase very slowly. If it does not, e04ugc will attempt to expand the internal workspace allocated for the basis factors. |
The following items are printed only if the problem is nonlinear or the superbasic set is non-empty (i.e., if the current solution is nonbasic).
Norm rg |
is the Euclidean norm of the reduced gradient at the start of the current iteration. During the optimality phase, this norm will be approximately zero after a unit step. |
nS |
is the current number of superbasic variables. |
Cond Hz |
is an estimate of the condition number of the reduced Hessian of the Lagrangian (not printed if ncnln and nonln are both zero). It is the square of the ratio between the largest and smallest diagonal elements of an upper triangular matrix . This constitutes a lower bound on the condition number of the matrix that approximates the reduced Hessian. The larger this number, the more difficult the problem. |
When , the following lines of intermediate printout ( characters) are sent to whenever the matrix or is factorized. Gaussian elimination is used to compute a sparse factorization of or , where is a lower triangular matrix and is an upper triangular matrix for some permutation matrices and . The factorization is stabilized in the manner described under the optional parameter (default value or 100.0).
Note that
may be factorized at the beginning of just some of the major iterations. It is immediately followed by a factorization of
itself. Note also that factorizations can occur during the solution of a QP problem.
Factorize |
is the factorization count. |
Demand |
is a code giving the reason for the present factorization as follows:
Code |
Meaning |
|
First factorization. |
|
The number of updates reached the value of the optional parameter (default value or 100). |
|
The number of nonzeros in the updated factors has increased significantly. |
|
Not enough storage to update factors. |
|
Row residuals too large (see the description for the optional parameter ). |
|
Ill-conditioning has caused inconsistent results. |
|
Iteration |
is the iteration count. |
Nonlinear |
is the number of nonlinear variables in the current basis (not printed if is factorized). |
Linear |
is the number of linear variables in (not printed if is factorized). |
Slacks |
is the number of slack variables in (not printed if is factorized). |
Elems |
is the number of nonzeros in (not printed if is factorized). |
Density |
is the percentage nonzero density of (not printed if is factorized). More precisely,
. |
Compressns |
is the number of times the data structure holding the partially factorized matrix needed to be compressed, in order to recover unused workspace. Ideally, it should be zero. |
Merit |
is the average Markowitz merit count for the elements chosen to be the diagonals of . Each merit count is defined to be , where and are the number of nonzeros in the column and row containing the element at the time it is selected to be the next diagonal. Merit is the average of m such quantities. It gives an indication of how much work was required to preserve sparsity during the factorization. |
lenL |
is the number of nonzeros in . |
lenU |
is the number of nonzeros in . |
Increase |
is the percentage increase in the number of nonzeros in and relative to the number of nonzeros in . More precisely, . |
m |
is the number of rows in the problem. Note that . |
Ut |
is the number of triangular rows of at the top of . |
d1 |
is the number of columns remaining when the density of the basis matrix being factorized reached 0.3. |
Lmax |
is the maximum subdiagonal element in the columns of . This will not exceed the value of the optional parameter (default value or 100.0). |
Bmax |
is the maximum nonzero element in (not printed if is factorized). |
BSmax |
is the maximum nonzero element in (not printed if is factorized). |
Umax |
is the maximum nonzero element in , excluding elements of that remain in unchanged. (For example, if a slack variable is in the basis, the corresponding row of will become a row of without modification. Elements in such rows will not contribute to Umax. If the basis is strictly triangular, none of the elements of will contribute, and Umax will be zero.)
Ideally, Umax should not be significantly larger than Bmax. If it is several orders of magnitude larger, it may be advisable to reset the to some value nearer unity.
Umax is not printed if is factorized. |
Umin |
is the magnitude of the smallest diagonal element of . |
Growth |
is the value of the ratio , which should not be too large.
Providing Lmax is not large (say ), the ratio is an estimate of the condition number of . If this number is extremely large, the basis is nearly singular and some numerical difficulties might occur. (However, an effort is made to avoid near-singularity by using slacks to replace columns of that would have made Umin extremely small, and the modified basis is refactorized.) |
Lt |
is the number of triangular columns of at the left of . |
bp |
is the size of the ‘bump’ or block to be factorized nontrivially after the triangular rows and columns of have been removed. |
d2 |
is the number of columns remaining when the density of the basis matrix being factorized has reached 0.6. |
When
, and
(default value
or
), the following lines of intermediate printout are sent to
whenever
. They refer to the number of columns selected by the Crash procedure during each of several passes through
while searching for a triangular basis matrix.
Slacks |
is the number of slacks selected initially. |
Free cols |
is the number of free columns in the basis, including those whose bounds are rather far apart. |
Preferred |
is the number of ‘preferred’ columns in the basis (i.e., for some ). It will be a subset of the columns for which was specified. |
Unit |
is the number of unit columns in the basis. |
Double |
is the number of columns in the basis containing two nonzeros. |
Triangle |
is the number of triangular columns in the basis with three (or more) nonzeros. |
Pad |
is the number of slacks used to pad the basis (to make it a nonsingular triangle). |
When or , and , the following lines of final printout ( characters) are sent to .
Let denote the th ‘column variable’, for . We assume that a typical variable has bounds .
The following describes the printout for each column (or variable).
Number |
is the column number . (This is used internally to refer to in the intermediate output.) |
Column |
gives the name of . |
State |
gives the state of relative to the bounds and . The various possible states are as follows:
LL |
is nonbasic at its lower limit, . |
UL |
is nonbasic at its upper limit, . |
EQ |
is nonbasic and fixed at the value . |
FR |
is nonbasic at some value strictly between its bounds: . |
BS |
is basic. Usually . |
SBS |
is superbasic. Usually . |
A key is sometimes printed before State to give some additional information about the state of . Note that unless the optional parameter (default value or 2) is specified, the tests for assigning a key are applied to the variables of the scaled problem.
A |
Alternative optimum possible. is nonbasic, but its reduced gradient is essentially zero. This means that if were allowed to start moving away from its current value, there would be no change in the value of the objective function. The values of the basic and superbasic variables might change, giving a genuine alternative solution. The values of the Lagrange multipliers might also change. |
D |
Degenerate. is basic, but it is equal to (or very close to) one of its bounds. |
I |
Infeasible. is basic and is currently violating one of its bounds by more than the value of the optional parameter (default value ). |
N |
Not precisely optimal. is nonbasic. Its reduced gradient is larger than the value of the optional parameter (default value ). |
|
Activity |
is the value of at the final iterate. |
Obj Gradient |
is the value of at the final iterate. (If any is infeasible, is the gradient of the sum of infeasibilities.) |
Lower Limit |
is , the lower bound specified for . None indicates that . |
Upper Limit |
is , the upper bound specified for . None indicates that . |
Reduced Gradnt |
is the value of at the final iterate. |
m + j |
is the value of . |
General linear constraints take the form . Let denote the th row of , for . The th constraint is therefore of the form , and the value of is called the row activity. Internally, the linear constraints take the form , where the slack variables should satisfy the bounds . For the th ‘row’, it is the slack variable that is directly available, and it is sometimes convenient to refer to its state. Slacks may be basic or nonbasic (but not superbasic).
Nonlinear constraints are treated similarly, except that the row activity and degree of infeasibility are computed directly from rather than from .
The following describes the printout for each row (or constraint).
Number |
is the value of . (This is used internally to refer to in the intermediate output.) |
Row |
gives the name of the th row. |
State |
gives the state of the th row relative to the bounds and . The various possible states are as follows:
LL |
The row is at its lower limit, . |
UL |
The row is at its upper limit, . |
EQ |
The limits are the same . |
BS |
The constraint is not binding. is basic. |
A key is sometimes printed before State to give some additional information about the state of . Note that unless the optional parameter (default value or 2) is specified, the tests for assigning a key are applied to the variables of the scaled problem.
A |
Alternative optimum possible. is nonbasic, but its reduced gradient is essentially zero. This means that if were allowed to start moving away from its current value, there would be no change in the value of the objective function. The values of the basic and superbasic variables might change, giving a genuine alternative solution. The values of the dual variables (or Lagrange multipliers) might also change. |
D |
Degenerate. is basic, but it is equal to (or very close to) one of its bounds. |
I |
Infeasible. is basic and is currently violating one of its bounds by more than the value of the optional parameter (default value ). |
N |
Not precisely optimal. is nonbasic. Its reduced gradient is larger than the value of the optional parameter (default value ). |
|
Activity |
is the value of (or for nonlinear rows) at the final iterate. |
Slack Activity |
is the value by which the row differs from its nearest bound. (For the free row (if any), it is set to Activity.) |
Lower Limit |
is , the lower bound specified for the th row. None indicates that . |
Upper Limit |
is , the upper bound specified for the th row. None indicates that . |
Dual Activity |
is the value of the dual variable . |
i |
gives the index of the th row. |
Numerical values are output with a fixed number of digits; they are not guaranteed to be accurate to this precision.