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 write(&self, file_path: &str) -> Result<(), Box<dyn Error>>

Write to CSV

Examples

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

fn main() {
    let a = matrix(c!(1,2,3,3,2,1), 3, 2, Col);
    a.write("example_data/test.csv");
}

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() {
    let a = matrix(c!(1,2,3,3,2,1), 3, 2, Col);
    a.write_round("example_data/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

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

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

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.

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

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

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

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

Performs the + operation.

impl Clone for Matrix

pub fn clone(&self) -> Matrix

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Matrix

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

Formats the value using the given formatter.

impl Default for Matrix

pub fn default() -> Matrix

Returns the "default value" for a type.

impl Display for Matrix

Pretty Print

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

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

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

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

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

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

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

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

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

Performs the / operation.

impl Environment for Matrix

impl FPMatrix for Matrix

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

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

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

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

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

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

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

pub fn col_mut_map<F>(&mut self, f: F) where
    F: Fn(Vec<f64>) -> Vec<f64>, 

pub fn row_mut_map<F>(&mut self, f: F) where
    F: Fn(Vec<f64>) -> Vec<f64>, 

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

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

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

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

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

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

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

impl InnerProduct for Matrix

Frobenius inner product

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

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

&Matrix to &Vec

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

Performs the conversion.

impl Into<Matrix> for SPMatrix

pub fn into(self) -> Matrix

Performs the conversion.

impl Into<SPMatrix> for Matrix

pub fn into(self) -> SPMatrix

Performs the conversion.

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

Matrix to Vec

pub fn into(self) -> Vec<f64>

Performs the conversion.

impl LinearAlgebra for Matrix

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

Backward Substitution for Upper Triangular

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

Forward substitution for Lower Triangular

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

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

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

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

pub fn rref(&self) -> Matrix

Reduced Row Echelon Form

Implementation of RosettaCode

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

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

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

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

pub 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

pub 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

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

impl MATLAB for Matrix

pub fn new(s: &str) -> Self

impl MatrixProduct for Matrix

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

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

impl MatrixPtr for Matrix

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

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

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

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

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

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

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

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

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

Performs the * operation.

impl Mul<i32> for Matrix

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i64> for Matrix

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<usize> for Matrix

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl MutMatrix for Matrix

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

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

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

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

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

pub fn neg(self) -> Self::Output

Performs the unary - operation.

impl Normed for Matrix

type Scalar = f64

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

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

impl PYTHON for Matrix

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

impl PartialEq<Matrix> for Matrix

PartialEq implements

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

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

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

This method tests for !=.

impl Printable for Matrix

pub fn print(&self)

impl R for Matrix

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

impl Scalable for Matrix

Modify Matrix

type Vec = Vec<f64>

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

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

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

impl ScalableMut for Matrix

type Vec = Vec<f64>

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

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

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

impl SimpleNorm for Matrix

Simple Frobenius norm

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

pub fn normalize(&self) -> Self

impl SimplerLinearAlgebra for Matrix

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

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

pub fn lu(&self) -> PQLU

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

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

pub fn qr(&self) -> QR

pub fn rref(&self) -> Matrix

pub fn det(&self) -> f64

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

pub fn inv(&self) -> Matrix

pub fn pseudo_inv(&self) -> Matrix

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

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

impl Statistics for Matrix

type Array = Matrix

type Value = Vec<f64>

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

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

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

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

pub fn cor(&self) -> Self

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

type Output = Matrix

The resulting type after applying the - operator.

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

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

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

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

Performs the - operation.

impl Vector for Matrix

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

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

pub fn mul_scalar<T: Into<f64>>(&self, other: T) -> Self