pub struct Matrix {
pub data: Vec<f64>,
pub row: usize,
pub col: usize,
pub shape: Shape,
}
Expand description
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§
source§impl Matrix
impl Matrix
Main matrix structure
sourcepub fn as_slice<'a>(&'a self) -> &'a [f64]
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]);
sourcepub fn as_mut_slice<'a>(&'a mut self) -> &'a mut [f64]
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));
sourcepub fn change_shape(&self) -> Self
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);
sourcepub fn change_shape_mut(&mut self)
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);
sourcepub fn spread(&self) -> String
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
sourcepub fn col(&self, index: usize) -> Vec<f64>
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));
}
sourcepub fn row(&self, index: usize) -> Vec<f64>
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));
}
sourcepub fn diag(&self) -> Vec<f64>
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));
}
sourcepub fn transpose(&self) -> Self
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]]
sourcepub fn t(&self) -> Self
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());
}
sourcepub fn from_index<F, G>(f: F, size: (usize, usize)) -> Matrix
pub fn from_index<F, G>(f: F, size: (usize, usize)) -> Matrix
From index operations
pub fn to_diag(&self) -> Matrix
sourcepub fn submat(&self, start: (usize, usize), end: (usize, usize)) -> 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);
}
sourcepub fn subs_mat(
&mut self,
start: (usize, usize),
end: (usize, usize),
m: &Matrix
)
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);
}
sourcepub fn from_series(
series: &Series,
row: usize,
col: usize,
shape: Shape
) -> Self
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§
source§impl Add<Matrix> for f64
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));
}
source§impl Add<Matrix> for i32
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));
}
source§impl Add<Matrix> for usize
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!(1 as usize + a, matrix!(2;5;1, 2, 2, Row));
}
source§impl<T> Add<T> for Matrix
impl<T> Add<T> for Matrix
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));
}
source§impl Add for Matrix
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.
source§impl FPMatrix for Matrix
impl FPMatrix for Matrix
source§fn col_map<F>(&self, f: F) -> Matrix
fn col_map<F>(&self, f: F) -> Matrix
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"));
}
source§fn row_map<F>(&self, f: F) -> Matrix
fn row_map<F>(&self, f: F) -> Matrix
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
fn col_mut_map<F>(&mut self, f: F)
fn row_mut_map<F>(&mut self, f: F)
fn reduce<F, T>(&self, init: T, f: F) -> f64
fn zip_with<F>(&self, f: F, other: &Matrix) -> Self
fn col_reduce<F>(&self, f: F) -> Vec<f64>
fn row_reduce<F>(&self, f: F) -> Vec<f64>
source§impl Index<(usize, usize)> for Matrix
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);
source§impl IndexMut<(usize, usize)> for Matrix
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));
}
source§impl LinearAlgebra for Matrix
impl LinearAlgebra for Matrix
source§fn lu(&self) -> PQLU
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));
}
source§fn qr(&self) -> QR
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();
}
source§fn svd(&self) -> SVD
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();
}
source§fn rref(&self) -> Matrix
fn rref(&self) -> Matrix
Reduced Row Echelon Form
Implementation of RosettaCode
source§fn det(&self) -> f64
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);
}
source§fn block(&self) -> (Self, Self, Self, Self)
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));
}
source§fn inv(&self) -> Self
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);
}
source§fn pseudo_inv(&self) -> Self
fn pseudo_inv(&self) -> Self
source§fn solve(&self, b: &Vec<f64>, sk: SolveKind) -> Vec<f64>
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
fn is_symmetric(&self) -> bool
source§impl LinearOp<Vec<f64>, Vec<f64>> for Matrix
impl LinearOp<Vec<f64>, Vec<f64>> for Matrix
TODO: Transpose Matrix as Linear operator for Vector
source§impl MatrixProduct for Matrix
impl MatrixProduct for Matrix
source§impl MatrixPtr for Matrix
impl MatrixPtr for Matrix
source§unsafe fn row_ptr(&self, idx: usize) -> Vec<*const f64>
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>
source§impl Mul<Matrix> for Vec<f64>
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));
}
source§impl Mul for Matrix
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));
}
source§impl Neg for Matrix
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]]
source§impl PartialEq for Matrix
impl PartialEq for Matrix
PartialEq implements
source§impl Scalable for Matrix
impl Scalable for Matrix
Modify Matrix
source§fn resize(&self, (r, c): (usize, usize), shape: Shape) -> 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"));
}
source§fn add_row(&self, v: &Self::Vec) -> Matrix
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"));
}
source§fn add_col(&self, v: &Self::Vec) -> Matrix
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>
source§impl ScalableMut for Matrix
impl ScalableMut for Matrix
source§fn resize_mut(&mut self, (r, c): (usize, usize), shape: Shape)
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"));
}
source§fn add_row_mut(&mut self, v: &Self::Vec)
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"));
}
source§fn add_col_mut(&mut self, v: &Self::Vec)
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>
source§impl SimpleNorm for Matrix
impl SimpleNorm for Matrix
Simple Frobenius norm
source§impl SimplerLinearAlgebra for Matrix
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
fn is_symmetric(&self) -> bool
source§impl Statistics for Matrix
impl Statistics for Matrix
source§fn mean(&self) -> Vec<f64>
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));
}
source§fn var(&self) -> Vec<f64>
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));
}
source§fn sd(&self) -> Vec<f64>
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));
}
source§fn cov(&self) -> Self
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
source§impl Sub<Matrix> for f64
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));
}
source§impl Sub for Matrix
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]]