Type Alias MatMut 

pub type MatMut<'a, T, Rows = usize, Cols = usize, RStride = isize, CStride = isize> = Mat<Mut<'a, T, Rows, Cols, RStride, CStride>>;

mutable view over a matrix, similar to a mutable reference to a 2d strided slice

note

unlike a slice, the data pointed to by MatMut<'_, T> is allowed to be partially or fully uninitialized under certain conditions. In this case, care must be taken to not perform any operations that read the uninitialized values, either directly or indirectly through any of the numerical library routines, unless it is explicitly permitted

move semantics

since MatMut mutably borrows data, it cannot be Copy. this means that if we pass a MatMut to a function that takes it by value, or use a method that consumes self like [MatMut::transpose_mut], this renders the original variable unusable

use faer::{Mat, MatMut};

fn takes_matmut(view: MatMut<'_, f64>) {}

let mut matrix = Mat::new();
let view = matrix.as_mut();

takes_matmut(view); // `view` is moved (passed by value)
takes_matmut(view); // this fails to compile since `view` was moved

the way to get around it is to use the reborrow::ReborrowMut trait, which allows us to mutably borrow a MatMut to obtain another MatMut for the lifetime of the borrow. it’s also similarly possible to immutably borrow a MatMut to obtain a MatRef for the lifetime of the borrow, using reborrow::Reborrow

use faer::{Mat, MatMut, MatRef};
use reborrow::*;
fn takes_matmut(view: MatMut<'_, f64>) {}
fn takes_matref(view: MatRef<'_, f64>) {}
let mut matrix = Mat::new();
let mut view = matrix.as_mut();
takes_matmut(view.rb_mut());
takes_matmut(view.rb_mut());
takes_matref(view.rb());
// view is still usable here

Aliased Type

#[repr(transparent)]
pub struct MatMut<'a, T, Rows = usize, Cols = usize, RStride = isize, CStride = isize>(/* private fields */);

Implementations

impl<'a, T> MatMut<'a, T>

pub fn from_row_major_array_mut<const ROWS: usize, const COLS: usize>( array: &'a mut [[T; COLS]; ROWS], ) -> Self

equivalent to MatMut::from_row_major_slice_mut(array.as_flattened_mut(), ROWS, COLS)

pub fn from_column_major_array_mut<const ROWS: usize, const COLS: usize>( array: &'a mut [[T; ROWS]; COLS], ) -> Self

equivalent to MatMut::from_column_major_slice_mut(array.as_flattened_mut(), ROWS, COLS)

impl<'a, T, Rows: Shape, Cols: Shape, RStride: Stride, CStride: Stride> MatMut<'a, T, Rows, Cols, RStride, CStride>

pub const unsafe fn from_raw_parts_mut( ptr: *mut T, nrows: Rows, ncols: Cols, row_stride: RStride, col_stride: CStride, ) -> Self

creates a MatMut from a pointer to the matrix data, dimensions, and strides

the row (resp. column) stride is the offset from the memory address of a given matrix element at index (row: i, col: j), to the memory address of the matrix element at index (row: i + 1, col: 0) (resp. (row: 0, col: i + 1)). this offset is specified in number of elements, not in bytes

safety

the behavior is undefined if any of the following conditions are violated:

• for each matrix unit, the entire memory region addressed by the matrix must be contained within a single allocation, accessible in its entirety by the corresponding pointer in ptr
• for each matrix unit, the corresponding pointer must be non null and properly aligned, even for a zero-sized matrix.
• the values accessible by the matrix must be initialized at some point before they are read, or references to them are formed
• no aliasing (including self aliasing) is allowed. in other words, none of the elements accessible by any matrix unit may be accessed for reads or writes by any other means for the duration of the lifetime 'a. no two elements within a single matrix unit may point to the same address (such a thing can be achieved with a zero stride, for example), and no two matrix units may point to the same address

example

use faer::{MatMut, mat};
// row major matrix with 2 rows, 3 columns, with a column at the end that we want to skip.
// the row stride is the pointer offset from the address of 1.0 to the address of 4.0,
// which is 4
// the column stride is the pointer offset from the address of 1.0 to the address of 2.0,
// which is 1
let mut data = [[1.0, 2.0, 3.0, f64::NAN], [4.0, 5.0, 6.0, f64::NAN]];
let mut matrix =
	unsafe { MatMut::from_raw_parts_mut(data.as_mut_ptr() as *mut f64, 2, 3, 4, 1) };
let expected = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
assert_eq!(expected.as_ref(), matrix);

pub fn as_ptr(&self) -> *const T

returns a pointer to the matrix data

pub fn nrows(&self) -> Rows

returns the number of rows of the matrix

pub fn ncols(&self) -> Cols

returns the number of columns of the matrix

pub fn shape(&self) -> (Rows, Cols)

returns the number of rows and columns of the matrix

pub fn row_stride(&self) -> RStride

returns the row stride of the matrix, specified in number of elements, not in bytes

pub fn col_stride(&self) -> CStride

returns the column stride of the matrix, specified in number of elements, not in bytes

pub fn map<U>(&self, f: impl Fn(&T) -> U) -> Mat<U, Rows, Cols>

pub fn for_each(&self, f: impl Fn(&T))

pub fn map_mut<U>(&mut self, f: impl FnMut(&mut T) -> U) -> Mat<U, Rows, Cols>

pub fn for_each_mut(&mut self, f: impl FnMut(&mut T))

pub fn ptr_at(&self, row: IdxInc<Rows>, col: IdxInc<Cols>) -> *const T

returns a raw pointer to the element at the given index

pub unsafe fn ptr_inbounds_at(&self, row: Idx<Rows>, col: Idx<Cols>) -> *const T

returns a raw pointer to the element at the given index, assuming the provided index is within the matrix bounds

safety

the behavior is undefined if any of the following conditions are violated:

• row < self.nrows()
• col < self.ncols()

pub fn split_at( self, row: IdxInc<Rows>, col: IdxInc<Cols>, ) -> (MatRef<'a, T, usize, usize, RStride, CStride>, MatRef<'a, T, usize, usize, RStride, CStride>, MatRef<'a, T, usize, usize, RStride, CStride>, MatRef<'a, T, usize, usize, RStride, CStride>)

see [MatRef::split_at]

pub fn split_at_row( self, row: IdxInc<Rows>, ) -> (MatRef<'a, T, usize, Cols, RStride, CStride>, MatRef<'a, T, usize, Cols, RStride, CStride>)

see [MatRef::split_at_row]

pub fn split_at_col( self, col: IdxInc<Cols>, ) -> (MatRef<'a, T, Rows, usize, RStride, CStride>, MatRef<'a, T, Rows, usize, RStride, CStride>)

see [MatRef::split_at_col]

pub fn transpose(self) -> MatRef<'a, T, Cols, Rows, CStride, RStride>

see [MatRef::transpose]

pub fn conjugate(self) -> MatRef<'a, T::Conj, Rows, Cols, RStride, CStride>

where T: Conjugate,

see [MatRef::conjugate]

pub fn canonical(self) -> MatRef<'a, T::Canonical, Rows, Cols, RStride, CStride>

where T: Conjugate,

see [MatRef::canonical]

pub fn adjoint(self) -> MatRef<'a, T::Conj, Cols, Rows, CStride, RStride>

where T: Conjugate,

see [MatRef::adjoint]

pub fn reverse_rows(self) -> MatRef<'a, T, Rows, Cols, RStride::Rev, CStride>

see [MatRef::reverse_rows]

pub fn reverse_cols(self) -> MatRef<'a, T, Rows, Cols, RStride, CStride::Rev>

see [MatRef::reverse_cols]

pub fn reverse_rows_and_cols( self, ) -> MatRef<'a, T, Rows, Cols, RStride::Rev, CStride::Rev>

see [MatRef::reverse_rows_and_cols]

pub fn submatrix<V: Shape, H: Shape>( self, row_start: IdxInc<Rows>, col_start: IdxInc<Cols>, nrows: V, ncols: H, ) -> MatRef<'a, T, V, H, RStride, CStride>

see [MatRef::submatrix]

pub fn subrows<V: Shape>( self, row_start: IdxInc<Rows>, nrows: V, ) -> MatRef<'a, T, V, Cols, RStride, CStride>

see [MatRef::subrows]

pub fn subcols<H: Shape>( self, col_start: IdxInc<Cols>, ncols: H, ) -> MatRef<'a, T, Rows, H, RStride, CStride>

see [MatRef::subcols]

pub fn as_shape<V: Shape, H: Shape>( self, nrows: V, ncols: H, ) -> MatRef<'a, T, V, H, RStride, CStride>

see [MatRef::as_shape]

pub fn as_row_shape<V: Shape>( self, nrows: V, ) -> MatRef<'a, T, V, Cols, RStride, CStride>

see [MatRef::as_row_shape]

pub fn as_col_shape<H: Shape>( self, ncols: H, ) -> MatRef<'a, T, Rows, H, RStride, CStride>

see [MatRef::as_col_shape]

pub fn as_dyn_stride(self) -> MatRef<'a, T, Rows, Cols, isize, isize>

see [MatRef::as_dyn_stride]

pub fn as_dyn(self) -> MatRef<'a, T, usize, usize, RStride, CStride>

see [MatRef::as_dyn]

pub fn as_dyn_rows(self) -> MatRef<'a, T, usize, Cols, RStride, CStride>

see [MatRef::as_dyn_rows]

pub fn as_dyn_cols(self) -> MatRef<'a, T, Rows, usize, RStride, CStride>

see [MatRef::as_dyn_cols]

pub fn row(self, i: Idx<Rows>) -> RowRef<'a, T, Cols, CStride>

see [MatRef::row]

pub fn col(self, j: Idx<Cols>) -> ColRef<'a, T, Rows, RStride>

see [MatRef::col]

pub fn col_iter( self, ) -> impl 'a + ExactSizeIterator + DoubleEndedIterator<Item = ColRef<'a, T, Rows, RStride>>

where Rows: 'a, Cols: 'a,

see [MatRef::col_iter]

pub fn row_iter( self, ) -> impl 'a + ExactSizeIterator + DoubleEndedIterator<Item = RowRef<'a, T, Cols, CStride>>

where Rows: 'a, Cols: 'a,

see [MatRef::row_iter]

pub fn par_col_iter( self, ) -> impl 'a + IndexedParallelIterator<Item = ColRef<'a, T, Rows, RStride>>

where T: Sync, Rows: 'a, Cols: 'a,

see [MatRef::par_col_iter]

pub fn par_row_iter( self, ) -> impl 'a + IndexedParallelIterator<Item = RowRef<'a, T, Cols, CStride>>

where T: Sync, Rows: 'a, Cols: 'a,

see [MatRef::par_row_iter]

pub fn par_col_chunks( self, chunk_size: usize, ) -> impl 'a + IndexedParallelIterator<Item = MatRef<'a, T, Rows, usize, RStride, CStride>>

where T: Sync, Rows: 'a, Cols: 'a,

see [MatRef::par_col_chunks]

pub fn par_col_partition( self, count: usize, ) -> impl 'a + IndexedParallelIterator<Item = MatRef<'a, T, Rows, usize, RStride, CStride>>

where T: Sync, Rows: 'a, Cols: 'a,

see [MatRef::par_col_partition]

pub fn par_row_chunks( self, chunk_size: usize, ) -> impl 'a + IndexedParallelIterator<Item = MatRef<'a, T, usize, Cols, RStride, CStride>>

where T: Sync, Rows: 'a, Cols: 'a,

see [MatRef::par_row_chunks]

pub fn par_row_partition( self, count: usize, ) -> impl 'a + IndexedParallelIterator<Item = MatRef<'a, T, usize, Cols, RStride, CStride>>

where T: Sync, Rows: 'a, Cols: 'a,

see [MatRef::par_row_partition]

pub fn try_as_col_major( self, ) -> Option<MatRef<'a, T, Rows, Cols, ContiguousFwd, CStride>>

see [MatRef::try_as_col_major]

pub fn try_as_row_major( self, ) -> Option<MatRef<'a, T, Rows, Cols, RStride, ContiguousFwd>>

see [MatRef::try_as_row_major]

pub fn bind<'M, 'N>( self, row: Guard<'M>, col: Guard<'N>, ) -> MatMut<'a, T, Dim<'M>, Dim<'N>, RStride, CStride>

see [MatRef::)]] #[doc(hidden)]

pub fn get<RowRange, ColRange>( self, row: RowRange, col: ColRange, ) -> <MatRef<'a, T, Rows, Cols, RStride, CStride> as MatIndex<RowRange, ColRange>>::Target

where MatRef<'a, T, Rows, Cols, RStride, CStride>: MatIndex<RowRange, ColRange>,

see [MatRef::get]

pub unsafe fn get_unchecked<RowRange, ColRange>( self, row: RowRange, col: ColRange, ) -> <MatRef<'a, T, Rows, Cols, RStride, CStride> as MatIndex<RowRange, ColRange>>::Target

where MatRef<'a, T, Rows, Cols, RStride, CStride>: MatIndex<RowRange, ColRange>,

see [MatRef::get_unchecked]

safety

same as [MatRef::get_unchecked]

pub fn get_mut<RowRange, ColRange>( self, row: RowRange, col: ColRange, ) -> <MatMut<'a, T, Rows, Cols, RStride, CStride> as MatIndex<RowRange, ColRange>>::Target

where MatMut<'a, T, Rows, Cols, RStride, CStride>: MatIndex<RowRange, ColRange>,

see [MatRef::get]

pub unsafe fn get_mut_unchecked<RowRange, ColRange>( self, row: RowRange, col: ColRange, ) -> <MatMut<'a, T, Rows, Cols, RStride, CStride> as MatIndex<RowRange, ColRange>>::Target

where MatMut<'a, T, Rows, Cols, RStride, CStride>: MatIndex<RowRange, ColRange>,

see [MatRef::get_unchecked]

safety

same as [MatRef::get_unchecked]

impl<'a, T, Rows: Shape, Cols: Shape, RStride: Stride, CStride: Stride> MatMut<'a, T, Rows, Cols, RStride, CStride>

pub fn as_ptr_mut(&self) -> *mut T

see [MatRef::as_ptr]

pub fn ptr_at_mut(&self, row: IdxInc<Rows>, col: IdxInc<Cols>) -> *mut T

see [MatRef::ptr_at]

pub unsafe fn ptr_inbounds_at_mut( &self, row: Idx<Rows>, col: Idx<Cols>, ) -> *mut T

see [MatRef::ptr_inbounds_at]

pub fn split_at_mut( self, row: IdxInc<Rows>, col: IdxInc<Cols>, ) -> (MatMut<'a, T, usize, usize, RStride, CStride>, MatMut<'a, T, usize, usize, RStride, CStride>, MatMut<'a, T, usize, usize, RStride, CStride>, MatMut<'a, T, usize, usize, RStride, CStride>)

see [MatRef::split_at]

pub fn split_at_row_mut( self, row: IdxInc<Rows>, ) -> (MatMut<'a, T, usize, Cols, RStride, CStride>, MatMut<'a, T, usize, Cols, RStride, CStride>)

see [MatRef::split_at_row]

pub fn split_at_col_mut( self, col: IdxInc<Cols>, ) -> (MatMut<'a, T, Rows, usize, RStride, CStride>, MatMut<'a, T, Rows, usize, RStride, CStride>)

see [MatRef::split_at_col]

pub fn transpose_mut(self) -> MatMut<'a, T, Cols, Rows, CStride, RStride>

see [MatRef::transpose]

pub fn conjugate_mut(self) -> MatMut<'a, T::Conj, Rows, Cols, RStride, CStride>

where T: Conjugate,

see [MatRef::conjugate]

pub fn canonical_mut( self, ) -> MatMut<'a, T::Canonical, Rows, Cols, RStride, CStride>

where T: Conjugate,

see [MatRef::canonical]

pub fn adjoint_mut(self) -> MatMut<'a, T::Conj, Cols, Rows, CStride, RStride>

where T: Conjugate,

see [MatRef::adjoint]

pub fn reverse_rows_mut( self, ) -> MatMut<'a, T, Rows, Cols, RStride::Rev, CStride>

see [MatRef::reverse_rows]

pub fn reverse_cols_mut( self, ) -> MatMut<'a, T, Rows, Cols, RStride, CStride::Rev>

see [MatRef::reverse_cols]

pub fn reverse_rows_and_cols_mut( self, ) -> MatMut<'a, T, Rows, Cols, RStride::Rev, CStride::Rev>

see [MatRef::reverse_rows_and_cols]

pub fn submatrix_mut<V: Shape, H: Shape>( self, row_start: IdxInc<Rows>, col_start: IdxInc<Cols>, nrows: V, ncols: H, ) -> MatMut<'a, T, V, H, RStride, CStride>

see [MatRef::submatrix]

pub fn subrows_mut<V: Shape>( self, row_start: IdxInc<Rows>, nrows: V, ) -> MatMut<'a, T, V, Cols, RStride, CStride>

see [MatRef::subrows]

pub fn subcols_mut<H: Shape>( self, col_start: IdxInc<Cols>, ncols: H, ) -> MatMut<'a, T, Rows, H, RStride, CStride>

see [MatRef::subcols]

pub fn as_shape_mut<V: Shape, H: Shape>( self, nrows: V, ncols: H, ) -> MatMut<'a, T, V, H, RStride, CStride>

see [MatRef::as_shape]

pub fn as_row_shape_mut<V: Shape>( self, nrows: V, ) -> MatMut<'a, T, V, Cols, RStride, CStride>

see [MatRef::as_row_shape]

pub fn as_col_shape_mut<H: Shape>( self, ncols: H, ) -> MatMut<'a, T, Rows, H, RStride, CStride>

see [MatRef::as_col_shape]

pub fn as_dyn_stride_mut(self) -> MatMut<'a, T, Rows, Cols, isize, isize>

see [MatRef::as_dyn_stride]

pub fn as_dyn_mut(self) -> MatMut<'a, T, usize, usize, RStride, CStride>

see [MatRef::as_dyn]

pub fn as_dyn_rows_mut(self) -> MatMut<'a, T, usize, Cols, RStride, CStride>

see [MatRef::as_dyn_rows]

pub fn as_dyn_cols_mut(self) -> MatMut<'a, T, Rows, usize, RStride, CStride>

see [MatRef::as_dyn_cols]

pub fn row_mut(self, i: Idx<Rows>) -> RowMut<'a, T, Cols, CStride>

see [MatRef::row]

pub fn col_mut(self, j: Idx<Cols>) -> ColMut<'a, T, Rows, RStride>

see [MatRef::col]

pub fn col_iter_mut( self, ) -> impl 'a + ExactSizeIterator + DoubleEndedIterator<Item = ColMut<'a, T, Rows, RStride>>

where Rows: 'a, Cols: 'a,

see [MatRef::col_iter]

pub fn row_iter_mut( self, ) -> impl 'a + ExactSizeIterator + DoubleEndedIterator<Item = RowMut<'a, T, Cols, CStride>>

where Rows: 'a, Cols: 'a,

see [MatRef::row_iter]

pub fn par_col_iter_mut( self, ) -> impl 'a + IndexedParallelIterator<Item = ColMut<'a, T, Rows, RStride>>

where T: Send, Rows: 'a, Cols: 'a,

see [MatRef::par_col_iter]

pub fn par_row_iter_mut( self, ) -> impl 'a + IndexedParallelIterator<Item = RowMut<'a, T, Cols, CStride>>

where T: Send, Rows: 'a, Cols: 'a,

see [MatRef::par_row_iter]

pub fn par_col_chunks_mut( self, chunk_size: usize, ) -> impl 'a + IndexedParallelIterator<Item = MatMut<'a, T, Rows, usize, RStride, CStride>>

where T: Send, Rows: 'a, Cols: 'a,

see [MatRef::par_col_chunks]

pub fn par_col_partition_mut( self, count: usize, ) -> impl 'a + IndexedParallelIterator<Item = MatMut<'a, T, Rows, usize, RStride, CStride>>

where T: Send, Rows: 'a, Cols: 'a,

see [MatRef::par_col_partition]

pub fn par_row_chunks_mut( self, chunk_size: usize, ) -> impl 'a + IndexedParallelIterator<Item = MatMut<'a, T, usize, Cols, RStride, CStride>>

where T: Send, Rows: 'a, Cols: 'a,

see [MatRef::par_row_chunks]

pub fn par_row_partition_mut( self, count: usize, ) -> impl 'a + IndexedParallelIterator<Item = MatMut<'a, T, usize, Cols, RStride, CStride>>

where T: Send, Rows: 'a, Cols: 'a,

see [MatRef::par_row_partition]

pub fn split_first_row_mut( self, ) -> Option<(RowMut<'a, T, Cols, CStride>, MatMut<'a, T, usize, Cols, RStride, CStride>)>

see [MatRef::split_first_row]

pub fn split_first_col_mut( self, ) -> Option<(ColMut<'a, T, Rows, RStride>, MatMut<'a, T, Rows, usize, RStride, CStride>)>

see [MatRef::split_first_col]

pub fn split_last_row_mut( self, ) -> Option<(RowMut<'a, T, Cols, CStride>, MatMut<'a, T, usize, Cols, RStride, CStride>)>

see [MatRef::split_last_row]

pub fn split_last_col_mut( self, ) -> Option<(ColMut<'a, T, Rows, RStride>, MatMut<'a, T, Rows, usize, RStride, CStride>)>

see [MatRef::split_last_col]

pub fn split_first_row( self, ) -> Option<(RowRef<'a, T, Cols, CStride>, MatRef<'a, T, usize, Cols, RStride, CStride>)>

see [MatRef::split_first_row]

pub fn split_first_col( self, ) -> Option<(ColRef<'a, T, Rows, RStride>, MatRef<'a, T, Rows, usize, RStride, CStride>)>

see [MatRef::split_first_col]

pub fn split_last_row( self, ) -> Option<(RowRef<'a, T, Cols, CStride>, MatRef<'a, T, usize, Cols, RStride, CStride>)>

see [MatRef::split_last_row]

pub fn split_last_col( self, ) -> Option<(ColRef<'a, T, Rows, RStride>, MatRef<'a, T, Rows, usize, RStride, CStride>)>

see [MatRef::split_last_col]

pub fn try_as_col_major_mut( self, ) -> Option<MatMut<'a, T, Rows, Cols, ContiguousFwd, CStride>>

see [MatRef::try_as_col_major]

pub fn try_as_row_major_mut( self, ) -> Option<MatMut<'a, T, Rows, Cols, RStride, ContiguousFwd>>

see [MatRef::try_as_row_major]

pub fn two_cols_mut( self, i0: Idx<Cols>, i1: Idx<Cols>, ) -> (ColMut<'a, T, Rows, RStride>, ColMut<'a, T, Rows, RStride>)

returns two views over the given columns

panics

panics if i0 == i1

pub fn two_rows_mut( self, i0: Idx<Rows>, i1: Idx<Rows>, ) -> (RowMut<'a, T, Cols, CStride>, RowMut<'a, T, Cols, CStride>)

returns two views over the given rows

panics

panics if i0 == i1

impl<'a, T, Rows: Shape, Cols: Shape> MatMut<'a, T, Rows, Cols>

pub fn from_column_major_slice_mut( slice: &'a mut [T], nrows: Rows, ncols: Cols, ) -> Self

where T: Sized,

creates a MatMut from slice views over the matrix data, and the matrix dimensions. the data is interpreted in a column-major format, so that the first chunk of nrows values from the slices goes in the first column of the matrix, the second chunk of nrows values goes in the second column, and so on

panics

the function panics if any of the following conditions are violated:

• nrows * ncols == slice.len()

example

use faer::{MatMut, mat};
let mut slice = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0_f64];
let view = MatMut::from_column_major_slice_mut(&mut slice, 3, 2);
let expected = mat![[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]];
assert_eq!(expected, view);

pub fn from_column_major_slice_with_stride_mut( slice: &'a mut [T], nrows: Rows, ncols: Cols, col_stride: usize, ) -> Self

where T: Sized,

creates a MatMut from slice views over the matrix data, and the matrix dimensions. the data is interpreted in a column-major format, where the beginnings of two consecutive columns are separated by col_stride elements.

pub fn from_row_major_slice_mut( slice: &'a mut [T], nrows: Rows, ncols: Cols, ) -> Self

where T: Sized,

creates a MatMut from slice views over the matrix data, and the matrix dimensions. the data is interpreted in a row-major format, so that the first chunk of ncols values from the slices goes in the first column of the matrix, the second chunk of ncols values goes in the second column, and so on

panics

the function panics if any of the following conditions are violated:

• nrows * ncols == slice.len()

example

use faer::{MatMut, mat};
let mut slice = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0_f64];
let view = MatMut::from_row_major_slice_mut(&mut slice, 3, 2);
let expected = mat![[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]];
assert_eq!(expected, view);

pub fn from_row_major_slice_with_stride_mut( slice: &'a mut [T], nrows: Rows, ncols: Cols, row_stride: usize, ) -> Self

where T: Sized,

creates a MatMut from slice views over the matrix data, and the matrix dimensions. the data is interpreted in a row-major format, where the beginnings of two consecutive rows are separated by row_stride elements.

impl<'a, T, Dim: Shape, RStride: Stride, CStride: Stride> MatMut<'a, T, Dim, Dim, RStride, CStride>

pub fn diagonal(self) -> DiagRef<'a, T, Dim, isize>

see [MatRef::diagonal]

impl<'a, T, Dim: Shape, RStride: Stride, CStride: Stride> MatMut<'a, T, Dim, Dim, RStride, CStride>

pub fn diagonal_mut(self) -> DiagMut<'a, T, Dim, isize>

see [MatRef::diagonal]

impl<'a, T, Rows: Shape, Cols: Shape> MatMut<'a, T, Rows, Cols>

where T: RealField,

pub fn min(self) -> Option<T>

see [MatRef::min]

pub fn max(self) -> Option<T>

see [MatRef::min]

Trait Implementations

impl<T, Rows: Shape, Cols: Shape, RStride: Stride, CStride: Stride> AsMatMut for MatMut<'_, T, Rows, Cols, RStride, CStride>

fn as_mat_mut(&mut self) -> MatMut<'_, T, Rows, Cols>

returns a view over self

impl<T, Rows: Shape, Cols: Shape, RStride: Stride, CStride: Stride> AsMatRef for MatMut<'_, T, Rows, Cols, RStride, CStride>

type Cols = Cols

column dimension type

type Owned = Mat<Own<T, Rows, Cols>>

owned matrix type

type Rows = Rows

row dimension type

type T = T

scalar type

fn as_mat_ref(&self) -> MatRef<'_, T, Rows, Cols>

returns a view over self

impl<T: ComplexField, ViewT: Conjugate<Canonical = T>> BiLinOp<T> for MatMut<'_, ViewT>

fn transpose_apply_scratch(&self, rhs_ncols: usize, par: ParShape) -> StackReq

computes the workspace layout required to apply the transpose or adjoint o self to a matrix with rhs_ncols columns

fn transpose_apply( &self, out: MatMut<'_, T>, rhs: MatRef<'_, T>, par: Par<'_>, stack: &mut MemStack, )

applies the transpose of self to rhs, and stores the result in out

fn adjoint_apply( &self, out: MatMut<'_, T>, rhs: MatRef<'_, T>, par: Par<'_>, stack: &mut MemStack, )

applies the adjoint of self to rhs, and stores the result in out

impl<T: ComplexField, ViewT: Conjugate<Canonical = T>> BiPrecond<T> for MatMut<'_, ViewT>

fn transpose_apply_in_place_scratch( &self, rhs_ncols: usize, par: ParShape, ) -> StackReq

computes the workspace layout required to apply the transpose or adjoint of self to a matrix with rhs_ncols columns in place

fn transpose_apply_in_place( &self, rhs: MatMut<'_, T>, par: Par<'_>, stack: &mut MemStack, )

applies the transpose of self to rhs, and stores the result in rhs

fn adjoint_apply_in_place( &self, rhs: MatMut<'_, T>, par: Par<'_>, stack: &mut MemStack, )

applies the adjoint of self to rhs, and stores the result in rhs

impl<'a, T, Rows: Shape, Cols: Shape, RStride: Stride, CStride: Stride> IntoView for MatMut<'a, T, Rows, Cols, RStride, CStride>

type Target = Mat<Mut<'a, T, Rows, Cols, RStride, CStride>>

fn into_view(self) -> Self::Target

impl<'a, T, Rows: Shape, Cols: Shape, RStride: Stride, CStride: Stride> IntoView for &'a MatMut<'_, T, Rows, Cols, RStride, CStride>

type Target = Mat<Ref<'a, T, Rows, Cols, RStride, CStride>>

fn into_view(self) -> Self::Target

impl<'a, T, Rows: Shape, Cols: Shape, RStride: Stride, CStride: Stride> IntoView for &'a mut MatMut<'_, T, Rows, Cols, RStride, CStride>

type Target = Mat<Mut<'a, T, Rows, Cols, RStride, CStride>>

fn into_view(self) -> Self::Target

impl<T: ComplexField, ViewT: Conjugate<Canonical = T>> LinOp<T> for MatMut<'_, ViewT>

fn nrows(&self) -> usize

output dimension of the operator

fn ncols(&self) -> usize

input dimension of the operator

fn apply_scratch(&self, rhs_ncols: usize, par: ParShape) -> StackReq

computes the workspace layout required to apply self or the conjugate o self to a matrix with rhs_ncols columns

fn apply( &self, out: MatMut<'_, T>, rhs: MatRef<'_, T>, par: Par<'_>, stack: &mut MemStack, )

applies self to rhs, and stores the result in out

fn conj_apply( &self, out: MatMut<'_, T>, rhs: MatRef<'_, T>, par: Par<'_>, stack: &mut MemStack, )

applies the conjugate of self to rhs, and stores the result in out

impl<'b, T, Rows: Shape, Cols: Shape, RStride: Stride, CStride: Stride> MatIndex for MatMut<'b, T, Rows, Cols, RStride, CStride>

type Cols = Cols

type of columns

type Dyn = Mat<Mut<'b, T>>

matrix type with type erased dimensions

type Index = (<Rows as ShapeIdx>::Idx<usize>, <Cols as ShapeIdx>::Idx<usize>)

indexing type

type Item = &'b mut T

item produced by the zip views

type Kind = Mat

type LayoutTransform = MatLayoutTransform

layout transformation type

type Rows = Rows

type of rows

type Slice = SliceMut<'b, T>

fn nrows(this: &Self) -> Self::Rows

returns the number of rows

fn ncols(this: &Self) -> Self::Cols

returns the number of columns

unsafe fn get_slice_unchecked<'a>( this: &'a mut Self, idx: Self::Index, n_elems: usize, ) -> <Self::Slice as SliceFamily<'a, Self::Item>>::Slice

returns slice at index of length n_elems

unsafe fn from_dyn_idx(idx: <Self::Dyn as MatIndex>::Index) -> Self::Index

converts a type erased index back to its original representation

unsafe fn get_unchecked(this: &mut Self, (i, j): Self::Index) -> Self::Item

get the item at the given index, skipping bound checks

unsafe fn next_unchecked<'a>( slice: &mut <Self::Slice as SliceFamily<'a, Self::Item>>::Slice, ) -> Self::Item

get the item at the given slice position, skipping bound checks

fn is_contiguous(this: &Self) -> bool

checks if the zip matrices are contiguous

fn preferred_layout(this: &Self) -> Self::LayoutTransform

computes the preferred iteration layout of the matrices

fn with_layout(this: Self, layout: Self::LayoutTransform) -> Self::Dyn

applies the layout transformation to the matrices

impl<'a, 'M, 'N, T, Rs: Stride, Cs: Stride> MatIndex<<Dim<'M> as ShapeIdx>::Idx<usize>, <Dim<'N> as ShapeIdx>::Idx<usize>> for MatMut<'a, T, Dim<'M>, Dim<'N>, Rs, Cs>

type Target = &'a mut T

sliced view type

fn get(this: Self, row: Idx<Dim<'M>>, col: Idx<Dim<'N>>) -> Self::Target

slice this using row and col

unsafe fn get_unchecked( this: Self, row: Idx<Dim<'M>>, col: Idx<Dim<'N>>, ) -> Self::Target

slice this using row and col without bound checks

impl<'a, 'M, T, Rs: Stride, Cs: Stride> MatIndex<<Dim<'M> as ShapeIdx>::Idx<usize>, <usize as ShapeIdx>::Idx<usize>> for MatMut<'a, T, Dim<'M>, usize, Rs, Cs>

type Target = &'a mut T

sliced view type

fn get(this: Self, row: Idx<Dim<'M>>, col: Idx<usize>) -> Self::Target

slice this using row and col

unsafe fn get_unchecked( this: Self, row: Idx<Dim<'M>>, col: Idx<usize>, ) -> Self::Target

slice this using row and col without bound checks

impl<'a, 'N, C: Shape, T, Rs: Stride, Cs: Stride, ColRange: IntoRange<IdxInc<C>, Len<C>: 'a>> MatIndex<<Dim<'N> as ShapeIdx>::Idx<usize>, ColRange> for MatMut<'a, T, Dim<'N>, C, Rs, Cs>

type Target = Row<Mut<'a, T, <ColRange as IntoRange<<C as ShapeIdx>::IdxInc<usize>>>::Len<C>, Cs>>

sliced view type

fn get(this: Self, row: Idx<Dim<'N>>, col: ColRange) -> Self::Target

slice this using row and col

unsafe fn get_unchecked( this: Self, row: Idx<Dim<'N>>, col: ColRange, ) -> Self::Target

slice this using row and col without bound checks

impl<'a, 'N, T, Rs: Stride, Cs: Stride> MatIndex<<usize as ShapeIdx>::Idx<usize>, <Dim<'N> as ShapeIdx>::Idx<usize>> for MatMut<'a, T, usize, Dim<'N>, Rs, Cs>

type Target = &'a mut T

sliced view type

fn get(this: Self, row: Idx<usize>, col: Idx<Dim<'N>>) -> Self::Target

slice this using row and col

unsafe fn get_unchecked( this: Self, row: Idx<usize>, col: Idx<Dim<'N>>, ) -> Self::Target

slice this using row and col without bound checks

impl<'a, T, Rs: Stride, Cs: Stride> MatIndex<<usize as ShapeIdx>::Idx<usize>, <usize as ShapeIdx>::Idx<usize>> for MatMut<'a, T, usize, usize, Rs, Cs>

type Target = &'a mut T

sliced view type

fn get(this: Self, row: Idx<usize>, col: Idx<usize>) -> Self::Target

slice this using row and col

unsafe fn get_unchecked( this: Self, row: Idx<usize>, col: Idx<usize>, ) -> Self::Target

slice this using row and col without bound checks

impl<'a, C: Shape, T, Rs: Stride, Cs: Stride, ColRange: IntoRange<IdxInc<C>, Len<C>: 'a>> MatIndex<<usize as ShapeIdx>::Idx<usize>, ColRange> for MatMut<'a, T, usize, C, Rs, Cs>

type Target = Row<Mut<'a, T, <ColRange as IntoRange<<C as ShapeIdx>::IdxInc<usize>>>::Len<C>, Cs>>

sliced view type

fn get(this: Self, row: Idx<usize>, col: ColRange) -> Self::Target

slice this using row and col

unsafe fn get_unchecked( this: Self, row: Idx<usize>, col: ColRange, ) -> Self::Target

slice this using row and col without bound checks

impl<'a, 'N, R: Shape, T, Rs: Stride, Cs: Stride, RowRange: IntoRange<IdxInc<R>, Len<R>: 'a>> MatIndex<RowRange, <Dim<'N> as ShapeIdx>::Idx<usize>> for MatMut<'a, T, R, Dim<'N>, Rs, Cs>

type Target = Col<Mut<'a, T, <RowRange as IntoRange<<R as ShapeIdx>::IdxInc<usize>>>::Len<R>, Rs>>

sliced view type

fn get(this: Self, row: RowRange, col: Idx<Dim<'N>>) -> Self::Target

slice this using row and col

unsafe fn get_unchecked( this: Self, row: RowRange, col: Idx<Dim<'N>>, ) -> Self::Target

slice this using row and col without bound checks

impl<'a, R: Shape, T, Rs: Stride, Cs: Stride, RowRange: IntoRange<IdxInc<R>, Len<R>: 'a>> MatIndex<RowRange, <usize as ShapeIdx>::Idx<usize>> for MatMut<'a, T, R, usize, Rs, Cs>

type Target = Col<Mut<'a, T, <RowRange as IntoRange<<R as ShapeIdx>::IdxInc<usize>>>::Len<R>, Rs>>

sliced view type

fn get(this: Self, row: RowRange, col: Idx<usize>) -> Self::Target

slice this using row and col

unsafe fn get_unchecked( this: Self, row: RowRange, col: Idx<usize>, ) -> Self::Target

slice this using row and col without bound checks

impl<'a, R: Shape, C: Shape, T, Rs: Stride, Cs: Stride, RowRange: IntoRange<IdxInc<R>, Len<R>: 'a>, ColRange: IntoRange<IdxInc<C>, Len<C>: 'a>> MatIndex<RowRange, ColRange> for MatMut<'a, T, R, C, Rs, Cs>

type Target = Mat<Mut<'a, T, <RowRange as IntoRange<<R as ShapeIdx>::IdxInc<usize>>>::Len<R>, <ColRange as IntoRange<<C as ShapeIdx>::IdxInc<usize>>>::Len<C>, Rs, Cs>>

sliced view type

fn get(this: Self, row: RowRange, col: ColRange) -> Self::Target

slice this using row and col

unsafe fn get_unchecked( this: Self, row: RowRange, col: ColRange, ) -> Self::Target

slice this using row and col without bound checks

impl<T: ComplexField, ViewT: Conjugate<Canonical = T>> Precond<T> for MatMut<'_, ViewT>

fn apply_in_place_scratch(&self, rhs_ncols: usize, par: ParShape) -> StackReq

computes the workspace layout required to apply self or the conjugate of self to a matrix with rhs_ncols columns in place

fn apply_in_place(&self, rhs: MatMut<'_, T>, par: Par<'_>, stack: &mut MemStack)

applies self to rhs, and stores the result in rhs

fn conj_apply_in_place( &self, rhs: MatMut<'_, T>, par: Par<'_>, stack: &mut MemStack, )

applies the conjugate of self to rhs, and stores the result in rhs