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

Main matrix structure

pub fn ptr(&self) -> *const f64

Raw pointer for self.data

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

Raw mutable pointer for self.data

pub fn as_slice<'a>(&'a self) -> &'a [f64]

Slice of self.data

Examples

extern crate peroxide;
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]);

pub fn as_mut_slice<'a>(&'a mut self) -> &'a mut [f64]

Mutable slice of self.data

Examples

extern crate peroxide;
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));

pub fn change_shape(&self) -> Self

Change Bindings

Row -> Col or Col -> Row

Examples

extern crate peroxide;
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);

pub fn change_shape_mut(&mut self)

Change Bindings Mutably

Row -> Col or Col -> Row

Examples

extern crate peroxide;
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);

pub fn spread(&self) -> String

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

Examples

extern crate peroxide;
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

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

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

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

pub fn transpose(&self) -> Self

Transpose

Examples

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

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

pub 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());
}

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

Should check shape

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

pub fn to_diag(&self) -> Matrix

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

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

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

Pretty Print

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

Formats the value using the given formatter.

impl Div<f64> for Matrix

Element-wise division between Matrix vs f64

type Output = Self

The resulting type after applying the / operator.

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

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

type Output = Self

The resulting type after applying the / operator.

fn div(self, other: i32) -> 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<i64> for Matrix

type Output = Self

The resulting type after applying the / operator.

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

type Output = Self

The resulting type after applying the / operator.

fn div(self, other: usize) -> 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 FPMatrix for Matrix

fn col_map<F>(&self, f: F) -> Matrix where
    F: Fn(Vec<f64>) -> Vec<f64>, 

Column map

Example

use peroxide::fuga::*;

fn main() {
    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::*;

fn main() {
    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"));
}

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, Global>> for &'a Matrix

&Matrix to &Vec

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

Performs the conversion.

impl Into<Matrix> for SPMatrix

fn into(self) -> Matrix

Performs the conversion.

impl Into<SPMatrix> for Matrix

fn into(self) -> SPMatrix

Performs the conversion.

impl Into<Vec<f64, Global>> for Matrix

Matrix to Vec

fn into(self) -> Vec<f64>

Performs the conversion.

impl LinearAlgebra for Matrix

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

Backward Substitution for Upper Triangular

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

Forward substitution for Lower Triangular

fn lu(&self) -> PQLU

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

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

fn main() {
    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(c!(1,0,0.5,1),2,2,Row));
    assert_eq!(u, matrix(c!(4,3,0,-0.5),2,2,Row));
}

fn qr(&self) -> QR

QR Decomposition

Translation of RosettaCode#Python

Example

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

fn main() {
    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

Singular Value Decomposition

Examples

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

fn main() {
    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 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: &Vec<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>

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

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

TODO: Transpose 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<'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 Vec<f64, Global>> 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 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 = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Redox<Vec<f64, Global>>> 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, Global>>> 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, Global>> 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 = Self

The resulting type after applying the * operator.

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

type Output = Self

The resulting type after applying the * operator.

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

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

type UnsignedScalar = f64

fn norm(&self, kind: Norm) -> 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 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 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 resize(&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.resize((3, 2), Row);
    let b2 = a.resize((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_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"));
}

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

type Vec = Vec<f64>

impl ScalableMut for Matrix

fn resize_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.resize_mut((3, 2), Row);
    assert_eq!(a, ml_matrix("1 2;3 4;5 6"));
    a.resize_mut((3, 2), Col);
    assert_eq!(a, ml_matrix("1 4;2 5;3 6"));
}

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

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

type Vec = Vec<f64>

impl SimpleNorm for Matrix

Simple Frobenius norm

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

fn normalize(&self) -> Self

impl SimplerLinearAlgebra for Matrix

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

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

fn lu(&self) -> PQLU

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

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

fn qr(&self) -> QR

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: &Vec<f64>) -> Vec<f64>

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

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

The resulting type after applying the - operator.

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

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