NAG Library Routine Document

d01gbf returns an approximation to the integral of a function over a hyper-rectangular region, using a Monte–Carlo method. An approximate relative error estimate is also returned. This routine is suitable for low accuracy work.

2

Specification

Fortran Interface

Subroutine d01gbf (

ndim, a, b, mincls, maxcls, functn, eps, acc, lenwrk, wrkstr, finest, ifail)

Integer, Intent (In)	::	ndim, maxcls, lenwrk
Integer, Intent (Inout)	::	mincls, ifail
Real (Kind=nag_wp), External	::	functn
Real (Kind=nag_wp), Intent (In)	::	a(ndim), b(ndim), eps
Real (Kind=nag_wp), Intent (Inout)	::	wrkstr(lenwrk), finest
Real (Kind=nag_wp), Intent (Out)	::	acc

C Header Interface

#include <nagmk26.h>

void	d01gbf_ (const Integer ndim, const double a[], const double b[], Integer mincls, const Integer maxcls, double (NAG_CALL functn)(const Integer ndim, const double x[]), const double eps, double acc, const Integer lenwrk, double wrkstr[], double finest, Integer ifail)

3

Description

d01gbf uses an adaptive Monte–Carlo method based on the algorithm described in Lautrup (1971). It is implemented for integrals of the form:

\int_{a_{1}}^{b_{1}} \int_{a_{2}}^{b_{2}} \dots \int_{a_{n}}^{b_{n}} f (x_{1}, x_{2}, \dots, x_{n}) d x_{n} \dots d x_{2} d x_{1} .

Upon entry, unless lenwrk has been set to the minimum value

10 \times ndim

, the routine subdivides the integration region into a number of equal volume subregions. Inside each subregion the integral and the variance are estimated by means of pseudorandom sampling. All contributions are added together to produce an estimate for the whole integral and total variance. The variance along each coordinate axis is determined and the routine uses this information to increase the density and change the widths of the sub-intervals along each axis, so as to reduce the total variance. The total number of subregions is then increased by a factor of two and the program recycles for another iteration. The program stops when a desired accuracy has been reached or too many integral evaluations are needed for the next cycle.

4

References

Lautrup B (1971) An adaptive multi-dimensional integration procedure Proc. 2nd Coll. Advanced Methods in Theoretical Physics, Marseille

5

Arguments

1: $ndim$ – IntegerInput

On entry:

n

, the number of dimensions of the integral.

Constraint:

ndim \geq 1

2: $a (ndim)$ – Real (Kind=nag_wp) arrayInput

On entry: the lower limits of integration,

a_{i}

, for

i = 1, 2, \dots, n

3: $b (ndim)$ – Real (Kind=nag_wp) arrayInput

On entry: the upper limits of integration,

b_{i}

, for

i = 1, 2, \dots, n

4: $mincls$ – IntegerInput/Output

On entry: must be set

either to the minimum number of integrand evaluations to be allowed, in which case $mincls \geq 0$ ;
or to a negative value. In this case, the routine assumes that a previous call had been made with the same arguments ndim, a and b and with either the same integrand (in which case d01gbf continues calculation) or a similar integrand (in which case d01gbf begins the calculation with the subdivision used in the last iteration of the previous call). See also wrkstr.

On exit: contains the number of integrand evaluations actually used by d01gbf.

5: $maxcls$ – IntegerInput

On entry: the maximum number of integrand evaluations to be allowed. In the continuation case this is the number of new integrand evaluations to be allowed. These counts do not include zero integrand values.

Constraints:

$maxcls > mincls$ ;
$maxcls \geq 4 \times (ndim + 1)$ .

6: $functn$ – real (Kind=nag_wp) Function, supplied by the user.External Procedure

functn must return the value of the integrand

f

at a given point.

The specification of functn is:

Fortran Interface

Function functn (

ndim, x)

Real (Kind=nag_wp)	::	functn
Integer, Intent (In)	::	ndim
Real (Kind=nag_wp), Intent (In)	::	x(ndim)

C Header Interface

#include <nagmk26.h>

double

functn (const Integer *ndim, const double x[])

1: $ndim$ – IntegerInput: On entry: $n$ , the number of dimensions of the integral.
2: $x (ndim)$ – Real (Kind=nag_wp) arrayInput: On entry: the coordinates of the point at which the integrand $f$ must be evaluated.

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

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

7: $eps$ – Real (Kind=nag_wp)Input

On entry: the relative accuracy required.

Constraint:

eps \geq 0.0

8: $acc$ – Real (Kind=nag_wp)Output

On exit: the estimated relative accuracy of finest.

9: $lenwrk$ – IntegerInput

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

For maximum efficiency, lenwrk should be about

3 \times ndim \times {(maxcls / 4)}^{1 / ndim} + 7 \times ndim .

If lenwrk is given the value

10 \times ndim

then the subroutine uses only one iteration of a crude Monte–Carlo method with maxcls sample points.

Constraint:

lenwrk \geq 10 \times ndim

10: $wrkstr (lenwrk)$ – Real (Kind=nag_wp) arrayInput/Output

On entry: if

mincls < 0

, wrkstr must be unchanged from the previous call of d01gbf – except that for a new integrand

wrkstr (lenwrk)

must be set to

0.0

. See also mincls.

On exit: contains information about the current sub-interval structure which could be used in later calls of d01gbf. In particular,

wrkstr (j)

gives the number of sub-intervals used along the

j

th coordinate axis.

11: $finest$ – Real (Kind=nag_wp)Input/Output

On entry: must be unchanged from a previous call to d01gbf.

On exit: the best estimate obtained for the integral.

12: $ifail$ – IntegerInput/Output

On entry: ifail must be set to

0

- 1 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 or 1

is recommended. If the output of error messages is undesirable, then the value

1

is recommended. Otherwise, because for this routine the values of the output arguments may be useful even if

ifail \neq 0

on exit, the recommended value is

- 1

. When the value $- 1 or 1$ is used it is essential to test the value of ifail on exit.

On exit:

ifail = 0

unless the routine detects an error or a warning has been flagged (see Section 6).

6

Error Indicators and Warnings

If on entry

ifail = 0

- 1

, explanatory error messages are output on the current error message unit (as defined by x04aaf).

Errors or warnings detected by the routine:

$ifail = 1$: On entry, $eps = 〈value〉$ .
Constraint: $eps \geq 0.0$ .

On entry, lenwrk is too small. $lenwrk = 〈value〉$ . Minimum possible dimension: $〈value〉$ .

On entry, $maxcls = 〈value〉$ and $mincls = 〈value〉$ .
Constraint: $maxcls > mincls$ .

On entry, $maxcls = 〈value〉$ and $ndim = 〈value〉$ .
Constraint: $maxcls \geq 4 \times (ndim + 1)$ .

On entry, $ndim = 〈value〉$ .
Constraint: $ndim \geq 1$ .

$ifail = 2$: maxcls too small to obtain required accuracy eps. $maxcls = 〈value〉$ and $eps = 〈value〉$ .

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

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

$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

A relative error estimate is output through the argument acc. The confidence factor is set so that the actual error should be less than acc 90% of the time. If you want a higher confidence level then a smaller value of eps should be used.

8

Parallelism and Performance

d01gbf is threaded by NAG for parallel execution in multithreaded implementations of the NAG Library.

Please consult the X06 Chapter Introduction for information on how to control and interrogate the OpenMP environment used within this routine. Please also consult the Users' Note for your implementation for any additional implementation-specific information.

9

Further Comments

The running time for d01gbf will usually be dominated by the time used to evaluate the integrand

f

, so the maximum time that could be used is approximately proportional to maxcls.

For some integrands, particularly those that are poorly behaved in a small part of the integration region, d01gbf may terminate with a value of acc which is significantly smaller than the actual relative error. This should be suspected if the returned value of mincls is small relative to the expected difficulty of the integral. Where this occurs, d01gbf should be called again, but with a higher entry value of mincls (e.g., twice the returned value) and the results compared with those from the previous call.

9.1

Additional Information

The exact values of finest and acc on return will depend (within statistical limits) on the sequence of random numbers generated within this routine.

10

Example

This example calculates the integral

\int_{0}^{1} \int_{0}^{1} \int_{0}^{1} \int_{0}^{1} \frac{4 x_{1} x_{3} \exp (2 x_{1} x_{3})}{{(1 + x_{2} + x_{4})}^{2}} d x_{1} d x_{2} d x_{3} d x_{4} = 0.575364 .

10.1

Program Text

Program Text (d01gbfe.f90)

10.2

Program Data

None.

10.3

Program Results

Program Results (d01gbfe.r)

NAG Library Manual, Mark 26

NAG AD Library Manual, Mark 26

NAG C Library Manual, Mark 26

D01 (quad) Chapter Contents

D01 (quad) Chapter Introduction

NAG Library Routine Document

d01gbf (md_mcarlo)

▸▿ Contents

1 Purpose

2 Specification

3 Description

4 References

5 Arguments

6 Error Indicators and Warnings

7 Accuracy

8 Parallelism and Performance

9 Further Comments

9.1 Additional Information

10 Example

10.1 Program Text

10.2 Program Data

10.3 Program Results

1

Purpose

2

Specification

3

Description

4

References

5

Arguments

6

Error Indicators and Warnings

7

Accuracy

8

Parallelism and Performance

9

Further Comments

9.1

Additional Information

10

Example

10.1

Program Text

10.2

Program Data

10.3

Program Results