Struct GaussLegendre

pub struct GaussLegendre { /* private fields */ }

A Gauss-Legendre quadrature scheme.

These rules can integrate functions on the domain [a, b].

Examples

Basic usage:

// initialize a Gauss-Legendre rule with 2 nodes
let quad = GaussLegendre::new(2)?;

// numerically integrate x^2 - 1/3 over the domain [0, 1]
let integral = quad.integrate(0.0, 1.0, |x| x * x - 1.0 / 3.0);

assert_abs_diff_eq!(integral, 0.0);

The nodes and weights are computed in O(n) time, so large quadrature rules are feasible:

let quad = GaussLegendre::new(1_000_000)?;

let integral = quad.integrate(-3.0, 3.0, |x| x.sin());

assert_abs_diff_eq!(integral, 0.0);

Implementations

impl GaussLegendre

pub fn new(deg: usize) -> Result<Self, GaussLegendreError>

Initializes a Gauss-Legendre quadrature rule of the given degree by computing the needed nodes and weights.

A rule of degree n can integrate polynomials of degree 2n-1 exactly.

Uses the algorithm by Ignace Bogaert, which has linear time complexity.

Errors

Returns an error if deg is smaller than 2.

pub fn par_new(deg: usize) -> Result<Self, GaussLegendreError>

Available on crate feature rayon only.

Same as new but runs in parallel.

Errors

Returns an error if deg is smaller than 2.

pub fn integrate<F>(&self, a: f64, b: f64, integrand: F) -> f64

where F: Fn(f64) -> f64,

Perform quadrature integration of given integrand from a to b.

Example

Basic usage

let glq_rule = GaussLegendre::new(3)?;

assert_abs_diff_eq!(glq_rule.integrate(-1.0, 1.0, |x| x.powi(5)), 0.0);

pub fn par_integrate<F>(&self, a: f64, b: f64, integrand: F) -> f64

where F: Fn(f64) -> f64 + Sync,

Available on crate feature rayon only.

Same as integrate but runs in parallel.

Example

let glq_rule = GaussLegendre::par_new(1_000_000)?;

assert_abs_diff_eq!(glq_rule.par_integrate(0.0, 1.0, |x| x.ln()), -1.0, epsilon = 1e-12);

impl GaussLegendre

pub fn nodes(&self) -> GaussLegendreNodes<'_>

Returns an iterator over the nodes of the quadrature rule.

pub fn weights(&self) -> GaussLegendreWeights<'_>

Returns an iterator over the weights of the quadrature rule.

pub fn iter(&self) -> GaussLegendreIter<'_>

Returns an iterator over the node-weight pairs of the quadrature rule.

pub fn as_node_weight_pairs(&self) -> &[(Node, Weight)]

Returns a slice of all the node-weight pairs of the quadrature rule.

pub fn into_node_weight_pairs(self) -> Vec<(Node, Weight)>

Converts the quadrature rule into a vector of node-weight pairs.

This function just returns the underlying vector without any computation or cloning.

pub fn degree(&self) -> usize

Returns the degree of the quadrature rule.

Trait Implementations

impl Clone for GaussLegendre

fn clone(&self) -> GaussLegendre

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GaussLegendre

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GaussLegendre

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<GaussLegendre> for GaussJacobi

Gauss-Legendre quadrature is equivalent to Gauss-Jacobi quadrature with alpha = beta = 0.

fn from(value: GaussLegendre) -> Self

Converts to this type from the input type.

impl<'a> IntoIterator for &'a GaussLegendre

type IntoIter = GaussLegendreIter<'a>

Which kind of iterator are we turning this into?

type Item = &'a (f64, f64)

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoIterator for GaussLegendre

type IntoIter = GaussLegendreIntoIter

Which kind of iterator are we turning this into?

type Item = (f64, f64)

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for GaussLegendre

fn eq(&self, other: &GaussLegendre) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for GaussLegendre

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for GaussLegendre