Struct rgsl::types::integration::IntegrationWorkspace

pub struct IntegrationWorkspace { /* fields omitted */ }

The QAG algorithm is a simple adaptive integration procedure. The integration region is divided into subintervals, and on each iteration the subinterval with the largest estimated error is bisected. This reduces the overall error rapidly, as the subintervals become concentrated around local difficulties in the integrand. These subintervals are managed by a gsl_integration_workspace struct, which handles the memory for the subinterval ranges, results and error estimates.

Methods

impl IntegrationWorkspace

fn new(n: usize) -> Option<IntegrationWorkspace>

This function allocates a workspace sufficient to hold n double precision intervals, their integration results and error estimates. One workspace may be used multiple times as all necessary reinitialization is performed automatically by the integration routines.

fn qag<T>(
    &mut self,
    f: function<T>,
    arg: &mut T,
    a: f64,
    b: f64,
    epsabs: f64,
    epsrel: f64,
    limit: usize,
    key: GaussKonrodRule,
    result: &mut f64,
    abserr: &mut f64
) -> Value

This function applies an integration rule adaptively until an estimate of the integral of f over (a,b) is achieved within the desired absolute and relative error limits, epsabs and epsrel. The function returns the final approximation, result, and an estimate of the absolute error, abserr. The integration rule is determined by the value of key, which should be chosen from the following symbolic names,

GSL_INTEG_GAUSS15 (key = 1)

GSL_INTEG_GAUSS21 (key = 2)

GSL_INTEG_GAUSS31 (key = 3)

GSL_INTEG_GAUSS41 (key = 4)

GSL_INTEG_GAUSS51 (key = 5)

GSL_INTEG_GAUSS61 (key = 6)

corresponding to the 15f64, 21f64, 31f64, 41f64, 51 and 61 point Gauss-Kronrod rules. The higher-order rules give better accuracy for smooth functions, while lower-order rules save time when the function contains local difficulties, such as discontinuities.

On each iteration the adaptive integration strategy bisects the interval with the largest error estimate. The subintervals and their results are stored in the memory provided by workspace. The maximum number of subintervals is given by limit, which may not exceed the allocated size of the workspace.

fn qags<T>(
    &mut self,
    f: function<T>,
    arg: &mut T,
    a: f64,
    b: f64,
    epsabs: f64,
    epsrel: f64,
    limit: usize,
    result: &mut f64,
    abserr: &mut f64
) -> Value

This function applies the Gauss-Kronrod 21-point integration rule adaptively until an estimate of the integral of f over (a,b) is achieved within the desired absolute and relative error limits, epsabs and epsrel. The results are extrapolated using the epsilon-algorithm, which accelerates the convergence of the integral in the presence of discontinuities and integrable singularities. The function returns the final approximation from the extrapolation, result, and an estimate of the absolute error, abserr. The subintervals and their results are stored in the memory provided by workspace. The maximum number of subintervals is given by limit, which may not exceed the allocated size of the workspace.

fn qagp<T>(
    &mut self,
    f: function<T>,
    arg: &mut T,
    pts: &mut [f64],
    epsabs: f64,
    epsrel: f64,
    limit: usize,
    result: &mut f64,
    abserr: &mut f64
) -> Value

This function applies the adaptive integration algorithm QAGS taking account of the user-supplied locations of singular points. The array pts of length npts should contain the endpoints of the integration ranges defined by the integration region and locations of the singularities. For example, to integrate over the region (a,b) with break-points at x_1, x_2, x_3 (where a < x_1 < x_2 < x_3 < b) the following pts array should be used

pts[0] = a pts[1] = x_1 pts[2] = x_2 pts[3] = x_3 pts[4] = b with npts = 5.

If you know the locations of the singular points in the integration region then this routine will be faster than QAGS.

fn qagi<T>(
    &mut self,
    f: function<T>,
    arg: &mut T,
    epsabs: f64,
    epsrel: f64,
    limit: usize,
    result: &mut f64,
    abserr: &mut f64
) -> Value

This function computes the integral of the function f over the infinite interval (-\infty,+\infty). The integral is mapped onto the semi-open interval (0,1] using the transformation x = (1-t)/t,

\int_{-\infty}^{+\infty} dx f(x) = \int_0¹ dt (f((1-t)/t) + f((-1+t)/t))/t^2.

It is then integrated using the QAGS algorithm. The normal 21-point Gauss-Kronrod rule of QAGS is replaced by a 15-point rule, because the transformation can generate an integrable singularity at the origin. In this case a lower-order rule is more efficient.

fn qagiu<T>(
    &mut self,
    f: function<T>,
    arg: &mut T,
    a: f64,
    epsabs: f64,
    epsrel: f64,
    limit: usize,
    result: &mut f64,
    abserr: &mut f64
) -> Value

This function computes the integral of the function f over the semi-infinite interval (a,+\infty). The integral is mapped onto the semi-open interval (0,1] using the transformation x = a + (1-t)/t,

\int_{a}^{+\infty} dx f(x) = \int_0¹ dt f(a + (1-t)/t)/t²

and then integrated using the QAGS algorithm.

fn qagil<T>(
    &mut self,
    f: function<T>,
    arg: &mut T,
    b: f64,
    epsabs: f64,
    epsrel: f64,
    limit: usize,
    result: &mut f64,
    abserr: &mut f64
) -> Value

This function computes the integral of the function f over the semi-infinite interval (-\infty,b). The integral is mapped onto the semi-open interval (0,1] using the transformation x = b - (1-t)/t,

\int_{-\infty}^{b} dx f(x) = \int_0¹ dt f(b - (1-t)/t)/t²

and then integrated using the QAGS algorithm.

fn qawc<T>(
    &mut self,
    f: function<T>,
    arg: &mut T,
    a: f64,
    b: f64,
    c: f64,
    epsabs: f64,
    epsrel: f64,
    limit: usize,
    result: &mut f64,
    abserr: &mut f64
) -> Value

This function computes the Cauchy principal value of the integral of f over (a,b), with a singularity at c,

I = \int_a^b dx f(x) / (x - c)

The adaptive bisection algorithm of QAG is used, with modifications to ensure that subdivisions do not occur at the singular point x = c. When a subinterval contains the point x = c or is close to it then a special 25-point modified Clenshaw-Curtis rule is used to control the singularity. Further away from the singularity the algorithm uses an ordinary 15-point Gauss-Kronrod integration rule.

fn sort_results(&mut self)

fn qpsrt(&mut self)

fn sum_results(&self) -> f64

fn retrieve(&self, a: &mut f64, b: &mut f64, r: &mut f64, e: &mut f64)

fn update(
    &mut self,
    a1: f64,
    b1: f64,
    area1: f64,
    error1: f64,
    a2: f64,
    b2: f64,
    area2: f64,
    error2: f64
)

fn set_initial_result(&mut self, result: f64, error: f64)

fn initialise(&mut self, a: f64, b: f64)

fn limit(&self) -> usize

fn size(&self) -> usize

Trait Implementations

impl Drop for IntegrationWorkspace

fn drop(&mut self)

A method called when the value goes out of scope.