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
//! Ordinary differential equation solvers.

use crate::{Vec1, vec1};

/// Explicit Euler method.
///
/// `f(t, y) -> dy/dt`. Returns `(t_values, y_values)`.
pub fn euler<F>(f: F, t0: f64, y0: f64, t_end: f64, n_steps: usize) -> (Vec1<f64>, Vec1<f64>)
where
    F: Fn(f64, f64) -> f64,
{
    assert!(n_steps > 0, "euler: n_steps must be > 0");
    let h = (t_end - t0) / n_steps as f64;
    let mut t = vec1![0.0; n_steps + 1];
    let mut y = vec1![0.0; n_steps + 1];
    t[1] = t0;
    y[1] = y0;
    for i in 1..=n_steps {
        y[i + 1] = y[i] + h * f(t[i], y[i]);
        t[i + 1] = t[i] + h;
    }
    (t, y)
}

/// Classical 4th-order Runge-Kutta.
pub fn rk4<F>(f: F, t0: f64, y0: f64, t_end: f64, n_steps: usize) -> (Vec1<f64>, Vec1<f64>)
where
    F: Fn(f64, f64) -> f64,
{
    assert!(n_steps > 0, "rk4: n_steps must be > 0");
    let h = (t_end - t0) / n_steps as f64;
    let mut t = vec1![0.0; n_steps + 1];
    let mut y = vec1![0.0; n_steps + 1];
    t[1] = t0;
    y[1] = y0;
    for i in 1..=n_steps {
        let ti = t[i];
        let yi = y[i];
        let k1 = f(ti, yi);
        let k2 = f(ti + h / 2.0, yi + h * k1 / 2.0);
        let k3 = f(ti + h / 2.0, yi + h * k2 / 2.0);
        let k4 = f(ti + h, yi + h * k3);
        y[i + 1] = yi + h / 6.0 * (k1 + 2.0 * k2 + 2.0 * k3 + k4);
        t[i + 1] = ti + h;
    }
    (t, y)
}

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

    #[test]
    fn rk4_exponential() {
        let (_, y) = rk4(|_t, y| y, 0.0, 1.0, 1.0, 1000);
        assert!((y[1001] - core::f64::consts::E).abs() < 1e-6);
    }

    #[test]
    fn euler_exponential() {
        let (_, y) = euler(|_t, y| y, 0.0, 1.0, 1.0, 10000);
        assert!((y[10001] - core::f64::consts::E).abs() < 0.01);
    }
}