# Struct extendr_api::prelude::MatMut

```
#[repr(C)]pub struct MatMut<'a, E>where
E: Entity,{
pub(super) inner: MatImpl<E>,
pub(super) __marker: PhantomData<&'a E>,
}
```

## Expand description

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_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
```

## Fields§

§`inner: MatImpl<E>`

§`__marker: PhantomData<&'a E>`

## Implementations§

§### impl<E> MatMut<'_, E>

### impl<E> MatMut<'_, E>

#### pub fn solve_lower_triangular_in_place(
&self,
rhs: impl ColBatchMut<<E as Conjugate>::Canonical>,
)

#### pub fn solve_lower_triangular_in_place( &self, rhs: impl ColBatchMut<<E as Conjugate>::Canonical>, )

Assuming `self`

is a lower triangular matrix, solves the equation `self * X = rhs`

, and
stores the result in `rhs`

.

#### pub fn solve_upper_triangular_in_place(
&self,
rhs: impl ColBatchMut<<E as Conjugate>::Canonical>,
)

#### pub fn solve_upper_triangular_in_place( &self, rhs: impl ColBatchMut<<E as Conjugate>::Canonical>, )

Assuming `self`

is an upper triangular matrix, solves the equation `self * X = rhs`

, and
stores the result in `rhs`

.

#### pub fn solve_unit_lower_triangular_in_place(
&self,
rhs: impl ColBatchMut<<E as Conjugate>::Canonical>,
)

#### pub fn solve_unit_lower_triangular_in_place( &self, rhs: impl ColBatchMut<<E as Conjugate>::Canonical>, )

Assuming `self`

is a unit lower triangular matrix, solves the equation `self * X = rhs`

,
and stores the result in `rhs`

.

The diagonal of the matrix is not accessed.

#### pub fn solve_unit_upper_triangular_in_place(
&self,
rhs: impl ColBatchMut<<E as Conjugate>::Canonical>,
)

#### pub fn solve_unit_upper_triangular_in_place( &self, rhs: impl ColBatchMut<<E as Conjugate>::Canonical>, )

Assuming `self`

is a unit upper triangular matrix, solves the equation `self * X = rhs`

,
and stores the result in `rhs`

The diagonal of the matrix is not accessed.

#### pub fn solve_lower_triangular<ViewE, B>(
&self,
rhs: B,
) -> <B as ColBatch<ViewE>>::Owned

#### pub fn solve_lower_triangular<ViewE, B>( &self, rhs: B, ) -> <B as ColBatch<ViewE>>::Owned

Assuming `self`

is a lower triangular matrix, solves the equation `self * X = rhs`

, and
returns the result.

#### pub fn solve_upper_triangular<ViewE, B>(
&self,
rhs: B,
) -> <B as ColBatch<ViewE>>::Owned

#### pub fn solve_upper_triangular<ViewE, B>( &self, rhs: B, ) -> <B as ColBatch<ViewE>>::Owned

Assuming `self`

is an upper triangular matrix, solves the equation `self * X = rhs`

, and
returns the result.

#### pub fn solve_unit_lower_triangular<ViewE, B>(
&self,
rhs: B,
) -> <B as ColBatch<ViewE>>::Owned

#### pub fn solve_unit_lower_triangular<ViewE, B>( &self, rhs: B, ) -> <B as ColBatch<ViewE>>::Owned

Assuming `self`

is a unit lower triangular matrix, solves the equation `self * X = rhs`

, and
returns the result.

The diagonal of the matrix is not accessed.

#### pub fn solve_unit_upper_triangular<ViewE, B>(
&self,
rhs: B,
) -> <B as ColBatch<ViewE>>::Owned

#### pub fn solve_unit_upper_triangular<ViewE, B>( &self, rhs: B, ) -> <B as ColBatch<ViewE>>::Owned

Assuming `self`

is a unit upper triangular matrix, solves the equation `self * X = rhs`

, and
returns the result.

The diagonal of the matrix is not accessed.

#### pub fn cholesky(
&self,
side: Side,
) -> Result<Cholesky<<E as Conjugate>::Canonical>, CholeskyError>

#### pub fn cholesky( &self, side: Side, ) -> Result<Cholesky<<E as Conjugate>::Canonical>, CholeskyError>

Returns the Cholesky decomposition of `self`

. Only the provided side is accessed.

#### pub fn lblt(&self, side: Side) -> Lblt<<E as Conjugate>::Canonical>

#### pub fn lblt(&self, side: Side) -> Lblt<<E as Conjugate>::Canonical>

Returns the Bunch-Kaufman decomposition of `self`

. Only the provided side is accessed.

#### pub fn partial_piv_lu(&self) -> PartialPivLu<<E as Conjugate>::Canonical>

#### pub fn partial_piv_lu(&self) -> PartialPivLu<<E as Conjugate>::Canonical>

Returns the LU decomposition of `self`

with partial (row) pivoting.

#### pub fn full_piv_lu(&self) -> FullPivLu<<E as Conjugate>::Canonical>

#### pub fn full_piv_lu(&self) -> FullPivLu<<E as Conjugate>::Canonical>

Returns the LU decomposition of `self`

with full pivoting.

#### pub fn col_piv_qr(&self) -> ColPivQr<<E as Conjugate>::Canonical>

#### pub fn col_piv_qr(&self) -> ColPivQr<<E as Conjugate>::Canonical>

Returns the QR decomposition of `self`

with column pivoting.

#### pub fn selfadjoint_eigendecomposition(
&self,
side: Side,
) -> SelfAdjointEigendecomposition<<E as Conjugate>::Canonical>

#### pub fn selfadjoint_eigendecomposition( &self, side: Side, ) -> SelfAdjointEigendecomposition<<E as Conjugate>::Canonical>

Returns the eigendecomposition of `self`

, assuming it is self-adjoint. Only the provided
side is accessed.

#### pub fn eigendecomposition<ComplexE>(&self) -> Eigendecomposition<ComplexE>

#### pub fn eigendecomposition<ComplexE>(&self) -> Eigendecomposition<ComplexE>

Returns the eigendecomposition of `self`

, as a complex matrix.

#### pub fn complex_eigendecomposition(
&self,
) -> Eigendecomposition<<E as Conjugate>::Canonical>

#### pub fn complex_eigendecomposition( &self, ) -> Eigendecomposition<<E as Conjugate>::Canonical>

Returns the eigendecomposition of `self`

, when `E`

is in the complex domain.

#### pub fn determinant(&self) -> <E as Conjugate>::Canonical

#### pub fn determinant(&self) -> <E as Conjugate>::Canonical

Returns the determinant of `self`

.

#### pub fn selfadjoint_eigenvalues(
&self,
side: Side,
) -> Vec<<<E as Conjugate>::Canonical as ComplexField>::Real>

#### pub fn selfadjoint_eigenvalues( &self, side: Side, ) -> Vec<<<E as Conjugate>::Canonical as ComplexField>::Real>

Returns the eigenvalues of `self`

, assuming it is self-adjoint. Only the provided
side is accessed. The order of the eigenvalues is currently unspecified.

#### pub fn singular_values(
&self,
) -> Vec<<<E as Conjugate>::Canonical as ComplexField>::Real>

#### pub fn singular_values( &self, ) -> Vec<<<E as Conjugate>::Canonical as ComplexField>::Real>

Returns the singular values of `self`

, in nonincreasing order.

#### pub fn eigenvalues<ComplexE>(&self) -> Vec<ComplexE>

#### pub fn eigenvalues<ComplexE>(&self) -> Vec<ComplexE>

Returns the eigenvalues of `self`

, as complex values. The order of the eigenvalues is
currently unspecified.

#### pub fn complex_eigenvalues(&self) -> Vec<<E as Conjugate>::Canonical>

#### pub fn complex_eigenvalues(&self) -> Vec<<E as Conjugate>::Canonical>

Returns the eigenvalues of `self`

, when `E`

is in the complex domain. The order of the
eigenvalues is currently unspecified.

§### impl<'a, E> MatMut<'a, E>where
E: Entity,

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

#### pub fn as_ptr(
self,
) -> <<E as Entity>::Group as ForType>::FaerOf<*const <E as Entity>::Unit>

#### pub fn as_ptr( self, ) -> <<E as Entity>::Group as ForType>::FaerOf<*const <E as Entity>::Unit>

Returns pointers to the matrix data.

#### pub fn as_ptr_mut(
self,
) -> <<E as Entity>::Group as ForType>::FaerOf<*mut <E as Entity>::Unit>

#### pub fn as_ptr_mut( self, ) -> <<E as Entity>::Group as ForType>::FaerOf<*mut <E as Entity>::Unit>

Returns pointers to the matrix data.

#### pub fn row_stride(&self) -> isize

#### 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

#### 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(
self,
row: usize,
col: usize,
) -> <<E as Entity>::Group as ForType>::FaerOf<*const <E as Entity>::Unit>

#### pub fn ptr_at( self, row: usize, col: usize, ) -> <<E as Entity>::Group as ForType>::FaerOf<*const <E as Entity>::Unit>

Returns raw pointers to the element at the given indices.

#### pub fn ptr_at_mut(
self,
row: usize,
col: usize,
) -> <<E as Entity>::Group as ForType>::FaerOf<*mut <E as Entity>::Unit>

#### pub fn ptr_at_mut( self, row: usize, col: usize, ) -> <<E as Entity>::Group as ForType>::FaerOf<*mut <E as Entity>::Unit>

Returns raw pointers to the element at the given indices.

#### pub unsafe fn ptr_inbounds_at(
self,
row: usize,
col: usize,
) -> <<E as Entity>::Group as ForType>::FaerOf<*const <E as Entity>::Unit>

#### pub unsafe fn ptr_inbounds_at( self, row: usize, col: usize, ) -> <<E as Entity>::Group as ForType>::FaerOf<*const <E as Entity>::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_mut(
self,
row: usize,
col: usize,
) -> <<E as Entity>::Group as ForType>::FaerOf<*mut <E as Entity>::Unit>

#### pub unsafe fn ptr_inbounds_at_mut( self, row: usize, col: usize, ) -> <<E as Entity>::Group as ForType>::FaerOf<*mut <E as Entity>::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 split_at_unchecked(
self,
row: usize,
col: usize,
) -> (MatRef<'a, E>, MatRef<'a, E>, MatRef<'a, E>, MatRef<'a, E>)

#### pub unsafe fn split_at_unchecked( self, row: usize, col: usize, ) -> (MatRef<'a, E>, MatRef<'a, E>, MatRef<'a, E>, MatRef<'a, E>)

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(
self,
row: usize,
col: usize,
) -> (MatRef<'a, E>, MatRef<'a, E>, MatRef<'a, E>, MatRef<'a, E>)

#### pub fn split_at( self, row: usize, col: usize, ) -> (MatRef<'a, E>, MatRef<'a, E>, MatRef<'a, E>, MatRef<'a, E>)

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_mut_unchecked(
self,
row: usize,
col: usize,
) -> (MatMut<'a, E>, MatMut<'a, E>, MatMut<'a, E>, MatMut<'a, E>)

#### pub unsafe fn split_at_mut_unchecked( self, row: usize, col: usize, ) -> (MatMut<'a, E>, MatMut<'a, E>, MatMut<'a, E>, MatMut<'a, E>)

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,
) -> (MatMut<'a, E>, MatMut<'a, E>, MatMut<'a, E>, MatMut<'a, E>)

#### pub fn split_at_mut( self, row: usize, col: usize, ) -> (MatMut<'a, E>, MatMut<'a, E>, MatMut<'a, E>, MatMut<'a, E>)

- 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_unchecked(
self,
row: usize,
) -> (MatRef<'a, E>, MatRef<'a, E>)

#### pub unsafe fn split_at_row_unchecked( self, row: usize, ) -> (MatRef<'a, E>, MatRef<'a, E>)

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(self, row: usize) -> (MatRef<'a, E>, MatRef<'a, E>)

#### pub fn split_at_row(self, row: usize) -> (MatRef<'a, E>, MatRef<'a, E>)

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_row_mut_unchecked(
self,
row: usize,
) -> (MatMut<'a, E>, MatMut<'a, E>)

#### pub unsafe fn split_at_row_mut_unchecked( self, row: usize, ) -> (MatMut<'a, E>, MatMut<'a, E>)

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) -> (MatMut<'a, E>, MatMut<'a, E>)

#### pub fn split_at_row_mut(self, row: usize) -> (MatMut<'a, E>, MatMut<'a, E>)

- top.
- bottom.

##### §Panics

The function panics if the following condition is violated:

`row <= self.nrows()`

.

#### pub unsafe fn split_at_col_unchecked(
self,
col: usize,
) -> (MatRef<'a, E>, MatRef<'a, E>)

#### pub unsafe fn split_at_col_unchecked( self, col: usize, ) -> (MatRef<'a, E>, MatRef<'a, E>)

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(self, col: usize) -> (MatRef<'a, E>, MatRef<'a, E>)

#### pub fn split_at_col(self, col: usize) -> (MatRef<'a, E>, MatRef<'a, E>)

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 unsafe fn split_at_col_mut_unchecked(
self,
col: usize,
) -> (MatMut<'a, E>, MatMut<'a, E>)

#### pub unsafe fn split_at_col_mut_unchecked( self, col: usize, ) -> (MatMut<'a, E>, MatMut<'a, E>)

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) -> (MatMut<'a, E>, MatMut<'a, E>)

#### pub fn split_at_col_mut(self, col: usize) -> (MatMut<'a, E>, MatMut<'a, E>)

- left.
- right.

##### §Panics

The function panics if the following condition is violated:

`col <= self.ncols()`

.

#### pub unsafe fn get_unchecked<RowRange, ColRange>(
self,
row: RowRange,
col: ColRange,
) -> <MatRef<'a, E> as MatIndex<RowRange, ColRange>>::Target

#### pub unsafe fn get_unchecked<RowRange, ColRange>( self, row: RowRange, col: ColRange, ) -> <MatRef<'a, E> as MatIndex<RowRange, ColRange>>::Target

Returns 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 fn get<RowRange, ColRange>(
self,
row: RowRange,
col: ColRange,
) -> <MatRef<'a, E> as MatIndex<RowRange, ColRange>>::Target

#### pub fn get<RowRange, ColRange>( self, row: RowRange, col: ColRange, ) -> <MatRef<'a, E> as MatIndex<RowRange, ColRange>>::Target

Returns 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 unsafe fn get_mut_unchecked<RowRange, ColRange>(
self,
row: RowRange,
col: ColRange,
) -> <MatMut<'a, E> as MatIndex<RowRange, ColRange>>::Target

#### pub unsafe fn get_mut_unchecked<RowRange, ColRange>( self, row: RowRange, col: ColRange, ) -> <MatMut<'a, E> as MatIndex<RowRange, ColRange>>::Target

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 fn get_mut<RowRange, ColRange>(
self,
row: RowRange,
col: ColRange,
) -> <MatMut<'a, E> as MatIndex<RowRange, ColRange>>::Target

#### pub fn get_mut<RowRange, ColRange>( self, row: RowRange, col: ColRange, ) -> <MatMut<'a, E> as MatIndex<RowRange, ColRange>>::Target

Returns mutable references to the element at the given indices, or submatrices if either
`row`

or `col`

is a range, with bound checks.

##### §Note

##### §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 unsafe fn read_unchecked(&self, row: usize, col: usize) -> E

#### 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

#### 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)

#### 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)

#### 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<ViewE>(&mut self, other: impl AsMatRef<ViewE>)where
ViewE: Conjugate<Canonical = E>,

#### pub fn copy_from_triangular_lower<ViewE>(&mut self, other: impl AsMatRef<ViewE>)where
ViewE: Conjugate<Canonical = 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<ViewE>(
&mut self,
other: impl AsMatRef<ViewE>,
)where
ViewE: Conjugate<Canonical = E>,

#### pub fn copy_from_strict_triangular_lower<ViewE>(
&mut self,
other: impl AsMatRef<ViewE>,
)where
ViewE: Conjugate<Canonical = 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<ViewE>(&mut self, other: impl AsMatRef<ViewE>)where
ViewE: Conjugate<Canonical = E>,

#### pub fn copy_from_triangular_upper<ViewE>(&mut self, other: impl AsMatRef<ViewE>)where
ViewE: Conjugate<Canonical = 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<ViewE>(
&mut self,
other: impl AsMatRef<ViewE>,
)where
ViewE: Conjugate<Canonical = E>,

#### pub fn copy_from_strict_triangular_upper<ViewE>(
&mut self,
other: impl AsMatRef<ViewE>,
)where
ViewE: Conjugate<Canonical = 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<ViewE>(&mut self, other: impl AsMatRef<ViewE>)where
ViewE: Conjugate<Canonical = E>,

#### pub fn copy_from<ViewE>(&mut self, other: impl AsMatRef<ViewE>)where
ViewE: Conjugate<Canonical = 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,

#### pub fn fill_zero(&mut self)where
E: ComplexField,

Fills the elements of `self`

with zeros.

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

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

Fills the elements of `self`

with copies of `constant`

.

#### pub fn transpose(self) -> MatRef<'a, E>

#### pub fn transpose(self) -> MatRef<'a, E>

Returns a view over the transpose of `self`

.

##### §Example

```
use faer::mat;
let matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_ref();
let transpose = view.transpose();
let expected = mat![[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]];
assert_eq!(expected.as_ref(), transpose);
```

#### pub fn transpose_mut(self) -> MatMut<'a, E>

#### pub fn transpose_mut(self) -> MatMut<'a, E>

Returns a view over the transpose of `self`

.

##### §Example

```
use faer::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 conjugate(self) -> MatRef<'a, <E as Conjugate>::Conj>where
E: Conjugate,

#### pub fn conjugate(self) -> MatRef<'a, <E as Conjugate>::Conj>where
E: Conjugate,

Returns a view over the conjugate of `self`

.

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

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

Returns a view over the conjugate of `self`

.

#### pub fn adjoint(self) -> MatRef<'a, <E as Conjugate>::Conj>where
E: Conjugate,

#### pub fn adjoint(self) -> MatRef<'a, <E as Conjugate>::Conj>where
E: Conjugate,

Returns a view over the conjugate transpose of `self`

.

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

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

Returns a view over the conjugate transpose of `self`

.

#### pub fn canonicalize(self) -> (MatRef<'a, <E as Conjugate>::Canonical>, Conj)where
E: Conjugate,

#### pub fn canonicalize(self) -> (MatRef<'a, <E as Conjugate>::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_mut(self) -> (MatMut<'a, <E as Conjugate>::Canonical>, Conj)where
E: Conjugate,

#### pub fn canonicalize_mut(self) -> (MatMut<'a, <E as Conjugate>::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 reverse_rows(self) -> MatRef<'a, E>

#### pub fn reverse_rows(self) -> MatRef<'a, E>

Returns a view over the `self`

, with the rows in reversed order.

##### §Example

```
use faer::mat;
let matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_ref();
let reversed_rows = view.reverse_rows();
let expected = mat![[4.0, 5.0, 6.0], [1.0, 2.0, 3.0]];
assert_eq!(expected.as_ref(), reversed_rows);
```

#### pub fn reverse_rows_mut(self) -> MatMut<'a, E>

#### pub fn reverse_rows_mut(self) -> MatMut<'a, E>

Returns a view over the `self`

, with the rows in reversed order.

##### §Example

```
use faer::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_cols(self) -> MatRef<'a, E>

#### pub fn reverse_cols(self) -> MatRef<'a, E>

Returns a view over the `self`

, with the columns in reversed order.

##### §Example

```
use faer::mat;
let matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_ref();
let reversed_cols = view.reverse_cols();
let expected = mat![[3.0, 2.0, 1.0], [6.0, 5.0, 4.0]];
assert_eq!(expected.as_ref(), reversed_cols);
```

#### pub fn reverse_cols_mut(self) -> MatMut<'a, E>

#### pub fn reverse_cols_mut(self) -> MatMut<'a, E>

Returns a view over the `self`

, with the columns in reversed order.

##### §Example

```
use faer::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_rows_and_cols(self) -> MatRef<'a, E>

#### pub fn reverse_rows_and_cols(self) -> MatRef<'a, E>

Returns a view over the `self`

, with the rows and the columns in reversed order.

##### §Example

```
use faer::mat;
let matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_ref();
let reversed = view.reverse_rows_and_cols();
let expected = mat![[6.0, 5.0, 4.0], [3.0, 2.0, 1.0]];
assert_eq!(expected.as_ref(), reversed);
```

#### pub fn reverse_rows_and_cols_mut(self) -> MatMut<'a, E>

#### pub fn reverse_rows_and_cols_mut(self) -> MatMut<'a, E>

Returns a view over the `self`

, with the rows and the columns in reversed order.

##### §Example

```
use faer::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 unsafe fn submatrix_unchecked(
self,
row_start: usize,
col_start: usize,
nrows: usize,
ncols: usize,
) -> MatRef<'a, E>

#### pub unsafe fn submatrix_unchecked( self, row_start: usize, col_start: usize, nrows: usize, ncols: usize, ) -> MatRef<'a, E>

Returns a view over the submatrix starting at indices `(row_start, col_start)`

, and with
dimensions `(nrows, ncols)`

.

##### §Safety

The behavior is undefined 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`

.

#### pub unsafe fn submatrix_mut_unchecked(
self,
row_start: usize,
col_start: usize,
nrows: usize,
ncols: usize,
) -> MatMut<'a, E>

#### pub unsafe fn submatrix_mut_unchecked( self, row_start: usize, col_start: usize, nrows: usize, ncols: usize, ) -> MatMut<'a, E>

Returns a view over the submatrix starting at indices `(row_start, col_start)`

, and with
dimensions `(nrows, ncols)`

.

##### §Safety

The behavior is undefined 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`

.

#### pub fn submatrix(
self,
row_start: usize,
col_start: usize,
nrows: usize,
ncols: usize,
) -> MatRef<'a, E>

#### pub fn submatrix( self, row_start: usize, col_start: usize, nrows: usize, ncols: usize, ) -> MatRef<'a, E>

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::mat;
let 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_ref();
let submatrix = view.submatrix(2, 1, 2, 2);
let expected = mat![[7.0, 11.0], [8.0, 12.0f64]];
assert_eq!(expected.as_ref(), submatrix);
```

#### pub fn submatrix_mut(
self,
row_start: usize,
col_start: usize,
nrows: usize,
ncols: usize,
) -> MatMut<'a, E>

#### pub fn submatrix_mut( self, row_start: usize, col_start: usize, nrows: usize, ncols: usize, ) -> MatMut<'a, E>

`(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::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 unsafe fn subrows_unchecked(
self,
row_start: usize,
nrows: usize,
) -> MatRef<'a, E>

#### pub unsafe fn subrows_unchecked( self, row_start: usize, nrows: usize, ) -> MatRef<'a, E>

Returns a view over the submatrix starting at row `row_start`

, and with number of rows
`nrows`

.

##### §Safety

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

`row_start <= self.nrows()`

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

.

#### pub unsafe fn subrows_mut_unchecked(
self,
row_start: usize,
nrows: usize,
) -> MatMut<'a, E>

#### pub unsafe fn subrows_mut_unchecked( self, row_start: usize, nrows: usize, ) -> MatMut<'a, E>

Returns a view over the submatrix starting at row `row_start`

, and with number of rows
`nrows`

.

##### §Safety

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

`row_start <= self.nrows()`

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

.

#### pub fn subrows(self, row_start: usize, nrows: usize) -> MatRef<'a, E>

#### pub fn subrows(self, row_start: usize, nrows: usize) -> MatRef<'a, E>

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::mat;
let 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_ref();
let subrows = view.subrows(1, 2);
let expected = mat![[2.0, 6.0, 10.0], [3.0, 7.0, 11.0],];
assert_eq!(expected.as_ref(), subrows);
```

#### pub fn subrows_mut(self, row_start: usize, nrows: usize) -> MatMut<'a, E>

#### pub fn subrows_mut(self, row_start: usize, nrows: usize) -> MatMut<'a, E>

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::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 unsafe fn subcols_unchecked(
self,
col_start: usize,
ncols: usize,
) -> MatRef<'a, E>

#### pub unsafe fn subcols_unchecked( self, col_start: usize, ncols: usize, ) -> MatRef<'a, E>

Returns a view over the submatrix starting at column `col_start`

, and with number of
columns `ncols`

.

##### §Safety

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

`col_start <= self.ncols()`

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

.

#### pub unsafe fn subcols_mut_unchecked(
self,
col_start: usize,
ncols: usize,
) -> MatMut<'a, E>

#### pub unsafe fn subcols_mut_unchecked( self, col_start: usize, ncols: usize, ) -> MatMut<'a, E>

Returns a view over the submatrix starting at column `col_start`

, and with number of
columns `ncols`

.

##### §Safety

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

`col_start <= self.ncols()`

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

.

#### pub fn subcols(self, col_start: usize, ncols: usize) -> MatRef<'a, E>

#### pub fn subcols(self, col_start: usize, ncols: usize) -> MatRef<'a, E>

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::mat;
let 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_ref();
let subcols = view.subcols(2, 1);
let expected = mat![[9.0], [10.0], [11.0], [12.0f64]];
assert_eq!(expected.as_ref(), subcols);
```

#### pub fn subcols_mut(self, col_start: usize, ncols: usize) -> MatMut<'a, E>

#### pub fn subcols_mut(self, col_start: usize, ncols: usize) -> MatMut<'a, E>

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::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 unsafe fn row_unchecked(self, row_idx: usize) -> RowRef<'a, E>

#### pub unsafe fn row_unchecked(self, row_idx: usize) -> RowRef<'a, E>

Returns a view over the row at the given index.

##### §Safety

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

`row_idx < self.nrows()`

.

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

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

Returns a view over the row at the given index.

##### §Safety

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

`row_idx < self.nrows()`

.

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

#### pub fn row(self, row_idx: usize) -> RowRef<'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_mut(self, row_idx: usize) -> RowMut<'a, E>

#### 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 two_rows_mut(
self,
row_idx0: usize,
row_idx1: usize,
) -> (RowMut<'a, E>, RowMut<'a, E>)

#### pub fn two_rows_mut( self, row_idx0: usize, row_idx1: usize, ) -> (RowMut<'a, E>, RowMut<'a, E>)

Returns views over the rows at the given indices.

##### §Panics

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

`row_idx0 < self.nrows()`

.`row_idx1 < self.nrows()`

.`row_idx0 == row_idx1`

.

#### pub unsafe fn col_unchecked(self, col_idx: usize) -> ColRef<'a, E>

#### pub unsafe fn col_unchecked(self, col_idx: usize) -> ColRef<'a, E>

Returns a view over the column at the given index.

##### §Safety

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

`col_idx < self.ncols()`

.

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

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

Returns a view over the column at the given index.

##### §Safety

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

`col_idx < self.ncols()`

.

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

#### pub fn col(self, col_idx: usize) -> ColRef<'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_mut(self, col_idx: usize) -> ColMut<'a, E>

#### 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 two_cols_mut(
self,
col_idx0: usize,
col_idx1: usize,
) -> (ColMut<'a, E>, ColMut<'a, E>)

#### pub fn two_cols_mut( self, col_idx0: usize, col_idx1: usize, ) -> (ColMut<'a, E>, ColMut<'a, E>)

Returns views over the columns at the given indices.

##### §Panics

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

`col_idx0 < self.ncols()`

.`col_idx1 < self.ncols()`

.`col_idx0 == col_idx1`

.

#### pub fn column_vector_as_diagonal(self) -> DiagRef<'a, E>

#### pub fn column_vector_as_diagonal(self) -> DiagRef<'a, E>

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

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

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

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

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

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

Returns the diagonal of the matrix.

#### pub fn to_owned(&self) -> Mat<<E as Conjugate>::Canonical>where
E: Conjugate,

#### pub fn to_owned(&self) -> Mat<<E as Conjugate>::Canonical>where
E: Conjugate,

Returns an owning `Mat`

of the data

#### pub fn has_nan(&self) -> boolwhere
E: ComplexField,

#### pub fn has_nan(&self) -> boolwhere
E: ComplexField,

Returns `true`

if any of the elements is NaN, otherwise returns `false`

.

#### pub fn is_all_finite(&self) -> boolwhere
E: ComplexField,

#### pub fn is_all_finite(&self) -> boolwhere
E: ComplexField,

Returns `true`

if all of the elements are finite, otherwise returns `false`

.

#### pub fn norm_max(&self) -> <E as ComplexField>::Realwhere
E: ComplexField,

#### pub fn norm_max(&self) -> <E as ComplexField>::Realwhere
E: ComplexField,

Returns the maximum norm of `self`

.

#### pub fn norm_l1(&self) -> <E as ComplexField>::Realwhere
E: ComplexField,

#### pub fn norm_l1(&self) -> <E as ComplexField>::Realwhere
E: ComplexField,

Returns the L1 norm of `self`

.

#### pub fn norm_l2(&self) -> <E as ComplexField>::Realwhere
E: ComplexField,

#### pub fn norm_l2(&self) -> <E as ComplexField>::Realwhere
E: ComplexField,

Returns the L2 norm of `self`

.

#### pub fn squared_norm_l2(&self) -> <E as ComplexField>::Realwhere
E: ComplexField,

#### pub fn squared_norm_l2(&self) -> <E as ComplexField>::Realwhere
E: ComplexField,

Returns the squared L2 norm of `self`

.

#### pub fn sum(&self) -> Ewhere
E: ComplexField,

#### pub fn sum(&self) -> Ewhere
E: ComplexField,

Returns the sum of `self`

.

#### pub fn kron(&self, rhs: impl As2D<E>) -> Mat<E>where
E: ComplexField,

#### pub fn kron(&self, rhs: impl As2D<E>) -> Mat<E>where
E: ComplexField,

Kronecker product of `self`

and `rhs`

.

This is an allocating operation; see `faer::linalg::kron`

for the
allocation-free version or more info in general.

#### pub fn split_first_col(self) -> Option<(ColRef<'a, E>, MatRef<'a, E>)>

#### pub fn split_first_col(self) -> Option<(ColRef<'a, E>, MatRef<'a, E>)>

Returns a reference to the first column and a view over the remaining ones if the matrix has
at least one column, otherwise `None`

.

#### pub fn split_last_col(self) -> Option<(ColRef<'a, E>, MatRef<'a, E>)>

#### pub fn split_last_col(self) -> Option<(ColRef<'a, E>, MatRef<'a, E>)>

Returns a reference to the last column and a view over the remaining ones if the matrix has
at least one column, otherwise `None`

.

#### pub fn split_first_row(self) -> Option<(RowRef<'a, E>, MatRef<'a, E>)>

#### pub fn split_first_row(self) -> Option<(RowRef<'a, E>, MatRef<'a, E>)>

Returns a reference to the first row and a view over the remaining ones if the matrix has
at least one row, otherwise `None`

.

#### pub fn split_last_row(self) -> Option<(RowRef<'a, E>, MatRef<'a, E>)>

#### pub fn split_last_row(self) -> Option<(RowRef<'a, E>, MatRef<'a, E>)>

Returns a reference to the last row and a view over the remaining ones if the matrix has
at least one row, otherwise `None`

.

#### pub fn split_first_col_mut(self) -> Option<(ColMut<'a, E>, MatMut<'a, E>)>

#### pub fn split_first_col_mut(self) -> Option<(ColMut<'a, E>, MatMut<'a, E>)>

Returns a reference to the first column and a view over the remaining ones if the matrix has
at least one column, otherwise `None`

.

#### pub fn split_last_col_mut(self) -> Option<(ColMut<'a, E>, MatMut<'a, E>)>

#### pub fn split_last_col_mut(self) -> Option<(ColMut<'a, E>, MatMut<'a, E>)>

Returns a reference to the last column and a view over the remaining ones if the matrix has
at least one column, otherwise `None`

.

#### pub fn split_first_row_mut(self) -> Option<(RowMut<'a, E>, MatMut<'a, E>)>

#### pub fn split_first_row_mut(self) -> Option<(RowMut<'a, E>, MatMut<'a, E>)>

Returns a reference to the first row and a view over the remaining ones if the matrix has
at least one row, otherwise `None`

.

#### pub fn split_last_row_mut(self) -> Option<(RowMut<'a, E>, MatMut<'a, E>)>

#### pub fn split_last_row_mut(self) -> Option<(RowMut<'a, E>, MatMut<'a, E>)>

Returns a reference to the last row and a view over the remaining ones if the matrix has
at least one row, otherwise `None`

.

#### pub fn col_iter(self) -> ColIter<'a, E>

#### pub fn col_iter(self) -> ColIter<'a, E>

Returns an iterator over the columns of the matrix.

#### pub fn row_iter(self) -> RowIter<'a, E>

#### pub fn row_iter(self) -> RowIter<'a, E>

Returns an iterator over the rows of the matrix.

#### pub fn col_iter_mut(self) -> ColIterMut<'a, E>

#### pub fn col_iter_mut(self) -> ColIterMut<'a, E>

Returns an iterator over the columns of the matrix.

#### pub fn row_iter_mut(self) -> RowIterMut<'a, E>

#### pub fn row_iter_mut(self) -> RowIterMut<'a, E>

Returns an iterator over the rows of the matrix.

#### pub fn col_chunks(self, chunk_size: usize) -> ColChunks<'a, E>

#### pub fn col_chunks(self, chunk_size: usize) -> ColChunks<'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 col_partition(self, count: usize) -> ColPartition<'a, E>

#### pub fn col_partition(self, count: usize) -> ColPartition<'a, E>

Returns an iterator that provides exactly `count`

successive chunks of the columns of this
matrix.

##### §Panics

Panics if `count == 0`

.

#### pub fn row_chunks(self, chunk_size: usize) -> RowChunks<'a, E>

#### pub fn row_chunks(self, chunk_size: usize) -> RowChunks<'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 row_partition(self, count: usize) -> RowPartition<'a, E>

#### pub fn row_partition(self, count: usize) -> RowPartition<'a, E>

Returns an iterator that provides exactly `count`

successive chunks of the rows of this
matrix.

##### §Panics

Panics if `count == 0`

.

#### pub fn col_chunks_mut(self, chunk_size: usize) -> ColChunksMut<'a, E>

#### pub fn col_chunks_mut(self, chunk_size: usize) -> ColChunksMut<'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 col_partition_mut(self, count: usize) -> ColPartitionMut<'a, E>

#### pub fn col_partition_mut(self, count: usize) -> ColPartitionMut<'a, E>

Returns an iterator that provides exactly `count`

successive chunks of the columns of this
matrix.

##### §Panics

Panics if `count == 0`

.

#### pub fn row_chunks_mut(self, chunk_size: usize) -> RowChunksMut<'a, E>

#### pub fn row_chunks_mut(self, chunk_size: usize) -> RowChunksMut<'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 row_partition_mut(self, count: usize) -> RowPartitionMut<'a, E>

#### pub fn row_partition_mut(self, count: usize) -> RowPartitionMut<'a, E>

Returns an iterator that provides exactly `count`

successive chunks of the rows of this
matrix.

##### §Panics

Panics if `count == 0`

.

#### pub fn par_col_chunks(
self,
chunk_size: usize,
) -> impl IndexedParallelIterator + 'a

#### pub fn par_col_chunks( self, chunk_size: usize, ) -> impl IndexedParallelIterator + 'a

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 par_col_partition(
self,
count: usize,
) -> impl IndexedParallelIterator + 'a

#### pub fn par_col_partition( self, count: usize, ) -> impl IndexedParallelIterator + 'a

Returns a parallel iterator that provides exactly `count`

successive chunks of the columns
of this matrix.

Only available with the `rayon`

feature.

#### pub fn par_row_chunks(
self,
chunk_size: usize,
) -> impl IndexedParallelIterator + 'a

#### pub fn par_row_chunks( self, chunk_size: usize, ) -> impl IndexedParallelIterator + 'a

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 par_row_partition(
self,
count: usize,
) -> impl IndexedParallelIterator + 'a

#### pub fn par_row_partition( self, count: usize, ) -> impl IndexedParallelIterator + 'a

Returns a parallel iterator that provides exactly `count`

successive chunks of the rows
of this matrix.

Only available with the `rayon`

feature.

#### pub fn par_col_chunks_mut(
self,
chunk_size: usize,
) -> impl IndexedParallelIterator + 'a

#### pub fn par_col_chunks_mut( self, chunk_size: usize, ) -> impl IndexedParallelIterator + 'a

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 par_col_partition_mut(
self,
count: usize,
) -> impl IndexedParallelIterator + 'a

#### pub fn par_col_partition_mut( self, count: usize, ) -> impl IndexedParallelIterator + 'a

Returns a parallel iterator that provides exactly `count`

successive chunks of the columns
of this matrix.

Only available with the `rayon`

feature.

#### pub fn par_row_chunks_mut(
self,
chunk_size: usize,
) -> impl IndexedParallelIterator + 'a

#### pub fn par_row_chunks_mut( self, chunk_size: usize, ) -> impl IndexedParallelIterator + 'a

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 par_row_partition_mut(
self,
count: usize,
) -> impl IndexedParallelIterator + 'a

#### pub fn par_row_partition_mut( self, count: usize, ) -> impl IndexedParallelIterator + 'a

Returns a parallel iterator that provides exactly `count`

successive chunks of the rows
of this matrix.

Only available with the `rayon`

feature.

## Trait Implementations§

§### impl<LhsE, RhsE> AddAssign<&Mat<RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> AddAssign<&Mat<RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

§#### fn add_assign(&mut self, other: &Mat<RhsE>)

#### fn add_assign(&mut self, other: &Mat<RhsE>)

`+=`

operation. Read more§### impl<LhsE, RhsE> AddAssign<&MatMut<'_, RhsE>> for Mat<LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> AddAssign<&MatMut<'_, RhsE>> for Mat<LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

§#### fn add_assign(&mut self, other: &MatMut<'_, RhsE>)

#### fn add_assign(&mut self, other: &MatMut<'_, RhsE>)

`+=`

operation. Read more§### impl<LhsE, RhsE> AddAssign<&MatMut<'_, RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> AddAssign<&MatMut<'_, RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

§#### fn add_assign(&mut self, other: &MatMut<'_, RhsE>)

#### fn add_assign(&mut self, other: &MatMut<'_, RhsE>)

`+=`

operation. Read more§### impl<LhsE, RhsE> AddAssign<&MatRef<'_, RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> AddAssign<&MatRef<'_, RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

§#### fn add_assign(&mut self, other: &MatRef<'_, RhsE>)

#### fn add_assign(&mut self, other: &MatRef<'_, RhsE>)

`+=`

operation. Read more§### impl<LhsE, RhsE> AddAssign<Mat<RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> AddAssign<Mat<RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

§#### fn add_assign(&mut self, other: Mat<RhsE>)

#### fn add_assign(&mut self, other: Mat<RhsE>)

`+=`

operation. Read more§### impl<LhsE, RhsE> AddAssign<MatMut<'_, RhsE>> for Mat<LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> AddAssign<MatMut<'_, RhsE>> for Mat<LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

§#### fn add_assign(&mut self, other: MatMut<'_, RhsE>)

#### fn add_assign(&mut self, other: MatMut<'_, RhsE>)

`+=`

operation. Read more§### impl<LhsE, RhsE> AddAssign<MatMut<'_, RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> AddAssign<MatMut<'_, RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

§#### fn add_assign(&mut self, other: MatMut<'_, RhsE>)

#### fn add_assign(&mut self, other: MatMut<'_, RhsE>)

`+=`

operation. Read more§### impl<LhsE, RhsE> AddAssign<MatRef<'_, RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> AddAssign<MatRef<'_, RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

§#### fn add_assign(&mut self, rhs: MatRef<'_, RhsE>)

#### fn add_assign(&mut self, rhs: MatRef<'_, RhsE>)

`+=`

operation. Read more§### impl<E> AsMatMut<E> for MatMut<'_, E>where
E: Entity,

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

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

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

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

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

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

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

§### impl<E> ColBatch<E> for MatMut<'_, E>where
E: Conjugate,

### impl<E> ColBatch<E> for MatMut<'_, E>where
E: Conjugate,

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

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

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

§### impl<LhsE, RhsE> DivAssign<Scale<RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> DivAssign<Scale<RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

§#### fn div_assign(&mut self, other: Scale<RhsE>)

#### fn div_assign(&mut self, other: Scale<RhsE>)

`/=`

operation. Read more§### impl<LhsE> DivAssign<f32> for MatMut<'_, LhsE>where
LhsE: ComplexField,

### impl<LhsE> DivAssign<f32> for MatMut<'_, LhsE>where
LhsE: ComplexField,

§#### fn div_assign(&mut self, other: f32)

#### fn div_assign(&mut self, other: f32)

`/=`

operation. Read more§### impl<LhsE> DivAssign<f64> for MatMut<'_, LhsE>where
LhsE: ComplexField,

### impl<LhsE> DivAssign<f64> for MatMut<'_, LhsE>where
LhsE: ComplexField,

§#### fn div_assign(&mut self, other: f64)

#### fn div_assign(&mut self, other: f64)

`/=`

operation. Read more§### impl<'a, E> MatIndex<'a> for MatMut<'_, E>where
E: Entity,

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

§#### unsafe fn get_unchecked(
&'a mut self,
_: <MatMut<'_, E> as MaybeContiguous>::Index,
) -> <MatMut<'_, E> as MatIndex<'a>>::Item

#### unsafe fn get_unchecked( &'a mut self, _: <MatMut<'_, E> as MaybeContiguous>::Index, ) -> <MatMut<'_, E> as MatIndex<'a>>::Item

§#### unsafe fn get_from_slice_unchecked(
slice: &'a mut <MatMut<'_, E> as MaybeContiguous>::Slice,
idx: usize,
) -> <MatMut<'_, E> as MatIndex<'a>>::Item

#### unsafe fn get_from_slice_unchecked( slice: &'a mut <MatMut<'_, E> as MaybeContiguous>::Slice, idx: usize, ) -> <MatMut<'_, E> as MatIndex<'a>>::Item

§#### fn is_contiguous(&self) -> bool

#### fn is_contiguous(&self) -> bool

§#### fn preferred_layout(
&self,
) -> <MatMut<'_, E> as MaybeContiguous>::LayoutTransform

#### fn preferred_layout( &self, ) -> <MatMut<'_, E> as MaybeContiguous>::LayoutTransform

§#### fn with_layout(
self,
layout: <MatMut<'_, E> as MaybeContiguous>::LayoutTransform,
) -> MatMut<'_, E>

#### fn with_layout( self, layout: <MatMut<'_, E> as MaybeContiguous>::LayoutTransform, ) -> MatMut<'_, E>

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

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

§### impl<'a, E> MatIndex<Range<usize>, usize> for MatMut<'a, E>where
E: Entity,

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

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

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

§### impl<'a, E> MatIndex<RangeFrom<usize>, usize> for MatMut<'a, E>where
E: Entity,

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

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

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

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

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

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

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

§### impl<'a, E> MatIndex<RangeInclusive<usize>, usize> for MatMut<'a, E>where
E: Entity,

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

§#### fn get(
this: MatMut<'a, E>,
row: RangeInclusive<usize>,
col: usize,
) -> <MatMut<'a, E> as MatIndex<RangeInclusive<usize>, usize>>::Target

#### fn get( this: MatMut<'a, E>, row: RangeInclusive<usize>, col: usize, ) -> <MatMut<'a, E> as MatIndex<RangeInclusive<usize>, usize>>::Target

`(row, col)`

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

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

`(row, col)`

, without bound checks.§### impl<E> MatIndex<RangeTo<usize>, Range<usize>> for MatMut<'_, E>where
E: Entity,

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

§### impl<'a, E> MatIndex<RangeTo<usize>, usize> for MatMut<'a, E>where
E: Entity,

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

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

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

§### impl<'a, E> MatIndex<RangeToInclusive<usize>, usize> for MatMut<'a, E>where
E: Entity,

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

§#### fn get(
this: MatMut<'a, E>,
row: RangeToInclusive<usize>,
col: usize,
) -> <MatMut<'a, E> as MatIndex<RangeToInclusive<usize>, usize>>::Target

#### fn get( this: MatMut<'a, E>, row: RangeToInclusive<usize>, col: usize, ) -> <MatMut<'a, E> as MatIndex<RangeToInclusive<usize>, usize>>::Target

`(row, col)`

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

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

`(row, col)`

, without bound checks.§### impl<E, RowRange> MatIndex<RowRange, RangeFrom<usize>> for MatMut<'_, E>

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

§#### type Target = <MatMut<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

#### type Target = <MatMut<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

§#### fn get(
this: MatMut<'_, E>,
row: RowRange,
col: RangeFrom<usize>,
) -> <MatMut<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

#### fn get( this: MatMut<'_, E>, row: RowRange, col: RangeFrom<usize>, ) -> <MatMut<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

`(row, col)`

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

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

`(row, col)`

, without bound checks.§### impl<E, RowRange> MatIndex<RowRange, RangeFull> for MatMut<'_, E>

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

§#### type Target = <MatMut<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

#### type Target = <MatMut<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

§#### fn get(
this: MatMut<'_, E>,
row: RowRange,
col: RangeFull,
) -> <MatMut<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

#### fn get( this: MatMut<'_, E>, row: RowRange, col: RangeFull, ) -> <MatMut<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

`(row, col)`

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

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

`(row, col)`

, without bound checks.§### impl<E, RowRange> MatIndex<RowRange, RangeInclusive<usize>> for MatMut<'_, E>

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

§#### type Target = <MatMut<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

#### type Target = <MatMut<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

§#### fn get(
this: MatMut<'_, E>,
row: RowRange,
col: RangeInclusive<usize>,
) -> <MatMut<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

#### fn get( this: MatMut<'_, E>, row: RowRange, col: RangeInclusive<usize>, ) -> <MatMut<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

`(row, col)`

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

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

`(row, col)`

, without bound checks.§### impl<E, RowRange> MatIndex<RowRange, RangeTo<usize>> for MatMut<'_, E>

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

§#### type Target = <MatMut<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

#### type Target = <MatMut<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

§#### fn get(
this: MatMut<'_, E>,
row: RowRange,
col: RangeTo<usize>,
) -> <MatMut<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

#### fn get( this: MatMut<'_, E>, row: RowRange, col: RangeTo<usize>, ) -> <MatMut<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

`(row, col)`

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

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

`(row, col)`

, without bound checks.§### impl<E, RowRange> MatIndex<RowRange, RangeToInclusive<usize>> for MatMut<'_, E>

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

§#### type Target = <MatMut<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

#### type Target = <MatMut<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

§#### fn get(
this: MatMut<'_, E>,
row: RowRange,
col: RangeToInclusive<usize>,
) -> <MatMut<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

#### fn get( this: MatMut<'_, E>, row: RowRange, col: RangeToInclusive<usize>, ) -> <MatMut<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

`(row, col)`

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

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

`(row, col)`

, without bound checks.§### impl<'a, E> MatIndex<usize, Range<usize>> for MatMut<'a, E>where
E: Entity,

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

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

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

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

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

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

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

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

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

§#### type LayoutTransform = MatLayoutTransform

#### type LayoutTransform = MatLayoutTransform

§#### unsafe fn get_slice_unchecked(
&mut self,
_: <MatMut<'_, E> as MaybeContiguous>::Index,
n_elems: usize,
) -> <MatMut<'_, E> as MaybeContiguous>::Slice

#### unsafe fn get_slice_unchecked( &mut self, _: <MatMut<'_, E> as MaybeContiguous>::Index, n_elems: usize, ) -> <MatMut<'_, E> as MaybeContiguous>::Slice

`n_elems`

.§### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for &SparseColMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for &SparseColMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for &SparseColMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for &SparseColMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for &SparseColMatRef<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for &SparseColMatRef<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for &SparseRowMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for &SparseRowMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for &SparseRowMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for &SparseRowMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for &SparseRowMatRef<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for &SparseRowMatRef<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for SparseColMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for SparseColMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for SparseColMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for SparseColMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for SparseColMatRef<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for SparseColMatRef<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for SparseRowMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for SparseRowMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for SparseRowMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for SparseRowMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for SparseRowMatRef<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for SparseRowMatRef<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&SparseColMat<I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&SparseColMat<I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&SparseColMat<I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&SparseColMat<I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&SparseColMatMut<'_, I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&SparseColMatMut<'_, I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&SparseColMatMut<'_, I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&SparseColMatMut<'_, I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&SparseColMatRef<'_, I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&SparseColMatRef<'_, I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&SparseColMatRef<'_, I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&SparseColMatRef<'_, I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&SparseRowMat<I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&SparseRowMat<I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&SparseRowMat<I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&SparseRowMat<I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&SparseRowMatMut<'_, I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&SparseRowMatMut<'_, I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&SparseRowMatMut<'_, I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&SparseRowMatMut<'_, I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&SparseRowMatRef<'_, I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&SparseRowMatRef<'_, I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<&SparseRowMatRef<'_, I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<&SparseRowMatRef<'_, I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for &SparseColMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for &SparseColMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for &SparseColMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for &SparseColMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for &SparseColMatRef<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for &SparseColMatRef<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for &SparseRowMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for &SparseRowMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for &SparseRowMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for &SparseRowMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for &SparseRowMatRef<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for &SparseRowMatRef<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for SparseColMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for SparseColMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for SparseColMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for SparseColMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for SparseColMatRef<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for SparseColMatRef<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for SparseRowMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for SparseRowMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for SparseRowMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for SparseRowMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for SparseRowMatRef<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for SparseRowMatRef<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<SparseColMat<I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<SparseColMat<I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<SparseColMat<I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<SparseColMat<I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<SparseColMatMut<'_, I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<SparseColMatMut<'_, I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<SparseColMatMut<'_, I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<SparseColMatMut<'_, I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<SparseColMatRef<'_, I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<SparseColMatRef<'_, I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<SparseColMatRef<'_, I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<SparseColMatRef<'_, I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<SparseRowMat<I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<SparseRowMat<I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<SparseRowMat<I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<SparseRowMat<I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<SparseRowMatMut<'_, I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<SparseRowMatMut<'_, I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<SparseRowMatMut<'_, I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<SparseRowMatMut<'_, I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<SparseRowMatRef<'_, I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<SparseRowMatRef<'_, I, RhsE>> for &MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<I, E, LhsE, RhsE> Mul<SparseRowMatRef<'_, I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

### impl<I, E, LhsE, RhsE> Mul<SparseRowMatRef<'_, I, RhsE>> for MatMut<'_, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§### impl<LhsE, RhsE> MulAssign<Scale<RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> MulAssign<Scale<RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

§#### fn mul_assign(&mut self, rhs: Scale<RhsE>)

#### fn mul_assign(&mut self, rhs: Scale<RhsE>)

`*=`

operation. Read more§### impl<LhsE> MulAssign<f32> for MatMut<'_, LhsE>where
LhsE: ComplexField,

### impl<LhsE> MulAssign<f32> for MatMut<'_, LhsE>where
LhsE: ComplexField,

§#### fn mul_assign(&mut self, other: f32)

#### fn mul_assign(&mut self, other: f32)

`*=`

operation. Read more§### impl<LhsE> MulAssign<f64> for MatMut<'_, LhsE>where
LhsE: ComplexField,

### impl<LhsE> MulAssign<f64> for MatMut<'_, LhsE>where
LhsE: ComplexField,

§#### fn mul_assign(&mut self, other: f64)

#### fn mul_assign(&mut self, other: f64)

`*=`

operation. Read more§### impl<'short, E> ReborrowMut<'short> for MatMut<'_, E>where
E: Entity,

### impl<'short, E> ReborrowMut<'short> for MatMut<'_, E>where
E: Entity,

§### impl<E> RowBatch<E> for MatMut<'_, E>where
E: Conjugate,

### impl<E> RowBatch<E> for MatMut<'_, E>where
E: Conjugate,

§### impl<E> Serialize for MatMut<'_, E>

### impl<E> Serialize for MatMut<'_, E>

§#### fn serialize<S>(
&self,
s: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

#### fn serialize<S>(
&self,
s: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

§### impl<LhsE, RhsE> SubAssign<&Mat<RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> SubAssign<&Mat<RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

§#### fn sub_assign(&mut self, other: &Mat<RhsE>)

#### fn sub_assign(&mut self, other: &Mat<RhsE>)

`-=`

operation. Read more§### impl<LhsE, RhsE> SubAssign<&MatMut<'_, RhsE>> for Mat<LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> SubAssign<&MatMut<'_, RhsE>> for Mat<LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

§#### fn sub_assign(&mut self, other: &MatMut<'_, RhsE>)

#### fn sub_assign(&mut self, other: &MatMut<'_, RhsE>)

`-=`

operation. Read more§### impl<LhsE, RhsE> SubAssign<&MatMut<'_, RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> SubAssign<&MatMut<'_, RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

§#### fn sub_assign(&mut self, other: &MatMut<'_, RhsE>)

#### fn sub_assign(&mut self, other: &MatMut<'_, RhsE>)

`-=`

operation. Read more§### impl<LhsE, RhsE> SubAssign<&MatRef<'_, RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> SubAssign<&MatRef<'_, RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

§#### fn sub_assign(&mut self, other: &MatRef<'_, RhsE>)

#### fn sub_assign(&mut self, other: &MatRef<'_, RhsE>)

`-=`

operation. Read more§### impl<LhsE, RhsE> SubAssign<Mat<RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> SubAssign<Mat<RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

§#### fn sub_assign(&mut self, other: Mat<RhsE>)

#### fn sub_assign(&mut self, other: Mat<RhsE>)

`-=`

operation. Read more§### impl<LhsE, RhsE> SubAssign<MatMut<'_, RhsE>> for Mat<LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> SubAssign<MatMut<'_, RhsE>> for Mat<LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

§#### fn sub_assign(&mut self, other: MatMut<'_, RhsE>)

#### fn sub_assign(&mut self, other: MatMut<'_, RhsE>)

`-=`

operation. Read more§### impl<LhsE, RhsE> SubAssign<MatMut<'_, RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> SubAssign<MatMut<'_, RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

§#### fn sub_assign(&mut self, other: MatMut<'_, RhsE>)

#### fn sub_assign(&mut self, other: MatMut<'_, RhsE>)

`-=`

operation. Read more§### impl<LhsE, RhsE> SubAssign<MatRef<'_, RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> SubAssign<MatRef<'_, RhsE>> for MatMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

§#### fn sub_assign(&mut self, rhs: MatRef<'_, RhsE>)

#### fn sub_assign(&mut self, rhs: MatRef<'_, RhsE>)

`-=`

operation. Read more### impl<E> ColBatchMut<E> for MatMut<'_, E>where
E: Conjugate,

### impl<E> RowBatchMut<E> for MatMut<'_, E>where
E: Conjugate,

## Auto Trait Implementations§

### impl<'a, E> Freeze for MatMut<'a, E>

### impl<'a, E> RefUnwindSafe for MatMut<'a, E>where
<<E as Entity>::Group as ForCopyType>::FaerOfCopy<NonNull<<E as Entity>::Unit>>: RefUnwindSafe,
E: RefUnwindSafe,

### impl<'a, E> Send for MatMut<'a, E>

### impl<'a, E> Sync for MatMut<'a, E>

### impl<'a, E> Unpin for MatMut<'a, E>

### impl<'a, E> UnwindSafe for MatMut<'a, E>where
<<E as Entity>::Group as ForCopyType>::FaerOfCopy<NonNull<<E as Entity>::Unit>>: UnwindSafe,
E: RefUnwindSafe,

## Blanket Implementations§

source§### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

source§#### fn borrow_mut(&mut self) -> &mut T

#### fn borrow_mut(&mut self) -> &mut T

source§### impl<T> IntoEither for T

### impl<T> IntoEither for T

source§#### fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

#### fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

`self`

into a `Left`

variant of `Either<Self, Self>`

if `into_left`

is `true`

.
Converts `self`

into a `Right`

variant of `Either<Self, Self>`

otherwise. Read moresource§#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ

#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ

`self`

into a `Left`

variant of `Either<Self, Self>`

if `into_left(&self)`

returns `true`

.
Converts `self`

into a `Right`

variant of `Either<Self, Self>`

otherwise. Read more