Struct MatrixSliceMut 

pub struct MatrixSliceMut<'a, T>
where
    T: 'a,
{ /* private fields */ }

A mutable MatrixSliceMut

This struct provides a mutable slice into a matrix.

The struct contains the upper left point of the slice and the width and height of the slice.

Implementations

impl<'a, T> MatrixSliceMut<'a, T>

pub fn from_matrix( mat: &'a mut Matrix<T>, start: [usize; 2], rows: usize, cols: usize, ) -> MatrixSliceMut<'a, T>

Produce a MatrixSliceMut from a mutable Matrix

Examples

use rulinalg::matrix::{Matrix, MatrixSliceMut};

let mut a = Matrix::new(3,3, (0..9).collect::<Vec<usize>>());
let slice = MatrixSliceMut::from_matrix(&mut a, [1,1], 2, 2);

pub unsafe fn from_raw_parts( ptr: *mut T, rows: usize, cols: usize, row_stride: usize, ) -> MatrixSliceMut<'a, T>

Creates a MatrixSliceMut from raw parts.

Examples

use rulinalg::matrix::MatrixSliceMut;

let mut a = vec![4.0; 16];

unsafe {
    // Create a mutable matrix slice with 3 rows, and 3 cols
    // The row stride of 4 specifies the distance between the start of each row in the data.
    let b = MatrixSliceMut::from_raw_parts(a.as_mut_ptr(), 3, 3, 4);
}

Safety

The pointer must be followed by a contiguous slice of data larger than row_stride * rows. If not then other operations will produce undefined behaviour.

Additionally cols should be less than the row_stride. It is possible to use this function safely whilst violating this condition. So long as max(cols, row_stride) * rows is less than the data size.

pub fn reslice( self, start: [usize; 2], rows: usize, cols: usize, ) -> MatrixSliceMut<'a, T>

Produce a MatrixSliceMut from an existing MatrixSliceMut.

This function will be deprecated. Prefer using BaseMatrixMut::sub_slice_mut instead;

Examples

use rulinalg::matrix::{Matrix, MatrixSliceMut};

let mut a = Matrix::new(3,3, (0..9).collect::<Vec<usize>>());
let slice = MatrixSliceMut::from_matrix(&mut a, [1,1], 2, 2);
let new_slice = slice.reslice([0,0], 1, 1);

Trait Implementations

impl<'a, 'b, 'c, T> Add<&'c Matrix<T>> for &'b MatrixSliceMut<'a, T>

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

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b, T> Add<&'b Matrix<T>> for MatrixSliceMut<'a, T>

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

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b, 'c, 'd, T> Add<&'d MatrixSlice<'b, T>> for &'c MatrixSliceMut<'a, T>

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

Performs elementwise addition between the slices.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: &MatrixSlice<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, 'c, T> Add<&'c MatrixSlice<'b, T>> for MatrixSliceMut<'a, T>

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

Performs elementwise addition between the slices.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: &MatrixSlice<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, 'c, T> Add<&'c MatrixSliceMut<'a, T>> for &'b Matrix<T>

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

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: &MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, T> Add<&'b MatrixSliceMut<'a, T>> for Matrix<T>

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

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: &MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, 'c, 'd, T> Add<&'d MatrixSliceMut<'b, T>> for &'c MatrixSlice<'a, T>

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

Performs elementwise addition between the slices.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: &MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, 'c, 'd, T> Add<&'d MatrixSliceMut<'b, T>> for &'c MatrixSliceMut<'a, T>

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

Performs elementwise addition between the slices.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: &MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, 'c, T> Add<&'c MatrixSliceMut<'b, T>> for MatrixSlice<'a, T>

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

Performs elementwise addition between the slices.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: &MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, 'c, T> Add<&'c MatrixSliceMut<'b, T>> for MatrixSliceMut<'a, T>

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

Performs elementwise addition between the slices.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: &MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, 'c, T> Add<&'c T> for &'b MatrixSliceMut<'a, T>

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

Scalar addition with matrix slice.

type Output = Matrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b, T> Add<&'b T> for MatrixSliceMut<'a, T>

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

Scalar addition with matrix slice.

type Output = Matrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b, T> Add<Matrix<T>> for &'b MatrixSliceMut<'a, T>

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

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, T> Add<Matrix<T>> for MatrixSliceMut<'a, T>

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

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b, 'c, T> Add<MatrixSlice<'b, T>> for &'c MatrixSliceMut<'a, T>

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

Performs elementwise addition between the slices.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: MatrixSlice<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, T> Add<MatrixSlice<'b, T>> for MatrixSliceMut<'a, T>

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

Performs elementwise addition between the slices.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: MatrixSlice<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, T> Add<MatrixSliceMut<'a, T>> for &'b Matrix<T>

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

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, T> Add<MatrixSliceMut<'a, T>> for Matrix<T>

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

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, 'c, T> Add<MatrixSliceMut<'b, T>> for &'c MatrixSlice<'a, T>

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

Performs elementwise addition between the slices.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, 'c, T> Add<MatrixSliceMut<'b, T>> for &'c MatrixSliceMut<'a, T>

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

Performs elementwise addition between the slices.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, T> Add<MatrixSliceMut<'b, T>> for MatrixSlice<'a, T>

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

Performs elementwise addition between the slices.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, T> Add<MatrixSliceMut<'b, T>> for MatrixSliceMut<'a, T>

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

Performs elementwise addition between the slices.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, T> Add<T> for &'b MatrixSliceMut<'a, T>

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

Scalar addition with matrix slice.

type Output = Matrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, T> Add<T> for MatrixSliceMut<'a, T>

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

Scalar addition with matrix slice.

type Output = Matrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b, T> AddAssign<&'b Matrix<T>> for MatrixSliceMut<'a, T>

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

Performs elementwise addition assignment between two matrices.

fn add_assign(&mut self, _rhs: &Matrix<T>)

Performs the += operation.

impl<'a, 'b, 'c, T> AddAssign<&'c MatrixSlice<'b, T>> for MatrixSliceMut<'a, T>

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

Performs elementwise addition assignment between two matrices.

fn add_assign(&mut self, _rhs: &MatrixSlice<'_, T>)

Performs the += operation.

impl<'a, 'b, T> AddAssign<&'b MatrixSliceMut<'a, T>> for Matrix<T>

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

Performs elementwise addition assignment between two matrices.

fn add_assign(&mut self, _rhs: &MatrixSliceMut<'_, T>)

Performs the += operation.

impl<'a, 'b, 'c, T> AddAssign<&'c MatrixSliceMut<'b, T>> for MatrixSliceMut<'a, T>

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

Performs elementwise addition assignment between two matrices.

fn add_assign(&mut self, _rhs: &MatrixSliceMut<'_, T>)

Performs the += operation.

impl<'a, 'b, T> AddAssign<&'b T> for MatrixSliceMut<'a, T>

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

Performs addition assignment between a mutable matrix slice and a scalar.

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

Performs the += operation.

impl<'a, T> AddAssign<Matrix<T>> for MatrixSliceMut<'a, T>

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

Performs elementwise addition assignment between two matrices.

fn add_assign(&mut self, _rhs: Matrix<T>)

Performs the += operation.

impl<'a, 'b, T> AddAssign<MatrixSlice<'b, T>> for MatrixSliceMut<'a, T>

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

Performs elementwise addition assignment between two matrices.

fn add_assign(&mut self, _rhs: MatrixSlice<'_, T>)

Performs the += operation.

impl<'a, T> AddAssign<MatrixSliceMut<'a, T>> for Matrix<T>

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

Performs elementwise addition assignment between two matrices.

fn add_assign(&mut self, _rhs: MatrixSliceMut<'_, T>)

Performs the += operation.

impl<'a, 'b, T> AddAssign<MatrixSliceMut<'b, T>> for MatrixSliceMut<'a, T>

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

Performs elementwise addition assignment between two matrices.

fn add_assign(&mut self, _rhs: MatrixSliceMut<'_, T>)

Performs the += operation.

impl<'a, T> AddAssign<T> for MatrixSliceMut<'a, T>

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

Performs addition assignment between a mutable matrix slice and a scalar.

fn add_assign(&mut self, _rhs: T)

Performs the += operation.

impl<'a, T> BaseMatrix<T> for MatrixSliceMut<'a, T>

fn rows(&self) -> usize

Rows in the matrix.

fn cols(&self) -> usize

Columns in the matrix.

fn row_stride(&self) -> usize

Row stride in the matrix.

fn as_ptr(&self) -> *const T

Top left index of the matrix.

fn is_empty(&self) -> bool

Returns true if the matrix contais no elements

fn as_slice(&self) -> MatrixSlice<'_, T>

Returns a MatrixSlice over the whole matrix.

unsafe fn get_unchecked(&self, index: [usize; 2]) -> &T

Get a reference to a point in the matrix without bounds checking.

fn get_row(&self, index: usize) -> Option<&[T]>

Returns the row of a matrix at the given index. None if the index is out of bounds.

unsafe fn get_row_unchecked(&self, index: usize) -> &[T]

Returns the row of a matrix at the given index without doing unbounds checking

fn iter<'a>(&self) -> SliceIter<'a, T>

where T: 'a,

Returns an iterator over the matrix data.

fn iter_rows(&self) -> Rows<'_, T>

Iterate over the rows of the matrix.

fn iter_diag(&self, k: DiagOffset) -> Diagonal<'_, T, Self>

Iterate over diagonal entries

fn sum_rows(&self) -> Vector<T>

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

The sum of the rows of the matrix.

fn sum_cols(&self) -> Vector<T>

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

The sum of the columns of the matrix.

fn sum(&self) -> T

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

The sum of all elements in the matrix

fn into_matrix(self) -> Matrix<T>

where T: Copy,

Convert the matrix struct into a owned Matrix.

fn select_rows<'a, I>(&self, rows: I) -> Matrix<T>

where T: Copy, I: IntoIterator<Item = &'a usize>, <I as IntoIterator>::IntoIter: ExactSizeIterator + Clone,

Select rows from matrix

fn select_cols<'a, I>(&self, cols: I) -> Matrix<T>

where T: Copy, I: IntoIterator<Item = &'a usize>, <I as IntoIterator>::IntoIter: ExactSizeIterator + Clone,

Select columns from matrix

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

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

The elementwise product of two matrices.

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

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

The elementwise division of two matrices.

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

where T: Copy,

Select block matrix from matrix

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

where T: Copy, S: BaseMatrix<T>,

Horizontally concatenates two matrices. With self on the left.

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

where T: Copy, S: BaseMatrix<T>,

Vertically concatenates two matrices. With self on top.

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

where T: Copy,

Extract the diagonal of the matrix

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

where T: Copy,

Tranposes the given matrix

fn is_diag(&self) -> bool

where T: Zero + PartialEq,

Checks if matrix is diagonal.

fn solve_u_triangular(&self, y: Vector<T>) -> Result<Vector<T>, Error>

where T: Any + Float,

Solves an upper triangular linear system.

fn solve_l_triangular(&self, y: Vector<T>) -> Result<Vector<T>, Error>

where T: Any + Float,

Solves a lower triangular linear system.

fn split_at( &self, mid: usize, axis: Axes, ) -> (MatrixSlice<'_, T>, MatrixSlice<'_, T>)

Split the matrix at the specified axis returning two MatrixSlices.

fn sub_slice<'a>( &self, start: [usize; 2], rows: usize, cols: usize, ) -> MatrixSlice<'a, T>

where T: 'a,

Produce a MatrixSlice from an existing matrix.

impl<'a, T> BaseMatrixMut<T> for MatrixSliceMut<'a, T>

fn as_mut_ptr(&mut self) -> *mut T

Top left index of the slice.

fn as_mut_slice(&mut self) -> MatrixSliceMut<'_, T>

Returns a MatrixSliceMut over the whole matrix.

unsafe fn get_unchecked_mut(&mut self, index: [usize; 2]) -> &mut T

Get a mutable reference to a point in the matrix without bounds checks.

fn iter_mut<'a>(&mut self) -> SliceIterMut<'a, T>

where T: 'a,

Returns a mutable iterator over the matrix.

fn get_row_mut(&mut self, index: usize) -> Option<&mut [T]>

Returns a mutable reference to the row of a matrix at the given index. None if the index is out of bounds.

unsafe fn get_row_unchecked_mut(&mut self, index: usize) -> &mut [T]

Returns a mutable reference to the row of a matrix at the given index without doing unbounds checking

fn swap_rows(&mut self, a: usize, b: usize)

Swaps two rows in a matrix.

fn swap_cols(&mut self, a: usize, b: usize)

Swaps two columns in a matrix.

fn iter_rows_mut(&mut self) -> RowsMut<'_, T>

Iterate over the mutable rows of the matrix.

fn iter_diag_mut(&mut self, k: DiagOffset) -> DiagonalMut<'_, T, Self>

Iterate over diagonal entries mutably

fn set_to<M>(self, target: M)

where M: BaseMatrix<T>, T: Copy,

Sets the underlying matrix data to the target data.

fn apply(self, f: &dyn Fn(T) -> T) -> Self

where T: Copy,

Applies a function to each element in the matrix.

fn split_at_mut( &mut self, mid: usize, axis: Axes, ) -> (MatrixSliceMut<'_, T>, MatrixSliceMut<'_, T>)

Split the matrix at the specified axis returning two MatrixSliceMuts.

fn sub_slice_mut<'a>( &mut self, start: [usize; 2], rows: usize, cols: usize, ) -> MatrixSliceMut<'a, T>

where T: 'a,

Produce a MatrixSliceMut from an existing matrix.

impl<'a, T> Debug for MatrixSliceMut<'a, T>

where T: Debug + 'a,

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

Formats the value using the given formatter.

impl<'a, 'b, 'c, T> Div<&'c T> for &'b MatrixSliceMut<'a, T>

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

Scalar division with matrix slice.

type Output = Matrix<T>

The resulting type after applying the / operator.

fn div(self, f: &T) -> Matrix<T>

Performs the / operation.

impl<'a, 'b, T> Div<&'b T> for MatrixSliceMut<'a, T>

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

Scalar division with matrix slice.

type Output = Matrix<T>

The resulting type after applying the / operator.

fn div(self, f: &T) -> Matrix<T>

Performs the / operation.

impl<'a, 'b, T> Div<T> for &'b MatrixSliceMut<'a, T>

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

Scalar division with matrix slice.

type Output = Matrix<T>

The resulting type after applying the / operator.

fn div(self, f: T) -> Matrix<T>

Performs the / operation.

impl<'a, T> Div<T> for MatrixSliceMut<'a, T>

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

Scalar division with matrix slice.

type Output = Matrix<T>

The resulting type after applying the / operator.

fn div(self, f: T) -> Matrix<T>

Performs the / operation.

impl<'a, 'b, T> DivAssign<&'b T> for MatrixSliceMut<'a, T>

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

Performs division assignment between a mutable matrix slice and a scalar.

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

Performs the /= operation.

impl<'a, T> DivAssign<T> for MatrixSliceMut<'a, T>

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

Performs division assignment between a mutable matrix slice and a scalar.

fn div_assign(&mut self, _rhs: T)

Performs the /= operation.

impl<'a, T> From<MatrixSliceMut<'a, T>> for Matrix<T>

where T: Copy,

fn from(slice: MatrixSliceMut<'a, T>) -> Matrix<T>

Converts to this type from the input type.

impl<'a, T> Index<[usize; 2]> for MatrixSliceMut<'a, T>

Indexes mutable matrix slice. Takes row index first then column.

type Output = T

The returned type after indexing.

fn index(&self, idx: [usize; 2]) -> &T

Performs the indexing (container[index]) operation.

impl<'a, T> IndexMut<[usize; 2]> for MatrixSliceMut<'a, T>

Indexes mutable matrix slice.

Takes row index first then column.

fn index_mut(&mut self, idx: [usize; 2]) -> &mut T

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

impl<'a, T> IntoIterator for &'a MatrixSliceMut<'a, T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = SliceIter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a MatrixSliceMut<'a, T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut MatrixSliceMut<'a, T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = SliceIterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a mut MatrixSliceMut<'a, T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for MatrixSliceMut<'a, T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = SliceIterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <MatrixSliceMut<'a, T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> Metric<T> for MatrixSliceMut<'a, T>

where T: Float,

fn norm(&self) -> T

Compute euclidean norm for matrix.

Examples

use rulinalg::matrix::{Matrix, MatrixSliceMut};
use rulinalg::Metric;

let mut a = Matrix::new(2,1, vec![3.0,4.0]);
let b = MatrixSliceMut::from_matrix(&mut a, [0,0], 2, 1);
let c = b.norm();

assert_eq!(c, 5.0);

impl<'a, 'b, 'c, T> Mul<&'c Matrix<T>> for &'b MatrixSliceMut<'a, T>

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

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T> Mul<&'b Matrix<T>> for MatrixSliceMut<'a, T>

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

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, 'c, 'd, T> Mul<&'d MatrixSlice<'b, T>> for &'c MatrixSliceMut<'a, T>

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

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, 'c, T> Mul<&'c MatrixSlice<'b, T>> for MatrixSliceMut<'a, T>

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

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, 'c, T> Mul<&'c MatrixSliceMut<'a, T>> for &'b Matrix<T>

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

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T> Mul<&'b MatrixSliceMut<'a, T>> for Matrix<T>

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

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, 'c, 'd, T> Mul<&'d MatrixSliceMut<'b, T>> for &'c MatrixSlice<'a, T>

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

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, 'c, 'd, T> Mul<&'d MatrixSliceMut<'b, T>> for &'c MatrixSliceMut<'a, T>

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

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, 'c, T> Mul<&'c MatrixSliceMut<'b, T>> for MatrixSlice<'a, T>

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

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, 'c, T> Mul<&'c MatrixSliceMut<'b, T>> for MatrixSliceMut<'a, T>

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

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, 'c, T> Mul<&'c T> for &'b MatrixSliceMut<'a, T>

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

Scalar multiplication with matrix slice.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T> Mul<&'b T> for MatrixSliceMut<'a, T>

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

Scalar multiplication with matrix slice.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T> Mul<Matrix<T>> for &'b MatrixSliceMut<'a, T>

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

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T> Mul<Matrix<T>> for MatrixSliceMut<'a, T>

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

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, 'c, T> Mul<MatrixSlice<'b, T>> for &'c MatrixSliceMut<'a, T>

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

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T> Mul<MatrixSlice<'b, T>> for MatrixSliceMut<'a, T>

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

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T> Mul<MatrixSliceMut<'a, T>> for &'b Matrix<T>

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

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T> Mul<MatrixSliceMut<'a, T>> for Matrix<T>

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

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, 'c, T> Mul<MatrixSliceMut<'b, T>> for &'c MatrixSlice<'a, T>

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

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, 'c, T> Mul<MatrixSliceMut<'b, T>> for &'c MatrixSliceMut<'a, T>

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

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T> Mul<MatrixSliceMut<'b, T>> for MatrixSlice<'a, T>

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

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T> Mul<MatrixSliceMut<'b, T>> for MatrixSliceMut<'a, T>

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

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T> Mul<T> for &'b MatrixSliceMut<'a, T>

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

Scalar multiplication with matrix slice.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T> Mul<T> for MatrixSliceMut<'a, T>

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

Scalar multiplication with matrix slice.

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T> MulAssign<&'b T> for MatrixSliceMut<'a, T>

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

Performs multiplication assignment between a mutable matrix slice and a scalar.

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

Performs the *= operation.

impl<'a, T> MulAssign<T> for MatrixSliceMut<'a, T>

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

Performs multiplication assignment between a mutable matrix slice and a scalar.

fn mul_assign(&mut self, _rhs: T)

Performs the *= operation.

impl<'a, 'b, T> Neg for &'b MatrixSliceMut<'a, T>

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

Gets negative of matrix slice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn neg(self) -> Matrix<T>

Performs the unary - operation.

impl<'a, T> Neg for MatrixSliceMut<'a, T>

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

Gets negative of matrix slice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn neg(self) -> Matrix<T>

Performs the unary - operation.

impl<'a, 'b, 'c, T> Sub<&'c Matrix<T>> for &'b MatrixSliceMut<'a, T>

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

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, 'b, T> Sub<&'b Matrix<T>> for MatrixSliceMut<'a, T>

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

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, 'b, 'c, 'd, T> Sub<&'d MatrixSlice<'b, T>> for &'c MatrixSliceMut<'a, T>

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

Performs elementwise subtraction between the slices.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: &MatrixSlice<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, 'c, T> Sub<&'c MatrixSlice<'b, T>> for MatrixSliceMut<'a, T>

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

Performs elementwise subtraction between the slices.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: &MatrixSlice<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, 'c, T> Sub<&'c MatrixSliceMut<'a, T>> for &'b Matrix<T>

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

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: &MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, T> Sub<&'b MatrixSliceMut<'a, T>> for Matrix<T>

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

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: &MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, 'c, 'd, T> Sub<&'d MatrixSliceMut<'b, T>> for &'c MatrixSlice<'a, T>

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

Performs elementwise subtraction between the slices.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: &MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, 'c, 'd, T> Sub<&'d MatrixSliceMut<'b, T>> for &'c MatrixSliceMut<'a, T>

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

Performs elementwise subtraction between the slices.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: &MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, 'c, T> Sub<&'c MatrixSliceMut<'b, T>> for MatrixSlice<'a, T>

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

Performs elementwise subtraction between the slices.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: &MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, 'c, T> Sub<&'c MatrixSliceMut<'b, T>> for MatrixSliceMut<'a, T>

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

Performs elementwise subtraction between the slices.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: &MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, 'c, T> Sub<&'c T> for &'b MatrixSliceMut<'a, T>

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

Scalar subtraction with matrix slice.

type Output = Matrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, 'b, T> Sub<&'b T> for MatrixSliceMut<'a, T>

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

Scalar subtraction with matrix slice.

type Output = Matrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, 'b, T> Sub<Matrix<T>> for &'b MatrixSliceMut<'a, T>

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

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, T> Sub<Matrix<T>> for MatrixSliceMut<'a, T>

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

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, 'b, 'c, T> Sub<MatrixSlice<'b, T>> for &'c MatrixSliceMut<'a, T>

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

Performs elementwise subtraction between the slices.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: MatrixSlice<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, T> Sub<MatrixSlice<'b, T>> for MatrixSliceMut<'a, T>

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

Performs elementwise subtraction between the slices.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: MatrixSlice<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, T> Sub<MatrixSliceMut<'a, T>> for &'b Matrix<T>

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

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, T> Sub<MatrixSliceMut<'a, T>> for Matrix<T>

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

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, 'c, T> Sub<MatrixSliceMut<'b, T>> for &'c MatrixSlice<'a, T>

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

Performs elementwise subtraction between the slices.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, 'c, T> Sub<MatrixSliceMut<'b, T>> for &'c MatrixSliceMut<'a, T>

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

Performs elementwise subtraction between the slices.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, T> Sub<MatrixSliceMut<'b, T>> for MatrixSlice<'a, T>

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

Performs elementwise subtraction between the slices.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, T> Sub<MatrixSliceMut<'b, T>> for MatrixSliceMut<'a, T>

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

Performs elementwise subtraction between the slices.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, T> Sub<T> for &'b MatrixSliceMut<'a, T>

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

Scalar subtraction with matrix slice.

type Output = Matrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, T> Sub<T> for MatrixSliceMut<'a, T>

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

Scalar subtraction with matrix slice.

type Output = Matrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, 'b, T> SubAssign<&'b Matrix<T>> for MatrixSliceMut<'a, T>

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

Performs elementwise subtraction assignment between two matrices.

fn sub_assign(&mut self, _rhs: &Matrix<T>)

Performs the -= operation.

impl<'a, 'b, 'c, T> SubAssign<&'c MatrixSlice<'b, T>> for MatrixSliceMut<'a, T>

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

Performs elementwise subtraction assignment between two matrices.

fn sub_assign(&mut self, _rhs: &MatrixSlice<'_, T>)

Performs the -= operation.

impl<'a, 'b, T> SubAssign<&'b MatrixSliceMut<'a, T>> for Matrix<T>

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

Performs elementwise subtraction assignment between two matrices.

fn sub_assign(&mut self, _rhs: &MatrixSliceMut<'_, T>)

Performs the -= operation.

impl<'a, 'b, 'c, T> SubAssign<&'c MatrixSliceMut<'b, T>> for MatrixSliceMut<'a, T>

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

Performs elementwise subtraction assignment between two matrices.

fn sub_assign(&mut self, _rhs: &MatrixSliceMut<'_, T>)

Performs the -= operation.

impl<'a, 'b, T> SubAssign<&'b T> for MatrixSliceMut<'a, T>

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

Performs subtraction assignment between a mutable matrix slice and a scalar.

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

Performs the -= operation.

impl<'a, T> SubAssign<Matrix<T>> for MatrixSliceMut<'a, T>

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

Performs elementwise subtraction assignment between two matrices.

fn sub_assign(&mut self, _rhs: Matrix<T>)

Performs the -= operation.

impl<'a, 'b, T> SubAssign<MatrixSlice<'b, T>> for MatrixSliceMut<'a, T>

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

Performs elementwise subtraction assignment between two matrices.

fn sub_assign(&mut self, _rhs: MatrixSlice<'_, T>)

Performs the -= operation.

impl<'a, T> SubAssign<MatrixSliceMut<'a, T>> for Matrix<T>

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

Performs elementwise subtraction assignment between two matrices.

fn sub_assign(&mut self, _rhs: MatrixSliceMut<'_, T>)

Performs the -= operation.

impl<'a, 'b, T> SubAssign<MatrixSliceMut<'b, T>> for MatrixSliceMut<'a, T>

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

Performs elementwise subtraction assignment between two matrices.

fn sub_assign(&mut self, _rhs: MatrixSliceMut<'_, T>)

Performs the -= operation.

impl<'a, T> SubAssign<T> for MatrixSliceMut<'a, T>

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

Performs subtraction assignment between a mutable matrix slice and a scalar.

fn sub_assign(&mut self, _rhs: T)

Performs the -= operation.