The gauss-quad
crate is a small library to calculate integrals of the type
using Gaussian quadrature.
To use the crate, the desired quadrature rule has to be included in the program, e.g. for a Gauss-Legendre rule
use gauss_quad::GaussLegendre;
The general call structure is to first initialize the n-point quadrature rule setting the degree n via
let quad = QUADRATURE_RULE::new(n)?;
where QUADRATURE_RULE can currently be set to calculate either:
QUADRATURE_RULE | Integral |
---|---|
Midpoint | |
Simpson | |
GaussLegendre | |
GaussJacobi | |
GaussLaguerre | |
GaussHermite |
A Gaussian quadrature rule of degree n can integrate a polynomial of degree 2n-1 exactly.
For the quadrature rules that take an additional parameter, such as Gauss-Laguerre and Gauss-Jacobi, the parameters have to be added to the initialization, e.g.
let quad = GaussLaguerre::new(n, alpha)?;
Then to calculate the integral of a function call
let integral = quad.integrate(a, b, f(x));
where a and b (both f64) are the integral bounds and the f(x) the integrand (Fn(f64) -> f64). For example to integrate a parabola from 0..1 one can use a lambda expression as integrand and call:
let integral = quad.integrate(0.0, 1.0, |x| x*x);
If the integral is improper, as in the case of Gauss-Laguerre and Gauss-Hermite integrals, no integral bounds should be passed and the call simplifies to
let integral = quad.integrate(f(x));
Rules can be nested into double and higher integrals:
let double_integral = quad.integrate(a, b, |x| quad.integrate(c(x), d(x), |y| f(x, y)));
If the computation time for the evaluation of the integrand is large (>> 100µs), the rayon feature can be used to parallelize the computation on multiple cores (for low computation any gain is overshadowed by the overhead from parallelization)
let slow_integral = quad.par_integrate(a, b, |x| f(x));