NAG Toolbox: nag_mip_iqp_dense (h02cb)

Purpose

Syntax

Description

References

Parameters

Compulsory Input Parameters

1:     $\mathrm{a}\left(\mathit{lda},:\right)$ – double array

The first dimension of the array a must be at least $\max \left(1,\mathbf{nclin}\right)$.

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$.

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.

2:     $\mathrm{bl}\left(\mathbf{n}+\mathbf{nclin}\right)$ – double array

3:     $\mathrm{bu}\left(\mathbf{n}+\mathbf{nclin}\right)$ – double array

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}$.

4:     $\mathrm{cvec}\left(:\right)$ – double array

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

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.

5:     $\mathrm{h}\left(\mathit{ldh},\mathit{tdh}\right)$ – double array

ldh, the first dimension of the array, must satisfy the constraint

if the problem is of type QP1, QP2 (the default), QP3 or QP4, $\mathit{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, $\mathit{ldh}\ge 1$

.

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.

6:     $\mathrm{qphess}$ – function handle or string containing name of m-file

In general, you need not provide a version of qphess, because a ‘default’ function with name nag_opt_qp_dense_sample_qphess (e54nfu) is included in the Library. However, the algorithm of nag_mip_iqp_dense (h02cb) 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 string nag_opt_qp_dense_sample_qphess (e54nfu).

[hx] = qphess(n, jthcol, h, ldh, x)

Input Parameters

1:     $\mathrm{n}$ – int64int32nag_int scalar

This is the same argument n as supplied to nag_mip_iqp_dense (h02cb).

2:     $\mathrm{jthcol}$ – int64int32nag_int scalar

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:     $\mathrm{h}\left(\mathit{ldh},\mathit{tdh}\right)$ – double array

This is the same argument h as supplied to nag_mip_iqp_dense (h02cb).

4:     $\mathrm{ldh}$ – int64int32nag_int scalar

This is the same argument ldh as supplied to nag_mip_iqp_dense (h02cb).

5:     $\mathrm{x}\left(\mathbf{n}\right)$ – double array

The vector $x$.

Output Parameters

1:     $\mathrm{hx}\left(\mathbf{n}\right)$ – double array

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.

7:     $\mathrm{intvar}\left(\mathbf{lintvr}\right)$ – int64int32nag_int array

$\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 nag_mip_iqp_dense (h02cb) 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.

8:     $\mathrm{istate}\left(\mathbf{n}+\mathbf{nclin}\right)$ – int64int32nag_int array

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 function. If nag_mip_iqp_dense (h02cb) 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 function 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}$.

9:     $\mathrm{xs}\left(\mathbf{n}\right)$ – double array

An initial estimate of the solution.

10:   $\mathrm{strtgy}$ – int64int32nag_int scalar

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$.

11:   $\mathrm{monit}$ – function handle or string containing name of m-file

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 Description) 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 string nag_mip_iqp_dense_dummy_monit (h02cbu).

[bstval, halt, count] = monit(intfnd, nodes, depth, obj, x, bstval, bstsol, bl, bu, n, halt, count)

Input Parameters

1:     $\mathrm{intfnd}$ – int64int32nag_int scalar

Specifies the number of integer solutions obtained so far.

2:     $\mathrm{nodes}$ – int64int32nag_int scalar

Specifies the number of nodes (sub-problems) solved so far.

3:     $\mathrm{depth}$ – int64int32nag_int scalar

Specifies the depth in the tree of sub-problems the algorithm has now reached.

4:     $\mathrm{obj}$ – double scalar

Specifies the value of the objective function of the end of the latest sub-problem.

5:     $\mathrm{x}\left(\mathbf{n}\right)$ – double array

Specifies the values of the independent variables at the end of the latest sub-problem.

6:     $\mathrm{bstval}$ – double scalar

Normally specifies the value of the best integer solution found so far.

7:     $\mathrm{bstsol}\left(\mathbf{n}\right)$ – double array

Specifies the solution vector which gives rise to the best integer solution value so far discovered.

8:     $\mathrm{bl}\left(\mathbf{n}\right)$ – double array

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

9:     $\mathrm{bu}\left(\mathbf{n}\right)$ – double array

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

10:   $\mathrm{n}$ – int64int32nag_int scalar

Specifies the number of variables.

11:   $\mathrm{halt}$ – logical scalar

Will have the value false.

12:   $\mathrm{count}$ – int64int32nag_int scalar

Unchanged from previous call.

Output Parameters

1:     $\mathrm{bstval}$ – double scalar

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 nag_mip_iqp_dense (h02cb) to the largest machine representable number (see nag_machine_real_largest (x02al)). 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 Description). 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.

2:     $\mathrm{halt}$ – logical scalar

If halt is set to true, nag_opt_qp_dense_solve (e04nf) 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}=\mathit{true}$ can save considerable unnecessary computation.

3:     $\mathrm{count}$ – int64int32nag_int scalar

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.

Optional Input Parameters

1:     $\mathrm{n}$ – int64int32nag_int scalar

Default: the dimension of the arrays bl, bu, cvec, xs. (An error is raised if these dimensions are not equal.)

$n$, the number of variables.

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

2:     $\mathrm{nclin}$ – int64int32nag_int scalar

Default: the first dimension of the array a.

$m_L$, the number of general linear constraints.

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

3:     $\mathrm{lintvr}$ – int64int32nag_int scalar

Default: the dimension of the array intvar.

The dimension of the array intvar. often lintvr is the number of variables that are constrained to be integer.

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

4:     $\mathrm{mdepth}$ – int64int32nag_int scalar

Default: $3\times \mathbf{n}/2$

The maximum depth (i.e., number of extra constraints) that nag_mip_iqp_dense (h02cb) may insert before admitting failure.

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

5:     $\mathrm{lwrk}$ – int64int32nag_int scalar

Suggested value: Note that this is an over-estimate for many problems so if there are a large number of variables or constraints then the user may wish to choose a smaller value for lwrk based on the formula given above.

Default: $2\times {\max \left(\mathbf{n},\left(\mathbf{nclin}+1\right)\right)}^2+9\times \mathbf{n}+5\times \mathbf{nclin}+4\times \mathbf{mdepth}$ 

The dimension of the array wrk.

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}$.

Output Parameters

1:     $\mathrm{istate}\left(\mathbf{n}+\mathbf{nclin}\right)$ – int64int32nag_int array

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.

2:     $\mathrm{xs}\left(\mathbf{n}\right)$ – double array

The point at which nag_mip_iqp_dense (h02cb) terminated. If $\mathbf{ifail}=\mathbf{0}$, $\mathbf{1}$ or $\mathbf{3}$, xs contains an estimate of the solution.

3:     $\mathrm{obj}$ – double scalar

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.

4:     $\mathrm{ax}\left(\max \left(1,\mathbf{nclin}\right)\right)$ – double array

The final values of the linear constraints $Ax$.

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

5:     $\mathrm{clamda}\left(\mathbf{n}+\mathbf{nclin}\right)$ – double array

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$.

6:     $\mathrm{ifail}$ – int64int32nag_int scalar

$\mathbf{ifail}=\mathbf{0}$ unless the function detects an error (see Error Indicators and Warnings).

Error Indicators and Warnings

Cases prefixed with W are classified as warnings and do not generate an error of type NAG:error_n. See nag_issue_warnings.

W  $\mathbf{ifail}=-1$

Algorithm terminated at your request ($\mathbf{halt}=\mathit{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 nag_mip_iqp_dense (h02cb).

   $\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 function. Please contact NAG with details of the call to nag_mip_iqp_dense (h02cb).

   $\mathbf{ifail}=-99$

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

   $\mathbf{ifail}=-399$

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

   $\mathbf{ifail}=-999$

Dynamic memory allocation failed.

Accuracy

Further Comments

Scaling

Description of the Printed Output

Example

Open in the MATLAB editor: h02cb_example

function h02cb_example


fprintf('h02cb example results\n\n');

big = 1e25;
a    = [ 1,     1,      1,      1,      1,      1,       1;
         0.15,  0.04,   0.02,   0.04,   0.02,   0.01,    0.03;
         0.03,  0.05,   0.08,   0.02,   0.06,   0.01,    0.00;
         0.02,  0.04,   0.01,   0.02,   0.02,   0.00,    0.00;
         0.02,  0.03,   0.00,   0.00,   0.01,   0.00,    0.00;
         0.70,  0.75,   0.80,   0.75,   0.80,   0.97,    0.00;
         0.02,  0.06,   0.08,   0.12,   0.02,   0.01,    0.97];
cvec = [-0.02, -0.20,  -0.20,  -0.20,  -0.20,   0.04,    0.04];
bl   = [-0.01, -0.10,  -0.01,  -0.04,  -0.10,  -0.01,   -0.01, ...
        -0.13, -big,   -big,   -big,   -big,   -0.0992, -0.003];
bu   = [ 0.01,  0.15,   0.03,   0.02,   0.05,   big,     big,  ...
        -0.13, -0.0049,-0.0064,-0.0037,-0.0012, big,     0.002];
h    = [ 2,     0,      0,      0,      0,      0,       0;
         0,     2,      0,      0,      0,      0,       0;
         0,     0,      2,      2,      0,      0,       0;
         0,     0,      2,      2,      0,      0,       0;
         0,     0,      0,      0,      2,      0,       0;
         0,     0,      0,      0,      0,     -2,      -2;
         0,     0,      0,      0,      0,     -2,      -2];
xs   = [-0.01,  0.03,   0,     -0.01,  -0.1,    0.02,    0.01];
intvar = [int64(4)];
istate = zeros(14, 1, 'int64');
strtgy = int64(2);

[istate, xs, obj, ax, clamda, ifail] = ...
h02cb( ...
       a, bl, bu, cvec, h, @qphess, intvar, istate, xs, strtgy, @monit);

fprintf('Optimal Integer Value is = %20.8e\n',obj);
disp('Components are:');
for j=1:7
  fprintf('x(%2d) = %12.8f\n',j,xs(j));
end



function [hx] = qphess(n, jthcol, h, ldh, x)
  hx = h*x;

function [bstval, halt, count] = monit(intfnd, nodes, depth, obj, x, ...
                                       bstval, bstsol, bl, bu, n, halt, count)

h02cb example results

Optimal Integer Value is =       3.74696620e-02
Components are:
x( 1) =  -0.01000000
x( 2) =  -0.07332830
x( 3) =  -0.00025809
x( 4) =   0.00000000
x( 5) =  -0.06335433
x( 6) =   0.01410944
x( 7) =   0.00283128

Algorithmic Details

Overview

Definition of the Search Direction

The Main Iteration

Choosing the Initial Working Set

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

h02cd('Print Level = 5')

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 nag_machine_precision (x02aj)).

Description of Monitoring Information