40 releases

0.9.1 Jun 4, 2021
0.8.4 Jan 28, 2021
0.8.2 Dec 27, 2020
0.8.0 Nov 22, 2020
0.0.3 Nov 19, 2018

#11 in Math

Download history 515/week @ 2021-02-24 577/week @ 2021-03-03 615/week @ 2021-03-10 889/week @ 2021-03-17 700/week @ 2021-03-24 749/week @ 2021-03-31 688/week @ 2021-04-07 805/week @ 2021-04-14 799/week @ 2021-04-21 496/week @ 2021-04-28 654/week @ 2021-05-05 926/week @ 2021-05-12 1001/week @ 2021-05-19 1004/week @ 2021-05-26 677/week @ 2021-06-02 440/week @ 2021-06-09

3,312 downloads per month
Used in 2 crates

MIT license

540KB
12K SLoC

Mathru

crate documentation minimum rustc 1.52.1 maintenance pipeline status

Mathru is a numeric library containing algorithms for linear algebra, analysis and statistics written in pure Rust with BLAS/LAPACK support.

Features

The following features are implemented in this create:

  • Algebra

  • Ordinary differential equation (ODE)

    • Explicit methods
      • Euler method
      • Heun's 2nd order method
      • Midpoint method
      • Ralston's 2nd order method
      • Kutta 3rd order
      • Heun's 3rd order method
      • Ralston's 3rd order method
      • Runge-Kutta 4th order
      • Runge-Kutta-Felhberg
      • Dormand-Prince
      • Cash-Karp
      • Tsitouras
      • Bogacki-Shampine
      • Adams-Bashforth
    • Automatic step size control with starting step size
    • Implicit methods
      • Implicit Euler
      • Backward differentiation formula (BDF)
  • Optimization

    • Gauss-Newton algorithm
    • Gradient descent
    • Newton method
    • Levenberg-Marquardt algorithm
    • Conjugate gradient method
  • Statistics

    • Probability distribution
      • Bernoulli
      • Beta
      • Binomial
      • Exponential
      • Gamma
      • Chi-squared
      • Normal
      • Log-Normal
      • Poisson
      • Raised cosine
      • Student-t
      • Uniform
    • Test
  • Elementary functions

    • trigonometric functions
    • hyperbolic functions
    • exponential functions
  • special functions

    • gamma functions
      • gamma function
      • log-gamma function
      • digamma function
      • upper incomplete gamma function
      • upper incomplete regularized gamma function
      • inverse upper incomplete regularized gamma function
      • lower incomplete gamma function
      • lower regularized incomplete gamma function
      • inverse lower regularized incomplete gamma function
    • beta functions
      • beta function
      • incomplete beta function
      • incomplete regularized beta function
    • error functions
      • error function
      • complementary error function
      • inverse error function
      • inverse complementary error function
    • hypergeometric functions

Usage

Add this to your Cargo.toml for the native Rust implementation:

[dependencies.mathru]
version = "^0.9"

Add the following lines to 'Cargo.toml' if the openblas library should be used:

[dependencies.mathru]
version = "^0.9"
default-features = false
features = "openblas"

One of the following implementations for linear algebra can be activated as a feature:

  • native: Native Rust implementation(activated by default)
  • openblas: Optimized BLAS library
  • netlib: Collection of mathematical software, papers, and databases
  • intel-mkl: Intel Math Kernel Library
  • accelerate Make large-scale mathematical computations and image calculations, optimized for high performance and low-energy consumption.(macOS only)

Then import the modules and it is ready to be used.

use mathru as mr;

Solve a system of linear equations

use mathru::{
    algebra::linear::{
        matrix::{LUDec, Solve},
        Matrix, Vector,
    },
    matrix, vector,
};

/// Solves a system of linear equations
fn main()
{
    let a: Matrix<f64> = matrix![6.0, 2.0, -1.0; -3.0, 5.0, 3.0; -2.0, 1.0, 3.0];
    let b: Vector<f64> = vector![48.0; 49.0; 24.0];

    // Decompose a into a lower and upper matrix
    let lu_dec: LUDec<f64> = a.dec_lu().unwrap();

    // Solve the system of linear equations with the decomposed matrix
    let _x1: Vector<f64> = lu_dec.solve(&b).unwrap();

    // Solve it directly
    let _x2: Vector<f64> = a.solve(&b).unwrap();
}

Solve ordinary differential equation with the Dormand-Prince algorithm

use mathru::{
    algebra::linear::Vector,
    analysis::differential_equation::ordinary::{problem, DormandPrince54, ExplicitODE},
};

fn main()
{
    // Create an ODE instance
    let problem: problem::Euler<f64> = problem::Euler::default();

    let (x_start, x_end) = problem.time_span();

    // Create a ODE solver instance
    let h_0: f64 = 0.0001;
    let n_max: u32 = 800;
    let abs_tol: f64 = 10e-7;

    let solver: DormandPrince54<f64> = DormandPrince54::new(abs_tol, h_0, n_max);

    // Solve ODE
    let (x, y): (Vec<f64>, Vec<Vector<f64>>) = solver.solve(&problem).unwrap();
}

Further examples

For further examples, see project page

Documentation

See project page for more information and examples. The API is documented on docs.rs.

License

Licensed under

Contribution

Any contribution is welcome!

Dependencies

~0.3–28MB
~489K SLoC