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
sourceimpl 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 where
F: Fn(usize, usize) -> G + Copy,
G: Into<f64>,
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_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
sourceimpl Add<Matrix> for Matrix
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.
sourceimpl 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));
}
sourceimpl 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));
}
sourceimpl 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));
}
sourceimpl<T> Add<T> for Matrix where
T: Into<f64> + Copy,
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));
}
sourceimpl<'a, T> Add<T> for &'a Matrix where
T: Into<f64> + Copy,
impl<'a, T> Add<T> for &'a Matrix where
T: Into<f64> + Copy,
Element-wise addition between &Matrix & f64
sourceimpl FPMatrix for Matrix
impl FPMatrix for Matrix
sourcefn col_map<F>(&self, f: F) -> Matrix where
F: Fn(Vec<f64>) -> Vec<f64>,
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"));
}
sourcefn row_map<F>(&self, f: F) -> Matrix where
F: Fn(Vec<f64>) -> Vec<f64>,
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,
sourceimpl 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);
sourceimpl 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));
}
sourceimpl LinearAlgebra for Matrix
impl LinearAlgebra for Matrix
sourcefn 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));
}
sourcefn 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();
}
sourcefn 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();
}
sourcefn cholesky(&self, uplo: UPLO) -> Matrix
fn cholesky(&self, uplo: UPLO) -> Matrix
Cholesky Decomposition
Examples
extern crate peroxide;
use peroxide::fuga::*;
fn main() {
let a = ml_matrix("1 2;2 5");
#[cfg(feature = "O3")]
{
let u = a.cholesky(Upper);
let l = a.cholesky(Lower);
assert_eq!(u, ml_matrix("1 2;0 1"));
assert_eq!(l, ml_matrix("1 0;2 1"));
}
a.print();
}
sourcefn rref(&self) -> Matrix
fn rref(&self) -> Matrix
Reduced Row Echelon Form
Implementation of RosettaCode
sourcefn 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);
}
sourcefn 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));
}
sourcefn 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);
}
sourcefn pseudo_inv(&self) -> Self
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
}
sourcefn 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
sourceimpl LinearOp<Vec<f64, Global>, Vec<f64, Global>> for Matrix
impl LinearOp<Vec<f64, Global>, Vec<f64, Global>> for Matrix
TODO: Transpose Matrix as Linear operator for Vector
sourceimpl MatrixProduct for Matrix
impl MatrixProduct for Matrix
sourceimpl MatrixPtr for Matrix
impl MatrixPtr for Matrix
sourceunsafe 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>
sourceimpl Mul<Matrix> for Matrix
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));
}
sourceimpl Mul<Matrix> for Vec<f64>
impl Mul<Matrix> for Vec<f64>
Matrix multiplication for Vec
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));
}
sourceimpl 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]]
sourceimpl Scalable for Matrix
impl Scalable for Matrix
Modify Matrix
sourcefn 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"));
}
sourcefn 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"));
}
sourcefn 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, Global>
sourceimpl ScalableMut for Matrix
impl ScalableMut for Matrix
sourcefn 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"));
}
sourcefn 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"));
}
sourcefn 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, Global>
sourceimpl SimpleNorm for Matrix
impl SimpleNorm for Matrix
Simple Frobenius norm
sourceimpl 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 cholesky(&self) -> Matrix
fn is_symmetric(&self) -> bool
sourceimpl Statistics for Matrix
impl Statistics for Matrix
sourcefn 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));
}
sourcefn 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));
}
sourcefn 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));
}
sourcefn 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, Global>
fn cor(&self) -> Self
sourceimpl Sub<Matrix> for Matrix
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]]
sourceimpl 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));
}
sourceimpl<'a, T> Sub<T> for &'a Matrix where
T: Into<f64> + Copy,
impl<'a, T> Sub<T> for &'a Matrix where
T: Into<f64> + Copy,
Subtraction between &Matrix & f64
impl Environment for Matrix
Auto Trait Implementations
impl RefUnwindSafe for Matrix
impl Send for Matrix
impl Sync for Matrix
impl Unpin for Matrix
impl UnwindSafe for Matrix
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more