Struct peroxide::structure::matrix::Matrix

pub struct Matrix {
    pub data: Vec<f64>,
    pub row: usize,
    pub col: usize,
    pub shape: Shape,
}

R-like matrix structure

Examples

use peroxide::fuga::*;

let a = Matrix {
    data: vec![1f64,2f64,3f64,4f64],
    row: 2,
    col: 2,
    shape: Row,
}; // [[1,2],[3,4]]

Fields

data: Vec<f64>

row: usize

col: usize

shape: Shape

Implementations

impl Matrix

pub fn write(&self, file_path: &str) -> Result<(), Box<dyn Error>>

Write to CSV

Examples

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

fn main() -> Result<(), Box<dyn Error>> {
    let a = matrix(c!(1,2,3,3,2,1), 3, 2, Col);
    a.write("example_data/test.csv")?;

    Ok(())
}

pub fn write_round( &self, file_path: &str, round: usize, ) -> Result<(), Box<dyn Error>>

Write to CSV (with round option)

Examples

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

fn main() -> Result<(), Box<dyn Error>> {
    let a = matrix(c!(1,2,3,3,2,1), 3, 2, Col);
    a.write_round("example_data/test.csv", 0)?;

    Ok(())
}

pub fn write_with_header( &self, file_path: &str, header: Vec<&str>, ) -> Result<(), Box<dyn Error>>

pub fn write_with_header_round( &self, file_path: &str, header: Vec<&str>, round: usize, ) -> Result<(), Box<dyn Error>>

pub fn read( file_path: &str, header: bool, delimiter: char, ) -> Result<Matrix, Box<dyn Error>>

Read from CSV

Examples

#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;
use std::process;

fn main() -> Result<(), Box<dyn Error>> {
    let a = matrix(c!(1,2,3,3,2,1), 3, 2, Col);
    a.write_round("example_data/test.csv", 0)?;

    let b = Matrix::read("example_data/test.csv", false, ','); // header = false, delimiter = ','
    match b {
        Ok(mat) => println!("{}", mat),
        Err(err) => {
            println!("{}", err);
            process::exit(1);
        }
    }

    Ok(())
}

pub fn from_series( series: &Series, row: usize, col: usize, shape: Shape, ) -> Self

Matrix from series

Example

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

fn main() {
    let a = Series::new(c!(1,2,3,4));
    let m = Matrix::from_series(&a, 2, 2, Row);
     
    assert_eq!(m, matrix(c!(1,2,3,4), 2, 2, Row));
}

Trait Implementations

impl<'a, 'b> Add<&'b Matrix> for &'a Matrix

type Output = Matrix

The resulting type after applying the + operator.

fn add(self, rhs: &'b Matrix) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Matrix> for f64

Element-wise addition between f64 & &Matrix

type Output = Matrix

The resulting type after applying the + operator.

fn add(self, other: &'a Matrix) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Matrix> for i32

Element-wise addition between i32 & &Matrix

type Output = Matrix

The resulting type after applying the + operator.

fn add(self, other: &'a Matrix) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Matrix> for usize

Element-wise addition between usize & &Matrix

type Output = Matrix

The resulting type after applying the + operator.

fn add(self, other: &'a Matrix) -> Self::Output

Performs the + operation.

impl Add<Matrix> for f64

Element-wise addition between f64 & matrix

Examples

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

fn main() {
    let a = matrix!(1;4;1, 2, 2, Row);
    assert_eq!(1f64 + a, matrix!(2;5;1, 2, 2, Row));
}

type Output = Matrix

The resulting type after applying the + operator.

fn add(self, other: Matrix) -> Matrix

Performs the + operation.

impl Add<Matrix> for i32

Element-wise addition between i32 & Matrix

Examples

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

fn main() {
    let a = matrix!(1;4;1, 2, 2, Row);
    assert_eq!(1 + a, matrix!(2;5;1, 2, 2, Row));
}

type Output = Matrix

The resulting type after applying the + operator.

fn add(self, other: Matrix) -> Matrix

Performs the + operation.

impl Add<Matrix> for usize

Element-wise addition between usize & matrix

Examples

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

fn main() {
    let a = matrix!(1;4;1, 2, 2, Row);
    assert_eq!(1usize + a, matrix!(2;5;1, 2, 2, Row));
}

type Output = Matrix

The resulting type after applying the + operator.

fn add(self, other: Matrix) -> Matrix

Performs the + operation.

impl<'a, T> Add<T> for &'a Matrix

where T: Into<f64> + Copy,

Element-wise addition between &Matrix & f64

type Output = Matrix

The resulting type after applying the + operator.

fn add(self, other: T) -> Self::Output

Performs the + operation.

impl<T> Add<T> for Matrix

where T: Into<f64> + Copy,

Element-wise addition between Matrix & f64

Examples

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

fn main() {
    let a = matrix!(1;4;1, 2, 2, Row);
    assert_eq!(a + 1, matrix!(2;5;1, 2, 2, Row));
}

type Output = Matrix

The resulting type after applying the + operator.

fn add(self, other: T) -> Self

Performs the + operation.

impl Add for Matrix

Element-wise addition of Matrix

Caution

You should remember ownership. If you use Matrix a,b then you can’t use them after.

type Output = Matrix

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self

Performs the + operation.

impl Clone for Matrix

fn clone(&self) -> Matrix

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Matrix

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Matrix

fn default() -> Matrix

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Matrix

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Matrix

Pretty Print

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Div<Matrix> for f32

type Output = Matrix

The resulting type after applying the / operator.

fn div(self, m: Matrix) -> Matrix

Performs the / operation.

impl Div<Matrix> for f64

type Output = Matrix

The resulting type after applying the / operator.

fn div(self, m: Matrix) -> Matrix

Performs the / operation.

impl<'a> Div<f64> for &'a Matrix

type Output = Matrix

The resulting type after applying the / operator.

fn div(self, other: f64) -> Self::Output

Performs the / operation.

impl Div<f64> for Matrix

Element-wise division between Matrix vs f64

type Output = Matrix

The resulting type after applying the / operator.

fn div(self, other: f64) -> Self

Performs the / operation.

impl<'a> Div<i32> for &'a Matrix

type Output = Matrix

The resulting type after applying the / operator.

fn div(self, other: i32) -> Self::Output

Performs the / operation.

impl Div<i32> for Matrix

type Output = Matrix

The resulting type after applying the / operator.

fn div(self, other: i32) -> Self

Performs the / operation.

impl<'a> Div<i64> for &'a Matrix

type Output = Matrix

The resulting type after applying the / operator.

fn div(self, other: i64) -> Self::Output

Performs the / operation.

impl Div<i64> for Matrix

type Output = Matrix

The resulting type after applying the / operator.

fn div(self, other: i64) -> Self

Performs the / operation.

impl<'a> Div<usize> for &'a Matrix

type Output = Matrix

The resulting type after applying the / operator.

fn div(self, other: usize) -> Self::Output

Performs the / operation.

impl Div<usize> for Matrix

type Output = Matrix

The resulting type after applying the / operator.

fn div(self, other: usize) -> Self

Performs the / operation.

impl Div for Matrix

type Output = Matrix

The resulting type after applying the / operator.

fn div(self, m: Matrix) -> Matrix

Performs the / operation.

impl ExpLogOps for Matrix

type Float = f64

fn exp(&self) -> Self

fn ln(&self) -> Self

fn log(&self, base: Self::Float) -> Self

fn log2(&self) -> Self

fn log10(&self) -> Self

impl FPMatrix for Matrix

fn col_map<F>(&self, f: F) -> Matrix

where F: Fn(Vec<f64>) -> Vec<f64>,

Column map

Example

use peroxide::fuga::*;

let x = ml_matrix("1 2;3 4;5 6");
let y = x.col_map(|c| c.fmap(|t| t - c.mean()));

assert_eq!(y, ml_matrix("-2 -2;0 0;2 2"));

fn row_map<F>(&self, f: F) -> Matrix

where F: Fn(Vec<f64>) -> Vec<f64>,

Row map

Example

use peroxide::fuga::*;

let x = ml_matrix("1 2 3;4 5 6");
let y = x.row_map(|r| r.fmap(|t| t - r.mean()));

assert_eq!(y, ml_matrix("-1 0 1;-1 0 1"));

type Scalar = f64

fn take_row(&self, n: usize) -> Self

fn take_col(&self, n: usize) -> Self

fn skip_row(&self, n: usize) -> Self

fn skip_col(&self, n: usize) -> Self

fn fmap<F>(&self, f: F) -> Matrix

where F: Fn(f64) -> f64,

fn col_mut_map<F>(&mut self, f: F)

where F: Fn(Vec<f64>) -> Vec<f64>,

fn row_mut_map<F>(&mut self, f: F)

where F: Fn(Vec<f64>) -> Vec<f64>,

fn reduce<F, T>(&self, init: T, f: F) -> f64

where F: Fn(f64, f64) -> f64, T: Into<f64>,

fn zip_with<F>(&self, f: F, other: &Matrix) -> Self

where F: Fn(f64, f64) -> f64,

fn col_reduce<F>(&self, f: F) -> Vec<f64>

where F: Fn(Vec<f64>) -> f64,

fn row_reduce<F>(&self, f: F) -> Vec<f64>

where F: Fn(Vec<f64>) -> f64,

impl Index<(usize, usize)> for Matrix

Index for Matrix

(usize, usize) -> f64

Examples

extern crate peroxide;
use peroxide::fuga::*;

let a = matrix(vec![1,2,3,4],2,2,Row);
assert_eq!(a[(0,1)], 2f64);

type Output = f64

The returned type after indexing.

fn index(&self, pair: (usize, usize)) -> &f64

Performs the indexing (container[index]) operation.

impl IndexMut<(usize, usize)> for Matrix

IndexMut for Matrix (Assign)

(usize, usize) -> f64

Examples

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

fn main() {
    let mut a = matrix!(1;4;1, 2, 2, Row);
    a[(1,1)] = 10.0;
    assert_eq!(a, matrix(c!(1,2,3,10), 2, 2, Row));
}

fn index_mut(&mut self, pair: (usize, usize)) -> &mut f64

Performs the mutable indexing (container[index]) operation.

impl InnerProduct for Matrix

Frobenius inner product

fn dot(&self, rhs: &Self) -> f64

impl<'a> Into<&'a Vec<f64>> for &'a Matrix

&Matrix to &Vec<f64>

fn into(self) -> &'a Vec<f64>

Converts this type into the (usually inferred) input type.

impl Into<Matrix> for &Vec<f64>

fn into(self) -> Matrix

Converts this type into the (usually inferred) input type.

impl Into<Matrix> for SPMatrix

fn into(self) -> Matrix

Converts this type into the (usually inferred) input type.

impl Into<Matrix> for Vec<f64>

Vec<f64> to Matrix

fn into(self) -> Matrix

Converts this type into the (usually inferred) input type.

impl Into<SPMatrix> for Matrix

fn into(self) -> SPMatrix

Converts this type into the (usually inferred) input type.

impl Into<Vec<f64>> for Matrix

Matrix to Vec<f64>

fn into(self) -> Vec<f64>

Converts this type into the (usually inferred) input type.

impl LinearAlgebra<Matrix> for Matrix

fn back_subs(&self, b: &[f64]) -> Vec<f64>

Backward Substitution for Upper Triangular

fn forward_subs(&self, b: &[f64]) -> Vec<f64>

Forward substitution for Lower Triangular

fn lu(&self) -> PQLU<Matrix>

LU Decomposition Implements (Complete Pivot)

Description

It use complete pivoting LU decomposition. You can get two permutations, and LU matrices.

Caution

It returns Option<PQLU> - You should unwrap to obtain real value.

• PQLU has four field - p, q, l, u.
  • p, q are permutations.
  • l, u are matrices.

Examples

use peroxide::fuga::*;

let a = matrix(vec![1,2,3,4], 2, 2, Row);
let pqlu = a.lu();
let (p,q,l,u) = (pqlu.p, pqlu.q, pqlu.l, pqlu.u);
assert_eq!(p, vec![1]); // swap 0 & 1 (Row)
assert_eq!(q, vec![1]); // swap 0 & 1 (Col)
assert_eq!(l, matrix(vec![1.0,0.0,0.5,1.0],2,2,Row));
assert_eq!(u, matrix(vec![4.0,3.0,0.0,-0.5],2,2,Row));

fn qr(&self) -> QR<Matrix>

QR Decomposition

Translation of RosettaCode#Python

Example

use peroxide::fuga::*;

let a = ml_matrix("12 -51 4;6 167 -68; -4 24 -41");
let qr = a.qr();
let r = ml_matrix("-14 -21 14; 0 -175 70; 0 0 -35");
#[cfg(feature="O3")]
{
    assert_eq!(r, qr.r);
}
qr.r.print();

fn svd(&self) -> SVD<Matrix>

Singular Value Decomposition

Examples

use peroxide::fuga::*;

let a = ml_matrix("3 2 2;2 3 -2");
#[cfg(feature="O3")]
{
    let svd = a.svd();
    assert!(eq_vec(&vec![5f64, 3f64], &svd.s, 1e-7));
}
a.print();

fn cholesky(&self, uplo: UPLO) -> Matrix

Cholesky Decomposition

Examples

use peroxide::fuga::*;

let a = ml_matrix("1 2;2 5");
#[cfg(feature = "O3")]
{
    let u = a.cholesky(Upper);
    let l = a.cholesky(Lower);

    assert_eq!(u, ml_matrix("1 2;0 1"));
    assert_eq!(l, ml_matrix("1 0;2 1"));
}
a.print();

fn rref(&self) -> Matrix

Reduced Row Echelon Form

Implementation of RosettaCode

fn det(&self) -> f64

Determinant

Examples

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

fn main() {
    let a = matrix!(1;4;1, 2, 2, Row);
    assert_eq!(a.det(), -2f64);
}

fn block(&self) -> (Self, Self, Self, Self)

Block Partition

Examples

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

fn main() {
    let a = matrix!(1;16;1, 4, 4, Row);
    let (m1, m2, m3, m4) = a.block();
    assert_eq!(m1, matrix(c!(1,2,5,6), 2, 2, Row));
    assert_eq!(m2, matrix(c!(3,4,7,8), 2, 2, Row));
    assert_eq!(m3, matrix(c!(9,10,13,14), 2, 2, Row));
    assert_eq!(m4, matrix(c!(11,12,15,16), 2, 2, Row));

    let b = matrix!(1;16;1, 4, 4, Col);
    let (m1, m2, m3, m4) = b.block();
    assert_eq!(m1, matrix(c!(1,2,5,6), 2, 2, Col));
    assert_eq!(m3, matrix(c!(3,4,7,8), 2, 2, Col));
    assert_eq!(m2, matrix(c!(9,10,13,14), 2, 2, Col));
    assert_eq!(m4, matrix(c!(11,12,15,16), 2, 2, Col));
}

fn inv(&self) -> Self

Inverse of Matrix

Caution

inv function returns Option<Matrix> Thus, you should use pattern matching or unwrap to obtain inverse.

Examples

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

fn main() {
    // Non-singular
    let a = matrix!(1;4;1, 2, 2, Row);
    assert_eq!(a.inv(), matrix(c!(-2,1,1.5,-0.5),2,2,Row));

    // Singular
    //let b = matrix!(1;9;1, 3, 3, Row);
    //let c = b.inv(); // Can compile but..
    //let d = b.det();
    //assert_eq!(d, 0f64);
}

fn pseudo_inv(&self) -> Self

Moore-Penrose Pseudo inverse

Description

$X^\dagger = (X^T X)^{-1} X^T$

Examples

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

fn main() {
    let a = matrix!(1;4;1, 2, 2, Row);
    let inv_a = a.inv();
    let pse_a = a.pseudo_inv();

    assert_eq!(inv_a, pse_a); // Nearly equal
}

fn solve(&self, b: &[f64], sk: SolveKind) -> Vec<f64>

Solve with Vector

Solve options

• LU: Gaussian elimination with Complete pivoting LU (GECP)
• WAZ: Solve with WAZ decomposition

Reference

• Biswa Nath Datta, Numerical Linear Algebra and Applications, Second Edition
• Ke Chen, Matrix Preconditioning Techniques and Applications, Cambridge Monographs on Applied and Computational Mathematics

fn waz(&self, d_form: Form) -> Option<WAZD<Matrix>>

fn solve_mat(&self, m: &Matrix, sk: SolveKind) -> Matrix

fn is_symmetric(&self) -> bool

impl LinearAlgebra<Matrix> for SPMatrix

Linear algebra for sparse matrix

Caution : In every ops in this trait, there is converting process to dense matrix

fn back_subs(&self, _b: &[f64]) -> Vec<f64>

fn forward_subs(&self, _b: &[f64]) -> Vec<f64>

fn lu(&self) -> PQLU<Matrix>

fn waz(&self, _d_form: Form) -> Option<WAZD<Matrix>>

fn qr(&self) -> QR<Matrix>

fn svd(&self) -> SVD<Matrix>

fn cholesky(&self, _uplo: UPLO) -> Matrix

fn rref(&self) -> Matrix

fn det(&self) -> f64

fn block(&self) -> (Matrix, Matrix, Matrix, Matrix)

fn inv(&self) -> Matrix

fn pseudo_inv(&self) -> Matrix

fn solve(&self, _b: &[f64], _sk: SolveKind) -> Vec<f64>

fn solve_mat(&self, _m: &Matrix, _sk: SolveKind) -> Matrix

fn is_symmetric(&self) -> bool

impl LinearOp<Vec<f64>, Vec<f64>> for Matrix

Matrix as Linear operator for Vector

fn apply(&self, other: &Vec<f64>) -> Vec<f64>

impl MATLAB for Matrix

fn new(s: &str) -> Self

impl MatrixProduct for Matrix

fn kronecker(&self, other: &Self) -> Self

fn hadamard(&self, other: &Self) -> Matrix

impl MatrixPtr for Matrix

unsafe fn row_ptr(&self, idx: usize) -> Vec<*const f64>

Row pointer

Examples

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

fn main() {
    let a = ml_matrix("1 2;3 4");
    unsafe {
        let b = a.row_ptr(1);
        let b_vec = ptr_to_vec(&b);
        assert_eq!(b_vec, vec![3f64, 4f64]);
    }
}

unsafe fn col_ptr(&self, idx: usize) -> Vec<*const f64>

impl MatrixTrait for Matrix

Main matrix structure

fn ptr(&self) -> *const f64

Raw pointer for self.data

fn mut_ptr(&mut self) -> *mut f64

Raw mutable pointer for self.data

fn as_slice(&self) -> &[f64]

Slice of self.data

Examples

use peroxide::fuga::*;

let a = matrix(vec![1,2,3,4], 2, 2, Col);
let b = a.as_slice();
assert_eq!(b, &[1f64,2f64,3f64,4f64]);

fn as_mut_slice(&mut self) -> &mut [f64]

Mutable slice of self.data

Examples

use peroxide::fuga::*;

let mut a = matrix(vec![1,2,3,4], 2, 2, Col);
let mut b = a.as_mut_slice();
b[0] = 5f64;
assert_eq!(b, &[5f64, 2f64, 3f64, 4f64]);
assert_eq!(a, matrix(vec![5,2,3,4], 2, 2, Col));

fn change_shape(&self) -> Self

Change Bindings

Row -> Col or Col -> Row

Examples

use peroxide::fuga::*;

let a = matrix(vec![1,2,3,4],2,2,Row);
assert_eq!(a.shape, Row);
let b = a.change_shape();
assert_eq!(b.shape, Col);

fn change_shape_mut(&mut self)

Change Bindings Mutably

Row -> Col or Col -> Row

Examples

use peroxide::fuga::*;

let a = matrix(vec![1,2,3,4],2,2,Row);
assert_eq!(a.shape, Row);
let b = a.change_shape();
assert_eq!(b.shape, Col);

fn spread(&self) -> String

Spread data(1D vector) to 2D formatted String

Examples

use peroxide::fuga::*;

let a = matrix(vec![1,2,3,4],2,2,Row);
println!("{}", a.spread()); // same as println!("{}", a);
// Result:
//       c[0] c[1]
// r[0]     1    3
// r[1]     2    4

fn col(&self, index: usize) -> Vec<f64>

Extract Column

Examples

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

fn main() {
    let a = matrix(c!(1,2,3,4), 2, 2, Row);
    assert_eq!(a.col(0), c!(1,3));
}

fn row(&self, index: usize) -> Vec<f64>

Extract Row

Examples

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

fn main() {
    let a = matrix(c!(1,2,3,4), 2, 2, Row);
    assert_eq!(a.row(0), c!(1,2));
}

fn diag(&self) -> Vec<f64>

Extract diagonal components

Examples

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

fn main() {
    let a = matrix!(1;4;1, 2, 2, Row);
    assert_eq!(a.diag(), c!(1,4));
}

fn transpose(&self) -> Self

Transpose

Examples

use peroxide::fuga::*;

let a = matrix(vec![1,2,3,4], 2, 2, Row);
println!("{}", a); // [[1,3],[2,4]]

fn t(&self) -> Self

R-like transpose function

Examples

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

fn main() {
    let a = matrix!(1;4;1, 2, 2, Row);
    assert_eq!(a.transpose(), a.t());
}

fn subs_col(&mut self, idx: usize, v: &[f64])

Substitute Col

fn subs_row(&mut self, idx: usize, v: &[f64])

Substitute Row

fn from_index<F, G>(f: F, size: (usize, usize)) -> Matrix

where F: Fn(usize, usize) -> G + Copy, G: Into<f64>,

From index operations

fn to_vec(&self) -> Vec<Vec<f64>>

Matrix to Vec<Vec<f64>>

To send Matrix to inline-python

fn submat(&self, start: (usize, usize), end: (usize, usize)) -> Matrix

Submatrix

Description

Return below elements of matrix to new matrix

$$ \begin{pmatrix} \ddots & & & & \\ & start & \cdots & end.1 & \\ & \vdots & \ddots & \vdots & \\ & end.0 & \cdots & end & \\ & & & & \ddots \end{pmatrix} $$

Examples

extern crate peroxide;
use peroxide::fuga::*;

fn main() {
    let a = ml_matrix("1 2 3;4 5 6;7 8 9");
    let b = ml_matrix("5 6;8 9");
    let c = a.submat((1, 1), (2, 2));
    assert_eq!(b, c);   
}

fn subs_mat(&mut self, start: (usize, usize), end: (usize, usize), m: &Matrix)

Substitute matrix to specific position

Description

Substitute below elements of matrix

$$ \begin{pmatrix} \ddots & & & & \\ & start & \cdots & end.1 & \\ & \vdots & \ddots & \vdots & \\ & end.0 & \cdots & end & \\ & & & & \ddots \end{pmatrix} $$

Examples

extern crate peroxide;
use peroxide::fuga::*;

fn main() {
    let mut a = ml_matrix("1 2 3;4 5 6;7 8 9");
    let b = ml_matrix("1 2;3 4");
    let c = ml_matrix("1 2 3;4 1 2;7 3 4");
    a.subs_mat((1,1), (2,2), &b);
    assert_eq!(a, c);       
}

type Scalar = f64

fn to_diag(&self) -> Matrix

impl<'a, 'b> Mul<&'b Matrix> for &'a Matrix

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, other: &'b Matrix) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'b Matrix> for &'a Vec<f64>

type Output = Vec<f64>

The resulting type after applying the * operator.

fn mul(self, other: &'b Matrix) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Matrix> for f64

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, other: &'a Matrix) -> Matrix

Performs the * operation.

impl<'a> Mul<&'a Matrix> for i32

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, other: &'a Matrix) -> Matrix

Performs the * operation.

impl<'a> Mul<&'a Matrix> for i64

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, other: &'a Matrix) -> Matrix

Performs the * operation.

impl<'a> Mul<&'a Matrix> for usize

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, other: &'a Matrix) -> Matrix

Performs the * operation.

impl<'a, 'b> Mul<&'b Vec<f64>> for &'a Matrix

type Output = Vec<f64>

The resulting type after applying the * operator.

fn mul(self, other: &'b Vec<f64>) -> Self::Output

Performs the * operation.

impl Mul<Matrix> for Vec<f64>

Matrix multiplication for Vec<f64> vs Matrix

Examples

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

fn main() {
    let a = matrix!(1;4;1, 2, 2, Row);
    let v = c!(1,2);
    assert_eq!(v * a, c!(7, 10));
}

type Output = Vec<f64>

The resulting type after applying the * operator.

fn mul(self, other: Matrix) -> Self::Output

Performs the * operation.

impl Mul<Matrix> for f64

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, other: Matrix) -> Matrix

Performs the * operation.

impl Mul<Matrix> for i32

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, other: Matrix) -> Matrix

Performs the * operation.

impl Mul<Matrix> for i64

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, other: Matrix) -> Matrix

Performs the * operation.

impl Mul<Matrix> for usize

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, other: Matrix) -> Matrix

Performs the * operation.

impl Mul<Redox<Vec<f64>>> for &Matrix

type Output = Redox<Vec<f64>>

The resulting type after applying the * operator.

fn mul(self, rhs: Redox<Vec<f64>>) -> Self::Output

Performs the * operation.

impl Mul<Redox<Vec<f64>>> for Matrix

type Output = Redox<Vec<f64>>

The resulting type after applying the * operator.

fn mul(self, rhs: Redox<Vec<f64>>) -> Self::Output

Performs the * operation.

impl Mul<Vec<f64>> for Matrix

type Output = Vec<f64>

The resulting type after applying the * operator.

fn mul(self, other: Vec<f64>) -> Self::Output

Performs the * operation.

impl Mul<f64> for Matrix

Element-wise multiplication between Matrix vs f64

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, other: f64) -> Self

Performs the * operation.

impl Mul<i32> for Matrix

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, other: i32) -> Self

Performs the * operation.

impl Mul<i64> for Matrix

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, other: i64) -> Self

Performs the * operation.

impl Mul<usize> for Matrix

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, other: usize) -> Self

Performs the * operation.

impl Mul for Matrix

Matrix Multiplication

Examples

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

fn main() {
    let a = matrix!(1;4;1, 2, 2, Row);
    let b = matrix!(1;4;1, 2, 2, Col);
    assert_eq!(a * b, matrix(c!(5, 11, 11, 25), 2, 2, Row));
}

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self

Performs the * operation.

impl MutMatrix for Matrix

type Scalar = f64

unsafe fn col_mut(&mut self, idx: usize) -> Vec<*mut f64>

unsafe fn row_mut(&mut self, idx: usize) -> Vec<*mut f64>

unsafe fn swap(&mut self, idx1: usize, idx2: usize, shape: Shape)

unsafe fn swap_with_perm(&mut self, p: &Vec<(usize, usize)>, shape: Shape)

impl<'a> Neg for &'a Matrix

Negation of &’a Matrix

type Output = Matrix

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Matrix

Negation of Matrix

Examples

extern crate peroxide;
use peroxide::fuga::*;

let a = matrix(vec![1,2,3,4],2,2,Row);
println!("{}", -a); // [[-1,-2],[-3,-4]]

type Output = Matrix

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl Normed for Matrix

fn norm(&self, kind: Norm) -> f64

Norm of Matrix

Example

use peroxide::fuga::*;

let a = ml_matrix("1 2;3 4");
assert_eq!(a.norm(Norm::F), (1f64 + 4f64 + 9f64 + 16f64).sqrt());

type UnsignedScalar = f64

fn normalize(&self, _kind: Norm) -> Self

where Self: Sized,

impl PYTHON for Matrix

fn new<T>(v: Vec<Vec<T>>) -> Self

where T: Into<f64> + Copy,

impl ParallelInnerProduct for Matrix

Frobenius inner product in parallel

fn par_dot(&self, rhs: &Self) -> f64

impl ParallelNormed for Matrix

fn par_norm(&self, kind: Norm) -> f64

Parallel version of norm

Example

use peroxide::fuga::*;

let a = ml_matrix("1 2;3 4");
assert_eq!(a.par_norm(Norm::F), (1f64 + 4f64 + 9f64 + 16f64).sqrt());

type UnsignedScalar = f64

impl PartialEq for Matrix

PartialEq implements

fn eq(&self, other: &Matrix) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PowOps for Matrix

type Float = f64

fn powi(&self, n: i32) -> Self

fn powf(&self, f: Self::Float) -> Self

fn pow(&self, _f: Self) -> Self

fn sqrt(&self) -> Self

impl Printable for Matrix

fn print(&self)

impl R for Matrix

fn new<T>(v: Vec<T>, x: usize, y: usize, shape: Shape) -> Self

where T: Into<f64>,

impl Scalable for Matrix

Modify Matrix

fn reshape(&self, (r, c): (usize, usize), shape: Shape) -> Matrix

Resize matrix

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

fn main() {
    let a = ml_matrix("1 2 3;4 5 6"); // ml_matrix has shape `Col`
    let b1 = a.reshape((3, 2), Row);
    let b2 = a.reshape((3, 2), Col);
    assert_eq!(b1, ml_matrix("1 2;3 4;5 6"));
    assert_eq!(b2, ml_matrix("1 4;2 5;3 6"));
}

fn add_col(&self, v: &Self::Vec) -> Matrix

Add column

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

fn main() {
    let a = ml_matrix("1 2 3;4 5 6");
    let b = c!(7,8);
    let c = a.add_col(&b);
    assert_eq!(c, ml_matrix("1 2 3 7;4 5 6 8"));
}

fn add_row(&self, v: &Self::Vec) -> Matrix

Add row

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

fn main() {
    let a = ml_matrix("1 2 3;4 5 6");
    let b = c!(7,8,9);
    let c = a.add_row(&b);
    assert_eq!(c, ml_matrix("1 2 3;4 5 6;7 8 9"));
}

type Vec = Vec<f64>

impl ScalableMut for Matrix

fn reshape_mut(&mut self, (r, c): (usize, usize), shape: Shape)

Resize matrix (Mutable)

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

fn main() {
    let mut a = ml_matrix("1 2 3;4 5 6"); // ml_matrix has shape `Row`
    a.reshape_mut((3, 2), Row);
    assert_eq!(a, ml_matrix("1 2;3 4;5 6"));
    a.reshape_mut((3, 2), Col);
    assert_eq!(a, ml_matrix("1 4;2 5;3 6"));
}

fn add_col_mut(&mut self, v: &Self::Vec)

Add column (Mutable)

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

fn main() {
    let mut a = ml_matrix("1 2 3;4 5 6");
    let b = c!(7,8);
    a.add_col_mut(&b);
    assert_eq!(a, ml_matrix("1 2 3 7;4 5 6 8"));
}

fn add_row_mut(&mut self, v: &Self::Vec)

Add row (Mutable)

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

fn main() {
    let mut a = ml_matrix("1 2 3;4 5 6");
    let b = c!(7,8,9);
    a.add_row_mut(&b);
    assert_eq!(a, ml_matrix("1 2 3;4 5 6;7 8 9"));
}

type Vec = Vec<f64>

impl Serialize for Matrix

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SimpleNorm for Matrix

Simple Frobenius norm

fn norm(&self) -> Self::Scalar

fn normalize(&self) -> Self

impl SimplerLinearAlgebra<Matrix> for Matrix

fn back_subs(&self, b: &[f64]) -> Vec<f64>

fn forward_subs(&self, b: &[f64]) -> Vec<f64>

fn lu(&self) -> PQLU<Matrix>

fn waz_diag(&self) -> Option<WAZD<Matrix>>

fn waz(&self) -> Option<WAZD<Matrix>>

fn qr(&self) -> QR<Matrix>

fn cholesky(&self) -> Matrix

fn rref(&self) -> Matrix

fn det(&self) -> f64

fn block(&self) -> (Matrix, Matrix, Matrix, Matrix)

fn inv(&self) -> Matrix

fn pseudo_inv(&self) -> Matrix

fn solve(&self, b: &[f64]) -> Vec<f64>

fn solve_mat(&self, m: &Matrix) -> Matrix

fn is_symmetric(&self) -> bool

impl Statistics for Matrix

fn mean(&self) -> Vec<f64>

Column Mean

Examples

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

fn main() {
    let m = matrix(c!(1,3,3,1), 2, 2, Col);
    assert_eq!(m.mean(), c!(2,2));
}

fn var(&self) -> Vec<f64>

Column variance

Examples

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

fn main() {
    let m = matrix(c!(1,2,3,3,2,1), 3, 2, Col);
    assert!(nearly_eq(m.var()[0], 1));
}

fn sd(&self) -> Vec<f64>

Column Standard Deviation

Examples

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

fn main() {
    let m = matrix(c!(1,2,3,3,2,1), 3, 2, Col);
    assert!(nearly_eq(m.sd()[0], 1));
}

fn cov(&self) -> Self

Covariance Matrix (Column based)

Examples

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

fn main() {
    let m = matrix(c!(1,2,3,3,2,1), 3, 2, Col);
    println!("{}", m.cov());

    //         c[0]    c[1]
    // r[0]  1.0000 -1.0000
    // r[1] -1.0000  1.0000
}

type Array = Matrix

type Value = Vec<f64>

fn cor(&self) -> Self

impl<'a, 'b> Sub<&'b Matrix> for &'a Matrix

type Output = Matrix

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Matrix) -> Matrix

Performs the - operation.

impl<'a> Sub<&'a Matrix> for f64

type Output = Matrix

The resulting type after applying the - operator.

fn sub(self, other: &'a Matrix) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Matrix> for i32

type Output = Matrix

The resulting type after applying the - operator.

fn sub(self, other: &'a Matrix) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Matrix> for usize

type Output = Matrix

The resulting type after applying the - operator.

fn sub(self, other: &'a Matrix) -> Self::Output

Performs the - operation.

impl Sub<Matrix> for f64

Subtraction Matrix with f64

Examples

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

fn main() {
    let a = matrix(vec![1,2,3,4],2,2,Row);
    assert_eq!(a - 1f64, matrix!(0;3;1, 2, 2, Row));
}

type Output = Matrix

The resulting type after applying the - operator.

fn sub(self, other: Matrix) -> Matrix

Performs the - operation.

impl Sub<Matrix> for i32

type Output = Matrix

The resulting type after applying the - operator.

fn sub(self, other: Matrix) -> Matrix

Performs the - operation.

impl Sub<Matrix> for usize

type Output = Matrix

The resulting type after applying the - operator.

fn sub(self, other: Matrix) -> Matrix

Performs the - operation.

impl<'a, T> Sub<T> for &'a Matrix

where T: Into<f64> + Copy,

Subtraction between &Matrix & f64

type Output = Matrix

The resulting type after applying the - operator.

fn sub(self, other: T) -> Self::Output

Performs the - operation.

impl<T> Sub<T> for Matrix

where T: Into<f64> + Copy,

Subtraction between Matrix & f64

type Output = Matrix

The resulting type after applying the - operator.

fn sub(self, other: T) -> Self

Performs the - operation.

impl Sub for Matrix

Subtraction between Matrix

Examples

extern crate peroxide;
use peroxide::fuga::*;

let a = matrix(vec![1,2,3,4],2,2,Row);
let b = matrix(vec![1,2,3,4],2,2,Col);
println!("{}", a - b); // [[0, -1], [1, 0]]

type Output = Matrix

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self

Performs the - operation.

impl TrigOps for Matrix

fn sin_cos(&self) -> (Self, Self)

fn sin(&self) -> Self

fn cos(&self) -> Self

fn tan(&self) -> Self

fn sinh(&self) -> Self

fn cosh(&self) -> Self

fn tanh(&self) -> Self

fn asin(&self) -> Self

fn acos(&self) -> Self

fn atan(&self) -> Self

fn asinh(&self) -> Self

fn acosh(&self) -> Self

fn atanh(&self) -> Self

fn asin_acos(&self) -> (Self, Self)

fn asinh_acosh(&self) -> (Self, Self)

impl Vector for Matrix

type Scalar = f64

fn add_vec(&self, other: &Self) -> Self

fn sub_vec(&self, other: &Self) -> Self

fn mul_scalar(&self, other: Self::Scalar) -> Self

impl Numeric<f64> for Matrix