NAG Library Routine Document

h02cbf  (iqp_dense_old)
h02cba (iqp_dense)

1

Purpose

2

Specification

3

Description

4

References

5

Arguments

1:     $\mathbf{n}$ – IntegerInput

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

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

2:     $\mathbf{nclin}$ – IntegerInput

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) arrayInput

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}$ – IntegerInput

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) arrayInput

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

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) arrayInput

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) arrayInput

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}$ – IntegerInput

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

#include <nagmk26.h> void  qphess (const Integer *n, const Integer *jthcol, const double h[], const Integer *ldh, const double x[], double hx[])

1:     $\mathbf{n}$ – IntegerInput

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

2:     $\mathbf{jthcol}$ – IntegerInput

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) arrayInput

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

4:     $\mathbf{ldh}$ – IntegerInput

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

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

On entry: the vector $x$.

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

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 arrayInput

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}$ – IntegerInput

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}$ – IntegerInput

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 arrayInput/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) arrayInput/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) arrayOutput

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) arrayOutput

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}$ – IntegerInput

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 arrayWorkspace

21:   $\mathbf{liwrk}$ – IntegerInput

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) arrayWorkspace

23:   $\mathbf{lwrk}$ – IntegerInput

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

#include <nagmk26.h> 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}$ – IntegerInput

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

2:     $\mathbf{nodes}$ – IntegerInput

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

3:     $\mathbf{depth}$ – IntegerInput

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) arrayInput

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 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 make sure that bstval is set using a statement of the form

IF (intfnd.EQ.0) $\mathbf{bstval}=$ cut-off value

on entry to monit. This statement 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) arrayInput

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) arrayInput

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) arrayInput

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

10:   $\mathbf{n}$ – IntegerInput

On entry: specifies the number of variables.

11:   $\mathbf{halt}$ – LogicalInput/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}$ – IntegerInput/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}$ – IntegerInput/Output

On entry: ifail must be set to $0$, $-1\text{ or }1$. If you are unfamiliar with this argument you should refer to Section 3.4 in How to Use the NAG Library and its Documentation for details.

For environments where it might be inappropriate to halt program execution when an error is detected, the value $-1\text{ or }1$ is recommended. If the output of error messages is undesirable, then the value $1$ is recommended. Otherwise, if you are not familiar with this argument, the recommended value is $0$. When the value $-\mathbf{1}\text{ 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$

Algorithm terminated at your request ($\mathbf{halt}=\mathrm{.TRUE.}$).

$\mathbf{ifail}=1$

Input argument error immediately detected.

$\mathbf{ifail}=2$

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

$\mathbf{ifail}=3$

mdepth is too small. Increase the value of mdepth and re-enter h02cbf.

$\mathbf{ifail}=4$

The basic problem (without integer constraints) is unbounded.

$\mathbf{ifail}=5$

The basic problem is infeasible.

$\mathbf{ifail}=6$

The basic problem requires too many iterations.

$\mathbf{ifail}=7$

The basic problem has a reduced Hessian which exceeds its assigned dimension.

$\mathbf{ifail}=8$

The basic problem has an invalid argument setting.

$\mathbf{ifail}=9$

The basic problem, as defined, is not standard.

$\mathbf{ifail}=10$

liwrk is too small.

$\mathbf{ifail}=11$

lwrk is too small.

$\mathbf{ifail}=12$

An internal error has occurred within the routine. Please contact NAG with details of the call to h02cbf.

$\mathbf{ifail}=-99$

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

See Section 3.9 in How to Use the NAG Library and its Documentation for further information.

$\mathbf{ifail}=-399$

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

See Section 3.8 in How to Use the NAG Library and its Documentation for further information.

$\mathbf{ifail}=-999$

Dynamic memory allocation failed.

See Section 3.7 in How to Use the NAG Library and its Documentation 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

Program Text (h02cbfe.f90)

10.2

Program Data

Program Data (h02cbfe.d)

10.3

Program Results

Program Results (h02cbfe.r)

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