Struct Matrix

#[repr(C)]
pub struct Matrix<const M: usize, const N: usize, T = f32> { /* private fields */ }

Represents a matrix with constant M rows and constant N columns.

The underlying data is represented as an array and is always stored in column-major order.

See the crate root for usage examples.

Implementations

impl<const D: usize, T> Matrix<D, D, T>

where T: Abs + PartialOrd + Copy + Zero + One + Sum + Add<Output = T> + Neg<Output = T> + Mul<Output = T> + Sub<Output = T> + Div<Output = T>,

pub fn inv(&self) -> Option<Self>

pub fn det(&self) -> T

pub fn lu(&self) -> (Matrix<D, D, T>, Matrix<D, D, T>, Matrix<D, D, T>)

impl<const M: usize, const N: usize, T> Matrix<M, N, T>

pub fn as_slice(&self) -> &[T]

Views the underlying data as a contiguous slice.

pub fn as_mut_slice(&mut self) -> &mut [T]

Views the underlying data as a contiguous mutable slice.

pub fn row(&self, i: usize) -> &Row<M, N, T>

Returns a reference to the i-th row of this matrix.

pub fn row_mut(&mut self, i: usize) -> &mut Row<M, N, T>

Returns a mutable reference to the i-th row of this matrix.

pub fn column(&self, i: usize) -> &Column<M, N, T>

Returns a reference to the i-th column of this matrix.

pub fn column_mut(&mut self, i: usize) -> &mut Column<M, N, T>

Returns a mutable reference to the i-th column of this matrix.

pub fn get<I>(&self, i: I) -> Option<&I::Output>

where I: MatrixIndex<Self>,

Returns a reference to an element in the matrix or None if out of bounds.

pub fn get_mut<I>(&mut self, i: I) -> Option<&mut I::Output>

where I: MatrixIndex<Self>,

Returns a mutable reference to an element in the matrix or None if out of bounds.

pub unsafe fn get_unchecked<I>(&self, i: I) -> &I::Output

where I: MatrixIndex<Self>,

Returns a reference to an element in the matrix without doing any bounds checking.

Safety

Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.

pub unsafe fn get_unchecked_mut<I>(&mut self, i: I) -> &mut I::Output

where I: MatrixIndex<Self>,

Returns a mutable reference to an element in the matrix without doing any bounds checking.

Safety

Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.

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

Returns an iterator over the underlying data.

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns a mutable iterator over the underlying data.

pub fn swap_rows(&mut self, r1: usize, r2: usize)

where T: Copy,

Swap the two given rows of this matrix

pub fn swap_columns(&mut self, c1: usize, c2: usize)

where T: Copy,

Swap the two given columns of this matrix

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

where T: Clone,

Transpose of the current matrix.

pub fn T(&self) -> Matrix<N, M, T>

where T: Clone,

Transpose of the current matrix.

pub fn norm(&self) -> T

where T: Copy + Zero + Abs + Sqrt + Add<Output = T> + Mul<Output = T>,

Compute the Frobenius norm

pub fn normalize(self) -> Self

where T: Copy + Zero + Abs + Sqrt + Add<Output = T> + Mul<Output = T> + Div<Output = T>,

Compute the Frobenius norm

impl<const N: usize, T> Matrix<N, N, T>

pub fn trace(&self) -> T

where T: Zero, for<'a> &'a T: Add<&'a T, Output = T>,

Compute the sum of diagonal elements

impl<T> Matrix<3, 1, T>

pub fn cross(&self, other: &Self) -> Self

where for<'a> &'a T: Mul<&'a T, Output = T> + Sub<&'a T, Output = T>,

Trait Implementations

impl<const M: usize, const N: usize, T: AbsDiffEq> AbsDiffEq for Matrix<M, N, T>

where T::Epsilon: Copy,

type Epsilon = <T as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

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

fn abs_diff_eq(&self, other: &Self, epsilon: Self::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, const M: usize, const N: usize> Add<&Matrix<M, N, T>> for &Matrix<M, N, T>

where T: Copy + Zero + Add<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the + operator.

fn add(self, other: &Matrix<M, N, T>) -> Self::Output

Performs the + operation.

impl<T, const M: usize, const N: usize> Add<&Matrix<M, N, T>> for Matrix<M, N, T>

where T: Copy + Add<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the + operator.

fn add(self, other: &Matrix<M, N, T>) -> Self::Output

Performs the + operation.

impl<T, const M: usize, const N: usize> Add<&T> for &Matrix<M, N, T>

where T: Copy + Zero + Add<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const M: usize, const N: usize> Add<&T> for Matrix<M, N, T>

where T: Copy + Add<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const M: usize, const N: usize> Add<Matrix<M, N, T>> for &Matrix<M, N, T>

where T: Copy + Zero + Add<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the + operator.

fn add(self, other: Matrix<M, N, T>) -> Self::Output

Performs the + operation.

impl<T, const M: usize, const N: usize> Add<T> for &Matrix<M, N, T>

where T: Copy + Zero + Add<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const M: usize, const N: usize> Add<T> for Matrix<M, N, T>

where T: Copy + Add<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const M: usize, const N: usize> Add for Matrix<M, N, T>

where T: Copy + Add<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the + operator.

fn add(self, other: Matrix<M, N, T>) -> Self::Output

Performs the + operation.

impl<T, const M: usize, const N: usize> AddAssign<&Matrix<M, N, T>> for Matrix<M, N, T>

where T: Copy + AddAssign,

fn add_assign(&mut self, other: &Matrix<M, N, T>)

Performs the += operation.

impl<T, const M: usize, const N: usize> AddAssign<&T> for Matrix<M, N, T>

where T: Copy + AddAssign<T>,

fn add_assign(&mut self, other: &T)

Performs the += operation.

impl<'a, T, const M: usize, const N: usize> AddAssign<T> for Matrix<M, N, T>

where T: Copy + AddAssign<T>,

fn add_assign(&mut self, other: T)

Performs the += operation.

impl<T, const M: usize, const N: usize> AddAssign for Matrix<M, N, T>

where T: Copy + AddAssign,

fn add_assign(&mut self, other: Matrix<M, N, T>)

Performs the += operation.

impl<const M: usize, const N: usize, T: Clone> Clone for Matrix<M, N, T>

fn clone(&self) -> Matrix<M, N, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, const M: usize, const N: usize> Debug for Matrix<M, N, T>

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

Formats the value using the given formatter.

impl<T: Display, const M: usize, const N: usize> Display for Matrix<M, N, T>

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

Formats the value using the given formatter.

impl<T, const M: usize, const N: usize> Div<&T> for &Matrix<M, N, T>

where T: Copy + Zero + Div<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const M: usize, const N: usize> Div<&T> for Matrix<M, N, T>

where T: Copy + Div<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const M: usize, const N: usize> Div<T> for &Matrix<M, N, T>

where T: Copy + Zero + Div<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const M: usize, const N: usize> Div<T> for Matrix<M, N, T>

where T: Copy + Div<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const M: usize, const N: usize> DivAssign<&T> for Matrix<M, N, T>

where T: Copy + DivAssign<T>,

fn div_assign(&mut self, other: &T)

Performs the /= operation.

impl<'a, T, const M: usize, const N: usize> DivAssign<T> for Matrix<M, N, T>

where T: Copy + DivAssign<T>,

fn div_assign(&mut self, other: T)

Performs the /= operation.

impl<T: Copy> From<(T, T, T)> for Matrix<1, 3, T>

fn from(src: (T, T, T)) -> Self

Converts to this type from the input type.

impl<T: Copy> From<(T, T, T)> for Matrix<3, 1, T>

fn from(src: (T, T, T)) -> Self

Converts to this type from the input type.

impl<T: Copy> From<(T, T, T, T)> for Matrix<1, 4, T>

fn from(src: (T, T, T, T)) -> Self

Converts to this type from the input type.

impl<T: Copy> From<(T, T, T, T)> for Matrix<4, 1, T>

fn from(src: (T, T, T, T)) -> Self

Converts to this type from the input type.

impl<T: Copy> From<Matrix<1, 3, T>> for (T, T, T)

fn from(src: Matrix<1, 3, T>) -> Self

Converts to this type from the input type.

impl<T: Copy> From<Matrix<1, 4, T>> for (T, T, T, T)

fn from(src: Matrix<1, 4, T>) -> Self

Converts to this type from the input type.

impl<T: Copy> From<Matrix<3, 1, T>> for (T, T, T)

fn from(src: Matrix<3, 1, T>) -> Self

Converts to this type from the input type.

impl<T: Copy> From<Matrix<4, 1, T>> for (T, T, T, T)

fn from(src: Matrix<4, 1, T>) -> Self

Converts to this type from the input type.

impl<T, const M: usize, const N: usize> FromIterator<T> for Matrix<M, N, T>

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = T>,

Create a new matrix from an iterator.

Elements will be filled in column-major order.

Panics

If the iterator doesn’t yield enough elements to fill the matrix.

impl<const M: usize, const N: usize, T: Hash> Hash for Matrix<M, N, T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, I, const M: usize, const N: usize> Index<I> for Matrix<M, N, T>

where I: MatrixIndex<Self>,

type Output = <I as MatrixIndex<Matrix<M, N, T>>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &I::Output

Performs the indexing (container[index]) operation.

impl<T, I, const M: usize, const N: usize> IndexMut<I> for Matrix<M, N, T>

where I: MatrixIndex<Self>,

fn index_mut(&mut self, index: I) -> &mut I::Output

Performs the mutable indexing (container[index]) operation.

impl<T, const M: usize, const N: usize> MatrixIndex<Matrix<M, N, T>> for (usize, usize)

type Output = T

The output type returned by methods.

fn get(self, matrix: &Matrix<M, N, T>) -> Option<&Self::Output>

Returns a shared reference to the output at this location, if in bounds.

fn get_mut(self, matrix: &mut Matrix<M, N, T>) -> Option<&mut Self::Output>

Returns a mutable reference to the output at this location, if in bounds.

unsafe fn get_unchecked( self, matrix: *const Matrix<M, N, T>, ) -> *const Self::Output

Returns a shared reference to the output at this location, without performing any bounds checking.

unsafe fn get_unchecked_mut( self, matrix: *mut Matrix<M, N, T>, ) -> *mut Self::Output

Returns a mutable reference to the output at this location, without performing any bounds checking.

fn index(self, matrix: &Matrix<M, N, T>) -> &Self::Output

Returns a shared reference to the output at this location, panicking if out of bounds.

fn index_mut(self, matrix: &mut Matrix<M, N, T>) -> &mut Self::Output

Returns a mutable reference to the output at this location, panicking if out of bounds.

impl<T, const M: usize, const N: usize> MatrixIndex<Matrix<M, N, T>> for usize

type Output = T

The output type returned by methods.

fn get(self, matrix: &Matrix<M, N, T>) -> Option<&Self::Output>

Returns a shared reference to the output at this location, if in bounds.

fn get_mut(self, matrix: &mut Matrix<M, N, T>) -> Option<&mut Self::Output>

Returns a mutable reference to the output at this location, if in bounds.

unsafe fn get_unchecked( self, matrix: *const Matrix<M, N, T>, ) -> *const Self::Output

Returns a shared reference to the output at this location, without performing any bounds checking.

unsafe fn get_unchecked_mut( self, matrix: *mut Matrix<M, N, T>, ) -> *mut Self::Output

Returns a mutable reference to the output at this location, without performing any bounds checking.

fn index(self, matrix: &Matrix<M, N, T>) -> &Self::Output

Returns a shared reference to the output at this location, panicking if out of bounds.

fn index_mut(self, matrix: &mut Matrix<M, N, T>) -> &mut Self::Output

Returns a mutable reference to the output at this location, panicking if out of bounds.

impl<T, const N: usize, const M: usize, const P: usize> Mul<&Matrix<N, P, T>> for &Matrix<M, N, T>

where T: Copy + Zero + Mul<Output = T> + Sum,

type Output = Matrix<M, P, T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const N: usize, const M: usize, const P: usize> Mul<&Matrix<N, P, T>> for Matrix<M, N, T>

where T: Copy + Zero + Mul<Output = T> + Sum,

type Output = Matrix<M, P, T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const M: usize, const N: usize> Mul<&T> for &Matrix<M, N, T>

where T: Copy + Zero + Mul<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const M: usize, const N: usize> Mul<&T> for Matrix<M, N, T>

where T: Copy + Mul<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const N: usize, const M: usize, const P: usize> Mul<Matrix<N, P, T>> for &Matrix<M, N, T>

where T: Copy + Zero + Mul<Output = T> + Sum,

type Output = Matrix<M, P, T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const N: usize, const M: usize, const P: usize> Mul<Matrix<N, P, T>> for Matrix<M, N, T>

where T: Copy + Zero + Mul<Output = T> + Sum,

type Output = Matrix<M, P, T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const M: usize, const N: usize> Mul<T> for &Matrix<M, N, T>

where T: Copy + Zero + Mul<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const M: usize, const N: usize> Mul<T> for Matrix<M, N, T>

where T: Copy + Mul<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const M: usize, const N: usize> MulAssign<&T> for Matrix<M, N, T>

where T: Copy + MulAssign<T>,

fn mul_assign(&mut self, other: &T)

Performs the *= operation.

impl<'a, T, const M: usize, const N: usize> MulAssign<T> for Matrix<M, N, T>

where T: Copy + MulAssign<T>,

fn mul_assign(&mut self, other: T)

Performs the *= operation.

impl<T, const M: usize, const N: usize> Neg for &Matrix<M, N, T>

where T: Copy + Zero + Neg<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, const M: usize, const N: usize> Neg for Matrix<M, N, T>

where T: Copy + Zero + Neg<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, const M: usize, const N: usize> Not for &Matrix<M, N, T>

where T: Copy + Zero + Not<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T, const M: usize, const N: usize> Not for Matrix<M, N, T>

where T: Copy + Zero + Not<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const M: usize, const N: usize, T: Ord> Ord for Matrix<M, N, T>

fn cmp(&self, other: &Matrix<M, N, T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<const M: usize, const N: usize, T: PartialEq> PartialEq for Matrix<M, N, T>

fn eq(&self, other: &Matrix<M, N, T>) -> 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<const M: usize, const N: usize, T: PartialOrd> PartialOrd for Matrix<M, N, T>

fn partial_cmp(&self, other: &Matrix<M, N, T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const M: usize, const N: usize, T: RelativeEq> RelativeEq for Matrix<M, N, T>

where T::Epsilon: Copy,

fn default_max_relative() -> Self::Epsilon

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

fn relative_eq( &self, other: &Self, epsilon: Self::Epsilon, max_relative: Self::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, const M: usize, const N: usize> Rem<&T> for &Matrix<M, N, T>

where T: Copy + Zero + Rem<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the % operator.

fn rem(self, other: &T) -> Self::Output

Performs the % operation.

impl<T, const M: usize, const N: usize> Rem<&T> for Matrix<M, N, T>

where T: Copy + Rem<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the % operator.

fn rem(self, other: &T) -> Self::Output

Performs the % operation.

impl<T, const M: usize, const N: usize> Rem<T> for &Matrix<M, N, T>

where T: Copy + Zero + Rem<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the % operator.

fn rem(self, other: T) -> Self::Output

Performs the % operation.

impl<T, const M: usize, const N: usize> Rem<T> for Matrix<M, N, T>

where T: Copy + Rem<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the % operator.

fn rem(self, other: T) -> Self::Output

Performs the % operation.

impl<T, const M: usize, const N: usize> RemAssign<&T> for Matrix<M, N, T>

where T: Copy + RemAssign<T>,

fn rem_assign(&mut self, other: &T)

Performs the %= operation.

impl<'a, T, const M: usize, const N: usize> RemAssign<T> for Matrix<M, N, T>

where T: Copy + RemAssign<T>,

fn rem_assign(&mut self, other: T)

Performs the %= operation.

impl<T, const M: usize, const N: usize> Sub<&Matrix<M, N, T>> for &Matrix<M, N, T>

where T: Copy + Zero + Sub<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the - operator.

fn sub(self, other: &Matrix<M, N, T>) -> Self::Output

Performs the - operation.

impl<T, const M: usize, const N: usize> Sub<&Matrix<M, N, T>> for Matrix<M, N, T>

where T: Copy + Sub<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the - operator.

fn sub(self, other: &Matrix<M, N, T>) -> Self::Output

Performs the - operation.

impl<T, const M: usize, const N: usize> Sub<&T> for &Matrix<M, N, T>

where T: Copy + Zero + Sub<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const M: usize, const N: usize> Sub<&T> for Matrix<M, N, T>

where T: Copy + Sub<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const M: usize, const N: usize> Sub<Matrix<M, N, T>> for &Matrix<M, N, T>

where T: Copy + Zero + Sub<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the - operator.

fn sub(self, other: Matrix<M, N, T>) -> Self::Output

Performs the - operation.

impl<T, const M: usize, const N: usize> Sub<T> for &Matrix<M, N, T>

where T: Copy + Zero + Sub<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const M: usize, const N: usize> Sub<T> for Matrix<M, N, T>

where T: Copy + Sub<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const M: usize, const N: usize> Sub for Matrix<M, N, T>

where T: Copy + Sub<Output = T>,

type Output = Matrix<M, N, T>

The resulting type after applying the - operator.

fn sub(self, other: Matrix<M, N, T>) -> Self::Output

Performs the - operation.

impl<T, const M: usize, const N: usize> SubAssign<&Matrix<M, N, T>> for Matrix<M, N, T>

where T: Copy + SubAssign,

fn sub_assign(&mut self, other: &Matrix<M, N, T>)

Performs the -= operation.

impl<T, const M: usize, const N: usize> SubAssign<&T> for Matrix<M, N, T>

where T: Copy + SubAssign<T>,

fn sub_assign(&mut self, other: &T)

Performs the -= operation.

impl<'a, T, const M: usize, const N: usize> SubAssign<T> for Matrix<M, N, T>

where T: Copy + SubAssign<T>,

fn sub_assign(&mut self, other: T)

Performs the -= operation.

impl<T, const M: usize, const N: usize> SubAssign for Matrix<M, N, T>

where T: Copy + SubAssign,

fn sub_assign(&mut self, other: Matrix<M, N, T>)

Performs the -= operation.

impl<const M: usize, const N: usize, T: Copy> Copy for Matrix<M, N, T>

impl<const M: usize, const N: usize, T: Eq> Eq for Matrix<M, N, T>

impl<const M: usize, const N: usize, T> StructuralPartialEq for Matrix<M, N, T>