Struct DenseMatrix

pub struct DenseMatrix<T> { /* private fields */ }

Dense matrix

Implementations

impl<T: Debug + Display + Copy + Sized> DenseMatrix<T>

pub fn new( nrows: usize, ncols: usize, values: Vec<T>, column_major: bool, ) -> Result<Self, Failed>

Create new instance of DenseMatrix without copying data. values should be in column-major order.

pub fn from_2d_array(values: &[&[T]]) -> Result<Self, Failed>

New instance of DenseMatrix from 2d array.

pub fn from_2d_vec(values: &Vec<Vec<T>>) -> Result<Self, Failed>

New instance of DenseMatrix from 2d vector.

pub fn iter(&self) -> Iter<'_, T>

Iterate over values of matrix

Trait Implementations

impl<T: Number + RealNumber + AbsDiffEq> AbsDiffEq for DenseMatrix<T>

where T::Epsilon: Copy,

type Epsilon = <T as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> T::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: T::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<T: Debug + Display + Copy + Sized> Array<T, (usize, usize)> for DenseMatrix<T>

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

retrieve a reference to a value at position

fn shape(&self) -> (usize, usize)

return shape of the array

fn is_empty(&self) -> bool

return true if array is empty

fn iterator<'b>(&'b self, axis: u8) -> Box<dyn Iterator<Item = &'b T> + 'b>

iterate over array’s values

impl<T: Debug + Display + Copy + Sized> Array2<T> for DenseMatrix<T>

fn get_row<'a>(&'a self, row: usize) -> Box<dyn ArrayView1<T> + 'a>

get row from 2d array

fn get_col<'a>(&'a self, col: usize) -> Box<dyn ArrayView1<T> + 'a>

get column from 2d array

fn slice<'a>( &'a self, rows: Range<usize>, cols: Range<usize>, ) -> Box<dyn ArrayView2<T> + 'a>

get a view of the 2d array

fn slice_mut<'a>( &'a mut self, rows: Range<usize>, cols: Range<usize>, ) -> Box<dyn MutArrayView2<T> + 'a>

where Self: Sized,

get a mutable view of the 2d array

fn fill(nrows: usize, ncols: usize, value: T) -> Self

fill 2d array with a given value

fn from_iterator<I: Iterator<Item = T>>( iter: I, nrows: usize, ncols: usize, axis: u8, ) -> Self

create 2d array from iterator

fn transpose(&self) -> Self

transpose 2d array

fn zeros(nrows: usize, ncols: usize) -> Self

where T: Number,

create a zero 2d array

fn ones(nrows: usize, ncols: usize) -> Self

where T: Number,

create a 2d array of ones

fn eye(size: usize) -> Self

where T: Number,

create an identity matrix

fn rand(nrows: usize, ncols: usize) -> Self

where T: RealNumber,

create a 2d array of random values

fn from_slice(slice: &dyn ArrayView2<T>) -> Self

crate from 2d slice

fn from_row(slice: &dyn ArrayView1<T>) -> Self

create from row

fn from_column(slice: &dyn ArrayView1<T>) -> Self

create from column

fn reshape(&self, nrows: usize, ncols: usize, axis: u8) -> Self

change shape of 2d array

fn matmul(&self, other: &dyn ArrayView2<T>) -> Self

where T: Number,

multiply two 2d arrays

fn ab( &self, a_transpose: bool, b: &dyn ArrayView2<T>, b_transpose: bool, ) -> Self

where T: Number,

matrix multiplication

fn ax(&self, a_transpose: bool, x: &dyn ArrayView1<T>) -> Self

where T: Number,

matrix vector multiplication

fn concatenate_1d<'a>(arrays: &'a [&'a dyn ArrayView1<T>], axis: u8) -> Self

concatenate 1d array

fn concatenate_2d<'a>(arrays: &'a [&'a dyn ArrayView2<T>], axis: u8) -> Self

concatenate 2d array

fn merge_1d<'a>( &'a self, arrays: &'a [&'a dyn ArrayView1<T>], axis: u8, append: bool, ) -> Self

merge 1d arrays

fn v_stack(&self, other: &dyn ArrayView2<T>) -> Self

Stack arrays in sequence vertically

fn h_stack(&self, other: &dyn ArrayView2<T>) -> Self

Stack arrays in sequence horizontally

fn map<O: Debug + Display + Copy + Sized, A: Array2<O>, F: FnMut(&T) -> O>( self, f: F, ) -> A

map array values

fn row_iter<'a>( &'a self, ) -> Box<dyn Iterator<Item = Box<dyn ArrayView1<T> + 'a>> + 'a>

iter rows

fn col_iter<'a>( &'a self, ) -> Box<dyn Iterator<Item = Box<dyn ArrayView1<T> + 'a>> + 'a>

iter cols

fn take(&self, index: &[usize], axis: u8) -> Self

take elements from 2d array

fn take_column(&self, column_index: usize) -> Self

Take an individual column from the matrix.

fn add_scalar(&self, x: T) -> Self

where T: Number,

add a scalar to the array

fn sub_scalar(&self, x: T) -> Self

where T: Number,

subtract a scalar from the array

fn div_scalar(&self, x: T) -> Self

where T: Number,

divide a scalar from the array

fn mul_scalar(&self, x: T) -> Self

where T: Number,

multiply a scalar to the array

fn add(&self, other: &dyn Array<T, (usize, usize)>) -> Self

where T: Number,

sum of two arrays

fn sub(&self, other: &dyn Array<T, (usize, usize)>) -> Self

where T: Number,

subtract two arrays

fn mul(&self, other: &dyn Array<T, (usize, usize)>) -> Self

where T: Number,

multiply two arrays

fn div(&self, other: &dyn Array<T, (usize, usize)>) -> Self

where T: Number,

divide two arrays

fn abs(&self) -> Self

where T: Number + Signed,

absolute values of the array

fn neg(&self) -> Self

where T: Number + Neg<Output = T>,

negation of the array

fn pow(&self, p: T) -> Self

where T: RealNumber,

values at power p

fn column_mean(&self) -> Vec<f64>

where T: Number + ToPrimitive,

compute mean for each column

fn copy_col_as_vec(&self, col: usize, result: &mut Vec<T>)

copy column as a vector

fn approximate_eq(&self, other: &Self, error: T) -> bool

where T: Number + RealNumber,

approximate equality of the elements of a matrix according to a given error

impl<T: Debug + Display + Copy + Sized> ArrayView2<T> for DenseMatrix<T>

fn max(&self, axis: u8) -> Vec<T>

where T: Number + PartialOrd,

return max value in array

fn sum(&self, axis: u8) -> Vec<T>

where T: Number,

return sum of element of array

fn min(&self, axis: u8) -> Vec<T>

where T: Number + PartialOrd,

return min value of array

fn argmax(&self, axis: u8) -> Vec<usize>

where T: Number + PartialOrd,

return positions of max values in both rows

fn mean_by(&self, axis: u8) -> Vec<f64>

where T: Number,

return mean value TODO: this can be made more readable and efficient using the methods in linalg::traits::stats

fn variance(&self, axis: u8) -> Vec<f64>

where T: Number + RealNumber,

return variance

fn std_dev(&self, axis: u8) -> Vec<f64>

where T: Number + RealNumber,

return standard deviation

fn cov(&self, cov: &mut dyn MutArrayView2<f64>)

where T: Number,

return covariance

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

print out array

fn norm(&self, p: f64) -> f64

where T: Number,

return norm

fn diag(&self) -> Vec<T>

return array diagonal

impl<T: Number + RealNumber> CholeskyDecomposable<T> for DenseMatrix<T>

fn cholesky(&self) -> Result<Cholesky<T, Self>, Failed>

Compute the Cholesky decomposition of a matrix.

fn cholesky_mut(self) -> Result<Cholesky<T, Self>, Failed>

Compute the Cholesky decomposition of a matrix. The input matrix will be used for factorization.

fn cholesky_solve_mut(self, b: Self) -> Result<Self, Failed>

Solves Ax = b

impl<T: Clone> Clone for DenseMatrix<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for DenseMatrix<T>

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

Formats the value using the given formatter.

impl<T: Debug + Display + Copy + Sized> Display for DenseMatrix<T>

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

Formats the value using the given formatter.

impl<T: Number + RealNumber> EVDDecomposable<T> for DenseMatrix<T>

fn evd(&self, symmetric: bool) -> Result<EVD<T, Self>, Failed>

Compute the eigen decomposition of a square matrix.

fn evd_mut(self, symmetric: bool) -> Result<EVD<T, Self>, Failed>

Compute the eigen decomposition of a square matrix. The input matrix will be used for factorization.

impl<T: Number + RealNumber> LUDecomposable<T> for DenseMatrix<T>

fn lu(&self) -> Result<LU<T, Self>, Failed>

Compute the LU decomposition of a square matrix.

fn lu_mut(self) -> Result<LU<T, Self>, Failed>

Compute the LU decomposition of a square matrix. The input matrix will be used for factorization.

fn lu_solve_mut(self, b: Self) -> Result<Self, Failed>

Solves Ax = b

impl<T: RealNumber> MatrixPreprocessing<T> for DenseMatrix<T>

fn binarize_mut(&mut self, threshold: T)

Each element of the matrix greater than the threshold becomes 1, while values less than or equal to the threshold become 0

fn binarize(self, threshold: T) -> Self

where Self: Sized,

Returns new matrix where elements are binarized according to a given threshold.

impl<T: RealNumber> MatrixStats<T> for DenseMatrix<T>

fn mean(&self, axis: u8) -> Vec<T>

Computes the arithmetic mean along the specified axis.

fn var(&self, axis: u8) -> Vec<T>

Computes variance along the specified axis.

fn std(&self, axis: u8) -> Vec<T>

Computes the standard deviation along the specified axis.

fn _mean_of_vector(v: &[T]) -> T

http://en.wikipedia.org/wiki/Arithmetic_mean Taken from statistical The MIT License (MIT) Copyright (c) 2015 Jeff Belgum

fn _sum_square_deviations_vec(v: &[T], c: Option<T>) -> T

Taken from statistical The MIT License (MIT) Copyright (c) 2015 Jeff Belgum

fn _var_of_vec(v: &[T], xbar: Option<T>) -> T

http://en.wikipedia.org/wiki/Variance#Sample_variance Taken from statistical The MIT License (MIT) Copyright (c) 2015 Jeff Belgum

fn standard_scale_mut(&mut self, mean: &[T], std: &[T], axis: u8)

standardize values by removing the mean and scaling to unit variance

impl<T: Debug + Display + Copy + Sized> MutArray<T, (usize, usize)> for DenseMatrix<T>

fn set(&mut self, pos: (usize, usize), x: T)

assign value to a position

fn iterator_mut<'b>( &'b mut self, axis: u8, ) -> Box<dyn Iterator<Item = &'b mut T> + 'b>

iterate over mutable values

fn swap(&mut self, a: S, b: S)

where S: Copy,

swap values between positions

fn div_element_mut(&mut self, pos: S, x: T)

where T: Number, S: Copy,

divide element by a given value

fn mul_element_mut(&mut self, pos: S, x: T)

where T: Number, S: Copy,

multiply element for a given value

fn add_element_mut(&mut self, pos: S, x: T)

where T: Number, S: Copy,

add a given value to an element

fn sub_element_mut(&mut self, pos: S, x: T)

where T: Number, S: Copy,

subtract a given value to an element

fn sub_scalar_mut(&mut self, x: T)

where T: Number,

subtract a given value to all the elements

fn add_scalar_mut(&mut self, x: T)

where T: Number,

add a given value to all the elements

fn mul_scalar_mut(&mut self, x: T)

where T: Number,

multiply a given value to all the elements

fn div_scalar_mut(&mut self, x: T)

where T: Number,

divide a given value to all the elements

fn add_mut(&mut self, other: &dyn Array<T, S>)

where T: Number, S: Eq,

add values from another array to the values of initial array

fn sub_mut(&mut self, other: &dyn Array<T, S>)

where T: Number, S: Eq,

subtract values from another array to the values of initial array

fn mul_mut(&mut self, other: &dyn Array<T, S>)

where T: Number, S: Eq,

multiply values from another array to the values of initial array

fn div_mut(&mut self, other: &dyn Array<T, S>)

where T: Number, S: Eq,

divide values from another array to the values of initial array

impl<T: Debug + Display + Copy + Sized> MutArrayView2<T> for DenseMatrix<T>

fn copy_from(&mut self, other: &dyn Array<T, (usize, usize)>)

copy values from another array

fn abs_mut(&mut self)

where T: Number + Signed,

update view with absolute values

fn neg_mut(&mut self)

where T: Number + Neg<Output = T>,

update view values with opposite sign

fn pow_mut(&mut self, p: T)

where T: RealNumber,

update view values at power p

fn scale_mut(&mut self, mean: &[T], std: &[T], axis: u8)

where T: Number,

scale view values

impl<T: Debug + Display + Copy + Sized + PartialEq> PartialEq for DenseMatrix<T>

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Number + RealNumber> QRDecomposable<T> for DenseMatrix<T>

fn qr(&self) -> Result<QR<T, Self>, Failed>

Compute the QR decomposition of a matrix.

fn qr_mut(self) -> Result<QR<T, Self>, Failed>

Compute the QR decomposition of a matrix. The input matrix will be used for factorization.

fn qr_solve_mut(self, b: Self) -> Result<Self, Failed>

Solves Ax = b

impl<T: Number + RealNumber + RelativeEq> RelativeEq for DenseMatrix<T>

where T::Epsilon: Copy,

fn default_max_relative() -> T::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq( &self, other: &Self, epsilon: T::Epsilon, max_relative: T::Epsilon, ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

The inverse of RelativeEq::relative_eq.

impl<T: Number + RealNumber> SVDDecomposable<T> for DenseMatrix<T>

fn svd_solve_mut(self, b: Self) -> Result<Self, Failed>

Solves Ax = b. Overrides original matrix in the process.

fn svd_solve(&self, b: Self) -> Result<Self, Failed>

Solves Ax = b

fn svd(&self) -> Result<SVD<T, Self>, Failed>

Compute the SVD decomposition of a matrix.

fn svd_mut(self) -> Result<SVD<T, Self>, Failed>

Compute the SVD decomposition of a matrix. The input matrix will be used for factorization.