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

extern crate peroxide;
use peroxide::*;

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

Methods

impl Matrix

Main matrix structure

pub fn change_shape(&self) -> Self

Change Bindings

Row -> Col or Col -> Row

Examples

extern crate peroxide;
use peroxide::*;

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);

pub fn spread(&self) -> String

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

Examples

extern crate peroxide;
use peroxide::*;

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

pub fn col(&self, index: usize) -> Vector

Extract Column

Examples

extern crate peroxide;
use peroxide::*;

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

pub fn row(&self, index: usize) -> Vector

Extract Row

Examples

extern crate peroxide;
use peroxide::*;

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

pub fn diag(&self) -> Vector

Extract diagonal components

Examples

extern crate peroxide;
use peroxide::*;

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

pub fn swap(&self, idx1: usize, idx2: usize, shape: Shape) -> Self

Swap row or col

Examples

extern crate peroxide;
use peroxide::*;

let a = matrix!(1;4;1, 2, 2, Row);
assert_eq!(a.swap(0,1,Row), matrix(c!(3,4,1,2),2,2,Row));
assert_eq!(a.swap(0,1,Col), matrix(c!(2,4,1,3),2,2,Col));

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

Write to CSV

Examples

extern crate peroxide;
use peroxide::*;

let a = matrix(c!(1,2,3,3,2,1), 3, 2, Col);
a.write("test.csv");

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

Write to CSV (with round option)

Examples

extern crate peroxide;
use peroxide::*;

let a = matrix(c!(1,2,3,3,2,1), 3, 2, Col);
a.write_round("test.csv", 0);

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

extern crate peroxide;
use peroxide::*;
use std::process;

let a = matrix(c!(1,2,3,3,2,1), 3, 2, Col);
a.write_round("test.csv", 0);

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

pub fn subs_col(&mut self, idx: usize, v: Vec<f64>)

Substitute Col

pub fn subs_row(&mut self, idx: usize, v: Vec<f64>)

Substitute Row

pub fn from_index<F, G>(f: F, size: (usize, usize)) -> Matrix where
    F: Fn(usize, usize) -> G + Copy,
    G: Into<f64>, 

From index operations

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

Matrix to Vec<Vec<f64>>

To send Matrix to inline-python

Trait Implementations

impl Statistics for Matrix

type Array = Matrix

type Value = Vector

fn mean(&self) -> Vector

Column Mean

Examples

extern crate peroxide;
use peroxide::*;

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

fn var(&self) -> Vector

Column variance

Examples

extern crate peroxide;
use peroxide::*;

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

fn sd(&self) -> Vector

Column Standard Deviation

Examples

extern crate peroxide;
use peroxide::*;

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

extern crate peroxide;
use peroxide::*;

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

fn cor(&self) -> Self

impl LinearOps for Matrix

fn to_matrix(&self) -> Self

Just clone

fn transpose(&self) -> Self

Transpose

Examples

extern crate peroxide;
use peroxide::*;

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

extern crate peroxide;
use peroxide::*;

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

impl FP for Matrix

fn take(&self, n: usize, shape: Shape) -> Self

fn skip(&self, n: usize, shape: Shape) -> Self

fn fmap<F>(&self, f: F) -> Matrix where
    F: Fn(f64) -> 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, 

impl LinearAlgebra for Matrix

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

Matrix norm

Kinds

• Frobenius : Frobenius norm
• PQ(usize, usize) : L_pq norm
• One : 1-norm
• Infinity : Infinity norm

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

LU Decomposition Implements

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

extern crate peroxide;
use peroxide::*;

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

fn det(&self) -> f64

Determinant

Examples

extern crate peroxide;
use peroxide::*;

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

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

Block Partition

Examples

extern crate peroxide;
use peroxide::*;

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) -> Option<Self>

Inverse of Matrix

Caution

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

Examples

extern crate peroxide;
use peroxide::*;

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

// Singular
let b = matrix!(1;9;1, 3, 3, Row);
assert_eq!(b.inv(), None);

fn pseudo_inv(&self) -> Option<Self>

Moore-Penrose Pseudo inverse

Description

(X^T X)^{-1} X

Examples

extern crate peroxide;
use peroxide::*;

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

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

impl MATLAB for Matrix

fn new(s: &str) -> Self

impl PYTHON for Matrix

fn new<T>(v: Vec<Vec<T>>) -> Self where
    T: Into<f64> + Copy, 

impl R for Matrix

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

impl Pickle for Matrix

fn write_single_pickle(&self, path: &str) -> Result<()>

fn write_pickle<W: Write>(&self, writer: &mut W) -> Result<()>

impl Printable for Matrix

fn print(&self)

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 PartialEq<Matrix> for Matrix

PartialEq implements

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Display for Matrix

Pretty Print

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

Formats the value using the given formatter.

impl Debug for Matrix

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

Formats the value using the given formatter.

impl Add<Matrix> 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 = Self

The resulting type after applying the + operator.

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

Performs the + operation.

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

Element-wise addition of &Matrix

type Output = Matrix

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add<T> for Matrix where
    T: Into<f64> + Copy, 

Element-wise addition between Matrix & f64

Examples

extern crate peroxide;
use peroxide::*;

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

type Output = Self

The resulting type after applying the + operator.

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

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 Add<Matrix> for f64

Element-wise addition between f64 & matrix

Examples

extern crate peroxide;
use peroxide::*;

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<'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 Add<Matrix> for i32

Element-wise addition between i32 & Matrix

Examples

extern crate peroxide;
use peroxide::*;

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<'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 Add<Matrix> for usize

Element-wise addition between usize & matrix

Examples

extern crate peroxide;
use peroxide::*;

let a = matrix!(1;4;1, 2, 2, Row);
assert_eq!(1 as usize + 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> 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 Sub<Matrix> for Matrix

Subtraction between Matrix

Examples

extern crate peroxide;
use peroxide::*;

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 = Self

The resulting type after applying the - operator.

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

Performs the - operation.

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

Subtraction between &'a Matrix

type Output = Matrix

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub<T> for Matrix where
    T: Into<f64> + Copy, 

Subtraction between Matrix & f64

type Output = Self

The resulting type after applying the - operator.

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

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 Sub<Matrix> for f64

Subtraction Matrix with f64

Examples

extern crate peroxide;
use peroxide::*;

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<'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 Sub<Matrix> for i32

type Output = Matrix

The resulting type after applying the - operator.

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

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 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> 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 Mul<f64> for Matrix

Element-wise multiplication between Matrix vs f64

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i64> for Matrix

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i32> for Matrix

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<usize> for Matrix

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Matrix

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Matrix

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Matrix

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, other: usize) -> 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 i64

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 usize

type Output = Matrix

The resulting type after applying the * operator.

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

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 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 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 usize

type Output = Matrix

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<T> for Matrix where
    T: LinearOps, 

Matrix Multiplication

Examples

extern crate peroxide;
use peroxide::*;

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));

let m = matrix!(1;4;1, 2, 2, Row);
let v = c!(1,2);
assert_eq!(m * v, matrix(c!(5,11),2,1,Col));

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T> Mul<&'b T> for &'a Matrix where
    T: LinearOps, 

type Output = Matrix

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix> for Vector

Matrix multiplication for Vector vs Matrix

Examples

extern crate peroxide;
use peroxide::*;

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

type Output = Matrix

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Matrix

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for Matrix

Negation of Matrix

Examples

extern crate peroxide;
use peroxide::*;

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

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

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 Index<(usize, usize)> for Matrix

Index for Matrix

(usize, usize) -> f64

Examples

extern crate peroxide;
use peroxide::*;

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

extern crate peroxide;
use peroxide::*;

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.