Scientific Computing in Rust

• Initial value problem solving
• Root finding algorithms
• Polynomials
• Polynomial Interpolation
• Scientific Constants
• Special functions/polynomials
• Numeric quadrature
• Numeric differentiation

Explanations of the features can be found here.

There are two adaptive Runge-Kutta methods, two Adams predictor-correctors, and two adaptive Backwards Differentiation Formulas implemented. The interface to all of the solvers is the same. As an example, this code solves y' = y using the Runge-Kutta-Fehlberg method.

use bacon_sci::ivp::{RK45, RungeKuttaSolver};
use nalgebra::SVector;

fn deriv(_t: f64, y: &[f64], _params: &mut ()) -> Result<SVector<f64, 1>, String> {
    Ok(SVector::<f64, 1>::from_column_slice(y))
}

fn solve() -> Result<(), String> {
    let solver = RK45::new()
                    .with_dt_min(0.01)?
                    .with_dt_max(0.1)?
                    .with_tolerance(1e-4)?
                    .with_initial_conditions(&[1.0])?
                    .with_start(0.0)?
                    .with_end(10.0)?
                    .build();
    let _solution = solver.solve_ivp(deriv, &mut ())?;
    Ok(())
}

There is also a solve_ivp function in bacon_sci::ivp that tries a fifth-order predictor-corrector followed by the Runge-Kutta-Fehlberg method followed by BDF6.

bacon_sci::roots implements the bisection method, Newton's method, the secant method, Newton's method for polynomials, and Müller's method for polynomials.

As an example, the following code snippet finds the root of x^3 using initial guesses of 0.1 and -0.1.

use bacon_sci::roots::secant;
use nalgebra::SVector;

fn cubic(x: &[f64]) -> SVector<f64, 1> {
    SVector::<f64, 1>::from_iterator(x.iter.map(|x| x.powi(3)))
}

fn solve() -> f64 {
    secant((&[-0.1], &[0.1]), cubic, 0.001, 1000).unwrap()
}

bacon_sci::polynomial implements a polynomial struct. bacon_sci::interp implements Lagrange interpolation, Hermite interpolation, and cubic spline interpolation.

Several scientific constants are defined in bacon_sci::constants. The data comes from NIST. The 2018 CODATA complete listing is available as a hashmap.

Currently, bacon_sci::special allows you to get Legendre polynomials, Hermite polynomials, Laguerre polynomials, and Chebyshev polynomials.

bacon_sci::differentiate allows first- and second-derivative evaluation numerically. bacon_sci::integrate implements Tanh-Sinh quadrature, adaptive Simpson's rule, Romberg integration, and several adaptive Gaussian integration schemes.