e04lb is a comprehensive modified Newton algorithm for finding:

an unconstrained minimum of a function of several variables
a minimum of a function of several variables subject to fixed upper and/or lower bounds on the variables.

First and second derivatives are required. The method is intended for functions which have continuous first and second derivatives (although it will usually work even if the derivatives have occasional discontinuities).

Syntax

C#
public static void e04lb( int n, E04..::..E04LB_FUNCT funct, E04..::..E04LB_H h, E04..::..E04LB_MONIT monit, int iprint, int maxcal, double eta, double xtol, double stepmx, int ibound, double[] bl, double[] bu, double[] x, double[] hesl, double[] hesd, int[] istate, out double f, double[] g, out int ifail )

public static void e04lb(
	int n,
	E04..::..E04LB_FUNCT funct,
	E04..::..E04LB_H h,
	E04..::..E04LB_MONIT monit,
	int iprint,
	int maxcal,
	double eta,
	double xtol,
	double stepmx,
	int ibound,
	double[] bl,
	double[] bu,
	double[] x,
	double[] hesl,
	double[] hesd,
	int[] istate,
	out double f,
	double[] g,
	out int ifail
)

Visual Basic
Public Shared Sub e04lb ( _ n As Integer, _ funct As E04..::..E04LB_FUNCT, _ h As E04..::..E04LB_H, _ monit As E04..::..E04LB_MONIT, _ iprint As Integer, _ maxcal As Integer, _ eta As Double, _ xtol As Double, _ stepmx As Double, _ ibound As Integer, _ bl As Double(), _ bu As Double(), _ x As Double(), _ hesl As Double(), _ hesd As Double(), _ istate As Integer(), _ <OutAttribute> ByRef f As Double, _ g As Double(), _ <OutAttribute> ByRef ifail As Integer _ )

Visual Basic

Public Shared Sub e04lb ( _
	n As Integer, _
	funct As E04..::..E04LB_FUNCT, _
	h As E04..::..E04LB_H, _
	monit As E04..::..E04LB_MONIT, _
	iprint As Integer, _
	maxcal As Integer, _
	eta As Double, _
	xtol As Double, _
	stepmx As Double, _
	ibound As Integer, _
	bl As Double(), _
	bu As Double(), _
	x As Double(), _
	hesl As Double(), _
	hesd As Double(), _
	istate As Integer(), _
	<OutAttribute> ByRef f As Double, _
	g As Double(), _
	<OutAttribute> ByRef ifail As Integer _
)

Visual C++
public: static void e04lb( int n, E04..::..E04LB_FUNCT^ funct, E04..::..E04LB_H^ h, E04..::..E04LB_MONIT^ monit, int iprint, int maxcal, double eta, double xtol, double stepmx, int ibound, array<double>^ bl, array<double>^ bu, array<double>^ x, array<double>^ hesl, array<double>^ hesd, array<int>^ istate, [OutAttribute] double% f, array<double>^ g, [OutAttribute] int% ifail )

Visual C++

public:
static void e04lb(
	int n, 
	E04..::..E04LB_FUNCT^ funct, 
	E04..::..E04LB_H^ h, 
	E04..::..E04LB_MONIT^ monit, 
	int iprint, 
	int maxcal, 
	double eta, 
	double xtol, 
	double stepmx, 
	int ibound, 
	array<double>^ bl, 
	array<double>^ bu, 
	array<double>^ x, 
	array<double>^ hesl, 
	array<double>^ hesd, 
	array<int>^ istate, 
	[OutAttribute] double% f, 
	array<double>^ g, 
	[OutAttribute] int% ifail
)

F#
static member e04lb : n : int * funct : E04..::..E04LB_FUNCT * h : E04..::..E04LB_H * monit : E04..::..E04LB_MONIT * iprint : int * maxcal : int * eta : float * xtol : float * stepmx : float * ibound : int * bl : float[] * bu : float[] * x : float[] * hesl : float[] * hesd : float[] * istate : int[] * f : float byref * g : float[] * ifail : int byref -> unit

static member e04lb : 
        n : int * 
        funct : E04..::..E04LB_FUNCT * 
        h : E04..::..E04LB_H * 
        monit : E04..::..E04LB_MONIT * 
        iprint : int * 
        maxcal : int * 
        eta : float * 
        xtol : float * 
        stepmx : float * 
        ibound : int * 
        bl : float[] * 
        bu : float[] * 
        x : float[] * 
        hesl : float[] * 
        hesd : float[] * 
        istate : int[] * 
        f : float byref * 
        g : float[] * 
        ifail : int byref -> unit

Parameters

n: Type: System..::..Int32
On entry: the number $n$ of independent variables.

Constraint: $n \geq 1$ .

funct: Type: NagLibrary..::..E04..::..E04LB_FUNCT
funct must evaluate the function $F (x)$ and its first derivatives $\frac{\partial F}{\partial x_{j}}$ at any point $x$ . (However, if you do not wish to calculate $F (x)$ or its first derivatives at a particular $x$ , there is the option of setting a parameter to cause e04lb to terminate immediately.)
A delegate of type E04LB_FUNCT.
Note: funct should be tested separately before being used in conjunction with e04lb.

h: Type: NagLibrary..::..E04..::..E04LB_H
h must calculate the second derivatives of $F$ at any point $x$ . (As with funct, there is the option of causing e04lb to terminate immediately.)
A delegate of type E04LB_H.
Note: h should be tested separately before being used in conjunction with e04lb.

monit: Type: NagLibrary..::..E04..::..E04LB_MONIT
If $iprint \geq 0$ , you must supply monit which is suitable for monitoring the minimization process. monit must not change the values of any of its parameters.
If $iprint < 0$ , a monit with the correct parameter list should still be supplied, although it will not be called.
A delegate of type E04LB_MONIT.
You should normally print out fc, gpjnrm and cond so as to be able to compare the quantities mentioned in [Accuracy]. It is normally helpful to examine xc, posdef and nf as well.

iprint

Type: System..::..Int32

On entry: the frequency with which monit is to be called.

$iprint > 0$: monit is called once every iprint iterations and just before exit from e04lb.
$iprint = 0$: monit is just called at the final point.
$iprint < 0$: monit is not called at all.

iprint should normally be set to a small positive number.

Suggested value:

iprint = 1

maxcal: Type: System..::..Int32
On entry: the maximum permitted number of evaluations of $F (x)$ , i.e., the maximum permitted number of calls of funct.
Suggested value: $maxcal = 50 \times n$ .

Constraint: $maxcal \geq 1$ .

eta: Type: System..::..Double
On entry: every iteration of e04lb involves a linear minimization (i.e., minimization of $F (x + α p)$ with respect to $α$ ). eta specifies how accurately these linear minimizations are to be performed. The minimum with respect to $α$ will be located more accurately for small values of eta (say, $0.01$ ) than for large values (say, $0.9$ ).
Although accurate linear minimizations will generally reduce the number of iterations of e04lb, this usually results in an increase in the number of function and gradient evaluations required for each iteration. On balance, it is usually more efficient to perform a low accuracy linear minimization.

Suggested value: $eta = 0.9$ is usually a good choice although a smaller value may be warranted if the matrix of second derivatives is expensive to compute compared with the function and first derivatives.
If $n = 1$ , eta should be set to $0.0$ (also when the problem is effectively one-dimensional even though $n > 1$ ; i.e., if for all except one of the variables the lower and upper bounds are equal).

Constraint: $0.0 \leq eta < 1.0$ .

xtol: Type: System..::..Double
On entry: the accuracy in $x$ to which the solution is required.
If $x_{true}$ is the true value of $x$ at the minimum, then $x_{sol}$ , the estimated position before a normal exit, is such that $‖x_{sol} - x_{true}‖ < xtol \times (1.0 + ‖x_{true}‖)$ , where $‖y‖ = \sqrt{\sum_{j = 1}^{n} y_{j}^{2}}$ . For example, if the elements of $x_{sol}$ are not much larger than $1.0$ in modulus, and if xtol is set to $10^{- 5}$ then $x_{sol}$ is usually accurate to about five decimal places. (For further details see [Accuracy].)

If the problem is scaled roughly as described in [Further Comments] and $ε$ is the machine precision, then $\sqrt{ε}$ is probably the smallest reasonable choice for xtol. (This is because, normally, to machine accuracy, $F (x + \sqrt{ε}, e_{j}) = F (x)$ where $e_{j}$ is any column of the identity matrix.)

If you set xtol to $0.0$ (or any positive value less than $ε$ ), e04lb will use $10.0 \times \sqrt{ε}$ instead of xtol.

Suggested value: $xtol = 0.0$ .

Constraint: $xtol \geq 0.0$ .

stepmx

Type: System..::..Double

On entry: an estimate of the Euclidean distance between the solution and the starting point supplied by you. (For maximum efficiency a slight overestimate is preferable.)

e04lb will ensure that, for each iteration,

\sqrt{\sum_{j = 1}^{n} {[x_{j}^{(k)} - x_{j}^{(k - 1)}]}^{2}} \leq stepmx

where

k

is the iteration number. Thus, if the problem has more than one solution, e04lb is most likely to find the one nearest to the starting point. On difficult problems, a realistic choice can prevent the sequence of

x^{(k)}

entering a region where the problem is ill-behaved and can also help to avoid possible overflow in the evaluation of

F (x)

. However, an underestimate of stepmx can lead to inefficiency.

Suggested value:

stepmx = 100000.0

Constraint:

stepmx \geq xtol

ibound

Type: System..::..Int32

On entry: specifies whether the problem is unconstrained or bounded. If there are bounds on the variables, ibound can be used to indicate whether the facility for dealing with bounds of special forms is to be used. It must be set to one of the following values:

$ibound = 0$: If the variables are bounded and you are supplying all the $l_{j}$ and $u_{j}$ individually.
$ibound = 1$: If the problem is unconstrained.
$ibound = 2$: If the variables are bounded, but all the bounds are of the form $0 \leq x_{j}$ .
$ibound = 3$: If all the variables are bounded, and $l_{1} = l_{2} = \dots = l_{n}$ and $u_{1} = u_{2} = \dots = u_{n}$ .
$ibound = 4$: If the problem is unconstrained. (The $ibound = 4$ option is provided purely for consistency with other methods. In e04lb it produces the same effect as $ibound = 1$ .)

Constraint:

0 \leq ibound \leq 4

bl: Type: array<System..::..Double>[]()[][]
An array of size [n]
On entry: the fixed lower bounds $l_{j}$ .
If ibound is set to $0$ , you must set $bl [j - 1]$ to $l_{j}$ , for $j = 1, 2, \dots, n$ . (If a lower bound is not specified for any $x_{j}$ , the corresponding $bl [j - 1]$ should be set to a large negative number, e.g., $- 10^{6}$ .)

If ibound is set to $3$ , you must set $bl [0]$ to $l_{1}$ ; e04lb will then set the remaining elements of bl equal to $bl [0]$ .

If ibound is set to $1$ , $2$ or $4$ , bl will be initialized by e04lb.

On exit: the lower bounds actually used by e04lb, e.g., if $ibound = 2$ , $bl [0] = bl [1] = \dots = bl [n - 1] = 0.0$ .

bu: Type: array<System..::..Double>[]()[][]
An array of size [n]
On entry: the fixed upper bounds $u_{j}$ .
If ibound is set to $0$ , you must set $bu [j - 1]$ to $u_{j}$ , for $j = 1, 2, \dots, n$ . (If an upper bound is not specified for any variable, the corresponding $bu [j - 1]$ should be set to a large positive number, e.g., $10^{6}$ .)

If ibound is set to $3$ , you must set $bu [0]$ to $u_{1}$ ; e04lb will then set the remaining elements of bu equal to $bu [0]$ .

If ibound is set to $1$ , $2$ or $4$ , bu will then be initialized by e04lb.

On exit: the upper bounds actually used by e04lb, e.g., if $ibound = 2$ , $bu [0] = bu [1] = \dots = bu [n - 1] = 10^{6}$ .

x: Type: array<System..::..Double>[]()[][]
An array of size [n]
On entry: $x [j - 1]$ must be set to a guess at the $j$ th component of the position of the minimum, for $j = 1, 2, \dots, n$ .
On exit: the final point $x^{(k)}$ . Thus, if $ifail = 0$ on exit, $x [j - 1]$ is the $j$ th component of the estimated position of the minimum.

hesl: Type: array<System..::..Double>[]()[][]
An array of size [lh]
On exit: during the determination of a direction $p_{z}$ (see [Description]), $H + E$ is decomposed into the product $L D L^{T}$ , where $L$ is a unit lower triangular matrix and $D$ is a diagonal matrix. (The matrices $H$ , $E$ , $L$ and $D$ are all of dimension $n_{z}$ , where $n_{z}$ is the number of variables free from their bounds. $H$ consists of those rows and columns of the full estimated second derivative matrix which relate to free variables. $E$ is chosen so that $H + E$ is positive definite.)
hesl and hesd are used to store the factors $L$ and $D$ . The elements of the strict lower triangle of $L$ are stored row by row in the first $n_{z} (n_{z} - 1) / 2$ positions of hesl. The diagonal elements of $D$ are stored in the first $n_{z}$ positions of hesd. In the last factorization before a normal exit, the matrix $E$ will be zero, so that hesl and hesd will contain, on exit, the factors of the final estimated second derivative matrix $H$ . The elements of hesd are useful for deciding whether to accept the results produced by e04lb (see [Accuracy]).

hesd: Type: array<System..::..Double>[]()[][]
An array of size [n]
On exit: during the determination of a direction $p_{z}$ (see [Description]), $H + E$ is decomposed into the product $L D L^{T}$ , where $L$ is a unit lower triangular matrix and $D$ is a diagonal matrix. (The matrices $H$ , $E$ , $L$ and $D$ are all of dimension $n_{z}$ , where $n_{z}$ is the number of variables free from their bounds. $H$ consists of those rows and columns of the full second derivative matrix which relate to free variables. $E$ is chosen so that $H + E$ is positive definite.)
hesl and hesd are used to store the factors $L$ and $D$ . The elements of the strict lower triangle of $L$ are stored row by row in the first $n_{z} (n_{z} - 1) / 2$ positions of hesl. The diagonal elements of $D$ are stored in the first $n_{z}$ positions of hesd.

In the last factorization before a normal exit, the matrix $E$ will be zero, so that hesl and hesd will contain, on exit, the factors of the final second derivative matrix $H$ . The elements of hesd are useful for deciding whether to accept the result produced by e04lb (see [Accuracy]).

istate

Type: array<System..::..Int32>[]()[][]

An array of size [n]

On exit: information about which variables are currently on their bounds and which are free. If

istate [j - 1]

is:

– equal to $- 1$ , $x_{j}$ is fixed on its upper bound;
– equal to $- 2$ , $x_{j}$ is fixed on its lower bound;
– equal to $- 3$ , $x_{j}$ is effectively a constant (i.e., $l_{j} = u_{j}$ );
– positive, $istate [j - 1]$ gives the position of $x_{j}$ in the sequence of free variables.

f: Type: System..::..Double%
On exit: the function value at the final point given in x.

g: Type: array<System..::..Double>[]()[][]
An array of size [n]
On exit: the first derivative vector corresponding to the final point given in x. The components of g corresponding to free variables should normally be close to zero.

ifail: Type: System..::..Int32%
On exit: $ifail = 0$ unless the method detects an error or a warning has been flagged (see [Error Indicators and Warnings]).

Description

e04lb is applicable to problems of the form:

Minimize F (x_{1}, x_{2}, \dots, x_{n}) subject to ​ l_{j} \leq x_{j} \leq u_{j}, j = 1, 2, \dots, n .

Special provision is made for unconstrained minimization (i.e., problems which actually have no bounds on the

x_{j}

), problems which have only non-negativity bounds, and problems in which

l_{1} = l_{2} = \dots = l_{n}

and

u_{1} = u_{2} = \dots = u_{n}

. It is possible to specify that a particular

x_{j}

should be held constant. You must supply a starting point, a funct to calculate the value of

F (x)

and its first derivatives

\frac{\partial F}{\partial x_{j}}

at any point

x

, and a h to calculate the second derivatives

\frac{\partial^{2} F}{\partial x_{i} \partial x_{j}}

A typical iteration starts at the current point

x

where

n_{z}

(say) variables are free from both their bounds. The vector of first derivatives of

F (x)

with respect to the free variables,

g_{z}

, and the matrix of second derivatives with respect to the free variables,

H

, are obtained. (These both have dimension

n_{z}

The equations

(H + E) p_{z} = - g_{z}

are solved to give a search direction

p_{z}

. (The matrix

E

is chosen so that

H + E

is positive definite.)

p_{z}

is then expanded to an

n

-vector

p

by the insertion of appropriate zero elements;

α

is found such that

F (x + α p)

is approximately a minimum (subject to the fixed bounds) with respect to

α

, and

x

is replaced by

x + α p

. (If a saddle point is found, a special search is carried out so as to move away from the saddle point.)

If any variable actually reaches a bound, it is fixed and

n_{z}

is reduced for the next iteration.

There are two sets of convergence criteria – a weaker and a stronger. Whenever the weaker criteria are satisfied, the Lagrange multipliers are estimated for all active constraints. If any Lagrange multiplier estimate is significantly negative, then one of the variables associated with a negative Lagrange multiplier estimate is released from its bound and the next search direction is computed in the extended subspace (i.e.,

n_{z}

is increased). Otherwise, minimization continues in the current subspace until the stronger criteria are satisfied. If at this point there are no negative or near-zero Lagrange multiplier estimates, the process is terminated.

If you specify that the problem is unconstrained, e04lb sets the

l_{j}

- 10^{6}

and the

u_{j}

10^{6}

. Thus, provided that the problem has been sensibly scaled, no bounds will be encountered during the minimization process and e04lb will act as an unconstrained minimization algorithm.

References

Gill P E and Murray W (1973) Safeguarded steplength algorithms for optimization using descent methods NPL Report NAC 37 National Physical Laboratory

Gill P E and Murray W (1974) Newton-type methods for unconstrained and linearly constrained optimization Math. Programming 7 311–350

Gill P E and Murray W (1976) Minimization subject to bounds on the variables NPL Report NAC 72 National Physical Laboratory

Error Indicators and Warnings

Note: e04lb may return useful information for one or more of the following detected errors or warnings.

Errors or warnings detected by the method:

Some error messages may refer to parameters that are dropped from this interface (IW, LIW, W, LW) In these cases, an error in another parameter has usually caused an incorrect value to be inferred.

$ifail < 0$: A negative value of ifail indicates an exit from e04lb because you have set iflag negative in funct or h. The value of ifail will be the same as your setting of iflag.

$ifail = 1$

On entry,	$n < 1$ ,
or	$maxcal < 1$ ,
or	$eta < 0.0$ ,
or	$eta \geq 1.0$ ,
or	$xtol < 0.0$ ,
or	$stepmx < xtol$ ,
or	$ibound < 0$ ,
or	$ibound > 4$ ,
or	$bl [j - 1] > bu [j - 1]$ for some $j$ if $ibound = 0$ ,
or	$bl [0] > bu [0]$ if $ibound = 3$ ,
or	$lh < \max (1, n \times (n - 1) / 2)$ ,

(Note that if you have set xtol to

0.0

, e04lb uses the default value and continues without failing.) When this exit occurs no values will have been assigned to f or to the elements of hesl, hesd or g.

$ifail = 2$: There have been maxcal function evaluations. If steady reductions in $F (x)$ were monitored up to the point where this exit occurred, then the exit probably occurred simply because maxcal was set too small, so the calculations should be restarted from the final point held in x. This exit may also indicate that $F (x)$ has no minimum.

$ifail = 3$: The conditions for a minimum have not all been met, but a lower point could not be found.
Provided that, on exit, the first derivatives of $F (x)$ with respect to the free variables are sufficiently small, and that the estimated condition number of the second derivative matrix is not too large, this error exit may simply mean that, although it has not been possible to satisfy the specified requirements, the algorithm has in fact found the minimum as far as the accuracy of the machine permits. Such a situation can arise, for instance, if xtol has been set so small that rounding errors in the evaluation of $F (x)$ or its derivatives make it impossible to satisfy the convergence conditions.
If the estimated condition number of the second derivative matrix at the final point is large, it could be that the final point is a minimum, but that the smallest eigenvalue of the Hessian matrix is so close to zero that it is not possible to recognize the point as a minimum.

$ifail = 4$: Not used. (This is done to make the significance of $ifail = 5$ similar for e04kd and e04lb.)

$ifail = 5$: All the Lagrange multiplier estimates which are not indisputably positive lie relatively close to zero, but it is impossible either to continue minimizing on the current subspace or to find a feasible lower point by releasing and perturbing any of the fixed variables. You should investigate as for $ifail = 3$ .

$ifail = -9000$: An error occured, see message report.
$ifail = -8000$: Negative dimension for array $〈value〉$
$ifail = -6000$: Invalid Parameters $〈value〉$

The values

ifail = 2

3

5

may also be caused by mistakes in user-supplied delegates funct or h, by the formulation of the problem or by an awkward function. If there are no such mistakes, it is worth restarting the calculations from a different starting point (not the point at which the failure occurred) in order to avoid the region which caused the failure.

Accuracy

A successful exit (

ifail = 0

) is made from e04lb when

H^{(k)}

is positive definite and when (B1, B2 and B3) or B4 hold, where

\begin{array}{l} B1 & \equiv & α^{(k)} \times ‖p^{(k)}‖ < (xtol + \sqrt{ε}) \times (1.0 + ‖x^{(k)}‖) \\ B2 & \equiv & |F^{(k)} - F^{(k - 1)}| < ({xtol}^{2} + ε) \times (1.0 + |F^{(k)}|) \\ B3 & \equiv & ‖g_{z}^{(k)}‖ < (ε^{1 / 3} + xtol) \times (1.0 + |F^{(k)}|) \\ B4 & \equiv & ‖g_{z}^{(k)}‖ < 0.01 \times \sqrt{ε} . \end{array}

(Quantities with superscript

k

are the values at the

k

th iteration of the quantities mentioned in [Description].

ε

is the machine precision and

‖.‖

denotes the Euclidean norm.)

ifail = 0

, then the vector in x on exit,

x_{sol}

, is almost certainly an estimate of the position of the minimum,

x_{true}

, to the accuracy specified by xtol.

ifail = 3

5

x_{sol}

may still be a good estimate of

x_{true}

, but the following checks should be made. Let the largest of the first

n_{z}

elements of hesd be

hesd [b - 1]

, let the smallest be

hesd [s - 1]

, and define

k = hesd [b - 1] / hesd [s - 1]

. The scalar

k

is usually a good estimate of the condition number of the projected Hessian matrix at

x_{sol}

. If

(i)	the sequence $\{F (x^{(k)})\}$ converges to $F (x_{sol})$ at a superlinear or fast linear rate,
(ii)	${‖g_{z} (x_{sol})‖}^{2} < 10.0 \times ε$ , and
(iii)	$k < 1.0 / ‖g_{z} (x_{sol})‖$ ,

then it is almost certain that

x_{sol}

is a close approximation to the position of a minimum. When (ii) is true, then usually

F (x_{sol})

is a close approximation to

F (x_{true})

. The quantities needed for these checks are all available via monit; in particular the value of cond in the last call of monit before exit gives

k

Further suggestions about confirmation of a computed solution are given in the E04 class.

Parallelism and Performance

None.

Further Comments

Timing

The number of iterations required depends on the number of variables, the behaviour of

F (x)

, the accuracy demanded and the distance of the starting point from the solution. The number of multiplications performed in an iteration of e04lb is

\frac{n_{z}^{3}}{6} + O (n_{z}^{2})

. In addition, each iteration makes one call of h and at least one call of funct. So, unless

F (x)

and its derivatives can be evaluated very quickly, the run time will be dominated by the time spent in funct and h.

Scaling

Ideally, the problem should be scaled so that, at the solution,

F (x)

and the corresponding values of the

x_{j}

are each in the range

(- 1, + 1)

, and so that at points one unit away from the solution,

F (x)

differs from its value at the solution by approximately one unit. This will usually imply that the Hessian matrix at the solution is well-conditioned. It is unlikely that you will be able to follow these recommendations very closely, but it is worth trying (by guesswork), as sensible scaling will reduce the difficulty of the minimization problem, so that e04lb will take less computer time.

Unconstrained Minimization

If a problem is genuinely unconstrained and has been scaled sensibly, the following points apply:

(a)	$n_{z}$ will always be $n$ ,
(b)	hesl and hesd will be factors of the full second derivative matrix with elements stored in the natural order,
(c)	the elements of $g$ should all be close to zero at the final point,
(d)	the values of the $istate [j - 1]$ given by monit and on exit from e04lb are unlikely to be of interest (unless they are negative, which would indicate that the modulus of one of the $x_{j}$ has reached $10^{6}$ for some reason),
(e)	monit's parameter gpjnrm simply gives the norm of the first derivative vector.

Example

Example program (C#): e04lbe.cs

Example program results: e04lbe.r