Struct easy_ml::matrices::Matrix

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

A general purpose matrix of some type. This type may implement no traits, in which case the matrix will be rather useless. If the type implements Clone most storage and accessor methods are defined and if the type implements Numeric then the matrix can be used in a mathematical way.

When doing numeric operations with Matrices you should be careful to not consume a matrix by accidentally using it by value. All the operations are also defined on references to matrices so you should favor &x * &y style notation for matrices you intend to continue using. There are also convenience operations defined for a matrix and a scalar.

Matrix size invariants

Matrices must always be at least 1x1. You cannot construct a matrix with no rows or no columns, and any function that resizes matrices will error if you try to use it in a way that would construct a 0x1, 1x0, or 0x0 matrix. The maximum size of a matrix is dependent on the platform’s std::usize::MAX value. Matrices with dimensions NxM such that N * M < std::usize::MAX should not cause any errors in this library, but attempting to expand their size further may cause panics and or errors. At the time of writing it is no longer possible to construct or use matrices where the product of their number of rows and columns exceed std::usize::MAX, but some constructor methods may be used to attempt this. Concerned readers should note that on a 64 bit computer this maximum value is 18,446,744,073,709,551,615 so running out of memory is likely to occur first.

Matrix layout and iterator performance

See iterators submodule for Matrix layout and iterator performance

Implementations

impl<T> Matrix<T>

Methods for matrices of any type, including non numerical types such as bool.

pub fn from_scalar(value: T) -> Matrix<T>

Creates a 1x1 matrix from some scalar

pub fn row(values: Vec<T>) -> Matrix<T>

Creates a row vector (1xN) from a list

pub fn column(values: Vec<T>) -> Matrix<T>

Creates a column vector (Nx1) from a list

pub fn from(values: Vec<Vec<T>>) -> Matrix<T>

Creates a matrix from a nested array of values, each inner vector being a row, and hence the outer vector containing all rows in sequence, the same way as when writing matrices in mathematics.

Example of a 2 x 3 matrix in both notations:

  [
     1, 2, 4
     8, 9, 3
  ]

use easy_ml::matrices::Matrix;
Matrix::from(vec![
    vec![ 1, 2, 4 ],
    vec![ 8, 9, 3 ]]);

Panics

Panics if the input is jagged or rows or column length is 0.

pub fn from_flat_row_major(size: (Row, Column), values: Vec<T>) -> Matrix<T>

Creates a matrix with the specified size from a row major vec of data. The length of the vec must match the size of the matrix or the constructor will panic.

Example of a 2 x 3 matrix in both notations:

  [
     1, 2, 4
     8, 9, 3
  ]

use easy_ml::matrices::Matrix;
Matrix::from_flat_row_major((2, 3), vec![
    1, 2, 4,
    8, 9, 3]);

This method is more efficient than Matrix::from but requires specifying the size explicitly and manually keeping track of where rows start and stop.

Panics

Panics if the length of the vec does not match the size of the matrix.

pub fn unit(value: T) -> Matrix<T>

👎 Deprecated since 1.1.0:

Incorrect use of terminology, a unit matrix is another term for an identity matrix, please use from_scalar instead

pub fn size(&self) -> (Row, Column)

Returns the dimensionality of this matrix in Row, Column format

pub fn rows(&self) -> Row

Gets the number of rows in this matrix.

pub fn columns(&self) -> Column

Gets the number of columns in this matrix.

pub fn get_reference(&self, row: Row, column: Column) -> &T

Gets a reference to the value at this row and column. Rows and Columns are 0 indexed.

Panics

Panics if the index is out of range.

pub fn set(&mut self, row: Row, column: Column, value: T)

Sets a new value to this row and column. Rows and Columns are 0 indexed.

Panics

Panics if the index is out of range.

pub fn remove_row(&mut self, row: Row)

Removes a row from this Matrix, shifting all other rows to the left. Rows are 0 indexed.

Panics

This will panic if the row does not exist or the matrix only has one row.

pub fn remove_column(&mut self, column: Column)

Removes a column from this Matrix, shifting all other columns to the left. Columns are 0 indexed.

Panics

This will panic if the column does not exist or the matrix only has one column.

pub fn column_reference_iter(
    &self,
    column: Column
) -> ColumnReferenceIterator<'_, T>

Returns an iterator over references to a column vector in this matrix. Columns are 0 indexed.

pub fn row_reference_iter(&self, row: Row) -> RowReferenceIterator<'_, T>

Returns an iterator over references to a row vector in this matrix. Rows are 0 indexed.

pub fn column_major_reference_iter(&self) -> ColumnMajorReferenceIterator<'_, T>

Returns a column major iterator over references to all values in this matrix, proceeding through each column in order.

pub fn row_major_reference_iter(&self) -> RowMajorReferenceIterator<'_, T>

Returns a row major iterator over references to all values in this matrix, proceeding through each row in order.

pub fn retain_mut(&mut self, slice: Slice2D)

Shrinks this matrix down from its current MxN size down to some new size OxP where O and P are determined by the kind of slice given and 1 <= O <= M and 1 <= P <= N.

Only rows and columns specified by the slice will be retained, so for instance if the Slice is constructed by Slice2D::new().rows(Slice::Range(0..2)).columns(Slice::Range(0..3)) then the modified matrix will be no bigger than 2x3 and contain up to the first two rows and first three columns that it previously had.

See Slice for constructing slices.

Panics

This function will panic if the slice would delete all rows or all columns from this matrix, ie the resulting matrix must be at least 1x1.

pub fn try_into_scalar(self) -> Result<T, ScalarConversionError>

Consumes a 1x1 matrix and converts it into a scalar without copying the data.

Example

use easy_ml::matrices::Matrix;
let x = Matrix::column(vec![ 1.0, 2.0, 3.0 ]);
let sum_of_squares: f64 = (x.transpose() * x).try_into_scalar()?;

impl<T: Clone> Matrix<T>

Methods for matrices with types that can be copied, but still not neccessarily numerical.

pub fn transpose(&self) -> Matrix<T>

Computes and returns the transpose of this matrix

use easy_ml::matrices::Matrix;
let x = Matrix::from(vec![
   vec![ 1, 2 ],
   vec![ 3, 4 ]]);
let y = Matrix::from(vec![
   vec![ 1, 3 ],
   vec![ 2, 4 ]]);
assert_eq!(x.transpose(), y);

pub fn transpose_mut(&mut self)

Transposes the matrix in place.

use easy_ml::matrices::Matrix;
let mut x = Matrix::from(vec![
   vec![ 1, 2 ],
   vec![ 3, 4 ]]);
x.transpose_mut();
let y = Matrix::from(vec![
   vec![ 1, 3 ],
   vec![ 2, 4 ]]);
assert_eq!(x, y);

pub fn column_iter(&self, column: Column) -> ColumnIterator<'_, T>

Returns an iterator over a column vector in this matrix. Columns are 0 indexed.

If you have a matrix such as:

[
   1, 2, 3
   4, 5, 6
   7, 8, 9
]

then a column of 0, 1, and 2 will yield [1, 4, 7], [2, 5, 8] and [3, 6, 9] respectively. If you do not need to copy the elements use column_reference_iter instead.

pub fn row_iter(&self, row: Row) -> RowIterator<'_, T>

Returns an iterator over a row vector in this matrix. Rows are 0 indexed.

If you have a matrix such as:

[
   1, 2, 3
   4, 5, 6
   7, 8, 9
]

then a row of 0, 1, and 2 will yield [1, 2, 3], [4, 5, 6] and [7, 8, 9] respectively. If you do not need to copy the elements use row_reference_iter instead.

pub fn column_major_iter(&self) -> ColumnMajorIterator<'_, T>

Returns a column major iterator over all values in this matrix, proceeding through each column in order.

If you have a matrix such as:

[
   1, 2
   3, 4
]

then the iterator will yield [1, 3, 2, 4]. If you do not need to copy the elements use column_major_reference_iter instead.

pub fn row_major_iter(&self) -> RowMajorIterator<'_, T>

Returns a row major iterator over all values in this matrix, proceeding through each row in order.

If you have a matrix such as:

[
   1, 2
   3, 4
]

then the iterator will yield [1, 2, 3, 4]. If you do not need to copy the elements use row_major_reference_iter instead.

pub fn empty(value: T, size: (Row, Column)) -> Matrix<T>

Creates a matrix of the provided size with all elements initialised to the provided value

pub fn get(&self, row: Row, column: Column) -> T

Gets a copy of the value at this row and column. Rows and Columns are 0 indexed.

Panics

Panics if the index is out of range.

pub fn scalar(&self) -> T

Similar to matrix.get(0, 0) in that this returns the element in the first row and first column, except that this method will panic if the matrix is not 1x1.

This is provided as a convenience function when you want to convert a unit matrix to a scalar, such as after taking a dot product of two vectors.

Example

use easy_ml::matrices::Matrix;
let x = Matrix::column(vec![ 1.0, 2.0, 3.0 ]);
let sum_of_squares: f64 = (x.transpose() * x).scalar();

Panics

Panics if the matrix is not 1x1

pub fn map_mut(&mut self, mapping_function: impl Fn(T) -> T)

Applies a function to all values in the matrix, modifying the matrix in place.

pub fn map_mut_with_index(
    &mut self,
    mapping_function: impl Fn(T, Row, Column) -> T
)

Applies a function to all values and each value’s index in the matrix, modifying the matrix in place.

pub fn map<U>(&self, mapping_function: impl Fn(T) -> U) -> Matrix<U> where
    U: Clone, 

Creates and returns a new matrix with all values from the original with the function applied to each. This can be used to change the type of the matrix such as creating a mask:

use easy_ml::matrices::Matrix;
let x = Matrix::from(vec![
   vec![ 0.0, 1.2 ],
   vec![ 5.8, 6.9 ]]);
let y = x.map(|element| element > 2.0);
let result = Matrix::from(vec![
   vec![ false, false ],
   vec![ true, true ]]);
assert_eq!(&y, &result);

pub fn map_with_index<U>(
    &self,
    mapping_function: impl Fn(T, Row, Column) -> U
) -> Matrix<U> where
    U: Clone, 

Creates and returns a new matrix with all values from the original and the index of each value mapped by a function. This can be used to perform elementwise operations that are not defined on the Matrix type itself.

Exmples

Matrix elementwise division:

use easy_ml::matrices::Matrix;
let x = Matrix::from(vec![
    vec![ 9.0, 2.0 ],
    vec![ 4.0, 3.0 ]]);
let y = Matrix::from(vec![
    vec![ 3.0, 2.0 ],
    vec![ 1.0, 3.0 ]]);
let z = x.map_with_index(|x, row, column| x / y.get(row, column));
let result = Matrix::from(vec![
    vec![ 3.0, 1.0 ],
    vec![ 4.0, 1.0 ]]);
assert_eq!(&z, &result);

pub fn insert_row(&mut self, row: Row, value: T)

Inserts a new row into the Matrix at the provided index, shifting other rows to the right and filling all entries with the provided value. Rows are 0 indexed.

Panics

This will panic if the row is greater than the number of rows in the matrix.

pub fn insert_row_with<I>(&mut self, row: Row, values: I) where
    I: Iterator<Item = T>, 

Inserts a new row into the Matrix at the provided index, shifting other rows to the right and filling all entries with the values from the iterator in sequence. Rows are 0 indexed.

Panics

This will panic if the row is greater than the number of rows in the matrix, or if the iterator has fewer elements than self.columns().

Example of duplicating a row:

use easy_ml::matrices::Matrix;
let x: Matrix<u8> = Matrix::row(vec![ 1, 2, 3 ]);
let mut y = x.clone();
// duplicate the first row as the second row
y.insert_row_with(1, x.row_iter(0));
assert_eq!((2, 3), y.size());
let mut values = y.column_major_iter();
assert_eq!(Some(1), values.next());
assert_eq!(Some(1), values.next());
assert_eq!(Some(2), values.next());
assert_eq!(Some(2), values.next());
assert_eq!(Some(3), values.next());
assert_eq!(Some(3), values.next());
assert_eq!(None, values.next());

pub fn insert_column(&mut self, column: Column, value: T)

Inserts a new column into the Matrix at the provided index, shifting other columns to the right and filling all entries with the provided value. Columns are 0 indexed.

Panics

This will panic if the column is greater than the number of columns in the matrix.

pub fn insert_column_with<I>(&mut self, column: Column, values: I) where
    I: Iterator<Item = T>, 

Inserts a new column into the Matrix at the provided index, shifting other columns to the right and filling all entries with the values from the iterator in sequence. Columns are 0 indexed.

Panics

This will panic if the column is greater than the number of columns in the matrix, or if the iterator has fewer elements than self.rows().

Example of duplicating a column:

use easy_ml::matrices::Matrix;
let x: Matrix<u8> = Matrix::column(vec![ 1, 2, 3 ]);
let mut y = x.clone();
// duplicate the first column as the second column
y.insert_column_with(1, x.column_iter(0));
assert_eq!((3, 2), y.size());
let mut values = y.column_major_iter();
assert_eq!(Some(1), values.next());
assert_eq!(Some(2), values.next());
assert_eq!(Some(3), values.next());
assert_eq!(Some(1), values.next());
assert_eq!(Some(2), values.next());
assert_eq!(Some(3), values.next());
assert_eq!(None, values.next());

pub fn retain(&self, slice: Slice2D) -> Matrix<T>

Makes a copy of this matrix shrunk down in size according to the slice. See retain_mut.

impl<T: Numeric> Matrix<T> where
    &'a T: NumericRef<T>, 

Methods for matrices with numerical types, such as f32 or f64.

Note that unsigned integers are not Numeric because they do not implement Neg. You must first wrap unsigned integers via Wrapping.

While these methods will all be defined on signed integer types as well, such as i16 or i32, in many cases integers cannot be used sensibly in these computations. If you have a matrix of type i8 for example, you should consider mapping it into a floating type before doing heavy linear algebra maths on it.

Determinants can be computed without loss of precision using sufficiently large signed integers because the only operations performed on the elements are addition, subtraction and mulitplication. However the inverse of a matrix such as

[
  4, 7
  2, 8
]

is

[
  0.6, -0.7,
 -0.2, 0.4
]

which requires a type that supports decimals to accurately represent.

Mapping matrix type example:

use easy_ml::matrices::Matrix;
use std::num::Wrapping;

let matrix: Matrix<u8> = Matrix::from(vec![
    vec![ 2, 3 ],
    vec![ 6, 0 ]
]);
// determinant is not defined on this matrix because u8 is not Numeric
// println!("{:?}", matrix.determinant()); // won't compile
// however Wrapping<u8> is numeric
let matrix = matrix.map(|element| Wrapping(element));
println!("{:?}", matrix.determinant()); // -> 238 (overflow)
println!("{:?}", matrix.map(|element| element.0 as i16).determinant()); // -> -18
println!("{:?}", matrix.map(|element| element.0 as f32).determinant()); // -> -18.0

pub fn determinant(&self) -> Option<T>

Returns the determinant of this square matrix, or None if the matrix does not have a determinant. See linear_algebra

pub fn inverse(&self) -> Option<Matrix<T>> where
    T: Add<Output = T> + Mul<Output = T> + Sub<Output = T> + Div<Output = T>, 

Computes the inverse of a matrix provided that it exists. To have an inverse a matrix must be square (same number of rows and columns) and it must also have a non zero determinant. See linear_algebra

pub fn covariance_column_features(&self) -> Matrix<T>

Computes the covariance matrix for this NxM feature matrix, in which each N’th row has M features to find the covariance and variance of. See linear_algebra

pub fn covariance_row_features(&self) -> Matrix<T>

Computes the covariance matrix for this NxM feature matrix, in which each M’th column has N features to find the covariance and variance of. See linear_algebra

impl<T: Numeric + Real> Matrix<T> where
    &'a T: NumericRef<T> + RealRef<T>, 

Methods for matrices with numerical real valued types, such as f32 or f64.

This excludes signed and unsigned integers as they do not support decimal precision and hence can’t be used for operations like square roots.

Third party fixed precision and infinite precision decimal types should be able to implement all of the methods for Real and then utilise these functions.

pub fn euclidean_length(&self) -> T

Computes the L2 norm of this row or column vector, also referred to as the length or magnitude, and written as ||x||, or sometimes |x|.

||a|| = sqrt(a₁² + a₂² + a₃²…) = sqrt(a^T * a)

This is a shorthand for (x.transpose() * x).scalar().sqrt() for column vectors and (x * x.transpose()).scalar().sqrt() for row vectors, ie the square root of the dot product of a vector with itself.

The euclidean length can be used to compute a unit vector, that is, a vector with length of 1. This should not be confused with a unit matrix, which is another name for an identity matrix.

use easy_ml::matrices::Matrix;
let a = Matrix::column(vec![ 1.0, 2.0, 3.0 ]);
let length = a.euclidean_length(); // (1^2 + 2^2 + 3^2)^0.5
let unit = a / length;
assert_eq!(unit.euclidean_length(), 1.0);

Panics

If the matrix is not a vector, ie if it has more than one row and more than one column.

impl<T: Numeric> Matrix<T>

pub fn diagonal(value: T, size: (Row, Column)) -> Matrix<T>

Creates a diagonal matrix of the provided size with the diagonal elements set to the provided value and all other elements in the matrix set to 0. A diagonal matrix is always square.

The size is still taken as a tuple to facilitate creating a diagonal matrix from the dimensionality of an existing one. If the provided value is 1 then this will create an identity matrix.

A 3 x 3 identity matrix:

[
  1, 0, 0
  0, 1, 0
  0, 0, 1
]

Panics

If the provided size is not square.

Trait Implementations

impl<T: Numeric> Add<&'_ Matrix<T>> for &Matrix<T> where
    &'a T: NumericRef<T>, 

Elementwise addition for two referenced matrices.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<T: Numeric> Add<&'_ Matrix<T>> for Matrix<T> where
    &'a T: NumericRef<T>, 

Elementwise addition for two matrices with one referenced.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<T: Numeric> Add<&'_ T> for &Matrix<T> where
    &'a T: NumericRef<T>, 

Operation for a matrix and scalar by reference. The scalar is applied to all elements, this is a shorthand for map().

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, rhs: &T) -> Self::Output

Performs the + operation.

impl<T: Numeric> Add<&'_ T> for Matrix<T> where
    &'a T: NumericRef<T>, 

Operation for a matrix by value and scalar by reference. The scalar is applied to all elements, this is a shorthand for map().

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, rhs: &T) -> Self::Output

Performs the + operation.

impl<T: Numeric> Add<Matrix<T>> for Matrix<T> where
    &'a T: NumericRef<T>, 

Elementwise addition for two matrices.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<T: Numeric> Add<Matrix<T>> for &Matrix<T> where
    &'a T: NumericRef<T>, 

Elementwise addition for two matrices with one referenced.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<T>) -> Self::Output

Performs the + operation.

impl<T: Numeric> Add<T> for &Matrix<T> where
    &'a T: NumericRef<T>, 

Operation for a matrix by reference and scalar by value. The scalar is applied to all elements, this is a shorthand for map().

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<T: Numeric> Add<T> for Matrix<T> where
    &'a T: NumericRef<T>, 

Operation for a matrix and scalar by value. The scalar is applied to all elements, this is a shorthand for map().

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

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

Any matrix of a Cloneable type implements Clone.

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

Any matrix of a Displayable + Cloneable type implements Display

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

Formats the value using the given formatter.

impl<T: Numeric> Div<&'_ T> for &Matrix<T> where
    &'a T: NumericRef<T>, 

Operation for a matrix and scalar by reference. The scalar is applied to all elements, this is a shorthand for map().

type Output = Matrix<T>

The resulting type after applying the / operator.

fn div(self, rhs: &T) -> Self::Output

Performs the / operation.

impl<T: Numeric> Div<&'_ T> for Matrix<T> where
    &'a T: NumericRef<T>, 

Operation for a matrix by value and scalar by reference. The scalar is applied to all elements, this is a shorthand for map().

type Output = Matrix<T>

The resulting type after applying the / operator.

fn div(self, rhs: &T) -> Self::Output

Performs the / operation.

impl<T: Numeric> Div<T> for &Matrix<T> where
    &'a T: NumericRef<T>, 

Operation for a matrix by reference and scalar by value. The scalar is applied to all elements, this is a shorthand for map().

type Output = Matrix<T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<T: Numeric> Div<T> for Matrix<T> where
    &'a T: NumericRef<T>, 

Operation for a matrix and scalar by value. The scalar is applied to all elements, this is a shorthand for map().

type Output = Matrix<T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<T: Numeric> Mul<&'_ Matrix<T>> for &Matrix<T> where
    &'a T: NumericRef<T>, 

Matrix multiplication for two referenced matrices.

This is matrix multiplication such that a matrix of dimensionality (LxM) multiplied with a matrix of dimensionality (MxN) yields a new matrix of dimensionality (LxN) with each element corresponding to the sum of products of the ith row in the first matrix and the jth column in the second matrix.

Matrices of the wrong sizes will result in a panic. No broadcasting is performed, ie you cannot multiply a (NxM) matrix by a (Nx1) column vector, you must transpose one of the arguments so that the operation is valid.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<T: Numeric> Mul<&'_ Matrix<T>> for Matrix<T> where
    &'a T: NumericRef<T>, 

Matrix multiplication for two matrices with one referenced.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<T: Numeric> Mul<&'_ T> for &Matrix<T> where
    &'a T: NumericRef<T>, 

Operation for a matrix and scalar by reference. The scalar is applied to all elements, this is a shorthand for map().

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &T) -> Self::Output

Performs the * operation.

impl<T: Numeric> Mul<&'_ T> for Matrix<T> where
    &'a T: NumericRef<T>, 

Operation for a matrix by value and scalar by reference. The scalar is applied to all elements, this is a shorthand for map().

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &T) -> Self::Output

Performs the * operation.

impl<T: Numeric> Mul<Matrix<T>> for Matrix<T> where
    &'a T: NumericRef<T>, 

Matrix multiplication for two matrices.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<T: Numeric> Mul<Matrix<T>> for &Matrix<T> where
    &'a T: NumericRef<T>, 

Matrix multiplication for two matrices with one referenced.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<T>) -> Self::Output

Performs the * operation.

impl<T: Numeric> Mul<T> for &Matrix<T> where
    &'a T: NumericRef<T>, 

Operation for a matrix by reference and scalar by value. The scalar is applied to all elements, this is a shorthand for map().

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T: Numeric> Mul<T> for Matrix<T> where
    &'a T: NumericRef<T>, 

Operation for a matrix and scalar by value. The scalar is applied to all elements, this is a shorthand for map().

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T: Numeric> Neg for &Matrix<T> where
    &'a T: NumericRef<T>, 

Elementwise negation for a referenced matrix.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Numeric> Neg for Matrix<T> where
    &'a T: NumericRef<T>, 

Elementwise negation for a matrix.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

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

PartialEq is implemented as two matrices are equal if and only if all their elements are equal and they have the same size.

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

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

This method tests for !=.

impl<T: Numeric> Sub<&'_ Matrix<T>> for &Matrix<T> where
    &'a T: NumericRef<T>, 

Elementwise subtraction for two referenced matrices.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<T: Numeric> Sub<&'_ Matrix<T>> for Matrix<T> where
    &'a T: NumericRef<T>, 

Elementwise subtraction for two matrices with one referenced.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<T: Numeric> Sub<&'_ T> for &Matrix<T> where
    &'a T: NumericRef<T>, 

Operation for a matrix and scalar by reference. The scalar is applied to all elements, this is a shorthand for map().

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &T) -> Self::Output

Performs the - operation.

impl<T: Numeric> Sub<&'_ T> for Matrix<T> where
    &'a T: NumericRef<T>, 

Operation for a matrix by value and scalar by reference. The scalar is applied to all elements, this is a shorthand for map().

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &T) -> Self::Output

Performs the - operation.

impl<T: Numeric> Sub<Matrix<T>> for Matrix<T> where
    &'a T: NumericRef<T>, 

Elementwise subtraction for two matrices.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<T: Numeric> Sub<Matrix<T>> for &Matrix<T> where
    &'a T: NumericRef<T>, 

Elementwise subtraction for two matrices with one referenced.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<T>) -> Self::Output

Performs the - operation.

impl<T: Numeric> Sub<T> for &Matrix<T> where
    &'a T: NumericRef<T>, 

Operation for a matrix by reference and scalar by value. The scalar is applied to all elements, this is a shorthand for map().

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<T: Numeric> Sub<T> for Matrix<T> where
    &'a T: NumericRef<T>, 

Operation for a matrix and scalar by value. The scalar is applied to all elements, this is a shorthand for map().

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.