#Numeric #Science #Dataframe #Plot #LinearAlgebra

peroxide

Rust comprehensive scientific computation library contains linear algebra, numerical analysis, statistics and machine learning tools with farmiliar syntax

158 releases (25 breaking)

new 0.26.4 Sep 24, 2020
0.26.0 Aug 27, 2020
0.25.3 Jul 31, 2020
0.21.4 Mar 21, 2020
0.6.6 Nov 29, 2018

#4 in Science

Download history 98/week @ 2020-06-09 273/week @ 2020-06-16 16/week @ 2020-06-23 160/week @ 2020-06-30 161/week @ 2020-07-07 350/week @ 2020-07-14 111/week @ 2020-07-21 226/week @ 2020-07-28 46/week @ 2020-08-04 370/week @ 2020-08-11 194/week @ 2020-08-18 212/week @ 2020-08-25 215/week @ 2020-09-01 511/week @ 2020-09-08 43/week @ 2020-09-15 94/week @ 2020-09-22

883 downloads per month
Used in puruda

MIT/Apache

560KB
13K SLoC

Peroxide

On crates.io On docs.rs

builds.sr.ht status travis github

maintenance

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

Why Peroxide?

1. Customize features

Peroxide provides various features.

  • default - Pure Rust (No dependencies of architecture - Perfect cross compilation)
  • O3 - OpenBLAS (Perfect performance but hard to set-up - Strongly recommend to read OpenBLAS for Rust)
  • plot - With matplotlib of python, we can draw any plots.
  • dataframe - Dataframe & netcdf
  • serde - serialization with Serde.

If you want to do high performance computation, then choose openblas feature. If you don't want to depend C/C++ or Fortran libraries, then choose default feature. If you want to draw plot with some great templates, then choose plot feature.

You can choose any features simultaneously.

2. Easy to optimize

Peroxide uses 1D data structure to describe matrix. So, it's too easy to integrate BLAS. It means peroxide guarantees perfect performance for linear algebraic computations.

3. Friendly syntax

Rust is so strange for Numpy, MATLAB, R users. Thus, it's harder to learn the more rusty libraries. With peroxide, you can do heavy computations with R, Numpy, MATLAB like syntax.

For example,

#[macro_use]
extern crate peroxide;
use peroxide::prelude::*;

fn main() {
    // MATLAB like matrix constructor
    let a = ml_matrix("1 2;3 4");

    // R like matrix constructor (default)
    let b = matrix(c!(1,2,3,4), 2, 2, Row);

    // Or use zeros
    let mut z = zeros(2, 2);
    z[(0,0)] = 1.0;
    z[(0,1)] = 2.0;
    z[(1,0)] = 3.0;
    z[(1,1)] = 4.0;
    
    // Simple but effective operations
    let c = a * b; // Matrix multiplication (BLAS integrated)

    // Easy to pretty print
    c.print();
    //       c[0] c[1]
    // r[0]     1    3
    // r[1]     2    4

    // Easy to do linear algebra
    c.det().print();
    c.inv().print();

    // and etc.
}

4. Can choose two different coding styles.

In peroxide, there are two different options.

  • prelude: To simple use.
  • fuga: To choose numerical algorithms explicitly.

For examples, let's see norm.

In prelude, use norm is simple: a.norm(). But it only uses L2 norm for Vec<f64>. (For Matrix, Frobenius norm.)

#[macro_use]
extern crate peroxide;
use peroxide::prelude::*;

fn main() {
    let a = c!(1, 2, 3);
    let l2 = a.norm();      // L2 is default vector norm
    
    assert_eq!(l2, 14f64.sqrt());
}

In fuga, use various norms. But you should write longer than prelude.

#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
   
fn main() {
    let a = c!(1, 2, 3);
    let l1 = a.norm(Norm::L1);
    let l2 = a.norm(Norm::L2);
    let l_inf = a.norm(Norm::LInf);
    assert_eq!(l1, 6f64);
    assert_eq!(l2, 14f64.sqrt());
    assert_eq!(l_inf, 3f64);
}

5. Batteries included

Peroxide can do many things.

  • Linear Algebra
    • Effective Matrix structure
    • Transpose, Determinant, Diagonal
    • LU Decomposition, Inverse matrix, Block partitioning
    • QR Decomposition
    • Singular Value Decomposition (SVD)
    • Reduced Row Echelon form
    • Column, Row operations
    • Eigenvalue, Eigenvector
  • Functional Programming
    • More easy functional programming with Vec<f64>
    • For matrix, there are three maps
      • fmap : map for all elements
      • col_map : map for column vectors
      • row_map : map for row vectors
  • Automatic Differentiation
    • Dual number system - for 1st order AD
    • Hyper dual number system - for 2nd order AD
    • Taylor mode Forward AD - for nth order AD
    • Exact jacobian
    • Real trait to constrain for f64 and Dual
    • Number structure to unify f64 and Dual
    • Above strokes will be updated soon
  • Numerical Analysis
    • Lagrange interpolation
    • Cubic spline
    • Non-linear regression
      • Gradient Descent
      • Gauss Newton
      • Levenberg Marquardt
    • Ordinary Differential Equation
      • Euler
      • Runge Kutta 4th order
      • Backward Euler
      • Gauss Legendre 4th order
    • Numerical Integration
      • Gauss-Legendre Quadrature
    • Root Finding
      • Bisection
      • False Position (Regula Falsi)
      • Secant
      • Newton
  • Statistics
    • More easy random with rand crate
    • Ordered Statistics
      • Median
      • Quantile (Matched with R quantile)
    • Probability Distributions
      • Bernoulli
      • Uniform
      • Binomial
      • Normal
      • Gamma
      • Beta
      • Student's-t
    • RNG algorithms
      • Acceptance Rejection
      • Marsaglia Polar
      • Ziggurat
      • Wrapper for rand-dist crate
  • Special functions
    • Wrapper for puruspe crate (pure rust)
  • Utils
    • R-like macro & functions
    • Matlab-like macro & functions
    • Numpy-like macro & functions
    • Julia-like macro & functions
  • Plotting
    • With pyo3 & matplotlib
  • DataFrame
    • Convert with Matrix
    • Read & Write csv files
    • Read & Write netcdf files

6. Compatible with Mathematics

After 0.23.0, peroxide is compatible with mathematical structures. Matrix, Vec<f64>, f64 are considered as inner product vector spaces. And Matrix, Vec<f64> are linear operators - Vec<f64> to Vec<f64> and Vec<f64> to f64. For future, peroxide will include more & more mathematical concepts. (But still practical.)

7. Written in Rust

Rust & Cargo are awesome for scientific computations. You can use any external packages easily with Cargo, not make. And default runtime performance of Rust is also great. If you use many iterations for computations, then Rust become great choice.

Latest README version

Corresponding to 0.26.3

Pre-requisite

  • For O3 feature - Need OpenBLAS
  • For plot feature - Need matplotlib of python
  • For dataframe feature - Need netcdf

Install

  • Add next block to your cargo.toml
  1. Default
    [dependencies]
    peroxide = "0.26"
    
  2. OpenBLAS
    [dependencies.peroxide]
    version = "0.26"
    default-features = false
    features = ["O3"] 
    
  3. Plot
    [dependencies.peroxide]
    version = "0.26"
    default-features = false
    features = ["plot"] 
    
  4. DataFrame
    [dependencies.peroxide]
    version = "0.26"
    default-features = false
    features = ["dataframe"]
    
  5. OpenBLAS & Plot & DataFrame
    [dependencies.peroxide]
    version = "0.26"
    default-features = false
    features = ["O3", "plot", "dataframe"] 
    

Useful tips for features

  • After 0.21.4, if size of matrix is smaller than 1000 x 1000, default is more effective than O3 feature.
  • To plot, use dataframe to export data as netcdf format and use python to draw plot.
    • plot feature has limited plot abilities.
    • There is a template of python code. - Socialst

Module Structure

Documentation

  • On docs.rs

Example

Peroxide Gallery

Version Info

To see RELEASES.md

Contributes Guide

See CONTRIBUTES.md

TODO

To see TODO.md

Dependencies

~2.6–4.5MB
~79K SLoC