mathru

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

Features

- Linear algebra
    - Vector
    - Matrix
        - Basic matrix operations(+,-,*)
        - Transposition
        - LU decomposition (native/lapack)
        - QR decomposition (native/lapack)
        - Hessenberg decomposition (native/lapack)
        - Singular value decomposition
        - Inverse (native/lapack)
        - Pseudo inverse (native/lapack)
        - Determinant (native/lapack)
        - Trace
        - Eigenvalue (native/lapack)

- Ordinary differential equation (ODE)
    - Heun's method
    - Runge-Kutta 4th order
    - Euler
    - Runge-Kutta 4(5)
    - Runge-Kutta-Felhberg 4(5)
    - Dormand-Prince 4(5)

- Optimization
    - Gauss-Newton algorithm
    - Gradient descent
    - Newton method
    - Levenberg-Marquardt algorithm
    - Conjugate gradient method

- Statistics
    - probability distribution
        - Bernoulli
        - Beta
        - Binomial
        - Chisquared
        - Exponential
        - Gamma
        - Chi-squared
        - Multinomial
        - Normal
        - Poisson
        - Raised cosine
        - Student-t
        - Uniform
    - test
        - Chi-squared 
        - G
        - Student-t

- elementary functions
    - trigonometric functions
    - hyperbolic functions
    - exponential functions

- special functions
    - gamma functions
    - beta functions
    - hypergeometrical functions

Usage

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

toml [dependencies.mathru] version = "0.5" Add the following lines to 'Cargo.toml' if the blas/lapack backend should be used:

toml [dependencies.mathru] version = "0.5" default-features = false features = ["blaslapack"]

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

``` rust use mathru::algebra::linear::{Matrix};

// Compute the LU decomposition of a 2x2 matrix let a: Matrix = Matrix::new(2, 2, vec![1.0, -2.0, 3.0, -7.0]); let l_ref: Matrix = Matrix::new(2, 2, vec![1.0, 0.0, 1.0 / 3.0, 1.0]);

let (l, u, p): (Matrix, Matrix, Matrix) = a.dec_lu();

asserteq!(lref, l); ```

Solve an ODE:

``` // // explicit ODE // x' = 1 + x^2 fn f(_t: &f64, x: &Vector) -> Vector { let result = vector![1.0] + x.clone().apply(&|e: &f64| -> f64 {return e * e;}) ;

return result;

}

let h0: f64 = 0.0001; let emax: f64 = 0.000001; let n_max: u32 = 500;

let init: Vector = vector![0.0]; let solver: Dopri5 = Dopri5::new(h0, emax, n_max);

let (t, y): (Vector, Matrix) = solver.solve(f, init, 0.0, 1.4);

let (m, _n): (usize, usize) = y.dim();

assert!(comparereal(&1.40, &t.get(&(m-1)), 0.0001)); assert!(comparereal(&1.4_f64.tan(), &y.get(&(m-1), &0), 0.0001));

```

Contributions

Any contribution is welcome!