Type Alias faer_core::MatMut

pub type MatMut<'a, E> = Matrix<DenseMut<'a, E>>;

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<'_, E> 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, or form references to them, either directly through MatMut::read, 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, this renders the original variable unusable.

use faer_core::{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_core::{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

struct MatMut<'a, E> { /* private fields */ }

Implementations

impl<'a, E: Entity> MatMut<'a, E>

pub fn from_column_major_slice( slice: GroupFor<E, &'a mut [E::Unit]>, nrows: usize, ncols: usize ) -> Self

👎Deprecated: replaced by faer_core::mat::from_column_major_slice_mut

pub fn from_row_major_slice( slice: GroupFor<E, &'a mut [E::Unit]>, nrows: usize, ncols: usize ) -> Self

👎Deprecated: replaced by faer_core::mat::from_row_major_slice_mut

pub unsafe fn from_raw_parts( ptr: GroupFor<E, *mut E::Unit>, nrows: usize, ncols: usize, row_stride: isize, col_stride: isize ) -> Self

👎Deprecated: replaced by faer_core::mat::from_raw_parts_mut

pub fn nrows(&self) -> usize

pub fn ncols(&self) -> usize

pub fn as_ptr_mut(self) -> GroupFor<E, *mut E::Unit>

Returns pointers to the matrix data.

pub fn as_ptr(self) -> GroupFor<E, *mut E::Unit>

👎Deprecated: replaced by MatMut::as_ptr_mut

pub fn row_stride(&self) -> isize

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

pub fn col_stride(&self) -> isize

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

pub fn ptr_at_mut(self, row: usize, col: usize) -> GroupFor<E, *mut E::Unit>

Returns raw pointers to the element at the given indices.

pub fn ptr_at(self, row: usize, col: usize) -> GroupFor<E, *mut E::Unit>

👎Deprecated: replaced by MatMut::ptr_at_mut

pub unsafe fn ptr_inbounds_at_mut( self, row: usize, col: usize ) -> GroupFor<E, *mut E::Unit>

Returns raw pointers to the element at the given indices, assuming the provided indices are within the matrix dimensions.

Safety

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

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

pub unsafe fn ptr_inbounds_at( self, row: usize, col: usize ) -> GroupFor<E, *mut E::Unit>

👎Deprecated: replaced by MatMut::ptr_inbounds_at_mut

pub unsafe fn split_at_mut_unchecked( self, row: usize, col: usize ) -> (Self, Self, Self, Self)

Splits the matrix horizontally and vertically at the given indices into four corners and returns an array of each submatrix, in the following order:

• top left.
• top right.
• bottom left.
• bottom right.

Safety

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

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

pub fn split_at_mut(self, row: usize, col: usize) -> (Self, Self, Self, Self)

Splits the matrix horizontally and vertically at the given indices into four corners and returns an array of each submatrix, in the following order:

• top left.
• top right.
• bottom left.
• bottom right.

Panics

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

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

pub unsafe fn split_at_row_mut_unchecked(self, row: usize) -> (Self, Self)

Splits the matrix horizontally at the given row into two parts and returns an array of each submatrix, in the following order:

• top.
• bottom.

Safety

The behavior is undefined if the following condition is violated:

• row <= self.nrows().

pub fn split_at_row_mut(self, row: usize) -> (Self, Self)

Splits the matrix horizontally at the given row into two parts and returns an array of each submatrix, in the following order:

• top.
• bottom.

Panics

The function panics if the following condition is violated:

• row <= self.nrows().

pub unsafe fn split_at_col_mut_unchecked(self, col: usize) -> (Self, Self)

Splits the matrix vertically at the given row into two parts and returns an array of each submatrix, in the following order:

• left.
• right.

Safety

The behavior is undefined if the following condition is violated:

• col <= self.ncols().

pub fn split_at_col_mut(self, col: usize) -> (Self, Self)

Splits the matrix vertically at the given row into two parts and returns an array of each submatrix, in the following order:

• left.
• right.

Panics

The function panics if the following condition is violated:

• col <= self.ncols().

pub fn split_at(self, row: usize, col: usize) -> (Self, Self, Self, Self)

👎Deprecated: replaced by MatMut::split_at_mut

pub fn split_at_row(self, row: usize) -> (Self, Self)

👎Deprecated: replaced by MatMut::split_at_row_mut

pub fn split_at_col(self, col: usize) -> (Self, Self)

👎Deprecated: replaced by MatMut::split_at_col_mut

pub unsafe fn get_mut_unchecked<RowRange, ColRange>( self, row: RowRange, col: ColRange ) -> <Self as MatIndex<RowRange, ColRange>>::Target

where Self: MatIndex<RowRange, ColRange>,

Returns mutable references to the element at the given indices, or submatrices if either row or col is a range.

Note

The values pointed to by the references are expected to be initialized, even if the pointed-to value is not read, otherwise the behavior is undefined.

Safety

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

• row must be contained in [0, self.nrows()).
• col must be contained in [0, self.ncols()).

pub unsafe fn get_unchecked<RowRange, ColRange>( self, row: RowRange, col: ColRange ) -> <Self as MatIndex<RowRange, ColRange>>::Target

where Self: MatIndex<RowRange, ColRange>,

👎Deprecated: replaced by MatMut::get_mut_unchecked

pub fn get_mut<RowRange, ColRange>( self, row: RowRange, col: ColRange ) -> <Self as MatIndex<RowRange, ColRange>>::Target

where Self: MatIndex<RowRange, ColRange>,

Returns mutable references to the element at the given indices, or submatrices if either row or col is a range, with bound checks.

Note

The values pointed to by the references are expected to be initialized, even if the pointed-to value is not read, otherwise the behavior is undefined.

Panics

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

• row must be contained in [0, self.nrows()).
• col must be contained in [0, self.ncols()).

pub fn get<RowRange, ColRange>( self, row: RowRange, col: ColRange ) -> <Self as MatIndex<RowRange, ColRange>>::Target

where Self: MatIndex<RowRange, ColRange>,

👎Deprecated: replaced by MatMut::get_mut

pub unsafe fn read_unchecked(&self, row: usize, col: usize) -> E

Reads the value of the element at the given indices.

Safety

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

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

pub fn read(&self, row: usize, col: usize) -> E

Reads the value of the element at the given indices, with bound checks.

Panics

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

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

pub unsafe fn write_unchecked(&mut self, row: usize, col: usize, value: E)

Writes the value to the element at the given indices.

Safety

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

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

pub fn write(&mut self, row: usize, col: usize, value: E)

Writes the value to the element at the given indices, with bound checks.

Panics

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

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

pub fn copy_from_triangular_lower(&mut self, other: impl AsMatRef<E>)

Copies the values from the lower triangular part of other into the lower triangular part of self. The diagonal part is included.

Panics

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

• self.nrows() == other.nrows().
• self.ncols() == other.ncols().
• self.nrows() == self.ncols().

pub fn copy_from_strict_triangular_lower(&mut self, other: impl AsMatRef<E>)

Copies the values from the lower triangular part of other into the lower triangular part of self. The diagonal part is excluded.

Panics

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

• self.nrows() == other.nrows().
• self.ncols() == other.ncols().
• self.nrows() == self.ncols().

pub fn copy_from_triangular_upper(&mut self, other: impl AsMatRef<E>)

Copies the values from the upper triangular part of other into the upper triangular part of self. The diagonal part is included.

Panics

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

• self.nrows() == other.nrows().
• self.ncols() == other.ncols().
• self.nrows() == self.ncols().

pub fn copy_from_strict_triangular_upper(&mut self, other: impl AsMatRef<E>)

Copies the values from the upper triangular part of other into the upper triangular part of self. The diagonal part is excluded.

Panics

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

• self.nrows() == other.nrows().
• self.ncols() == other.ncols().
• self.nrows() == self.ncols().

pub fn copy_from(&mut self, other: impl AsMatRef<E>)

Copies the values from other into self.

Panics

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

• self.nrows() == other.nrows().
• self.ncols() == other.ncols().

pub fn fill_zero(&mut self)

where E: ComplexField,

Fills the elements of self with zeros.

pub fn fill(&mut self, constant: E)

Fills the elements of self with copies of constant.

pub fn transpose_mut(self) -> Self

Returns a view over the transpose of self.

Example

use faer_core::mat;

let mut matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_mut();
let transpose = view.transpose_mut();

let mut expected = mat![[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]];
assert_eq!(expected.as_mut(), transpose);

pub fn transpose(self) -> Self

👎Deprecated: replaced by MatMut::transpose_mut

pub fn conjugate_mut(self) -> MatMut<'a, E::Conj>

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn conjugate(self) -> MatMut<'a, E::Conj>

where E: Conjugate,

👎Deprecated: replaced by MatMut::conjugate_mut

pub fn adjoint_mut(self) -> MatMut<'a, E::Conj>

where E: Conjugate,

Returns a view over the conjugate transpose of self.

pub fn adjoint(self) -> MatMut<'a, E::Conj>

where E: Conjugate,

👎Deprecated: replaced by MatMut::adjoint_mut

pub fn canonicalize_mut(self) -> (MatMut<'a, E::Canonical>, Conj)

where E: Conjugate,

Returns a view over the canonical representation of self, as well as a flag declaring whether self is implicitly conjugated or not.

pub fn canonicalize(self) -> (MatMut<'a, E::Canonical>, Conj)

where E: Conjugate,

👎Deprecated: replaced by MatMut::canonicalize_mut

pub fn reverse_rows_mut(self) -> Self

Returns a view over the self, with the rows in reversed order.

Example

use faer_core::mat;

let mut matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_mut();
let reversed_rows = view.reverse_rows_mut();

let mut expected = mat![[4.0, 5.0, 6.0], [1.0, 2.0, 3.0]];
assert_eq!(expected.as_mut(), reversed_rows);

pub fn reverse_rows(self) -> Self

👎Deprecated: replaced by MatMut::reverse_rows_mut

pub fn reverse_cols_mut(self) -> Self

Returns a view over the self, with the columns in reversed order.

Example

use faer_core::mat;

let mut matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_mut();
let reversed_cols = view.reverse_cols_mut();

let mut expected = mat![[3.0, 2.0, 1.0], [6.0, 5.0, 4.0]];
assert_eq!(expected.as_mut(), reversed_cols);

pub fn reverse_cols(self) -> Self

👎Deprecated: replaced by MatMut::reverse_cols_mut

pub fn reverse_rows_and_cols_mut(self) -> Self

Returns a view over the self, with the rows and the columns in reversed order.

Example

use faer_core::mat;

let mut matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_mut();
let reversed = view.reverse_rows_and_cols_mut();

let mut expected = mat![[6.0, 5.0, 4.0], [3.0, 2.0, 1.0]];
assert_eq!(expected.as_mut(), reversed);

pub fn reverse_rows_and_cols(self) -> Self

👎Deprecated: replaced by MatMut::reverse_rows_and_cols_mut

pub fn submatrix_mut( self, row_start: usize, col_start: usize, nrows: usize, ncols: usize ) -> Self

Returns a view over the submatrix starting at indices (row_start, col_start), and with dimensions (nrows, ncols).

Panics

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

• row_start <= self.nrows().
• col_start <= self.ncols().
• nrows <= self.nrows() - row_start.
• ncols <= self.ncols() - col_start.

Example

use faer_core::mat;

let mut matrix = mat![
    [1.0, 5.0, 9.0],
    [2.0, 6.0, 10.0],
    [3.0, 7.0, 11.0],
    [4.0, 8.0, 12.0f64],
];

let view = matrix.as_mut();
let submatrix = view.submatrix_mut(2, 1, 2, 2);

let mut expected = mat![[7.0, 11.0], [8.0, 12.0f64]];
assert_eq!(expected.as_mut(), submatrix);

pub fn submatrix( self, row_start: usize, col_start: usize, nrows: usize, ncols: usize ) -> Self

👎Deprecated: replaced by MatMut::submatrix_mut

pub fn subrows_mut(self, row_start: usize, nrows: usize) -> Self

Returns a view over the submatrix starting at row row_start, and with number of rows nrows.

Panics

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

• row_start <= self.nrows().
• nrows <= self.nrows() - row_start.

Example

use faer_core::mat;

let mut matrix = mat![
    [1.0, 5.0, 9.0],
    [2.0, 6.0, 10.0],
    [3.0, 7.0, 11.0],
    [4.0, 8.0, 12.0f64],
];

let view = matrix.as_mut();
let subrows = view.subrows_mut(1, 2);

let mut expected = mat![[2.0, 6.0, 10.0], [3.0, 7.0, 11.0],];
assert_eq!(expected.as_mut(), subrows);

pub fn subrows(self, row_start: usize, nrows: usize) -> Self

👎Deprecated: replaced by MatMut::subrows_mut

pub fn subcols_mut(self, col_start: usize, ncols: usize) -> Self

Returns a view over the submatrix starting at column col_start, and with number of columns ncols.

Panics

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

• col_start <= self.ncols().
• ncols <= self.ncols() - col_start.

Example

use faer_core::mat;

let mut matrix = mat![
    [1.0, 5.0, 9.0],
    [2.0, 6.0, 10.0],
    [3.0, 7.0, 11.0],
    [4.0, 8.0, 12.0f64],
];

let view = matrix.as_mut();
let subcols = view.subcols_mut(2, 1);

let mut expected = mat![[9.0], [10.0], [11.0], [12.0f64]];
assert_eq!(expected.as_mut(), subcols);

pub fn subcols(self, col_start: usize, ncols: usize) -> Self

👎Deprecated: replaced by MatMut::subcols_mut

pub fn row_mut(self, row_idx: usize) -> RowMut<'a, E>

Returns a view over the row at the given index.

Panics

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

• row_idx < self.nrows().

pub fn row(self, row_idx: usize) -> RowMut<'a, E>

👎Deprecated: replaced by MatMut::row_mut

pub fn col_mut(self, col_idx: usize) -> ColMut<'a, E>

Returns a view over the column at the given index.

Panics

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

• col_idx < self.ncols().

pub fn col(self, col_idx: usize) -> ColMut<'a, E>

👎Deprecated: replaced by MatMut::col_mut

pub fn column_vector_as_diagonal_mut(self) -> Matrix<DiagMut<'a, E>>

Given a matrix with a single column, returns an object that interprets the column as a diagonal matrix, whoes diagonal elements are values in the column.

pub fn column_vector_as_diagonal(self) -> Matrix<DiagMut<'a, E>>

👎Deprecated: replaced by MatMut::column_vector_as_diagonal_mut

pub fn diagonal_mut(self) -> Matrix<DiagMut<'a, E>>

pub fn diagonal(self) -> Matrix<DiagMut<'a, E>>

👎Deprecated: replaced by MatMut::diagonal_mut

pub fn to_owned(&self) -> Mat<E::Canonical>

where E: Conjugate,

Returns an owning Mat of the data

pub fn has_nan(&self) -> bool

where E: ComplexField,

Returns true if any of the elements is NaN, otherwise returns false.

pub fn is_all_finite(&self) -> bool

where E: ComplexField,

Returns true if all of the elements are finite, otherwise returns false.

pub fn norm_max(&self) -> E::Real

where E: ComplexField,

Returns the maximum norm of self.

pub fn norm_l2(&self) -> E::Real

where E: ComplexField,

Returns the L2 norm of self.

pub fn as_ref(&self) -> MatRef<'_, E>

Returns a view over the matrix.

pub fn as_mut(&mut self) -> MatMut<'_, E>

Returns a mutable view over the matrix.

pub fn col_chunks_mut( self, chunk_size: usize ) -> impl 'a + DoubleEndedIterator<Item = MatMut<'a, E>>

Returns an iterator that provides successive chunks of the columns of this matrix, with each having at most chunk_size columns.

If the number of columns is a multiple of chunk_size, then all chunks have chunk_size columns.

pub fn into_col_chunks( self, chunk_size: usize ) -> impl 'a + DoubleEndedIterator<Item = MatMut<'a, E>>

👎Deprecated: replaced by MatMut::col_chunks_mut

pub fn row_chunks_mut( self, chunk_size: usize ) -> impl 'a + DoubleEndedIterator<Item = MatMut<'a, E>>

Returns an iterator that provides successive chunks of the rows of this matrix, with each having at most chunk_size rows.

If the number of rows is a multiple of chunk_size, then all chunks have chunk_size rows.

pub fn into_row_chunks( self, chunk_size: usize ) -> impl 'a + DoubleEndedIterator<Item = MatMut<'a, E>>

👎Deprecated: replaced by MatMut::row_chunks_mut

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

Returns a parallel iterator that provides successive chunks of the columns of this matrix, with each having at most chunk_size columns.

If the number of columns is a multiple of chunk_size, then all chunks have chunk_size columns.

Only available with the rayon feature.

pub fn into_par_col_chunks( self, chunk_size: usize ) -> impl 'a + IndexedParallelIterator<Item = MatMut<'a, E>>

👎Deprecated: replaced by MatMut::par_col_chunks_mut

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

Returns a parallel iterator that provides successive chunks of the rows of this matrix, with each having at most chunk_size rows.

If the number of rows is a multiple of chunk_size, then all chunks have chunk_size rows.

Only available with the rayon feature.

pub fn into_par_row_chunks( self, chunk_size: usize ) -> impl 'a + IndexedParallelIterator<Item = MatMut<'a, E>>

👎Deprecated: replaced by MatMut::par_row_chunks_mut

impl<'a, E: RealField> MatMut<'a, Complex<E>>

pub fn real_imag_mut(self) -> Complex<MatMut<'a, E>>

Trait Implementations

impl<E: Entity> AsMatMut<E> for &mut MatMut<'_, E>

fn as_mat_mut(&mut self) -> MatMut<'_, E>

impl<E: Entity> AsMatMut<E> for MatMut<'_, E>

fn as_mat_mut(&mut self) -> MatMut<'_, E>

impl<E: Entity> AsMatRef<E> for &MatMut<'_, E>

fn as_mat_ref(&self) -> MatRef<'_, E>

impl<E: Entity> AsMatRef<E> for MatMut<'_, E>

fn as_mat_ref(&self) -> MatRef<'_, E>

impl<'a, FromE: Entity, ToE: Entity> Coerce<Matrix<DenseMut<'a, ToE>>> for MatMut<'a, FromE>

fn coerce(self) -> MatMut<'a, ToE>

impl<'a, E: Entity> Debug for MatMut<'a, E>

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

Formats the value using the given formatter.

impl<E: Entity> DenseAccess<E> for MatMut<'_, E>

fn fetch_single(&self, row: usize, col: usize) -> E

impl<E: SimpleEntity> Index<(usize, usize)> for MatMut<'_, E>

type Output = E

The returned type after indexing.

fn index(&self, (row, col): (usize, usize)) -> &E

Performs the indexing (container[index]) operation.

impl<E: SimpleEntity> IndexMut<(usize, usize)> for MatMut<'_, E>

fn index_mut(&mut self, (row, col): (usize, usize)) -> &mut E

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

impl<'a, E: Entity> IntoConst for MatMut<'a, E>

type Target = Matrix<DenseRef<'a, E>>

fn into_const(self) -> Self::Target

impl<'a, E: Entity> MatIndex<'a> for MatMut<'_, E>

type Item = ReadWrite<'a, E>

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

unsafe fn get_from_slice_unchecked( slice: &'a mut Self::Slice, idx: usize ) -> Self::Item

fn is_contiguous(&self) -> bool

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

fn with_layout(self, layout: Self::LayoutTransform) -> Self

impl<E: Entity> MatIndex<Range<usize>, Range<usize>> for MatMut<'_, E>

type Target = Matrix<DenseMut<'_, E>>

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

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

impl<E: Entity> MatIndex<Range<usize>, usize> for MatMut<'_, E>

type Target = Matrix<DenseMut<'_, E>>

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

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

impl<E: Entity> MatIndex<RangeFrom<usize>, Range<usize>> for MatMut<'_, E>

type Target = Matrix<DenseMut<'_, E>>

fn get(this: Self, row: RangeFrom<usize>, col: Range<usize>) -> Self

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

impl<E: Entity> MatIndex<RangeFrom<usize>, usize> for MatMut<'_, E>

type Target = Matrix<DenseMut<'_, E>>

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

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

impl<E: Entity> MatIndex<RangeFull, Range<usize>> for MatMut<'_, E>

type Target = Matrix<DenseMut<'_, E>>

fn get(this: Self, row: RangeFull, col: Range<usize>) -> Self

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

impl<'a, E: Entity> MatIndex<RangeFull, usize> for MatMut<'a, E>

type Target = Matrix<DenseColMut<'a, E>>

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

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

impl<E: Entity> MatIndex<RangeInclusive<usize>, Range<usize>> for MatMut<'_, E>

type Target = Matrix<DenseMut<'_, E>>

fn get(this: Self, row: RangeInclusive<usize>, col: Range<usize>) -> Self

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

impl<E: Entity> MatIndex<RangeInclusive<usize>, usize> for MatMut<'_, E>

type Target = Matrix<DenseMut<'_, E>>

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

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

impl<E: Entity> MatIndex<RangeTo<usize>, Range<usize>> for MatMut<'_, E>

type Target = Matrix<DenseMut<'_, E>>

fn get(this: Self, row: RangeTo<usize>, col: Range<usize>) -> Self

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

impl<E: Entity> MatIndex<RangeTo<usize>, usize> for MatMut<'_, E>

type Target = Matrix<DenseMut<'_, E>>

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

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

impl<E: Entity> MatIndex<RangeToInclusive<usize>, Range<usize>> for MatMut<'_, E>

type Target = Matrix<DenseMut<'_, E>>

fn get(this: Self, row: RangeToInclusive<usize>, col: Range<usize>) -> Self

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

impl<E: Entity> MatIndex<RangeToInclusive<usize>, usize> for MatMut<'_, E>

type Target = Matrix<DenseMut<'_, E>>

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

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

impl<E: Entity, RowRange> MatIndex<RowRange, RangeFrom<usize>> for MatMut<'_, E>

where Self: MatIndex<RowRange, Range<usize>>,

type Target = <Matrix<DenseMut<'_, E>> as MatIndex<RowRange, Range<usize>>>::Target

fn get( this: Self, row: RowRange, col: RangeFrom<usize> ) -> <Self as MatIndex<RowRange, Range<usize>>>::Target

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

impl<E: Entity, RowRange> MatIndex<RowRange, RangeFull> for MatMut<'_, E>

where Self: MatIndex<RowRange, Range<usize>>,

type Target = <Matrix<DenseMut<'_, E>> as MatIndex<RowRange, Range<usize>>>::Target

fn get( this: Self, row: RowRange, col: RangeFull ) -> <Self as MatIndex<RowRange, Range<usize>>>::Target

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

impl<E: Entity, RowRange> MatIndex<RowRange, RangeInclusive<usize>> for MatMut<'_, E>

where Self: MatIndex<RowRange, Range<usize>>,

type Target = <Matrix<DenseMut<'_, E>> as MatIndex<RowRange, Range<usize>>>::Target

fn get( this: Self, row: RowRange, col: RangeInclusive<usize> ) -> <Self as MatIndex<RowRange, Range<usize>>>::Target

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

impl<E: Entity, RowRange> MatIndex<RowRange, RangeTo<usize>> for MatMut<'_, E>

where Self: MatIndex<RowRange, Range<usize>>,

type Target = <Matrix<DenseMut<'_, E>> as MatIndex<RowRange, Range<usize>>>::Target

fn get( this: Self, row: RowRange, col: RangeTo<usize> ) -> <Self as MatIndex<RowRange, Range<usize>>>::Target

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

impl<E: Entity, RowRange> MatIndex<RowRange, RangeToInclusive<usize>> for MatMut<'_, E>

where Self: MatIndex<RowRange, Range<usize>>,

type Target = <Matrix<DenseMut<'_, E>> as MatIndex<RowRange, Range<usize>>>::Target

fn get( this: Self, row: RowRange, col: RangeToInclusive<usize> ) -> <Self as MatIndex<RowRange, Range<usize>>>::Target

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

impl<E: Entity> MatIndex<usize, Range<usize>> for MatMut<'_, E>

type Target = Matrix<DenseMut<'_, E>>

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

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

impl<'a, E: Entity> MatIndex<usize, usize> for MatMut<'a, E>

type Target = <<E as Entity>::Group as ForType>::FaerOf<&'a mut <E as Entity>::Unit>

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

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

impl<E: Entity> MatShape for MatMut<'_, E>

type Rows = usize

type Cols = usize

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

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

impl<E: Entity> Matrix<E> for MatMut<'_, E>

fn rows(&self) -> usize

fn cols(&self) -> usize

fn access(&self) -> Access<'_, E>

Expose dense or sparse access to the matrix.

impl<E: Entity> MaybeContiguous for MatMut<'_, E>

type Index = (usize, usize)

type Slice = <<E as Entity>::Group as ForType>::FaerOf<&'static mut [MaybeUninit<<E as Entity>::Unit>]>

type LayoutTransform = MatLayoutTransform

unsafe fn get_slice_unchecked( &mut self, (i, j): Self::Index, n_elems: usize ) -> Self::Slice

impl<'short, 'a, E: Entity> Reborrow<'short> for MatMut<'a, E>

type Target = Matrix<DenseRef<'short, E>>

fn rb(&'short self) -> Self::Target

impl<'short, 'a, E: Entity> ReborrowMut<'short> for MatMut<'a, E>

type Target = Matrix<DenseMut<'short, E>>

fn rb_mut(&'short mut self) -> Self::Target

impl<E: Entity> ViewMut for &MatMut<'_, E>

type Target<'a> = Matrix<DenseRef<'a, E>> where Self: 'a

fn view_mut(&mut self) -> Self::Target<'_>

impl<E: Entity> ViewMut for &mut MatMut<'_, E>

type Target<'a> = Matrix<DenseMut<'a, E>> where Self: 'a

fn view_mut(&mut self) -> Self::Target<'_>

impl<E: Entity> ViewMut for MatMut<'_, E>

type Target<'a> = Matrix<DenseMut<'a, E>> where Self: 'a

fn view_mut(&mut self) -> Self::Target<'_>