Numerical Integration - Maple Help

Online Help

All Products    Maple    MapleSim


Home : Support : Online Help : Mathematics : Numerical Computations : Approximations : evalf : evalf/Int

Numerical Integration

 

Calling Sequence

Parameters

Description

Optional Arguments

Outline of the Numerical Integration Polyalgorithm (1-D Integrals)

Special (List) Syntax for Multiple Integrals

The Method Names

Examples

Calling Sequence

evalf(Int(f, x=a..b, ...))

evalf∫abfⅆx

evalf(Int(f, a..b, ...))

 

evalf(Int(f, list-of-equations, ...))

 

evalf(Int(f, list-of-ranges, ...))

 

evalf(int(f, x=a..b))

evalf∫abfⅆx

Parameters

f

-

algebraic expression or procedure; the integrand

x

-

name; the variable of integration

a, b

-

endpoints of the interval of integration

list-of-equations

-

list of equations [x1=a1..b1, ..., xn=an..bn]

list-of-ranges

-

list of ranges [a1..b1, ..., an..bn]

...

-

(optional) zero or more options, as described below

Description

• 

The most common command for numerical integration is evalf(Int(f, x=a..b)) where the integration command is expressed in inert form to avoid first invoking the symbolic integration routines. It is also possible to invoke evalf on an unevaluated integral returned by the symbolic int command, as in evalf(int(f, x=a..b)), if it happens that symbolic int fails (returns an unevaluated integral).

• 

All numerical integration calling sequences can also be accessed directly from the int command by using the numeric option.

• 

You can enter the command evalf/Int using either the 1-D or 2-D calling sequence. For example, evalf(Int(1/(x^2+1), x=0..infinity)) is equivalent to evalf01x2+1ⅆx.

• 

The integrand f may be another unevaluated integral, that is, multiple integrals are supported. A special list syntax (see below) can be used to specify multiple integrals, rather than using nested integrals. Integrals expressed in the standard non-list notation are referred to as 1-D (one-dimensional) integrals including the case of nested 1-D integrals.

• 

If the integrand f is specified as a procedure or a Maple operator, then the second argument must be a range a..b and not an equation, that is, a variable of integration must not be specified.

• 

Various levels of user information are displayed during the computation if infolevel[`evalf/int`] is assigned values between 1 and 4.

Optional Arguments

• 

Additional options may be specified as equations. (For backward compatibility some options are accepted as values rather than equations, as specified below.) An option is one of the following forms:

method = <name>  or  <name>

digits = <posint>  or  <posint>

epsilon = <numeric>

methodoptions = <list>

maxintervals = <posint>

• 

The specification method = <name> (or simply <name>) indicates a particular numerical integration method to be applied. The methods that can be specified are described below. By default, a hybrid symbolic-numeric strategy is applied.

• 

The specification digits = <posint> (or simply <posint>) indicates the number of digits of precision for the computation. Some additional guard digits are carried during the computation to attempt to achieve a result with <posint> correct digits (although a larger tolerance can be specified by using the 'epsilon' option). By default, the Maple environment variable Digits specifies the precision for the computation.

• 

The specification epsilon = <numeric> specifies the relative error tolerance for the computed result. The routines attempt to achieve a final result with a relative error less than this value. By default, the relative error tolerance which the routines attempt to achieve for the final result is

eps&equals;0.5101digits

  

where digits is the precision specified for the computation. In attempting to achieve this accuracy, the working value of Digits is increased as deemed necessary. It is an error to specify 'epsilon' smaller than the default value above, and for any value larger than 1e-3 the value 1e-3 is used instead if the method in use is deterministic (i.e. not the MonteCarlo or Cuba methods).

  

Note: For some integrands, the numerical accuracy attained when computing values of the integrand may be insufficient to allow the value of the integral to be computed to the default tolerance eps (even though the computation is using some number of guard digits). In such cases, specifying a larger tolerance (relative to the setting of digits) via the 'epsilon' option may be helpful. Alternatively, increasing Digits and fixing 'epsilon' may provide the desired answer (see the end of the examples section).

• 

The specification methodoptions = <list> specifies a list of zero or more options that are specific to a method selected with the method option. In particular, if the _d01ajc or _d01akc method is selected, one can supply an option of the form methodoptions=[maxintervals = <posint>] to specify a maximal number of subintervals that can be used internally by those methods.

• 

For backward compatibility, the option maxintervals = <posint> for the _d01ajc and _d01akc methods can also be specified as a separate option, as an argument to Int directly, rather than in the methodoptions option.

Outline of the Numerical Integration Polyalgorithm (1-D Integrals)

• 

In the default case (no particular method specified), the problem is first passed to NAG integration routines if Digits is not too large (that is, if Digits <= evalhf(Digits)). The NAG routines are in a compiled C library and hence operate at hardware floating-point speed. If the NAG routines cannot perform the integration, then some singularity handling may be performed and control may pass back to the NAG routines with a modified problem. Native Maple routines are invoked if the NAG routines cannot solve the problem (for example, if Digits is too large or if the integrand involves functions for which hardware floating-point evaluation is not supported).

• 

The native Maple hybrid symbolic-numeric solution strategy is as follows. The default numerical method applied is Clenshaw-Curtis quadrature (_CCquad). If slow convergence is detected then there must be singularities in or near the interval of integration (perhaps in the complex plane). Some techniques of symbolic analysis are used to deal with the singularities. For problems with non-removable endpoint singularities, an adaptive double-exponential quadrature method (_Dexp) is applied.

• 

If singularities interior to the interval are suspected, then an attempt is made to locate the singularities in order to break up the interval of integration. Finally, if still unsuccessful, then the interval is subdivided and the _Dexp method is applied, or if the method was already _Dexp or _Sinc then an adaptive Gaussian quadrature method (_Gquad) is applied.

• 

For the limits of integration, the values infinity and/or -infinity are valid, and a symbolic-numeric strategy attempts to deal with singularities. Techniques employed include variable transformations, subtracting out the singularity, and integration of a truncated generalized series near the singularity.

• 

No singularity handling is attempted in the case where the integrand f is specified as a procedure or a Maple operator.

Special (List) Syntax for Multiple Integrals

• 

A numerical multiple integration problem may be specified in a natural way using nested one-dimensional integrals, for example:

 evalf( Int(...(Int(Int(f, x1=a1..b1), x2=a2..b2), ...), xn=an..bn) )

  

where the integrand f depends on x1, x2, ..., xn. Such a problem may also be specified using the following special multiple integration notation with a list as the second argument:

 evalf( Int(f, [x1=a1..b1, x2=a2..b2, ..., xn=an..bn]) ) .

• 

Additional optional arguments may be stated just as in the case of 1-D integration. Also as in 1-D integration, the integrand f may be specified as a procedure in which case the second argument must be a list of ranges: [a1..b1, a2..b2, ..., an..bn].

• 

Whether a multiple integration problem is stated using nested integrals or using the list notation, the arguments will be extracted so as to invoke the same numerical multiple integration routines.

The Method Names

• 

The optional argument method = <name> (or simply <name>) accepts the following method names.

method = _DEFAULT

--

equivalent to not specifying a method; the solution strategy outlined above is applied for 1-D integrals; for multiple integrals, the problem is passed to the _cuhre method and if it fails, then the problem is treated via nested 1-D integration.

 

 

 

method = _NoNAG

--

indicates to avoid calling NAG routines; otherwise follow the _DEFAULT strategy.

 

 

 

method = _NoMultiple

--

indicates to avoid calling numerical multiple integration routines; compute multiple integrals via nested 1-D integration.

Maple Methods

• 

Specifying a method indicates to try only that method (in particular, no NAG methods and no singularity handling).

method = _CCquad

--

Clenshaw-Curtis quadrature method.

 

 

 

method = _Dexp

--

adaptive double-exponential method.

 

 

 

method = _Gquad

--

adaptive Gaussian quadrature method.

 

 

 

method = _Sinc

--

adaptive sinc quadrature method.

 

 

 

method = _NCrule

--

adaptive Newton-Cotes method "quanc8". Note that in contrast to the other Maple methods listed here, "quanc8" (method = _NCrule) is a fixed-order method and hence it is not recommended for very high precisions (e.g. Digits > 15).

NAG Methods

• 

Specifying a method indicates to try only that method (in particular, no singularity handling and no Maple methods).

method = _d01ajc

--

for finite interval of integration; allows for badly behaved integrands; uses adaptive Gauss 10-point and Kronrod 21-point rules.

 

 

 

method = _d01akc

--

for finite interval of integration, oscillating integrands; uses adaptive Gauss 30-point and Kronrod 61-point rules.

 

 

 

method = _d01amc

--

for semi-infinite/infinite interval of integration.

Multiple Integration Methods

• 

These methods are for multiple integrals over a hyperrectangle, that is, the limits of integration are finite constants.

• 

Specifying a method indicates to try only that method (in particular, do not revert to nested 1-D integration).

method = _cuhre

--

dimensions 2 to 15; ACM TOMS Algorithm 698.

 

 

 

method = _MonteCarlo

--

Monte Carlo method; for low accuracy only (less than 5 digits of accuracy); NAG routine 'd01gbc'.

 

 

 

method = _CubaVegas

--

Vegas method; for low accuracy. For details and method-specific options, see evalf/Int/cuba.

 

 

 

method = _CubaSuave

--

Suave method; for low accuracy. For details and method-specific options, see evalf/Int/cuba.

 

 

 

method = _CubaDivonne

--

Divonne method; for low accuracy. For details and method-specific options, see evalf/Int/cuba.

 

 

 

method = _CubaCuhre

--

Cuhre method. For details and method-specific options, see evalf/Int/cuba.

Examples

evalf&int;01&ExponentialE;x3x2&plus;1&DifferentialD;x

0.6649369431

(1)

evalf&int;0&infin;1x2&plus;1&DifferentialD;x

1.570796327

(2)

evalf&int;0&infin;sinxlnx&ExponentialE;x3&DifferentialD;x

0.1957885158

(3)

The following integrals are computed to higher precision.

e11&Gamma;x&colon;

&int;02e1&DifferentialD;x&equals;evalfInte1&comma;x&equals;0..2&comma;digits&equals;20&comma;method&equals;_Dexp

&int;021&Gamma;x&DifferentialD;x&equals;1.6263783986861406145

(4)

e2&ExponentialE;vv221&plus;1&ExponentialE;v2&colon;

&int;0&infin;e2&DifferentialD;v&equals;evalf&lsqb;20&rsqb;&int;0&infin;e2&DifferentialD;v

&int;0&infin;&ExponentialE;v12v21&plus;12&ExponentialE;v&DifferentialD;v&equals;1.3055168991185060654

(5)

e311&plus;ln1&plus;x&colon;

&int;01e3&DifferentialD;x&equals;evalf&lsqb;32&rsqb;Inte3&comma;x&equals;0..1&comma;method&equals;_Gquad

&int;0111&plus;ln1&plus;x&DifferentialD;x&equals;0.73716070962368003213791626905536

(6)

r&int;&infin;&infin;sechx&ExponentialE;x2&DifferentialD;x

r:=&int;&infin;&infin;sechx&ExponentialE;x2&DifferentialD;x

(7)

evalfr

1.479061171

(8)

evalf&lsqb;25&rsqb;r

1.479061171449575890854454

(9)

The following command returns an error because procedure f is invoked with argument x, a symbolic name.

f := proc(x) if x < 2 then 2*x else x^2 end if; end proc;

f:=procxifx<2then2&ast;xelsex&Hat;2end ifend proc

(10)

evalf&int;03fx&DifferentialD;x

Error, (in f) cannot determine if this expression is true or false: x < 2

When the integrand f is a procedure, the following syntax should be used.

evalfIntf&comma;0..3

10.33333333

(11)

Note that the following command also works by delaying the evaluation of fx via unevaluation quotes.

evalf&int;03&apos;f&apos;x&DifferentialD;x

10.33333333

(12)

Multiple integrals may be expressed as nested one-dimensional integrals.

&int;02&int;03&int;04&ExponentialE;x&plus;y&plus;z5x&plus;110y&plus;215z&plus;3&DifferentialD;x&DifferentialD;y&DifferentialD;z

&int;02&int;03&int;04&ExponentialE;x&plus;y&plus;z5x&plus;110y&plus;215z&plus;3&DifferentialD;x&DifferentialD;y&DifferentialD;z

(13)

evalf

0.9331611325

(14)

Numerical multiple integration may also be invoked using a list syntax.

d1w2x2y2z2&colon;

gdcoswxyzdwxyzsinwxyz

g:=w2x2y2z2&plus;1coswxyzw2x2y2z2&plus;1wxyzsinwxyz

(15)

evalf&int;01&int;01&int;01&int;01g&DifferentialD;w&DifferentialD;x&DifferentialD;y&DifferentialD;z

0.9717798177

(16)

When low accuracy is sufficient, the Monte Carlo method may be used.

h12&plus;sin&pi;87x1&plus;x2&plus;x3&plus;x4&plus;x5&plus;x6

h:=12&plus;sin&pi;87x1&plus;x2&plus;x3&plus;x4&plus;x5&plus;x6

(17)

evalfInth&comma;x1&equals;1..1&comma;x2&equals;1..1&comma;x3&equals;1..1&comma;x4&equals;1..1&comma;x5&equals;1..1&comma;x6&equals;1..1&comma;method&equals;_MonteCarlo&comma;&epsilon;&equals;0.005

36.91495206

(18)

Only trust about 3 digits when epsilon = 0.5e-2.

evalf&lsqb;3&rsqb;

36.9

(19)

The following integrand has a region near x=0.5 where evaluation incurs catastrophic cancellation to the extent that the function cannot even be evaluated to 1 significant Digit at standard precision.

igrand12sin&pi;xsin355x113

igrand:=12sin&pi;xsin355113x

(20)

evalfigrandx&equals;0.5|igrandx&equals;0.5

Float&infin;

(21)

Note that evalf fails to compute this integral with default settings.

evalf&int;01igrand&DifferentialD;x

&int;0.1.12.1.sin3.141592654x1.sin3.141592920x&DifferentialD;x

(22)

So to compute the value of this integral to 10 digits, we need to add significant guard digits:

evalf&lsqb;15&rsqb;igrandx&equals;0.5|igrandx&equals;0.5

1.111111111111111014

(23)

evalf&lsqb;20&rsqb;igrandx&equals;0.5|igrandx&equals;0.5

1.12417780445826433691014

(24)

evalf&lsqb;25&rsqb;igrandx&equals;0.5|igrandx&equals;0.5

1.1241776059444067750290701014

(25)

So we add 15 digits to assure we get the answer to 10 digits:

evalf&lsqb;25&rsqb;Intigrand&comma;x&equals;0..1&comma;&epsilon;&equals;1.10-10

1.499451605234141071490295107

(26)

In the following example, the default setting for the maximum number of subintervals, 500 in this case, is not enough for successful integration using the NAG method for oscillatory integrands, _d01akc, which would be suitable for this integrand. By supplying a higher upper bound, we can get successful completion with this method.

igrandsin&ExponentialE;x1&plus;x2

igrand:=sin&ExponentialE;xx2&plus;1

(27)

evalfIntigrand&comma;x&equals;10..10&comma;method&equals;_d01akc

Error, (in `evalf/int`) NE_QUAD_MAX_SUBDIV:
  The maximum number of subdivisions has
  been reached: max_num_subint = 500

evalfIntigrand&comma;x&equals;10..10&comma;method&equals;_d01akc&comma;methodoptions&equals;maxintervals&equals;1000

1.235076653

(28)

See Also

Digits

dsolve/numeric

evalf

infolevel

Int

int

 


Download Help Document

Was this information helpful?



Please add your Comment (Optional)
E-mail Address (Optional)
What is ? This question helps us to combat spam