Struct MatrixSliceMut 

pub struct MatrixSliceMut<'a, T: NumAssign + Copy + Default, const ROW: usize, const COL: usize> {
    pub matrix: &'a mut Matrix<T, ROW, COL>,
    /* private fields */
}

Fields

matrix: &'a mut Matrix<T, ROW, COL>

Implementations

impl<'a, T: NumAssign + Copy + Default, const ROW: usize, const COL: usize> MatrixSliceMut<'a, T, ROW, COL>

Copy values from one slice to another.

Example

use lightmatrix::{matrix::*,matrix_slice::*};
let (mut m1, mut m2) = (
    Matrix::<f64, 15, 10>::default(),
    Matrix::<f64, 15, 15>::default(),
);

//fill matrices with values...

let src = MatrixSlice::from((&m1, ((2..15), (3..15))));
let mut dest = MatrixSliceMut::from((&mut m2, ((5..8), (7..10))));
dest.assign(src);

pub fn assign<const ROW_OTHER: usize, const COL_OTHER: usize>( &mut self, other: MatrixSlice<'a, T, ROW_OTHER, COL_OTHER>, )

Trait Implementations

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW1: usize, const COL1: usize, const ROW2: usize, const COL2: usize> AddAssign<MatrixSlice<'a, T, ROW2, COL2>> for MatrixSliceMut<'a, T, ROW1, COL1>

fn add_assign(&mut self, rhs: MatrixSlice<'a, T, ROW2, COL2>)

Performs the += operation.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW1: usize, const COL1: usize, const ROW2: usize, const COL2: usize> AddAssign<MatrixSliceMut<'a, T, ROW2, COL2>> for MatrixSliceMut<'a, T, ROW1, COL1>

fn add_assign(&mut self, rhs: MatrixSliceMut<'a, T, ROW2, COL2>)

Performs the += operation.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW1: usize, const COL1: usize> AddAssign<T> for MatrixSliceMut<'a, T, ROW1, COL1>

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<'a, T: Debug + NumAssign + Copy + Default, const ROW: usize, const COL: usize> Debug for MatrixSliceMut<'a, T, ROW, COL>

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

Formats the value using the given formatter.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW1: usize, const COL1: usize, const ROW2: usize, const COL2: usize> DivAssign<MatrixSlice<'a, T, ROW2, COL2>> for MatrixSliceMut<'a, T, ROW1, COL1>

fn div_assign(&mut self, rhs: MatrixSlice<'a, T, ROW2, COL2>)

Performs the /= operation.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW1: usize, const COL1: usize, const ROW2: usize, const COL2: usize> DivAssign<MatrixSliceMut<'a, T, ROW2, COL2>> for MatrixSliceMut<'a, T, ROW1, COL1>

fn div_assign(&mut self, rhs: MatrixSliceMut<'a, T, ROW2, COL2>)

Performs the /= operation.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW1: usize, const COL1: usize> DivAssign<T> for MatrixSliceMut<'a, T, ROW1, COL1>

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<'a, T: NumAssign + Copy + Default, const ROW_DEST: usize, const COL_DEST: usize, const ROW: usize, const COL: usize> From<&'a MatrixSliceMut<'a, T, ROW, COL>> for Matrix<T, ROW_DEST, COL_DEST>

convert a matrix slice to an owned matrix

fn from(m: &MatrixSliceMut<'a, T, ROW, COL>) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (Range<usize>, Range<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (Range<usize>, Range<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (Range<usize>, RangeFrom<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (Range<usize>, RangeFrom<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (Range<usize>, RangeFull))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (Range<usize>, RangeFull)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (Range<usize>, RangeInclusive<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (Range<usize>, RangeInclusive<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (Range<usize>, RangeTo<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (Range<usize>, RangeTo<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (Range<usize>, RangeToInclusive<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (Range<usize>, RangeToInclusive<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeFrom<usize>, Range<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeFrom<usize>, Range<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeFrom<usize>, RangeFrom<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeFrom<usize>, RangeFrom<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeFrom<usize>, RangeFull))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeFrom<usize>, RangeFull)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeFrom<usize>, RangeInclusive<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeFrom<usize>, RangeInclusive<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeFrom<usize>, RangeTo<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeFrom<usize>, RangeTo<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeFrom<usize>, RangeToInclusive<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeFrom<usize>, RangeToInclusive<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeFull, Range<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeFull, Range<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeFull, RangeFrom<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeFull, RangeFrom<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeFull, RangeFull))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeFull, RangeFull)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeFull, RangeInclusive<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeFull, RangeInclusive<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeFull, RangeTo<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeFull, RangeTo<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeFull, RangeToInclusive<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeFull, RangeToInclusive<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeInclusive<usize>, Range<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeInclusive<usize>, Range<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeInclusive<usize>, RangeFrom<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeInclusive<usize>, RangeFrom<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeInclusive<usize>, RangeFull))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeInclusive<usize>, RangeFull)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeInclusive<usize>, RangeInclusive<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeInclusive<usize>, RangeInclusive<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeInclusive<usize>, RangeTo<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeInclusive<usize>, RangeTo<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeInclusive<usize>, RangeToInclusive<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeInclusive<usize>, RangeToInclusive<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeTo<usize>, Range<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeTo<usize>, Range<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeTo<usize>, RangeFrom<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeTo<usize>, RangeFrom<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeTo<usize>, RangeFull))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeTo<usize>, RangeFull)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeTo<usize>, RangeInclusive<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeTo<usize>, RangeInclusive<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeTo<usize>, RangeTo<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeTo<usize>, RangeTo<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeTo<usize>, RangeToInclusive<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeTo<usize>, RangeToInclusive<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeToInclusive<usize>, Range<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeToInclusive<usize>, Range<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeToInclusive<usize>, RangeFrom<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeToInclusive<usize>, RangeFrom<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeToInclusive<usize>, RangeFull))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeToInclusive<usize>, RangeFull)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeToInclusive<usize>, RangeInclusive<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeToInclusive<usize>, RangeInclusive<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeToInclusive<usize>, RangeTo<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeToInclusive<usize>, RangeTo<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<(&'a mut Matrix<T, ROW, COL>, (RangeToInclusive<usize>, RangeToInclusive<usize>))> for MatrixSliceMut<'a, T, ROW, COL>

get a mutable slice of the input matrix

fn from( (m, (range_rows, range_cols)): (&'a mut Matrix<T, ROW, COL>, (RangeToInclusive<usize>, RangeToInclusive<usize>)), ) -> Self

Converts to this type from the input type.

impl<'a, T: NumAssign + Copy + Default, const ROW: usize, const COL: usize> From<MatrixSliceMut<'a, T, ROW, COL>> for MatrixSlice<'a, T, ROW, COL>

fn from(m: MatrixSliceMut<'a, T, ROW, COL>) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW1: usize, const COL1: usize, const ROW2: usize, const COL2: usize> MulAssign<MatrixSlice<'a, T, ROW2, COL2>> for MatrixSliceMut<'a, T, ROW1, COL1>

fn mul_assign(&mut self, rhs: MatrixSlice<'a, T, ROW2, COL2>)

Performs the *= operation.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW1: usize, const COL1: usize, const ROW2: usize, const COL2: usize> MulAssign<MatrixSliceMut<'a, T, ROW2, COL2>> for MatrixSliceMut<'a, T, ROW1, COL1>

fn mul_assign(&mut self, rhs: MatrixSliceMut<'a, T, ROW2, COL2>)

Performs the *= operation.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW1: usize, const COL1: usize> MulAssign<T> for MatrixSliceMut<'a, T, ROW1, COL1>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW1: usize, const COL1: usize, const ROW2: usize, const COL2: usize> RemAssign<MatrixSlice<'a, T, ROW2, COL2>> for MatrixSliceMut<'a, T, ROW1, COL1>

fn rem_assign(&mut self, rhs: MatrixSlice<'a, T, ROW2, COL2>)

Performs the %= operation.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW1: usize, const COL1: usize, const ROW2: usize, const COL2: usize> RemAssign<MatrixSliceMut<'a, T, ROW2, COL2>> for MatrixSliceMut<'a, T, ROW1, COL1>

fn rem_assign(&mut self, rhs: MatrixSliceMut<'a, T, ROW2, COL2>)

Performs the %= operation.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW1: usize, const COL1: usize> RemAssign<T> for MatrixSliceMut<'a, T, ROW1, COL1>

fn rem_assign(&mut self, rhs: T)

Performs the %= operation.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW1: usize, const COL1: usize, const ROW2: usize, const COL2: usize> SubAssign<MatrixSlice<'a, T, ROW2, COL2>> for MatrixSliceMut<'a, T, ROW1, COL1>

fn sub_assign(&mut self, rhs: MatrixSlice<'a, T, ROW2, COL2>)

Performs the -= operation.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW1: usize, const COL1: usize, const ROW2: usize, const COL2: usize> SubAssign<MatrixSliceMut<'a, T, ROW2, COL2>> for MatrixSliceMut<'a, T, ROW1, COL1>

fn sub_assign(&mut self, rhs: MatrixSliceMut<'a, T, ROW2, COL2>)

Performs the -= operation.

impl<'a, T: 'a + NumAssign + Copy + Default, const ROW1: usize, const COL1: usize> SubAssign<T> for MatrixSliceMut<'a, T, ROW1, COL1>

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.