public class Quadrature extends Object implements Serializable, Cloneable
Quadrature
is a generalpurpose integrator that uses a globally
adaptive scheme in order to reduce the absolute error. It subdivides the
interval [A, B] and uses a point
GaussKronrod rule to estimate the integral over each subinterval. The
error for each subinterval is estimated by comparison with the kpoint
Gauss quadrature rule. The subinterval with the largest estimated error is
then bisected and the same procedure is applied to both halves. The
bisection process is continued until either the error criterion is satisfied,
roundoff error is detected, the subintervals become too small, or the
maximum number of subintervals allowed is reached. The Class Quadrature
is based on the subroutine QAG
by Piessens et al. (1983).
If the function to be integrated has endpoint singularities then
extrapolation should be enabled.
As described above, the integral's value is approximated by applying a quadrature rule to
a series of subdivisions of the interval.
The sequence of approximate values converges to the integral's value.
The algorithm can be used to extrapolate from
the initial terms of the sequence to its limit.
Without extrapolation, the quadrature approximation sequence converges slowly
if the function being integrated has endpoint singularities.
The algorithm accelerates convergence of the sequence in this case.
The class EpsilonAlgorithm
implements the algorithm.
With extrapolation, this class is similar to the subroutine QAGS
by Piessens et al. (1983).
The desired absolute error, , can be set using setAbsoluteError
.
The desired relative error, , can be set using setRelativeError
.
The method eval
computes the approximate integral value
.
It also computes an error estimate E, which can be retrieved using getErrorEstimate
.
These are related by the following equation:
Modifier and Type  Class and Description 

static interface 
Quadrature.Function
Public interface function for the Quadrature class.

Constructor and Description 

Quadrature()
Constructs a Quadrature object.

Modifier and Type  Method and Description 

double 
eval(Quadrature.Function objectF,
double a,
double b)
Returns the value of the integral from a to b.

double 
getErrorEstimate()
Returns an estimate of the relative error in the computed result.

int 
getErrorStatus()
Returns the nonfatal error status.

void 
setAbsoluteError(double errorAbsolute)
Sets the absolute error tolerance.

void 
setExtrapolation(boolean doExtrapolation)
If true, the epsilonalgorithm for extrapolation is enabled.

void 
setMaxSubintervals(int maxSubintervals)
Sets the maximum number of subintervals allowed.

void 
setRelativeError(double errorRelative)
Sets the relative error tolerance.

void 
setRule(int rule)
Set the GaussKronrod rule.

public double eval(Quadrature.Function objectF, double a, double b)
objectF
 an implementation of Function
containing the function
to be integrateda
 a double
specifying the lower limit of integrationb
 a double
specifying the upper limit of integration,
either or both of a and b can be Double.POSITIVE_INFINITY or
Double.NEGATIVE_INFINITYpublic double getErrorEstimate()
double
specifying an estimate of the relative
error in the computed resultpublic int getErrorStatus()
int
specifying the nonfatal error status:
Status  Meaning 
0  No error. 
1  Maximum number of subdivisions allowed has been achieved. One can allow more subdivisions by using setMaxSubintervals. If this yields no improvement it is advised to analyze the integrand in order to determine the integration difficulties. If the position of a local difficulty can be determined (e.g. singularity, discontinuity within the interval) one will probably gain from splitting up the interval at this point and calling the integrator on the subranges. If possible, an appropriate specialpurpose integrator should be used, which is designed for handling the type of difficulty involved. 
2  The occurrence of roundoff error is detected, which prevents the requested tolerance from being achieved. The error may be underestimated. 
3  Extremely bad integrand behavior occurs at some points of the integration interval. 
4  The algorithm does not converge. Roundoff error is detected in the extrapolation table. It is presumed that the requested tolerance cannot be achieved, and that the returned result is the best which can be obtained. 
5  The algorithm does not converge. Roundoff error is detected in the extrapolation table. It is presumed that the requested tolerance cannot be achieved, and that the returned result is the best that can be obtained. 
6  The integral is probably divergent, or slowly convergent. It must be noted that divergence can occur with any other status value. 
public void setAbsoluteError(double errorAbsolute)
errorAbsolute
 a double
scalar value specifying the
absolute error tolerance. The default value is 1.0536712127723714E8.public void setExtrapolation(boolean doExtrapolation)
doExtrapolation
 a boolean
, true if the epsilonalgorithm for
extrapolation is to be enabled, false otherwisepublic void setMaxSubintervals(int maxSubintervals)
maxSubintervals
 an int
specifying the maximum number
of subintervals to be allowed. The default is 500.public void setRelativeError(double errorRelative)
errorRelative
 a double
scalar value specifying the
relative error tolerance. The default value is 1.0536712127723714E8.public void setRule(int rule)
Rule  Data points used 
1  7  15 
2  10  21 
3  15  31 
4  20  41 
5  25  51 
6  30  61 
rule
 an int
specifying the rule
to be used. The default is 3.Copyright © 19702015 Rogue Wave Software
Built October 13 2015.