[−][src]Struct peroxide::structure::matrix::Matrix
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
[src]
Main matrix structure
pub fn ptr(&self) -> *const f64
[src]
Raw pointer for self.data
pub fn mut_ptr(&mut self) -> *mut f64
[src]
Raw mutable pointer for self.data
pub fn as_slice<'a>(&'a self) -> &'a [f64]
[src]
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]
[src]
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
[src]
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)
[src]
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
[src]
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>
[src]
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>
[src]
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>
[src]
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
[src]
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
[src]
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>>
[src]
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>>
[src]
&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>>
[src]
&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>>
[src]
&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>>
[src]
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>)
[src]
Should check shape
pub fn subs_col(&mut self, idx: usize, v: &Vec<f64>)
[src]
Substitute Col
pub fn subs_row(&mut self, idx: usize, v: &Vec<f64>)
[src]
Substitute Row
pub fn from_index<F, G>(f: F, size: (usize, usize)) -> Matrix where
F: Fn(usize, usize) -> G + Copy,
G: Into<f64>,
[src]
F: Fn(usize, usize) -> G + Copy,
G: Into<f64>,
From index operations
pub fn to_vec(&self) -> Vec<Vec<f64>>
[src]
Matrix to Vec<Vec<f64>>
To send Matrix
to inline-python
pub fn to_diag(&self) -> Matrix
[src]
Trait Implementations
impl<'a> Add<&'a Matrix> for f64
[src]
Element-wise addition between f64 & &Matrix
type Output = Matrix
The resulting type after applying the +
operator.
fn add(self, other: &'a Matrix) -> Self::Output
[src]
impl<'a> Add<&'a Matrix> for i32
[src]
Element-wise addition between i32 & &Matrix
type Output = Matrix
The resulting type after applying the +
operator.
fn add(self, other: &'a Matrix) -> Self::Output
[src]
impl<'a> Add<&'a Matrix> for usize
[src]
Element-wise addition between usize & &Matrix
type Output = Matrix
The resulting type after applying the +
operator.
fn add(self, other: &'a Matrix) -> Self::Output
[src]
impl<'a, 'b> Add<&'b Matrix> for &'a Matrix
[src]
type Output = Matrix
The resulting type after applying the +
operator.
fn add(self, rhs: &'b Matrix) -> Self::Output
[src]
impl Add<Matrix> for Matrix
[src]
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
[src]
impl Add<Matrix> for f64
[src]
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)); }
type Output = Matrix
The resulting type after applying the +
operator.
fn add(self, other: Matrix) -> Matrix
[src]
impl Add<Matrix> for i32
[src]
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)); }
type Output = Matrix
The resulting type after applying the +
operator.
fn add(self, other: Matrix) -> Matrix
[src]
impl Add<Matrix> for usize
[src]
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)); }
type Output = Matrix
The resulting type after applying the +
operator.
fn add(self, other: Matrix) -> Matrix
[src]
impl<T> Add<T> for Matrix where
T: Into<f64> + Copy,
[src]
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
[src]
impl<'a, T> Add<T> for &'a Matrix where
T: Into<f64> + Copy,
[src]
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
[src]
impl Clone for Matrix
[src]
impl Debug for Matrix
[src]
impl Default for Matrix
[src]
impl Display for Matrix
[src]
Pretty Print
impl Div<f64> for Matrix
[src]
Element-wise division between Matrix vs f64
type Output = Self
The resulting type after applying the /
operator.
fn div(self, other: f64) -> Self
[src]
impl<'a> Div<f64> for &'a Matrix
[src]
type Output = Matrix
The resulting type after applying the /
operator.
fn div(self, other: f64) -> Self::Output
[src]
impl Div<i32> for Matrix
[src]
type Output = Self
The resulting type after applying the /
operator.
fn div(self, other: i32) -> Self
[src]
impl<'a> Div<i32> for &'a Matrix
[src]
type Output = Matrix
The resulting type after applying the /
operator.
fn div(self, other: i32) -> Self::Output
[src]
impl Div<i64> for Matrix
[src]
type Output = Self
The resulting type after applying the /
operator.
fn div(self, other: i64) -> Self
[src]
impl<'a> Div<i64> for &'a Matrix
[src]
type Output = Matrix
The resulting type after applying the /
operator.
fn div(self, other: i64) -> Self::Output
[src]
impl Div<usize> for Matrix
[src]
type Output = Self
The resulting type after applying the /
operator.
fn div(self, other: usize) -> Self
[src]
impl<'a> Div<usize> for &'a Matrix
[src]
type Output = Matrix
The resulting type after applying the /
operator.
fn div(self, other: usize) -> Self::Output
[src]
impl Environment for Matrix
[src]
impl FPMatrix for Matrix
[src]
fn take_row(&self, n: usize) -> Self
[src]
fn take_col(&self, n: usize) -> Self
[src]
fn skip_row(&self, n: usize) -> Self
[src]
fn skip_col(&self, n: usize) -> Self
[src]
fn fmap<F>(&self, f: F) -> Matrix where
F: Fn(f64) -> f64,
[src]
F: Fn(f64) -> f64,
fn col_map<F>(&self, f: F) -> Matrix where
F: Fn(Vec<f64>) -> Vec<f64>,
[src]
F: Fn(Vec<f64>) -> Vec<f64>,
fn row_map<F>(&self, f: F) -> Matrix where
F: Fn(Vec<f64>) -> Vec<f64>,
[src]
F: Fn(Vec<f64>) -> Vec<f64>,
fn col_mut_map<F>(&mut self, f: F) where
F: Fn(Vec<f64>) -> Vec<f64>,
[src]
F: Fn(Vec<f64>) -> Vec<f64>,
fn row_mut_map<F>(&mut self, f: F) where
F: Fn(Vec<f64>) -> Vec<f64>,
[src]
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>,
[src]
F: Fn(f64, f64) -> f64,
T: Into<f64>,
fn zip_with<F>(&self, f: F, other: &Matrix) -> Self where
F: Fn(f64, f64) -> f64,
[src]
F: Fn(f64, f64) -> f64,
fn col_reduce<F>(&self, f: F) -> Vec<f64> where
F: Fn(Vec<f64>) -> f64,
[src]
F: Fn(Vec<f64>) -> f64,
fn row_reduce<F>(&self, f: F) -> Vec<f64> where
F: Fn(Vec<f64>) -> f64,
[src]
F: Fn(Vec<f64>) -> f64,
impl Index<(usize, usize)> for Matrix
[src]
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
[src]
impl IndexMut<(usize, usize)> for Matrix
[src]
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)); }
impl InnerProduct for Matrix
[src]
Frobenius inner product
impl<'a> Into<&'a Vec<f64>> for &'a Matrix
[src]
&Matrix to &Vec
impl Into<Matrix> for Vec<f64>
[src]
Vec
impl<'_> Into<Matrix> for &'_ Vec<f64>
[src]
impl Into<Matrix> for SPMatrix
[src]
impl Into<SPMatrix> for Matrix
[src]
impl Into<Vec<f64>> for Matrix
[src]
Matrix to Vec
impl LinearAlgebra for Matrix
[src]
fn back_subs(&self, b: &Vec<f64>) -> Vec<f64>
[src]
Backward Substitution for Upper Triangular
fn forward_subs(&self, b: &Vec<f64>) -> Vec<f64>
[src]
Forward substitution for Lower Triangular
fn lu(&self) -> PQLU
[src]
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 waz(&self, d_form: Form) -> Option<WAZD>
[src]
fn qr(&self) -> QR
[src]
QR Decomposition
Translation of RosettaCode#Python
fn rref(&self) -> Matrix
[src]
Reduced Row Echelon Form
Implementation of RosettaCode
fn det(&self) -> f64
[src]
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)
[src]
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
[src]
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
[src]
Moore-Penrose Pseudo inverse
Description
$(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>
[src]
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 solve_mat(&self, m: &Matrix, sk: SolveKind) -> Matrix
[src]
impl LinearOp<Vec<f64>, Vec<f64>> for Matrix
[src]
TODO: Transpose Matrix as Linear operator for Vector
impl MATLAB for Matrix
[src]
impl MatrixProduct for Matrix
[src]
impl MatrixPtr for Matrix
[src]
unsafe fn row_ptr(&self, idx: usize) -> Vec<*const f64>
[src]
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>
[src]
impl<'a> Mul<&'a Matrix> for f64
[src]
type Output = Matrix
The resulting type after applying the *
operator.
fn mul(self, other: &'a Matrix) -> Matrix
[src]
impl<'a> Mul<&'a Matrix> for i64
[src]
type Output = Matrix
The resulting type after applying the *
operator.
fn mul(self, other: &'a Matrix) -> Matrix
[src]
impl<'a> Mul<&'a Matrix> for i32
[src]
type Output = Matrix
The resulting type after applying the *
operator.
fn mul(self, other: &'a Matrix) -> Matrix
[src]
impl<'a> Mul<&'a Matrix> for usize
[src]
type Output = Matrix
The resulting type after applying the *
operator.
fn mul(self, other: &'a Matrix) -> Matrix
[src]
impl<'a, 'b> Mul<&'b Matrix> for &'a Matrix
[src]
type Output = Matrix
The resulting type after applying the *
operator.
fn mul(self, other: &'b Matrix) -> Self::Output
[src]
impl<'a, 'b> Mul<&'b Matrix> for &'a Vec<f64>
[src]
type Output = Vec<f64>
The resulting type after applying the *
operator.
fn mul(self, other: &'b Matrix) -> Self::Output
[src]
impl<'a, 'b> Mul<&'b Vec<f64>> for &'a Matrix
[src]
type Output = Vec<f64>
The resulting type after applying the *
operator.
fn mul(self, other: &'b Vec<f64>) -> Self::Output
[src]
impl Mul<Matrix> for f64
[src]
type Output = Matrix
The resulting type after applying the *
operator.
fn mul(self, other: Matrix) -> Matrix
[src]
impl Mul<Matrix> for i64
[src]
type Output = Matrix
The resulting type after applying the *
operator.
fn mul(self, other: Matrix) -> Matrix
[src]
impl Mul<Matrix> for i32
[src]
type Output = Matrix
The resulting type after applying the *
operator.
fn mul(self, other: Matrix) -> Matrix
[src]
impl Mul<Matrix> for usize
[src]
type Output = Matrix
The resulting type after applying the *
operator.
fn mul(self, other: Matrix) -> Matrix
[src]
impl Mul<Matrix> for Matrix
[src]
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
[src]
impl Mul<Matrix> for Vec<f64>
[src]
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)); }
type Output = Vec<f64>
The resulting type after applying the *
operator.
fn mul(self, other: Matrix) -> Self::Output
[src]
impl Mul<Redox<Vec<f64>>> for Matrix
[src]
type Output = Redox<Vec<f64>>
The resulting type after applying the *
operator.
fn mul(self, rhs: Redox<Vec<f64>>) -> Self::Output
[src]
impl<'_> Mul<Redox<Vec<f64>>> for &'_ Matrix
[src]
type Output = Redox<Vec<f64>>
The resulting type after applying the *
operator.
fn mul(self, rhs: Redox<Vec<f64>>) -> Self::Output
[src]
impl Mul<Vec<f64>> for Matrix
[src]
type Output = Vec<f64>
The resulting type after applying the *
operator.
fn mul(self, other: Vec<f64>) -> Self::Output
[src]
impl Mul<f64> for Matrix
[src]
Element-wise multiplication between Matrix vs f64
type Output = Self
The resulting type after applying the *
operator.
fn mul(self, other: f64) -> Self
[src]
impl Mul<i32> for Matrix
[src]
type Output = Self
The resulting type after applying the *
operator.
fn mul(self, other: i32) -> Self
[src]
impl Mul<i64> for Matrix
[src]
type Output = Self
The resulting type after applying the *
operator.
fn mul(self, other: i64) -> Self
[src]
impl Mul<usize> for Matrix
[src]
type Output = Self
The resulting type after applying the *
operator.
fn mul(self, other: usize) -> Self
[src]
impl MutMatrix for Matrix
[src]
unsafe fn col_mut(&mut self, idx: usize) -> Vec<*mut f64>
[src]
unsafe fn row_mut(&mut self, idx: usize) -> Vec<*mut f64>
[src]
unsafe fn swap(&mut self, idx1: usize, idx2: usize, shape: Shape)
[src]
unsafe fn swap_with_perm(&mut self, p: &Vec<(usize, usize)>, shape: Shape)
[src]
impl Neg for Matrix
[src]
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]]
impl<'a> Neg for &'a Matrix
[src]
Negation of &'a Matrix
type Output = Matrix
The resulting type after applying the -
operator.
fn neg(self) -> Self::Output
[src]
impl Normed for Matrix
[src]
type Scalar = f64
fn norm(&self, kind: Norm) -> f64
[src]
fn normalize(&self, _kind: Norm) -> Self where
Self: Sized,
[src]
Self: Sized,
impl PYTHON for Matrix
[src]
impl PartialEq<Matrix> for Matrix
[src]
PartialEq implements
impl Printable for Matrix
[src]
impl R for Matrix
[src]
impl Scalable for Matrix
[src]
Modify Matrix
type Vec = Vec<f64>
fn resize(&self, (r, c): (usize, usize), shape: Shape) -> Matrix
[src]
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
[src]
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
[src]
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
[src]
type Vec = Vec<f64>
fn resize_mut(&mut self, (r, c): (usize, usize), shape: Shape)
[src]
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)
[src]
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)
[src]
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
[src]
Simple Frobenius norm
impl SimplerLinearAlgebra for Matrix
[src]
fn back_subs(&self, b: &Vec<f64>) -> Vec<f64>
[src]
fn forward_subs(&self, b: &Vec<f64>) -> Vec<f64>
[src]
fn lu(&self) -> PQLU
[src]
fn waz(&self) -> Option<WAZD>
[src]
fn waz_diag(&self) -> Option<WAZD>
[src]
fn qr(&self) -> QR
[src]
fn rref(&self) -> Matrix
[src]
fn det(&self) -> f64
[src]
fn block(&self) -> (Matrix, Matrix, Matrix, Matrix)
[src]
fn inv(&self) -> Matrix
[src]
fn pseudo_inv(&self) -> Matrix
[src]
fn solve(&self, b: &Vec<f64>) -> Vec<f64>
[src]
fn solve_mat(&self, m: &Matrix) -> Matrix
[src]
impl Statistics for Matrix
[src]
type Array = Matrix
type Value = Vec<f64>
fn mean(&self) -> Vec<f64>
[src]
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>
[src]
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>
[src]
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
[src]
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 }
fn cor(&self) -> Self
[src]
impl<'a> Sub<&'a Matrix> for f64
[src]
type Output = Matrix
The resulting type after applying the -
operator.
fn sub(self, other: &'a Matrix) -> Self::Output
[src]
impl<'a> Sub<&'a Matrix> for i32
[src]
type Output = Matrix
The resulting type after applying the -
operator.
fn sub(self, other: &'a Matrix) -> Self::Output
[src]
impl<'a> Sub<&'a Matrix> for usize
[src]
type Output = Matrix
The resulting type after applying the -
operator.
fn sub(self, other: &'a Matrix) -> Self::Output
[src]
impl<'a, 'b> Sub<&'b Matrix> for &'a Matrix
[src]
type Output = Matrix
The resulting type after applying the -
operator.
fn sub(self, rhs: &'b Matrix) -> Matrix
[src]
impl Sub<Matrix> for Matrix
[src]
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
[src]
impl Sub<Matrix> for f64
[src]
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)); }
type Output = Matrix
The resulting type after applying the -
operator.
fn sub(self, other: Matrix) -> Matrix
[src]
impl Sub<Matrix> for i32
[src]
type Output = Matrix
The resulting type after applying the -
operator.
fn sub(self, other: Matrix) -> Matrix
[src]
impl Sub<Matrix> for usize
[src]
type Output = Matrix
The resulting type after applying the -
operator.
fn sub(self, other: Matrix) -> Matrix
[src]
impl<T> Sub<T> for Matrix where
T: Into<f64> + Copy,
[src]
T: Into<f64> + Copy,
Subtraction between Matrix & f64
type Output = Self
The resulting type after applying the -
operator.
fn sub(self, other: T) -> Self
[src]
impl<'a, T> Sub<T> for &'a Matrix where
T: Into<f64> + Copy,
[src]
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
[src]
impl Vector for Matrix
[src]
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
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,