Struct la::Matrix

pub struct Matrix<T> {
    // some fields omitted
}

Methods

impl<T: Copy> Matrix<T>

fn get_mut_data<'a>(&'a mut self) -> &'a mut Vec<T>

fn get_mref<'lt>(&'lt mut self, row: usize, col: usize) -> &'lt mut T

fn mmap<'a>(&'a mut self, f: &Fn(&T) -> T) -> &'a mut Matrix<T>

impl<T: Num + Neg<Output=T> + Copy> Matrix<T>

fn mneg<'a>(&'a mut self) -> &'a mut Matrix<T>

fn mscale<'a>(&'a mut self, factor: T) -> &'a mut Matrix<T>

fn madd<'a>(&'a mut self, m: &Matrix<T>) -> &'a mut Matrix<T>

fn msub<'a>(&'a mut self, m: &Matrix<T>) -> &'a mut Matrix<T>

fn melem_mul<'a>(&'a mut self, m: &Matrix<T>) -> &'a mut Matrix<T>

fn melem_div<'a>(&'a mut self, m: &Matrix<T>) -> &'a mut Matrix<T>

fn mmul<'a>(&self, m: &Matrix<T>, dst: &'a mut Matrix<T>) -> &'a mut Matrix<T>

impl<T: Copy> Matrix<T>

fn set<'a>(&'a mut self, row: usize, col: usize, val: T) -> &'a mut Matrix<T>

fn mt<'a>(&'a mut self) -> &'a mut Matrix<T>

impl<T: Copy> Matrix<T>

fn new(no_rows: usize, no_cols: usize, data: Vec<T>) -> Matrix<T>

fn dirty(no_rows: usize, no_cols: usize) -> Matrix<T>

fn vector(data: Vec<T>) -> Matrix<T>

fn row_vector(data: Vec<T>) -> Matrix<T>

fn rows(&self) -> usize

fn cols(&self) -> usize

fn get_data<'a>(&'a self) -> &'a Vec<T>

fn get_ref<'lt>(&'lt self, row: usize, col: usize) -> &'lt T

fn map<S: Copy>(&self, f: &Fn(&T) -> S) -> Matrix<S>

fn reduce<S: Copy>(&self, init: &Vec<S>, f: &Fn(&S, &T) -> S) -> Matrix<S>

fn is_square(&self) -> bool

fn is_not_square(&self) -> bool

impl<T: Num + Copy> Matrix<T>

fn id(m: usize, n: usize) -> Matrix<T>

fn zero(no_rows: usize, no_cols: usize) -> Matrix<T>

fn diag(data: Vec<T>) -> Matrix<T>

fn block_diag(m: usize, n: usize, data: Vec<T>) -> Matrix<T>

fn zero_vector(no_rows: usize) -> Matrix<T>

fn one_vector(no_rows: usize) -> Matrix<T>

impl<T: Num + Neg<Output=T> + Copy> Matrix<T>

fn scale(&self, factor: T) -> Matrix<T>

fn elem_mul(&self, m: &Matrix<T>) -> Matrix<T>

fn elem_div(&self, m: &Matrix<T>) -> Matrix<T>

fn dot(&self, m: &Matrix<T>) -> T

impl<T: Copy> Matrix<T>

fn get(&self, row: usize, col: usize) -> T

fn cr(&self, m: &Matrix<T>) -> Matrix<T>

fn cb(&self, m: &Matrix<T>) -> Matrix<T>

fn t(&self) -> Matrix<T>

fn minor(&self, row: usize, col: usize) -> Matrix<T>

fn sub_matrix<RRI, RCI, RR, RC>(&self, rows: RR, cols: RC) -> Matrix<T> where RRI: MatrixRangeIterator, RCI: MatrixRangeIterator, RR: MatrixRange<RRI>, RC: MatrixRange<RCI>

fn get_columns<RCI: MatrixRangeIterator, RC: MatrixRange<RCI>>(&self, columns: RC) -> Matrix<T>

fn get_rows<RCI: MatrixRangeIterator, RC: MatrixRange<RCI>>(&self, row: RC) -> Matrix<T>

fn permute(&self, rows: &[usize], columns: &[usize]) -> Matrix<T>

fn permute_rows(&self, rows: &[usize]) -> Matrix<T>

fn permute_columns(&self, columns: &[usize]) -> Matrix<T>

fn filter_rows(&self, f: &Fn(&Matrix<T>, usize) -> bool) -> Matrix<T>

fn filter_columns(&self, f: &Fn(&Matrix<T>, usize) -> bool) -> Matrix<T>

fn select_rows(&self, selector: &[bool]) -> Matrix<T>

fn select_columns(&self, selector: &[bool]) -> Matrix<T>

impl<T: Debug + Copy> Matrix<T>

fn print(&self)

impl<T: Rand + Copy> Matrix<T>

fn random(no_rows: usize, no_cols: usize) -> Matrix<T>

impl<T: Float + ApproxEq<T> + Signed + Copy> Matrix<T>

fn trace(&self) -> T

fn det(&self) -> T

fn solve(&self, b: &Matrix<T>) -> Option<Matrix<T>>

fn inverse(&self) -> Option<Matrix<T>>

fn is_singular(&self) -> bool

fn is_non_singular(&self) -> bool

fn pinverse(&self) -> Matrix<T>

fn vector_euclidean_norm(&self) -> T

fn length(&self) -> T

fn vector_1_norm(&self) -> T

fn vector_2_norm(&self) -> T

fn vector_p_norm(&self, p: T) -> T

fn frobenius_norm(&self) -> T

fn vector_inf_norm(&self) -> T

fn is_symmetric(&self) -> bool

fn is_non_symmetric(&self) -> bool

fn approx_eq(&self, m: &Matrix<T>) -> bool

Trait Implementations

impl<T: Debug + Copy> Debug for Matrix<T>

fn fmt(&self, fmt: &mut Formatter) -> Result

impl<'a, T: Neg<Output=T> + Copy> Neg for &'a Matrix<T>

type Output = Matrix<T>

fn neg(self) -> Matrix<T>

impl<T: Neg<Output=T> + Copy> Neg for Matrix<T>

type Output = Matrix<T>

fn neg(self) -> Matrix<T>

impl<'a, 'b, T: Add<T, Output=T> + Copy> Add<&'a Matrix<T>> for &'b Matrix<T>

type Output = Matrix<T>

fn add(self, m: &Matrix<T>) -> Matrix<T>

impl<'a, T: Add<T, Output=T> + Copy> Add<Matrix<T>> for &'a Matrix<T>

type Output = Matrix<T>

fn add(self, m: Matrix<T>) -> Matrix<T>

impl<'a, T: Add<T, Output=T> + Copy> Add<&'a Matrix<T>> for Matrix<T>

type Output = Matrix<T>

fn add(self, m: &Matrix<T>) -> Matrix<T>

impl<T: Add<T, Output=T> + Copy> Add<Matrix<T>> for Matrix<T>

type Output = Matrix<T>

fn add(self, m: Matrix<T>) -> Matrix<T>

impl<'a, 'b, T: Sub<T, Output=T> + Copy> Sub<&'a Matrix<T>> for &'b Matrix<T>

type Output = Matrix<T>

fn sub(self, m: &Matrix<T>) -> Matrix<T>

impl<'a, T: Sub<T, Output=T> + Copy> Sub<Matrix<T>> for &'a Matrix<T>

type Output = Matrix<T>

fn sub(self, m: Matrix<T>) -> Matrix<T>

impl<'a, T: Sub<T, Output=T> + Copy> Sub<&'a Matrix<T>> for Matrix<T>

type Output = Matrix<T>

fn sub(self, m: &Matrix<T>) -> Matrix<T>

impl<T: Sub<T, Output=T> + Copy> Sub<Matrix<T>> for Matrix<T>

type Output = Matrix<T>

fn sub(self, m: Matrix<T>) -> Matrix<T>

impl<'a, 'b, T: Add<T, Output=T> + Mul<T, Output=T> + Zero + Copy> Mul<&'a Matrix<T>> for &'b Matrix<T>

type Output = Matrix<T>

fn mul(self, m: &'a Matrix<T>) -> Matrix<T>

impl<'a, T: Add<T, Output=T> + Mul<T, Output=T> + Zero + Copy> Mul<Matrix<T>> for &'a Matrix<T>

type Output = Matrix<T>

fn mul(self, m: Matrix<T>) -> Matrix<T>

impl<T: Add<T, Output=T> + Mul<T, Output=T> + Zero + Copy> Mul<Matrix<T>> for Matrix<T>

type Output = Matrix<T>

fn mul(self, m: Matrix<T>) -> Matrix<T>

impl<'a, T: Add<T, Output=T> + Mul<T, Output=T> + Zero + Copy> Mul<&'a Matrix<T>> for Matrix<T>

type Output = Matrix<T>

fn mul(self, m: &'a Matrix<T>) -> Matrix<T>

impl<T: Copy> Index<(usize, usize)> for Matrix<T>

type Output = T

fn index<'a>(&'a self, (y, x): (usize, usize)) -> &'a T

impl<'a, T: Copy> BitOr<&'a Matrix<T>> for Matrix<T>

type Output = Matrix<T>

fn bitor(self, rhs: &Matrix<T>) -> Matrix<T>

Derived Implementations

impl<T: Clone> Clone for Matrix<T>

fn clone(&self) -> Matrix<T>

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

impl<T: PartialEq> PartialEq for Matrix<T>

fn eq(&self, __arg_0: &Matrix<T>) -> bool

fn ne(&self, __arg_0: &Matrix<T>) -> bool