NAG FL Interface
h02cbf (iqp_​dense)

1 Purpose

2 Specification

3 Description

4 References

5 Arguments

1: $\mathbf{n}$ – Integer Input

On entry: $n$, the number of variables.

Constraint: $\mathbf{n}>0$.

2: $\mathbf{nclin}$ – Integer Input

On entry: $m_L$, the number of general linear constraints.

Constraint: $\mathbf{nclin}\ge 0$.

3: $\mathbf{a}\left(\mathbf{lda},*\right)$ – Real (Kind=nag_wp) array Input

Note: the second dimension of the array a must be at least $\mathbf{n}$ if $\mathbf{nclin}>0$ and at least $1$ if $\mathbf{nclin}=0$.

On entry: the $\mathit{i}$th row of a must contain the coefficients of the $\mathit{i}$th general linear constraint, for $\mathit{i}=1,2,\dots ,m_L$.

If $\mathbf{nclin}=0$, the array a is not referenced.

4: $\mathbf{lda}$ – Integer Input

On entry: the first dimension of the array a as declared in the (sub)program from which h02cbf is called.

Constraint: $\mathbf{lda}\ge \max \left(1,\mathbf{nclin}\right)$.

5: $\mathbf{bl}\left(\mathbf{n}+\mathbf{nclin}\right)$ – Real (Kind=nag_wp) array Input

6: $\mathbf{bu}\left(\mathbf{n}+\mathbf{nclin}\right)$ – Real (Kind=nag_wp) array Input

On entry: bl must contain the lower bounds and bu the upper bounds, for all the constraints in the following order. The first $n$ elements of each array must contain the bounds on the variables, and the next $m_L$ elements the bounds for the general linear constraints (if any). To specify a nonexistent lower bound (i.e., $l_j=-\infty$), set $\mathbf{bl}\left(j\right)\le -\mathit{bigbnd}$, and to specify a nonexistent upper bound (i.e., $u_j=+\infty$), set $\mathbf{bu}\left(j\right)\ge \mathit{bigbnd}$; the default value of $\mathit{bigbnd}$ is ${10}^{20}$, but this may be changed by the Infinite Bound Size. To specify the $j$th constraint as an equality, set $\mathbf{bl}\left(j\right)=\mathbf{bu}\left(j\right)=\beta$, say, where $\left|\beta \right|<\mathit{bigbnd}$.

Constraints:

• $\mathbf{bl}\left(\mathit{j}\right)\le \mathbf{bu}\left(\mathit{j}\right)$, for $\mathit{j}=1,2,\dots ,\mathbf{n}+\mathbf{nclin}$;
• if $\mathbf{bl}\left(j\right)=\mathbf{bu}\left(j\right)=\beta$, $\left|\beta \right|<\mathit{bigbnd}$.

7: $\mathbf{cvec}\left(*\right)$ – Real (Kind=nag_wp) array Input

Note: the dimension of the array cvec must be at least $\mathbf{n}$ if the problem is of type LP, QP2 (the default) or QP4, and at least $1$ otherwise.

On entry: the coefficients of the explicit linear term of the objective function when the problem is of type LP, QP2 (the default) and QP4.

If the problem is of type FP, QP1, or QP3, cvec is not referenced.

8: $\mathbf{h}\left(\mathbf{ldh},*\right)$ – Real (Kind=nag_wp) array Input

Note: the second dimension of the array h must be at least $\mathbf{n}$ if it is to be used to store $H$ explicitly, and at least $1$ otherwise.

On entry: may be used to store the quadratic term $H$ of the QP objective function if desired. In some cases, you need not use h to store $H$ explicitly (see the specification of qphess). The elements of h are referenced only by qphess. The number of rows of $H$ is denoted by $m$, whose default value is $n$. (The Hessian Rows may be used to specify a value of $m<n$.)

If the default version of qphess is used and the problem is of type QP1 or QP2 (the default), the first $m$ rows and columns of h must contain the leading $m$ by $m$ rows and columns of the symmetric Hessian matrix $H$. Only the diagonal and upper triangular elements of the leading $m$ rows and columns of h are referenced. The remaining elements need not be assigned.

If the default version of qphess is used and the problem is of type QP3 or QP4, the first $m$ rows of h must contain an $m$ by $n$ upper trapezoidal factor of the symmetric Hessian matrix $H^{\mathrm{T}}H$. The factor need not be of full rank, i.e., some of the diagonal elements may be zero. However, as a general rule, the larger the dimension of the leading nonsingular sub-matrix of h, the fewer iterations will be required. Elements outside the upper trapezoidal part of the first $m$ rows of h need not be assigned.

In other situations, it may be desirable to compute $Hx$ or $H^{\mathrm{T}}Hx$ without accessing h – for example, if $H$ or $H^{\mathrm{T}}H$ is sparse or has special structure. The arguments h and ldh may then refer to any convenient array.

If the problem is of type FP or LP, h is not referenced.

9: $\mathbf{ldh}$ – Integer Input

On entry: the first dimension of the array h as declared in the (sub)program from which h02cbf is called.

Constraints:

• if the problem is of type QP1, QP2 (the default), QP3 or QP4, $\mathbf{ldh}\ge \mathbf{n}$ or at least the value of the optional parameter Hessian Rows ($\text{default value}=n$);
• if the problem is of type FP or LP, $\mathbf{ldh}\ge 1$.

10: $\mathbf{qphess}$ – Subroutine, supplied by the NAG Library or the user. External Procedure

In general, you need not provide a version of qphess, because a ‘default’ subroutine with name e04nfu is included in the Library. However, the algorithm of h02cbf requires only the product of $H$ or $H^{\mathrm{T}}H$ and a vector $x$; and in some cases you may obtain increased efficiency by providing a version of qphess that avoids the need to define the elements of the matrices $H$ or $H^{\mathrm{T}}H$ explicitly. qphess is not referenced if the problem is of type FP or LP, in which case qphess may be the routine e04nfu.

The specification of qphess is:

Fortran Interface

Subroutine qphess ( n, jthcol, h, ldh, x, hx) Integer, Intent (In) :: n, jthcol, ldh Real (Kind=nag_wp), Intent (In) :: h(ldh,*), x(n) Real (Kind=nag_wp), Intent (Out) :: hx(n)

C Header Interface

void  qphess_ (const Integer *n, const Integer *jthcol, const double h[], const Integer *ldh, const double x[], double hx[])

C++ Header Interface

#include <nag.h> extern "C" { void  qphess_ (const Integer &n, const Integer &jthcol, const double h[], const Integer &ldh, const double x[], double hx[]) }

1: $\mathbf{n}$ – Integer Input

On entry: this is the same argument n as supplied to h02cbf.

2: $\mathbf{jthcol}$ – Integer Input

On entry: specifies whether or not the vector $x$ is a column of the identity matrix.

$\mathbf{jthcol}=j>0$

The vector $x$ is the $j$th column of the identity matrix, and hence $Hx$ or ${\mathbf{h}}^{\mathrm{T}}Hx$ is the $j$th column of $\mathbf{h}$ or ${\mathbf{h}}^{\mathrm{T}}H$, respectively, which may in some cases require very little computation and qphess may be coded to take advantage of this. However special code is not necessary because $x$ is always stored explicitly in the array x.

$\mathbf{jthcol}=0$

$x$ has no special form.

3: $\mathbf{h}\left(\mathbf{ldh},*\right)$ – Real (Kind=nag_wp) array Input

On entry: this is the same argument h as supplied to h02cbf.

4: $\mathbf{ldh}$ – Integer Input

On entry: this is the same argument ldh as supplied to h02cbf.

5: $\mathbf{x}\left(\mathbf{n}\right)$ – Real (Kind=nag_wp) array Input

On entry: the vector $x$.

6: $\mathbf{hx}\left(\mathbf{n}\right)$ – Real (Kind=nag_wp) array Output

On exit: the product $Hx$ if the problem is of type QP1 or QP2 (the default), or the product ${\mathbf{h}}^{\mathrm{T}}Hx$ if the problem is of type QP3 or QP4.

qphess must either be a module subprogram USEd by, or declared as EXTERNAL in, the (sub)program from which h02cbf is called. Arguments denoted as Input must not be changed by this procedure.

Note: qphess should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by h02cbf. If your code inadvertently does return any NaNs or infinities, h02cbf is likely to produce unexpected results.

11: $\mathbf{intvar}\left(\mathbf{lintvr}\right)$ – Integer array Input

On entry: $\mathbf{intvar}\left(i\right)$ must contain the index of the solution vector $x$ which is required to be integer. For example, if $x_1$ and $x_3$ are constrained to take integer values then $\mathbf{intvar}\left(1\right)$ might be set to $1$ and $\mathbf{intvar}\left(2\right)$ to $3$. The order in which the indices are specified is important, since this determines the order in which the sub-problems are generated. As a rule-of-thumb, the important variables should always be specified first. Thus, in the above example, if $x_3$ relates to a more important quantity than $x_1$, then it might be advantageous to set $\mathbf{intvar}\left(1\right)=3$ and $\mathbf{intvar}\left(2\right)=1$. If $k$ is the smallest integer such that $\mathbf{intvar}\left(k\right)$ is less than or equal to zero then h02cbf assumes that $k-1$ variables are constrained to be integer; components $\mathbf{intvar}\left(k+1\right)$, $\dots$, $\mathbf{intvar}\left(\mathbf{lintvr}\right)$ are not referenced.

12: $\mathbf{lintvr}$ – Integer Input

On entry: the dimension of the array intvar as declared in the (sub)program from which h02cbf is called. Often lintvr is the number of variables that are constrained to be integer.

Constraint: $\mathbf{lintvr}>0$.

13: $\mathbf{mdepth}$ – Integer Input

On entry: the maximum depth (i.e., number of extra constraints) that h02cbf may insert before admitting failure.

Suggested value: $\mathbf{mdepth}=3\times \mathbf{n}/2$.

Constraint: $\mathbf{mdepth}\ge 1$.

14: $\mathbf{istate}\left(\mathbf{n}+\mathbf{nclin}\right)$ – Integer array Input/Output

On entry: need not be set if the (default) optional parameter Cold Start is used.

If the optional parameter Warm Start has been chosen, istate specifies the desired status of the constraints at the start of the feasibility phase. More precisely, the first $n$ elements of istate refer to the upper and lower bounds on the variables, and the next $m_L$ elements refer to the general linear constraints (if any). Possible values for $\mathbf{istate}\left(j\right)$ are as follows:

$\mathbf{istate}\left(j\right)$	Meaning
0	The corresponding constraint should not be in the initial working set.
1	The constraint should be in the initial working set at its lower bound.
2	The constraint should be in the initial working set at its upper bound.
3	The constraint should be in the initial working set as an equality. This value must not be specified unless $\mathbf{bl}\left(j\right)=\mathbf{bu}\left(j\right)$.

The values $-2$, $-1$ and $4$ are also acceptable but will be reset to zero by the routine. If h02cbf has been called previously with the same values of n and nclin, istate already contains satisfactory information. (See also the description of the optional parameter Warm Start.) The routine also adjusts (if necessary) the values supplied in xs to be consistent with istate.

Constraint: $-2\le \mathbf{istate}\left(\mathit{j}\right)\le 4$, for $\mathit{j}=1,2,\dots ,\mathbf{n}+\mathbf{nclin}$.

On exit: the status of the constraints in the working set at the point returned in xs. The significance of each possible value of $\mathbf{istate}\left(j\right)$ is as follows:

$\mathbf{istate}\left(j\right)$	Meaning
$-2$	The constraint violates its lower bound by more than the feasibility tolerance.
$-1$	The constraint violates its upper bound by more than the feasibility tolerance.
$\phantom{-}0$	The constraint is satisfied to within the feasibility tolerance, but is not in the working set.
$\phantom{-}1$	This inequality constraint is included in the working set at its lower bound.
$\phantom{-}2$	This inequality constraint is included in the working set at its upper bound.
$\phantom{-}3$	This constraint is included in the working set as an equality. This value of istate can occur only when $\mathbf{bl}\left(j\right)=\mathbf{bu}\left(j\right)$.
$\phantom{-}4$	This corresponds to optimality being declared with $\mathbf{xs}\left(j\right)$ being temporarily fixed at its current value. This value of istate can occur only when $\mathbf{ifail}=\mathbf{1}$ on exit.

15: $\mathbf{xs}\left(\mathbf{n}\right)$ – Real (Kind=nag_wp) array Input/Output

On entry: an initial estimate of the solution.

On exit: the point at which h02cbf terminated. If $\mathbf{ifail}=\mathbf{0}$, $\mathbf{1}$ or $\mathbf{3}$, xs contains an estimate of the solution.

16: $\mathbf{obj}$ – Real (Kind=nag_wp) Output

On exit: the value of the objective function at $x$ if $x$ is feasible, or the sum of infeasibilities at $x$ otherwise. If the problem is of type FP and $x$ is feasible, obj is set to zero.

17: $\mathbf{ax}\left(\max \left(1,\mathbf{nclin}\right)\right)$ – Real (Kind=nag_wp) array Output

On exit: the final values of the linear constraints $Ax$.

If $\mathbf{nclin}=0$, ax is not referenced.

18: $\mathbf{clamda}\left(\mathbf{n}+\mathbf{nclin}\right)$ – Real (Kind=nag_wp) array Output

On exit: the values of the Lagrange-multipliers for each constraint with respect to the current working set. The first $n$ elements contain the multipliers for the bound constraints on the variables, and the next $m_L$ elements contain the multipliers for the general linear constraints (if any). If $\mathbf{istate}\left(j\right)=0$ (i.e., constraint $j$ is not in the working set), $\mathbf{clamda}\left(j\right)$ is zero. If $x$ is optimal, $\mathbf{clamda}\left(j\right)$ should be non-negative if $\mathbf{istate}\left(j\right)=1$, non-positive if $\mathbf{istate}\left(j\right)=2$ and zero if $\mathbf{istate}\left(j\right)=4$.

19: $\mathbf{strtgy}$ – Integer Input

On entry: determines a branching strategy to be used throughout the computation, as follows:

$\mathbf{strtgy}$	Meaning
$0$	Always left branch first, i.e., impose an upper bound constraint on the variable first.
$1$	Always right branch first, i.e., impose a lower bound constraint on the variable first.
$2$	Branch towards the nearest integer, i.e., if $x_k=2.4$ then impose an upper bound constraint $x_k\le 2$, whereas if $x_k=2.6$ then impose the lower bound constraint $x_k\ge 3.0$.
$3$	A random choice is made between a left-hand and a right-hand branch.

Constraint: $\mathbf{strtgy}=0$, $1$, $2$ or $3$.

20: $\mathbf{iwrk}\left(\mathbf{liwrk}\right)$ – Integer array Workspace

21: $\mathbf{liwrk}$ – Integer Input

On entry: the dimension of the array iwrk as declared in the (sub)program from which h02cbf is called.

Constraint: $\mathbf{liwrk}\ge 2\times \mathbf{n}+3+2\times \mathbf{mdepth}$.

22: $\mathbf{wrk}\left(\mathbf{lwrk}\right)$ – Real (Kind=nag_wp) array Workspace

23: $\mathbf{lwrk}$ – Integer Input

On entry: the dimension of the array wrk as declared in the (sub)program from which h02cbf is called.

Constraints:

• if the problem type is QP2 (the default) or QP4,
  • if $\mathbf{nclin}>0$, $\mathbf{lwrk}\ge 2\times {\mathbf{n}}^2+9\times \mathbf{n}+5\times \mathbf{nclin}+4\times \mathbf{mdepth}$;
  • if $\mathbf{nclin}=0$, $\mathbf{lwrk}\ge {\mathbf{n}}^2+9\times \mathbf{n}+4\times \mathbf{mdepth}$;
• if the problem type is QP1 or QP3,
  • if $\mathbf{nclin}>0$, $\mathbf{lwrk}\ge 2\times {\mathbf{n}}^2+8\times \mathbf{n}+5\times \mathbf{nclin}+4\times \mathbf{mdepth}$;
  • if $\mathbf{nclin}=0$, $\mathbf{lwrk}\ge {\mathbf{n}}^2+8\times \mathbf{n}+4\times \mathbf{mdepth}$;
• if the problem type is LP,
  • if $\mathbf{nclin}=0$, $\mathbf{lwrk}\ge 9\times \mathbf{n}+1+4\times \mathbf{mdepth}$;
  • if $\mathbf{nclin}\ge \mathbf{n}$, $\mathbf{lwrk}\ge 2\times {\mathbf{n}}^2+9\times \mathbf{n}+5\times \mathbf{nclin}+4\times \mathbf{mdepth}$;
  • otherwise $\mathbf{lwrk}\ge 2\times {\left(\mathbf{nclin}+1\right)}^2+9\times \mathbf{n}+5\times \mathbf{nclin}+4\times \mathbf{mdepth}$;
• if the problem type is FP,
  • if $\mathbf{nclin}=0$, $\mathbf{lwrk}\ge 8\times \mathbf{n}+1+4\times \mathbf{mdepth}$;
  • if $\mathbf{nclin}\ge \mathbf{n}$, $\mathbf{lwrk}\ge 2\times {\mathbf{n}}^2+8\times \mathbf{n}+5\times \mathbf{nclin}+4\times \mathbf{mdepth}$;
  • otherwise $\mathbf{lwrk}\ge 2\times {\left(\mathbf{nclin}+1\right)}^2+8\times \mathbf{n}+5\times \mathbf{nclin}+4\times \mathbf{mdepth}$.

24: $\mathbf{monit}$ – Subroutine, supplied by the NAG Library or the user. External Procedure

monit may be used to print out intermediate output and to affect the course of the computation. Specifically, it allows you to specify a realistic value for the cut-off value (see Section 3) and to terminate the algorithm. If you do not require any intermediate output, have no estimate of the cut-off value and require an exhaustive tree search then monit may be the dummy routine h02cbu.

The specification of monit is:

Fortran Interface

Subroutine monit ( intfnd, nodes, depth, obj, x, bstval, bstsol, bl, bu, n, halt, count) Integer, Intent (In) :: intfnd, nodes, depth, n Integer, Intent (Inout) :: count Real (Kind=nag_wp), Intent (In) :: obj, x(n), bstsol(n), bl(n), bu(n) Real (Kind=nag_wp), Intent (Inout) :: bstval Logical, Intent (Inout) :: halt

C Header Interface

void  monit_ (const Integer *intfnd, const Integer *nodes, const Integer *depth, const double *obj, const double x[], double *bstval, const double bstsol[], const double bl[], const double bu[], const Integer *n, logical *halt, Integer *count)

C++ Header Interface

#include <nag.h> extern "C" { void  monit_ (const Integer &intfnd, const Integer &nodes, const Integer &depth, const double &obj, const double x[], double &bstval, const double bstsol[], const double bl[], const double bu[], const Integer &n, logical &halt, Integer &count) }

1: $\mathbf{intfnd}$ – Integer Input

On entry: specifies the number of integer solutions obtained so far.

2: $\mathbf{nodes}$ – Integer Input

On entry: specifies the number of nodes (sub-problems) solved so far.

3: $\mathbf{depth}$ – Integer Input

On entry: specifies the depth in the tree of sub-problems the algorithm has now reached.

4: $\mathbf{obj}$ – Real (Kind=nag_wp) Input

On entry: specifies the value of the objective function of the end of the latest sub-problem.

5: $\mathbf{x}\left(\mathbf{n}\right)$ – Real (Kind=nag_wp) array Input

On entry: specifies the values of the independent variables at the end of the latest sub-problem.

6: $\mathbf{bstval}$ – Real (Kind=nag_wp) Input/Output

On entry: normally specifies the value of the best integer solution found so far.

On exit: may be set to a cut-off value if you are an experienced user as follows. Before an integer solution has been found bstval will be set by h02cbf to the largest machine representable number (see x02alf). If you know that the solution being sought is a much smaller number, then bstval may be set to this number as a cut-off value (see Section 3). Beware of setting bstval too small, since then no integer solutions will be discovered. Also, on entry to monit, bstval should be set using a statement of the form

if (intfnd == 0) bstval = cut_off_value

Setting bstval in this way will not prevent the normal operation of the algorithm when subsequent integer solutions are found. It would be a grievous mistake to unconditionally set bstval and if you have any doubts whatsoever about the correct use of this argument then you are strongly recommended to leave it unchanged.

7: $\mathbf{bstsol}\left(\mathbf{n}\right)$ – Real (Kind=nag_wp) array Input

On entry: specifies the solution vector which gives rise to the best integer solution value so far discovered.

8: $\mathbf{bl}\left(\mathbf{n}\right)$ – Real (Kind=nag_wp) array Input

On entry: $\mathbf{bl}\left(i\right)$ specifies the current lower bounds on the variable $x_i$.

9: $\mathbf{bu}\left(\mathbf{n}\right)$ – Real (Kind=nag_wp) array Input

On entry: $\mathbf{bu}\left(i\right)$ specifies the current upper bounds on the variable $x_i$.

10: $\mathbf{n}$ – Integer Input

On entry: specifies the number of variables.

11: $\mathbf{halt}$ – Logical Input/Output

On entry: will have the value .FALSE..

On exit: if halt is set to .TRUE., e04nff/​e04nfa will be brought to a halt with $\mathbf{ifail}=-\mathbf{1}$. This facility may be useful if you are content with any integer solution, or with any integer solution that fits certain criteria. Under these circumstances setting $\mathbf{halt}=\mathrm{.TRUE.}$ can save considerable unnecessary computation.

12: $\mathbf{count}$ – Integer Input/Output

On entry: unchanged from previous call.

On exit: may be used by you to save the last value of intfnd. If a subsequent call of monit has a value of intfnd which is greater than count, then you know that a new integer solution has been found at this node.

monit must either be a module subprogram USEd by, or declared as EXTERNAL in, the (sub)program from which h02cbf is called. Arguments denoted as Input must not be changed by this procedure.

Note: monit should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by h02cbf. If your code inadvertently does return any NaNs or infinities, h02cbf is likely to produce unexpected results.

25: $\mathbf{ifail}$ – Integer Input/Output

On entry: ifail must be set to $0$, $-1$ or $1$ to set behaviour on detection of an error; these values have no effect when no error is detected.

A value of $0$ causes the printing of an error message and program execution will be halted; otherwise program execution continues. A value of $-1$ means that an error message is printed while a value of $1$ means that it is not.

If halting is not appropriate, the value $-1$ or $1$ is recommended. If message printing is undesirable, then the value $1$ is recommended. Otherwise, the value $0$ is recommended. When the value $-\mathbf{1}$ or $\mathbf{1}$ is used it is essential to test the value of ifail on exit.

On exit: $\mathbf{ifail}=\mathbf{0}$ unless the routine detects an error or a warning has been flagged (see Section 6).

6 Error Indicators and Warnings

$\mathbf{ifail}=1$

Invalid input argument for basic problem.

On entry, $\mathbf{lda}=〈\mathit{\text{value}}〉$ and $\mathbf{nclin}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{lda}\ge \max \left(1,\mathbf{nclin}\right)$.

On entry, $\mathbf{lintvr}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{lintvr}\ge 1$.

On entry, $\mathbf{mdepth}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{mdepth}\ge 1$.

On entry, $\mathbf{n}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{n}>0$.

On entry, $\mathbf{nclin}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{nclin}\ge 0$.

On entry, $\mathbf{strtgy}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{strtgy}=0$, $1$, $2$ or $3$.

$\mathbf{ifail}=2$

No integer solutions found. (Check that bstval has not been set too small.)

$\mathbf{ifail}=3$

Need to increase depth, $\mathbf{mdepth}=〈\mathit{\text{value}}〉$.

$\mathbf{ifail}=4$

Basic problem (without integer constraints) unbounded.

$\mathbf{ifail}=5$

Basic problem is infeasible.

$\mathbf{ifail}=6$

Basic problem requires too many iterations.

$\mathbf{ifail}=7$

Basic problem has a reduced Hessian exceeding assigned dimensions.

$\mathbf{ifail}=9$

Error in designated problem type.

$\mathbf{ifail}=10$

liwrk is too small. liwrk must be at least $\mathrm{LIWMIN}$: $\mathbf{liwrk}=〈\mathit{\text{value}}〉$, $\mathrm{LIWMIN}=〈\mathit{\text{value}}〉$.

$\mathbf{ifail}=11$

lwrk is too small. lwrk must be at least $\mathrm{LWMIN}$: $\mathbf{lwrk}=〈\mathit{\text{value}}〉$, $\mathrm{LWMIN}=〈\mathit{\text{value}}〉$.

$\mathbf{ifail}=12$

Unexpected error in NAG routine – contact NAG.

$\mathbf{ifail}=-1$

Halted at your request.

$\mathbf{ifail}=-99$

An unexpected error has been triggered by this routine. Please contact NAG.

See Section 7 in the Introduction to the NAG Library FL Interface for further information.

$\mathbf{ifail}=-399$

Your licence key may have expired or may not have been installed correctly.

See Section 8 in the Introduction to the NAG Library FL Interface for further information.

$\mathbf{ifail}=-999$

Dynamic memory allocation failed.

See Section 9 in the Introduction to the NAG Library FL Interface for further information.

7 Accuracy

8 Parallelism and Performance

9 Further Comments

9.1 Scaling

9.2 Description of the Printed Output

10 Example

10.1 Program Text

10.2 Program Data

10.3 Program Results

11 Algorithmic Details

11.1 Overview

11.2 Definition of the Search Direction

11.3 The Main Iteration

11.4 Choosing the Initial Working Set

12 Optional Parameters

• Check Frequency
• Cold Start
• Crash Tolerance
• Defaults
• Expand Frequency
• Feasibility Phase Iteration Limit
• Feasibility Tolerance
• Hessian Rows
• Infinite Bound Size
• Infinite Step Size
• Iteration Limit
• Iters
• Itns
• List
• Maximum Degrees of Freedom
• Minimum Sum of Infeasibilities
• Monitoring File
• Nolist
• Optimality Phase Iteration Limit
• Optimality Tolerance
• Print Level
• Problem Type
• Rank Tolerance
• Warm Start

Begin
  Print Level = 5
End

Call h02ccf(ioptns, inform)

Call h02cdf ('Print Level = 5')

12.1 Description of the Optional Parameters

• the keywords, where the minimum abbreviation of each keyword is underlined (if no characters of an optional qualifier are underlined, the qualifier may be omitted);
• a parameter value, where the letters $a$, $i$ and $r$ denote options that take character, integer and real values respectively;
• the default value, where the symbol $\epsilon$ is a generic notation for machine precision (see x02ajf).

13 Description of Monitoring Information