# Struct extendr_api::prelude::Mat

```
#[repr(C)]pub struct Mat<E>where
E: Entity,{
inner: MatOwnImpl<E>,
row_capacity: usize,
col_capacity: usize,
__marker: PhantomData<E>,
}
```

## Expand description

Heap allocated resizable matrix, similar to a 2D `Vec`

.

## §Note

The memory layout of `Mat`

is guaranteed to be column-major, meaning that it has a row stride
of `1`

, and an unspecified column stride that can be queried with `Mat::col_stride`

.

This implies that while each individual column is stored contiguously in memory, the matrix as a whole may not necessarily be contiguous. The implementation may add padding at the end of each column when overaligning each column can provide a performance gain.

Let us consider a 3×4 matrix

```
0 │ 3 │ 6 │ 9
───┼───┼───┼───
1 │ 4 │ 7 │ 10
───┼───┼───┼───
2 │ 5 │ 8 │ 11
```

The memory representation of the data held by such a matrix could look like the following:

```
0 1 2 X 3 4 5 X 6 7 8 X 9 10 11 X
```

where X represents padding elements.

## Fields§

§`inner: MatOwnImpl<E>`

§`row_capacity: usize`

§`col_capacity: usize`

§`__marker: PhantomData<E>`

## Implementations§

§### impl<E> Mat<E>

### impl<E> Mat<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<E> Mat<E>where
E: Entity,

### impl<E> Mat<E>where
E: Entity,

#### pub fn with_capacity(row_capacity: usize, col_capacity: usize) -> Mat<E>

#### pub fn with_capacity(row_capacity: usize, col_capacity: usize) -> Mat<E>

Returns a new matrix with dimensions `(0, 0)`

, with enough capacity to hold a maximum of
`row_capacity`

rows and `col_capacity`

columns without reallocating. If either is `0`

,
the matrix will not allocate.

##### §Panics

The function panics if the total capacity in bytes exceeds `isize::MAX`

.

#### pub fn from_fn(
nrows: usize,
ncols: usize,
f: impl FnMut(usize, usize) -> E,
) -> Mat<E>

#### pub fn from_fn( nrows: usize, ncols: usize, f: impl FnMut(usize, usize) -> E, ) -> Mat<E>

Returns a new matrix with dimensions `(nrows, ncols)`

, filled with the provided function.

##### §Panics

The function panics if the total capacity in bytes exceeds `isize::MAX`

.

#### pub fn zeros(nrows: usize, ncols: usize) -> Mat<E>

#### pub fn zeros(nrows: usize, ncols: usize) -> Mat<E>

Returns a new matrix with dimensions `(nrows, ncols)`

, filled with zeros.

##### §Panics

The function panics if the total capacity in bytes exceeds `isize::MAX`

.

#### pub fn identity(nrows: usize, ncols: usize) -> Mat<E>where
E: ComplexField,

#### pub fn identity(nrows: usize, ncols: usize) -> Mat<E>where
E: ComplexField,

Returns a new matrix with dimensions `(nrows, ncols)`

, filled with zeros, except the main
diagonal which is filled with ones.

##### §Panics

The function panics if the total capacity in bytes exceeds `isize::MAX`

.

#### pub unsafe fn set_dims(&mut self, nrows: usize, ncols: usize)

#### pub unsafe fn set_dims(&mut self, nrows: usize, ncols: usize)

Set the dimensions of the matrix.

##### §Safety

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

`nrows < self.row_capacity()`

.`ncols < self.col_capacity()`

.- The elements that were previously out of bounds but are now in bounds must be initialized.

#### 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 a pointer to the data of the matrix.

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

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

Returns a mutable pointer to the data of the matrix.

#### pub fn row_capacity(&self) -> usize

#### pub fn row_capacity(&self) -> usize

Returns the row capacity, that is, the number of rows that the matrix is able to hold without needing to reallocate, excluding column insertions.

#### pub fn col_capacity(&self) -> usize

#### pub fn col_capacity(&self) -> usize

Returns the column capacity, that is, the number of columns that the matrix is able to hold without needing to reallocate, excluding row insertions.

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

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

Returns the offset between the first elements of two successive rows in the matrix.
Always returns `1`

since the matrix is column major.

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

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

Returns the offset between the first elements of two successive columns in the matrix.

#### pub fn reserve_exact(&mut self, row_capacity: usize, col_capacity: usize)

#### pub fn reserve_exact(&mut self, row_capacity: usize, col_capacity: usize)

Reserves the minimum capacity for `row_capacity`

rows and `col_capacity`

columns without reallocating. Does nothing if the capacity is already sufficient.

##### §Panics

The function panics if the new total capacity in bytes exceeds `isize::MAX`

.

#### pub fn resize_with(
&mut self,
new_nrows: usize,
new_ncols: usize,
f: impl FnMut(usize, usize) -> E,
)

#### pub fn resize_with( &mut self, new_nrows: usize, new_ncols: usize, f: impl FnMut(usize, usize) -> E, )

Resizes the matrix in-place so that the new dimensions are `(new_nrows, new_ncols)`

.
New elements are created with the given function `f`

, so that elements at indices `(i, j)`

are created by calling `f(i, j)`

.

#### pub fn truncate(&mut self, new_nrows: usize, new_ncols: usize)

#### pub fn truncate(&mut self, new_nrows: usize, new_ncols: usize)

Truncates the matrix so that its new dimensions are `new_nrows`

and `new_ncols`

.

Both of the new dimensions must be smaller than or equal to the current dimensions.

##### §Panics

- Panics if
`new_nrows > self.nrows()`

. - Panics if
`new_ncols > self.ncols()`

.

#### pub fn col_as_slice(
&self,
col: usize,
) -> <<E as Entity>::Group as ForType>::FaerOf<&[<E as Entity>::Unit]>

#### pub fn col_as_slice( &self, col: usize, ) -> <<E as Entity>::Group as ForType>::FaerOf<&[<E as Entity>::Unit]>

Returns a reference to a slice over the column at the given index.

#### pub fn col_as_slice_mut(
&mut self,
col: usize,
) -> <<E as Entity>::Group as ForType>::FaerOf<&mut [<E as Entity>::Unit]>

#### pub fn col_as_slice_mut( &mut self, col: usize, ) -> <<E as Entity>::Group as ForType>::FaerOf<&mut [<E as Entity>::Unit]>

Returns a mutable reference to a slice over the column at the given index.

#### pub fn col_ref(
&self,
col: usize,
) -> <<E as Entity>::Group as ForType>::FaerOf<&[<E as Entity>::Unit]>

👎Deprecated: replaced by `Mat::col_as_slice`

#### pub fn col_ref( &self, col: usize, ) -> <<E as Entity>::Group as ForType>::FaerOf<&[<E as Entity>::Unit]>

`Mat::col_as_slice`

Returns a reference to a slice over the column at the given index.

#### pub fn col_mut(
&mut self,
col: usize,
) -> <<E as Entity>::Group as ForType>::FaerOf<&mut [<E as Entity>::Unit]>

👎Deprecated: replaced by `Mat::col_as_slice_mut`

#### pub fn col_mut( &mut self, col: usize, ) -> <<E as Entity>::Group as ForType>::FaerOf<&mut [<E as Entity>::Unit]>

`Mat::col_as_slice_mut`

Returns a mutable reference to a slice over the column at the given index.

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

#### pub unsafe fn get_unchecked<RowRange, ColRange>( &self, row: RowRange, col: ColRange, ) -> <MatRef<'_, 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<'_, E> as MatIndex<RowRange, ColRange>>::Target

#### pub fn get<RowRange, ColRange>( &self, row: RowRange, col: ColRange, ) -> <MatRef<'_, 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>(
&mut self,
row: RowRange,
col: ColRange,
) -> <MatMut<'_, E> as MatIndex<RowRange, ColRange>>::Target

#### pub unsafe fn get_mut_unchecked<RowRange, ColRange>( &mut self, row: RowRange, col: ColRange, ) -> <MatMut<'_, 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>(
&mut self,
row: RowRange,
col: ColRange,
) -> <MatMut<'_, E> as MatIndex<RowRange, ColRange>>::Target

#### pub fn get_mut<RowRange, ColRange>( &mut self, row: RowRange, col: ColRange, ) -> <MatMut<'_, 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 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 conjugate(&self) -> MatRef<'_, <E as Conjugate>::Conj>where
E: Conjugate,

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

Returns a view over the conjugate of `self`

.

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

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

Returns a view over the conjugate transpose of `self`

.

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

Kroneckor 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 col_chunks(&self, chunk_size: usize) -> impl DoubleEndedIterator

#### pub fn col_chunks(&self, chunk_size: usize) -> impl DoubleEndedIterator

Returns an iterator that provides successive chunks of the columns of a view over 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_chunks_mut(&mut self, chunk_size: usize) -> impl DoubleEndedIterator

#### pub fn col_chunks_mut(&mut self, chunk_size: usize) -> impl DoubleEndedIterator

Returns an iterator that provides successive chunks of the columns of a mutable view over
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 par_col_chunks(&self, chunk_size: usize) -> impl IndexedParallelIterator

#### pub fn par_col_chunks(&self, chunk_size: usize) -> impl IndexedParallelIterator

Returns a parallel iterator that provides successive chunks of the columns of a view over
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_chunks_mut(
&mut self,
chunk_size: usize,
) -> impl IndexedParallelIterator

#### pub fn par_col_chunks_mut( &mut self, chunk_size: usize, ) -> impl IndexedParallelIterator

Returns a parallel iterator that provides successive chunks of the columns of a mutable view
over 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 row_chunks(&self, chunk_size: usize) -> impl DoubleEndedIterator

#### pub fn row_chunks(&self, chunk_size: usize) -> impl DoubleEndedIterator

Returns an iterator that provides successive chunks of the rows of a view over 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_chunks_mut(&mut self, chunk_size: usize) -> impl DoubleEndedIterator

#### pub fn row_chunks_mut(&mut self, chunk_size: usize) -> impl DoubleEndedIterator

Returns an iterator that provides successive chunks of the rows of a mutable view over
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 par_row_chunks(&self, chunk_size: usize) -> impl IndexedParallelIterator

#### pub fn par_row_chunks(&self, chunk_size: usize) -> impl IndexedParallelIterator

Returns a parallel iterator that provides successive chunks of the rows of a view over 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_chunks_mut(
&mut self,
chunk_size: usize,
) -> impl IndexedParallelIterator

#### pub fn par_row_chunks_mut( &mut self, chunk_size: usize, ) -> impl IndexedParallelIterator

Returns a parallel iterator that provides successive chunks of the rows of a mutable view
over 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.

## Trait Implementations§

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

### impl<LhsE, RhsE> AddAssign<&Mat<RhsE>> for Mat<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<&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<&MatRef<'_, RhsE>> for Mat<LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> AddAssign<&MatRef<'_, RhsE>> for Mat<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 Mat<LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> AddAssign<Mat<RhsE>> for Mat<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<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<MatRef<'_, RhsE>> for Mat<LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> AddAssign<MatRef<'_, RhsE>> for Mat<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<E> AsMatMut<E> for Mat<E>where
E: Entity,

### impl<E> AsMatMut<E> for Mat<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 Mat<E>where
E: Entity,

### impl<E> AsMatRef<E> for Mat<E>where
E: Entity,

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

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

§### impl<E> ColBatch<E> for Mat<E>where
E: Conjugate,

### impl<E> ColBatch<E> for Mat<E>where
E: Conjugate,

§### impl<E> DenseAccess<E> for Mat<E>where
E: Entity,

### impl<E> DenseAccess<E> for Mat<E>where
E: Entity,

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

§### impl<'a, E> Deserialize<'a> for Mat<E>where
E: Entity + Deserialize<'a>,

### impl<'a, E> Deserialize<'a> for Mat<E>where
E: Entity + Deserialize<'a>,

§#### fn deserialize<D>(d: D) -> Result<Mat<E>, <D as Deserializer<'a>>::Error>where
D: Deserializer<'a>,

#### fn deserialize<D>(d: D) -> Result<Mat<E>, <D as Deserializer<'a>>::Error>where
D: Deserializer<'a>,

§### impl<E> Distribution<Mat<E>> for NormalMat<E>

### impl<E> Distribution<Mat<E>> for NormalMat<E>

§### impl<E> Distribution<Mat<E>> for StandardMat

### impl<E> Distribution<Mat<E>> for StandardMat

§### impl<E> Distribution<Mat<E>> for StandardNormalMat

### impl<E> Distribution<Mat<E>> for StandardNormalMat

§### impl<E> Distribution<Mat<E>> for UnitaryMat

### impl<E> Distribution<Mat<E>> for UnitaryMat

source§### impl From<Mat<f64>> for RMatrix<f64>

### impl From<Mat<f64>> for RMatrix<f64>

Convert a `faer::Mat<f64>`

into an `RMatrix<f64>`

which is not NA aware.

§### impl<I, E, LhsE, RhsE> Mul<&Mat<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<&Mat<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<&Mat<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<&Mat<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<&Mat<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<&Mat<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<&Mat<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<&Mat<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<&Mat<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<&Mat<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<&Mat<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<&Mat<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<&Mat<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<&Mat<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<&Mat<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<&Mat<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<&Mat<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<&Mat<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<&Mat<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<&Mat<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<&Mat<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<&Mat<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<&Mat<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<&Mat<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 &Mat<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 &Mat<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 Mat<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 Mat<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 &Mat<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 &Mat<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 Mat<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 Mat<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 &Mat<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 &Mat<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 Mat<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 Mat<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 &Mat<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 &Mat<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 Mat<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 Mat<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 &Mat<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 &Mat<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 Mat<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 Mat<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 &Mat<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 &Mat<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 Mat<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 Mat<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<Mat<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<Mat<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<Mat<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<Mat<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<Mat<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<Mat<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<Mat<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<Mat<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<Mat<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<Mat<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<Mat<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<Mat<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<Mat<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<Mat<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<Mat<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<Mat<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<Mat<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<Mat<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<Mat<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<Mat<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<Mat<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<Mat<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<Mat<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<Mat<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 &Mat<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 &Mat<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 Mat<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 Mat<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 &Mat<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 &Mat<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 Mat<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 Mat<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 &Mat<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 &Mat<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 Mat<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 Mat<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 &Mat<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 &Mat<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 Mat<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 Mat<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 &Mat<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 &Mat<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 Mat<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 Mat<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 &Mat<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 &Mat<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 Mat<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 Mat<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 Mat<LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

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

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

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

`*=`

operation. Read more§### impl<LhsE, RhsE> PartialEq<MatMut<'_, RhsE>> for Mat<LhsE>

### impl<LhsE, RhsE> PartialEq<MatMut<'_, RhsE>> for Mat<LhsE>

§### impl<LhsE, RhsE> PartialEq<MatRef<'_, RhsE>> for Mat<LhsE>

### impl<LhsE, RhsE> PartialEq<MatRef<'_, RhsE>> for Mat<LhsE>

§### impl<E> RowBatch<E> for Mat<E>where
E: Conjugate,

### impl<E> RowBatch<E> for Mat<E>where
E: Conjugate,

§### impl<E> Serialize for Mat<E>

### impl<E> Serialize for Mat<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 Mat<LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> SubAssign<&Mat<RhsE>> for Mat<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<&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<&MatRef<'_, RhsE>> for Mat<LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> SubAssign<&MatRef<'_, RhsE>> for Mat<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 Mat<LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> SubAssign<Mat<RhsE>> for Mat<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<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<MatRef<'_, RhsE>> for Mat<LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

### impl<LhsE, RhsE> SubAssign<MatRef<'_, RhsE>> for Mat<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<E> ColBatchMut<E> for Mat<E>where
E: Conjugate,

### impl<E> RowBatchMut<E> for Mat<E>where
E: Conjugate,

## Auto Trait Implementations§

### impl<E> Freeze for Mat<E>

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

### impl<E> Send for Mat<E>

### impl<E> Sync for Mat<E>

### impl<E> Unpin for Mat<E>

### impl<E> UnwindSafe for Mat<E>where
<<E as Entity>::Group as ForCopyType>::FaerOfCopy<NonNull<<E as Entity>::Unit>>: UnwindSafe,
E: UnwindSafe,

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