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

Implementations

impl Matrix

Main matrix structure

pub fn change_shape(&self) -> Matrix

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

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

Trait Implementations

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

The resulting type after applying the + operator.

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

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

Element-wise addition between f64 & 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 Add<Matrix> for usize

Element-wise addition between f64 & 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<T> Add<T> for Matrixwhere
    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 = Matrix

The resulting type after applying the + operator.

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

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<T> CreateMatrix<T> for Matrixwhere
    T: Into<f64>,

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

Matrix generic constructor

You can use any numeric type vector e.g. u32, i32, i64, …

Examples

extern crate peroxide;
use peroxide::*;

let a = Matrix::new(
    vec![1,2,3,4], // Can use any Into<f64> type
    2,
    2,
    Row,
);

impl Debug for Matrix

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

Formats the value using the given formatter.

impl Display for Matrix

Pretty Print

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

Formats the value using the given formatter.

impl FP for Matrix

fn fmap<F>(&self, f: F) -> Matrixwhere
    F: Fn(f64) -> f64,

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

fn zip_with<F>(&self, f: F, other: &Matrix) -> Matrixwhere
    F: Fn(f64, f64) -> f64,

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<'a>(&'a mut self, pair: (usize, usize)) -> &'a mut f64

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

impl LinearAlgebra for Matrix

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

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

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

impl LinearOps for Matrix

fn to_matrix(&self) -> Matrix

Just clone

fn transpose(&self) -> Matrix

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

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

Element-wise matrix multiplication

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); // [[1,6],[6,16]]

type Output = Matrix

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<T> for Matrixwhere
    T: Into<f64> + Copy,

type Output = Matrix

The resulting type after applying the * operator.

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

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

The resulting type after applying the - operator.

fn neg(self) -> Matrix

Performs the unary - operation.

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

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

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

impl Printable for Matrix

fn print(&self)

impl Rem<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 rem(self, other: Matrix) -> Matrix

Performs the % operation.

impl<T> Rem<T> for Matrixwhere
    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 = Matrix

The resulting type after applying the % operator.

fn rem(self, other: T) -> Matrix

Performs the % operation.

impl Statistics for Matrix

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

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

type Array = Matrix

type Value = Vec<f64, Global>

fn cor(&self) -> Matrix

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

The resulting type after applying the - operator.

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

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 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<T> Sub<T> for Matrixwhere
    T: Into<f64> + Copy,

type Output = Matrix

The resulting type after applying the - operator.

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

Performs the - operation.