one-indexed-vec 0.2.0

A one-based (1-indexed) wrapper around Vec<T>: element at position N is accessed via vec[N].
Documentation
//! Numerical integration.

/// Trapezoidal rule on `∫_a^b f(x) dx` with `n` subintervals.
///
/// ```rust
/// use one_indexed_vec::numerical::integrate::trapezoid;
/// let v = trapezoid(|x| x * x, 0.0, 1.0, 1000);
/// assert!((v - 1.0 / 3.0).abs() < 1e-6);
/// ```
pub fn trapezoid<F>(f: F, a: f64, b: f64, n: usize) -> f64
where
    F: Fn(f64) -> f64,
{
    assert!(n > 0, "trapezoid: n must be > 0");
    let h = (b - a) / n as f64;
    let mut sum = 0.5 * (f(a) + f(b));
    for i in 1..n {
        sum += f(a + i as f64 * h);
    }
    sum * h
}

/// Simpson's rule. `n` must be even.
///
/// ```rust
/// use one_indexed_vec::numerical::integrate::simpson;
/// let v = simpson(|x| x * x, 0.0, 1.0, 1000);
/// assert!((v - 1.0 / 3.0).abs() < 1e-10);
/// ```
pub fn simpson<F>(f: F, a: f64, b: f64, n: usize) -> f64
where
    F: Fn(f64) -> f64,
{
    assert!(n > 0, "simpson: n must be > 0");
    assert!(n % 2 == 0, "simpson: n must be even");
    let h = (b - a) / n as f64;
    let mut sum = f(a) + f(b);
    for i in 1..n {
        let x = a + i as f64 * h;
        sum += if i % 2 == 1 { 4.0 * f(x) } else { 2.0 * f(x) };
    }
    sum * h / 3.0
}

/// 5-point Gauss-Legendre quadrature.
///
/// ```rust
/// use one_indexed_vec::numerical::integrate::gauss_legendre_5;
/// let v = gauss_legendre_5(|x| x * x, 0.0, 1.0);
/// assert!((v - 1.0 / 3.0).abs() < 1e-10);
/// ```
pub fn gauss_legendre_5<F>(f: F, a: f64, b: f64) -> f64
where
    F: Fn(f64) -> f64,
{
    const X: [f64; 5] = [
        -0.906_179_845_938_664,
        -0.538_469_310_105_683,
        0.0,
        0.538_469_310_105_683,
        0.906_179_845_938_664,
    ];
    const W: [f64; 5] = [
        0.236_926_885_056_189,
        0.478_628_670_499_366,
        0.568_888_888_888_889,
        0.478_628_670_499_366,
        0.236_926_885_056_189,
    ];
    let c = 0.5 * (b - a);
    let d = 0.5 * (b + a);
    let mut sum = 0.0;
    for i in 0..5 {
        sum += W[i] * f(c * X[i] + d);
    }
    c * sum
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn trapezoid_square() {
        let v = trapezoid(|x| x * x, 0.0, 1.0, 1000);
        assert!((v - 1.0 / 3.0).abs() < 1e-6);
    }

    #[test]
    fn simpson_square() {
        let v = simpson(|x| x * x, 0.0, 1.0, 1000);
        assert!((v - 1.0 / 3.0).abs() < 1e-10);
    }

    #[test]
    fn gauss_square() {
        let v = gauss_legendre_5(|x| x * x, 0.0, 1.0);
        assert!((v - 1.0 / 3.0).abs() < 1e-10);
    }

    #[test]
    fn sin_integral() {
        let v = simpson(|x| x.sin(), 0.0, core::f64::consts::PI, 1000);
        assert!((v - 2.0).abs() < 1e-10);
    }
}