AdaptiveIntegrator<T> Class

public class AdaptiveIntegrator<T> : NumericalIntegrator<T>
where T : Object, INumber<T>

Public Class AdaptiveIntegrator(Of T As {Object, INumber(Of T)})
	Inherits NumericalIntegrator(Of T)

generic<typename T>
where T : Object, INumber<T>
public ref class AdaptiveIntegrator : public NumericalIntegrator<T>

type AdaptiveIntegrator<'T when 'T : Object and INumber<'T>> = 
    class
        inherit NumericalIntegrator<'T>
    end

Inheritance

Object  →  ManagedIterativeAlgorithm<T, T, SolutionReport<T, T>>  →  IterativeAlgorithm<T>  →  NumericalIntegrator<T>  →  AdaptiveIntegrator<T>

Type Parameters

T

The AdaptiveIntegrator<T> class provides the most robust, reliable, and in most cases the fastest numerical integration algorithm. It uses a simple integration rule to approximate the integral over subintervals. In each step, the interval with the largest estimated error is divided in two, and new approximations for these two subintervals are calculated. This process continues until the total estimated error over all intervals is within the desired tolerance.

AdaptiveIntegrator<T> inherits from NumericalIntegrator<T>, the abstract base class for all numerical integration classes. It, in turn, inherits from the [!:IterativeAlgorithm] class. All properties of this class are also available. The [!:IterativeAlgorithm.AbsoluteTolerance] and [!:IterativeAlgorithm.RelativeTolerance] properties set the desired precision as specified by the [!:IterativeAlgorithm.ConvergenceCriterion] property. The default value for both tolerances is SqrtEpsilon (roughly 10^-8). MaxIterations sets the maximum number of iterations, which in this case is the maximum number of subintervals. The default value for this property is 5000. IterationsNeeded returns the actual number of iterations performed after the algorithm has completed.

The Integrate(Func<T, T>, T, T, T[]) method does the actual work of numerically integrating an integrand. It takes three parameters. The first parameter is a function of one variable that specifies the function to integrate. The second and third parameters are T values that specify the lower and upper bounds of the integration interval.

The IntegrationRule<T> property lets you specify which integration rule to use to approximate integrals on a subinterval. Integration rules can be obtained by calling static methods of the IntegrationRule<T> class. The default is the 31-point rule for normal integrands, and the 15-point rule when singularities are expected, and when integrating over infinite intervals. For oscillating integrands, the higher order rules will tend to give better results.

Several enhancements make this the integration algorithm of choice, especially for 'difficult' target functions.

An extra property, UseExtrapolation, lets you specify whether special precautions should be taken to deal with singularities. If UseExtrapolation is true, an extrapolation algorithm is used to approximate the integral near a singularity or singularities. Because this option requires extra resources, it is recommended only for integrands that actually have singularities inside or at the boundaries of the integration interval.

The SetSingularities(T[]) and GetSingularities() methods let you specify and retrieve the points inside the integration interval where the integrand has a singularity or a discontinuity. They are returned as a T array containing the problem points. Extrapolation is used once again to approximate the integral near the singularity or singularities. Specifying the problem points in the target function can lead to speed-ups of several orders of magnitude.

Unlike other classes, this integrator can deal successfully with infinite integration intervals. Specify [!:T.NegativeInfinity] or [!:T.PositiveInfinity] for one or both bounds of the integration interval. Internally, the class transforms the infinite interval to a finite interval, and performs the integration of the transformed integrand over the transformed interval.

Reference