Peroxide

Pure Rust numeric library contains linear algebra, numerical analysis, statistics and machine learning tools with R, MATLAB, Python like macros.

Latest README version

Corresponding to 0.8.7.

Install

• Add next line to your cargo.toml

peroxide = "0.8"

Module Structure

• src
  • bin : For test some libraries
    • dual.rs : Test automatic differentiation
    • oxide.rs : Test any
    • poly.rs : Test polynomial
    • lotka.rs : Solve lotka-volterra equation
    • mlp.rs : Multi-layer perceptron example
    • tov.rs : Solve Tolman-Oppenheimer-Volkoff equation
  • lib.rs : mod and re-export
  • ml : For machine learning (Beta)
    • mod.rs
    • reg.rs : Regression tools
  • macros : Macro files
    • matlab_macro.rs : MATLAB like macro
    • mod.rs
    • r_macro.rs : R like macro
  • numerical : To do numerical things
    • bdf.rs : Backward Differentiation Formula
    • gauss_legendre.rs : Gauss-Legendre 4th order
    • interp.rs : Interpolation
    • mod.rs
    • newton.rs : Newton's Method
    • ode.rs : Merge all ODE algorithm to one module
    • runge_kutta.rs : Runge Kutta 4th order
    • spline.rs : Natural Spline
    • utils.rs : Utils to do numerical things (e.g. jacobian)
  • operation : To define general operations
    • extra_ops.rs
    • mod.rs
  • statistics : Statistical Tools
    • mod.rs
    • dist.rs : Probability distributions
    • rand.rs : Wrapper for rand crate
    • stat.rs : Statistical tools
  • structure : Fundamental data structures
    • dataframe.rs : Not yet implemented
    • dual.rs : Dual number system for automatic differentiation
    • matrix.rs : Matrix
    • multinomial.rs : For multinomial (Beta)
    • mod.rs
    • polynomial.rs : Polynomial
    • vector.rs : Extra tools for Vec<f64>
  • util
    • mod.rs
    • api.rs : Matrix constructor for various language style
    • non_macro.rs : Primordial version of macros
    • print.rs : To print conveniently
    • useful.rs : Useful utils to implement library

Documentation

There is Peroxide Gitbook

Not yet documentized contents

Polynomial

// Peroxide
extern crate peroxide;
use peroxide::*;

fn main() {
    // Declare polynomial
    let a = poly(c!(1,3,2));
    a.print(); // x^2 + 3x + 2
    a.eval(1); // Evaluate when x = 1 -> 6.0
    
    let b = poly(c!(1,2,3,4));       // x^3 + 2x^2 + 3x + 4
    (a.clone() + b.clone()).print(); // x^3 + 3x^2 + 6x + 6
    (a.clone() - b.clone()).print(); // -x^3 - x^2 - 2
    (a.clone() * b.clone()).print(); // x^5 + 5x^4 + 11x^3 + 17x^2 + 18x + 8
    
    let c = poly(c!(1, -1));
    c.print();                       // x - 1
    c.pow(2).print();                // x^2 - 2x + 1
}

Interpolation (Beta)

• Lagrange polynomial interpolation
• Chebyshev nodes

// Peroxide
extern crate peroxide;
use peroxide::*;

fn main() {
    let a = c!(-1, 0, 1);
    let b = c!(1, 0, 1);

    let l = lagrange_polynomial(a, b);
    l.print(); // x^2
}

Spline (Beta)

• Natural cubic spline

// Peroxide
extern crate peroxide;
use peroxide::*;

fn main() {
    let x = c!(0.9, 1.3, 1.9, 2.1);
    let y = c!(1.3, 1.5, 1.85, 2.1);

    let s = cubic_spline(x, y);

    for i in 0 .. s.len() {
        s[i].print();
    }
    
    // -0.2347x^3 + 0.6338x^2 - 0.0329x + 0.9873
    // 0.9096x^3 - 3.8292x^2 + 5.7691x - 1.5268
    // -2.2594x^3 + 14.2342x^2 - 28.5513x + 20.2094
}

MATLAB like macro

• zeros - zero vector or matrix
• eye - identity matrix
• rand - random matrix (range from 0 to 1)

Automatic Differentiation

• Implemented AD with dual number structure.
• Available functions
  • sin, cos, tan
  • pow, powf
  • +,-,x,/
  • exp, ln

extern crate peroxide;
use peroxide::*;

fn main() {
    let a = dual(0, 1); // x at x = 0
    a.sin().print();    // sin(x) at x = 0
    
    // value: 0  // sin(0) = 0
    // slope: 1  // cos(0) = 1
}

Jacobian

• Implemented by AD - Exact Jacobian

extern crate peroxide;
use peroxide::*;

fn main() {
    let xs = c!(1, 1);
    jacobian(xs, f).print();
    
    //      c[0] c[1]
    // r[0]    6    3
}

// f(t, x) = 3t^2 * x
fn f(xs: Vec<Dual>) -> Vec<Dual> {
    let t = xs[0];
    let x = xs[1];

    vec![t.pow(2) * 3. * x]
}

Ordinary Differential Equation

• Solve 1st order ODE with various methods
• Explicit Method
  • RK4: Runge-Kutta 4th order
• Implicit Method
  • BDF1: Backward Euler
  • GL4: Gauss-Legendre 4th order

Caution

• input function should have form (Dual, Vec<Dual>) -> Vec<Dual>

// Lotka-Volterra
extern crate peroxide;
use peroxide::*;

fn main() {
    // t = 0, x = 2, y = 1
    let xs = c!(2, 1);
    let rk4_records = solve(lotka_volterra, xs.clone(), (0, 10), 1e-3, RK4);
    let bdf_records = solve(lotka_volterra, xs.clone(), (0, 10), 1e-3, BDF1(1e-15));
    let gl4_records = solve(lotka_volterra, xs, (0, 10), 1e-3, GL4(1e-15));
    //rk4_records.write_with_header("example_data/lotka_rk4.csv", vec!["t", "x", "y"]);
    //bdf_records.write_with_header("example_data/lotka_bdf.csv", vec!["t", "x", "y"]);
    gl4_records.write_with_header("example_data/lotka_gl4.csv", vec!["t", "x", "y"]);
}

fn lotka_volterra(_t: Dual, xs: Vec<Dual>) -> Vec<Dual> {
    let a = 4.;
    let c = 1.;

    let x = xs[0];
    let y = xs[1];

    vec![
        a * (x - x*y),
        -c * (y - x*y)
    ]
}

Version Info

To see RELEASES.md

TODO

To see TODO.md