# Struct extendr_api::prelude::sparse::SparseColMatMut

```
pub struct SparseColMatMut<'a, I, E>{
pub(crate) symbolic: SymbolicSparseColMatRef<'a, I>,
pub(crate) values: SliceGroupMut<'a, E>,
}
```

## Expand description

Sparse matrix view in column-major format, either compressed or uncompressed.

## Fields§

§`symbolic: SymbolicSparseColMatRef<'a, I>`

§`values: SliceGroupMut<'a, E>`

## Implementations§

§### impl<'a, I, E> SparseColMatMut<'a, I, E>

### impl<'a, I, E> SparseColMatMut<'a, I, E>

#### pub fn new(
symbolic: SymbolicSparseColMatRef<'a, I>,
values: <<E as Entity>::Group as ForType>::FaerOf<&'a mut [<E as Entity>::Unit]>,
) -> SparseColMatMut<'a, I, E>

#### pub fn new( symbolic: SymbolicSparseColMatRef<'a, I>, values: <<E as Entity>::Group as ForType>::FaerOf<&'a mut [<E as Entity>::Unit]>, ) -> SparseColMatMut<'a, I, E>

Creates a new sparse matrix view.

##### §Panics

Panics if the length of `values`

is not equal to the length of
`symbolic.row_indices()`

.

#### pub fn as_ref(&self) -> SparseColMatRef<'_, I, E>

#### pub fn as_ref(&self) -> SparseColMatRef<'_, I, E>

Returns a view over `self`

.

#### pub fn as_mut(&mut self) -> SparseColMatMut<'_, I, E>

#### pub fn as_mut(&mut self) -> SparseColMatMut<'_, I, E>

Returns a mutable view over `self`

.

Note that the symbolic structure cannot be changed through this view.

#### pub fn to_owned(
&self,
) -> Result<SparseColMat<I, <E as Conjugate>::Canonical>, FaerError>

#### pub fn to_owned( &self, ) -> Result<SparseColMat<I, <E as Conjugate>::Canonical>, FaerError>

Copies `self`

into a newly allocated matrix.

##### §Note

Allows unsorted matrices, producing an unsorted output.

#### pub fn to_sorted(
&self,
) -> Result<SparseColMat<I, <E as Conjugate>::Canonical>, FaerError>

#### pub fn to_sorted( &self, ) -> Result<SparseColMat<I, <E as Conjugate>::Canonical>, FaerError>

Copies `self`

into a newly allocated matrix with sorted indices.

##### §Note

Allows unsorted matrices, producing a sorted output.

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

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

Copies `self`

into a newly allocated dense matrix

#### pub fn to_row_major(
&self,
) -> Result<SparseRowMat<I, <E as Conjugate>::Canonical>, FaerError>

#### pub fn to_row_major( &self, ) -> Result<SparseRowMat<I, <E as Conjugate>::Canonical>, FaerError>

Copies `self`

into a newly allocated matrix, with row-major order.

##### §Note

Allows unsorted matrices, producing a sorted output.

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

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

Returns a view over the transpose of `self`

in row-major format.

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

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

Returns a view over the transpose of `self`

in row-major format.

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

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

Returns a view over the conjugate of `self`

.

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

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

Returns a view over the conjugate of `self`

.

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

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

Returns a view over the canonical view of `self`

, along with whether it has been conjugated
or not.

#### pub fn canonicalize_mut(
self,
) -> (SparseColMatMut<'a, I, <E as Conjugate>::Canonical>, Conj)where
E: Conjugate,

#### pub fn canonicalize_mut(
self,
) -> (SparseColMatMut<'a, I, <E as Conjugate>::Canonical>, Conj)where
E: Conjugate,

Returns a view over the canonical view of `self`

, along with whether it has been conjugated
or not.

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

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

Returns a view over the conjugate transpose of `self`

.

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

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

Returns a view over the conjugate transpose of `self`

.

#### pub fn values(
self,
) -> <<E as Entity>::Group as ForType>::FaerOf<&'a [<E as Entity>::Unit]>

#### pub fn values( self, ) -> <<E as Entity>::Group as ForType>::FaerOf<&'a [<E as Entity>::Unit]>

Returns the numerical values of the matrix.

#### pub fn values_mut(
self,
) -> <<E as Entity>::Group as ForType>::FaerOf<&'a mut [<E as Entity>::Unit]>

#### pub fn values_mut( self, ) -> <<E as Entity>::Group as ForType>::FaerOf<&'a mut [<E as Entity>::Unit]>

Returns the numerical values of the matrix.

#### pub fn values_of_col(
self,
j: usize,
) -> <<E as Entity>::Group as ForType>::FaerOf<&'a [<E as Entity>::Unit]>

#### pub fn values_of_col( self, j: usize, ) -> <<E as Entity>::Group as ForType>::FaerOf<&'a [<E as Entity>::Unit]>

#### pub fn values_of_col_mut(
self,
j: usize,
) -> <<E as Entity>::Group as ForType>::FaerOf<&'a mut [<E as Entity>::Unit]>

#### pub fn values_of_col_mut( self, j: usize, ) -> <<E as Entity>::Group as ForType>::FaerOf<&'a mut [<E as Entity>::Unit]>

#### pub fn symbolic(&self) -> SymbolicSparseColMatRef<'a, I>

#### pub fn symbolic(&self) -> SymbolicSparseColMatRef<'a, I>

Returns the symbolic structure of the matrix.

#### pub fn parts(
self,
) -> (SymbolicSparseColMatRef<'a, I>, <<E as Entity>::Group as ForType>::FaerOf<&'a [<E as Entity>::Unit]>)

#### pub fn parts( self, ) -> (SymbolicSparseColMatRef<'a, I>, <<E as Entity>::Group as ForType>::FaerOf<&'a [<E as Entity>::Unit]>)

Decomposes the matrix into the symbolic part and the numerical values.

#### pub fn parts_mut(
self,
) -> (SymbolicSparseColMatRef<'a, I>, <<E as Entity>::Group as ForType>::FaerOf<&'a mut [<E as Entity>::Unit]>)

#### pub fn parts_mut( self, ) -> (SymbolicSparseColMatRef<'a, I>, <<E as Entity>::Group as ForType>::FaerOf<&'a mut [<E as Entity>::Unit]>)

Decomposes the matrix into the symbolic part and the numerical values.

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

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

Returns the number of symbolic non-zeros in the matrix.

The value is guaranteed to be less than `I::Signed::MAX`

.

##### §Note

Allows unsorted matrices, but the output is a count of all the entries, including the duplicate ones.

#### pub fn nnz_per_col(&self) -> Option<&'a [I]>

#### pub fn nnz_per_col(&self) -> Option<&'a [I]>

Returns the count of non-zeros per column of the matrix.

#### pub fn row_indices(&self) -> &'a [I]

#### pub fn row_indices(&self) -> &'a [I]

Returns the row indices.

#### pub fn row_indices_of_col_raw(&self, j: usize) -> &'a [I]

#### pub fn row_indices_of_col_raw(&self, j: usize) -> &'a [I]

#### pub fn row_indices_of_col(
&self,
j: usize,
) -> impl ExactSizeIterator + DoubleEndedIterator + 'a

#### pub fn row_indices_of_col( &self, j: usize, ) -> impl ExactSizeIterator + DoubleEndedIterator + 'a

#### pub fn col_range(&self, j: usize) -> Range<usize>

#### pub fn col_range(&self, j: usize) -> Range<usize>

Returns the range that the column `j`

occupies in `self.row_indices()`

.

##### §Panics

Panics if `j >= self.ncols()`

.

#### pub unsafe fn col_range_unchecked(&self, j: usize) -> Range<usize>

#### pub unsafe fn col_range_unchecked(&self, j: usize) -> Range<usize>

Returns the range that the column `j`

occupies in `self.row_indices()`

.

##### §Safety

The behavior is undefined if `j >= self.ncols()`

.

#### pub fn get(
self,
row: usize,
col: usize,
) -> Option<<<E as Entity>::Group as ForType>::FaerOf<&'a <E as Entity>::Unit>>

#### pub fn get( self, row: usize, col: usize, ) -> Option<<<E as Entity>::Group as ForType>::FaerOf<&'a <E as Entity>::Unit>>

Returns a reference to the value at the given index, or None if the symbolic structure doesn’t contain it, or contains multiple indices with the given index.

##### §Panics

Panics if `row >= self.nrows()`

Panics if `col >= self.ncols()`

#### pub fn get_mut(
self,
row: usize,
col: usize,
) -> Option<<<E as Entity>::Group as ForType>::FaerOf<&'a mut <E as Entity>::Unit>>

#### pub fn get_mut( self, row: usize, col: usize, ) -> Option<<<E as Entity>::Group as ForType>::FaerOf<&'a mut <E as Entity>::Unit>>

Returns a reference to the value at the given index, or None if the symbolic structure doesn’t contain it, or contains multiple values with the given index.

##### §Panics

Panics if `row >= self.nrows()`

.

Panics if `col >= self.ncols()`

.

§### impl<I, E> SparseColMatMut<'_, I, E>where
I: Index,
E: ComplexField,

### impl<I, E> SparseColMatMut<'_, I, E>where
I: Index,
E: ComplexField,

#### pub fn fill_from_order_and_values(
&mut self,
order: &ValuesOrder<I>,
values: <<E as Entity>::Group as ForType>::FaerOf<&[<E as Entity>::Unit]>,
mode: FillMode,
)

#### pub fn fill_from_order_and_values( &mut self, order: &ValuesOrder<I>, values: <<E as Entity>::Group as ForType>::FaerOf<&[<E as Entity>::Unit]>, mode: FillMode, )

Fill the matrix from a previously created value order. The provided values must correspond to the same indices that were provided in the function call from which the order was created.

##### §Note

The symbolic structure is not changed.

§### impl<I, E> SparseColMatMut<'_, I, E>where
I: Index,
E: ComplexField,

### impl<I, E> SparseColMatMut<'_, I, E>where
I: Index,
E: ComplexField,

#### pub fn sp_solve_lower_triangular_in_place(&self, rhs: impl ColBatchMut<E>)

#### pub fn sp_solve_lower_triangular_in_place(&self, rhs: impl ColBatchMut<E>)

Assuming `self`

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

, and
stores the result in `rhs`

.

##### §Note

The matrix indices need not be sorted, but the diagonal element is assumed to be the first stored element in each column.

#### pub fn sp_solve_upper_triangular_in_place(&self, rhs: impl ColBatchMut<E>)

#### pub fn sp_solve_upper_triangular_in_place(&self, rhs: impl ColBatchMut<E>)

Assuming `self`

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

, and
stores the result in `rhs`

.

##### §Note

The matrix indices need not be sorted, but the diagonal element is assumed to be the last stored element in each column.

#### pub fn sp_solve_unit_lower_triangular_in_place(&self, rhs: impl ColBatchMut<E>)

#### pub fn sp_solve_unit_lower_triangular_in_place(&self, rhs: impl ColBatchMut<E>)

Assuming `self`

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

,
and stores the result in `rhs`

.

##### §Note

The matrix indices need not be sorted, but the diagonal element is assumed to be the first stored element in each column.

#### pub fn sp_solve_unit_upper_triangular_in_place(&self, rhs: impl ColBatchMut<E>)

#### pub fn sp_solve_unit_upper_triangular_in_place(&self, rhs: impl ColBatchMut<E>)

Assuming `self`

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

,
and stores the result in `rhs`

.

##### §Note

The matrix indices need not be sorted, but the diagonal element is assumed to be the last stored element in each column.

#### pub fn sp_cholesky(&self, side: Side) -> Result<Cholesky<I, E>, CholeskyError>

#### pub fn sp_cholesky(&self, side: Side) -> Result<Cholesky<I, E>, CholeskyError>

Returns the Cholesky decomposition of `self`

. Only the provided side is accessed.

## Trait Implementations§

§### impl<I, E, LhsE, RhsE> Add<&SparseColMat<I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Add<&SparseColMat<I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`+`

operator.§#### fn add(
self,
other: &SparseColMat<I, RhsE>,
) -> <&SparseColMatMut<'_, I, LhsE> as Add<&SparseColMat<I, RhsE>>>::Output

#### fn add( self, other: &SparseColMat<I, RhsE>, ) -> <&SparseColMatMut<'_, I, LhsE> as Add<&SparseColMat<I, RhsE>>>::Output

`+`

operation. Read more§### impl<I, E, LhsE, RhsE> Add<&SparseColMat<I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Add<&SparseColMat<I, RhsE>> for SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`+`

operator.§#### fn add(
self,
other: &SparseColMat<I, RhsE>,
) -> <SparseColMatMut<'_, I, LhsE> as Add<&SparseColMat<I, RhsE>>>::Output

#### fn add( self, other: &SparseColMat<I, RhsE>, ) -> <SparseColMatMut<'_, I, LhsE> as Add<&SparseColMat<I, RhsE>>>::Output

`+`

operation. Read more§### impl<I, E, LhsE, RhsE> Add<&SparseColMatMut<'_, I, RhsE>> for &SparseColMat<I, LhsE>

### impl<I, E, LhsE, RhsE> Add<&SparseColMatMut<'_, I, RhsE>> for &SparseColMat<I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`+`

operator.§#### fn add(
self,
other: &SparseColMatMut<'_, I, RhsE>,
) -> <&SparseColMat<I, LhsE> as Add<&SparseColMatMut<'_, I, RhsE>>>::Output

#### fn add( self, other: &SparseColMatMut<'_, I, RhsE>, ) -> <&SparseColMat<I, LhsE> as Add<&SparseColMatMut<'_, I, RhsE>>>::Output

`+`

operation. Read more§### impl<I, E, LhsE, RhsE> Add<&SparseColMatMut<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Add<&SparseColMatMut<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`+`

operator.§#### fn add(
self,
other: &SparseColMatMut<'_, I, RhsE>,
) -> <&SparseColMatMut<'_, I, LhsE> as Add<&SparseColMatMut<'_, I, RhsE>>>::Output

#### fn add( self, other: &SparseColMatMut<'_, I, RhsE>, ) -> <&SparseColMatMut<'_, I, LhsE> as Add<&SparseColMatMut<'_, I, RhsE>>>::Output

`+`

operation. Read more§### impl<I, E, LhsE, RhsE> Add<&SparseColMatMut<'_, I, RhsE>> for &SparseColMatRef<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Add<&SparseColMatMut<'_, I, RhsE>> for &SparseColMatRef<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`+`

operator.§#### fn add(
self,
other: &SparseColMatMut<'_, I, RhsE>,
) -> <&SparseColMatRef<'_, I, LhsE> as Add<&SparseColMatMut<'_, I, RhsE>>>::Output

#### fn add( self, other: &SparseColMatMut<'_, I, RhsE>, ) -> <&SparseColMatRef<'_, I, LhsE> as Add<&SparseColMatMut<'_, I, RhsE>>>::Output

`+`

operation. Read more§### impl<I, E, LhsE, RhsE> Add<&SparseColMatMut<'_, I, RhsE>> for SparseColMat<I, LhsE>

### impl<I, E, LhsE, RhsE> Add<&SparseColMatMut<'_, I, RhsE>> for SparseColMat<I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`+`

operator.§#### fn add(
self,
other: &SparseColMatMut<'_, I, RhsE>,
) -> <SparseColMat<I, LhsE> as Add<&SparseColMatMut<'_, I, RhsE>>>::Output

#### fn add( self, other: &SparseColMatMut<'_, I, RhsE>, ) -> <SparseColMat<I, LhsE> as Add<&SparseColMatMut<'_, I, RhsE>>>::Output

`+`

operation. Read more§### impl<I, E, LhsE, RhsE> Add<&SparseColMatMut<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Add<&SparseColMatMut<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`+`

operator.§#### fn add(
self,
other: &SparseColMatMut<'_, I, RhsE>,
) -> <SparseColMatMut<'_, I, LhsE> as Add<&SparseColMatMut<'_, I, RhsE>>>::Output

#### fn add( self, other: &SparseColMatMut<'_, I, RhsE>, ) -> <SparseColMatMut<'_, I, LhsE> as Add<&SparseColMatMut<'_, I, RhsE>>>::Output

`+`

operation. Read more§### impl<I, E, LhsE, RhsE> Add<&SparseColMatMut<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Add<&SparseColMatMut<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`+`

operator.§#### fn add(
self,
other: &SparseColMatMut<'_, I, RhsE>,
) -> <SparseColMatRef<'_, I, LhsE> as Add<&SparseColMatMut<'_, I, RhsE>>>::Output

#### fn add( self, other: &SparseColMatMut<'_, I, RhsE>, ) -> <SparseColMatRef<'_, I, LhsE> as Add<&SparseColMatMut<'_, I, RhsE>>>::Output

`+`

operation. Read more§### impl<I, E, LhsE, RhsE> Add<&SparseColMatRef<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Add<&SparseColMatRef<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`+`

operator.§#### fn add(
self,
other: &SparseColMatRef<'_, I, RhsE>,
) -> <&SparseColMatMut<'_, I, LhsE> as Add<&SparseColMatRef<'_, I, RhsE>>>::Output

#### fn add( self, other: &SparseColMatRef<'_, I, RhsE>, ) -> <&SparseColMatMut<'_, I, LhsE> as Add<&SparseColMatRef<'_, I, RhsE>>>::Output

`+`

operation. Read more§### impl<I, E, LhsE, RhsE> Add<&SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Add<&SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`+`

operator.§#### fn add(
self,
other: &SparseColMatRef<'_, I, RhsE>,
) -> <SparseColMatMut<'_, I, LhsE> as Add<&SparseColMatRef<'_, I, RhsE>>>::Output

#### fn add( self, other: &SparseColMatRef<'_, I, RhsE>, ) -> <SparseColMatMut<'_, I, LhsE> as Add<&SparseColMatRef<'_, I, RhsE>>>::Output

`+`

operation. Read more§### impl<I, E, LhsE, RhsE> Add<SparseColMat<I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Add<SparseColMat<I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`+`

operator.§#### fn add(
self,
other: SparseColMat<I, RhsE>,
) -> <&SparseColMatMut<'_, I, LhsE> as Add<SparseColMat<I, RhsE>>>::Output

#### fn add( self, other: SparseColMat<I, RhsE>, ) -> <&SparseColMatMut<'_, I, LhsE> as Add<SparseColMat<I, RhsE>>>::Output

`+`

operation. Read more§### impl<I, E, LhsE, RhsE> Add<SparseColMat<I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Add<SparseColMat<I, RhsE>> for SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`+`

operator.§#### fn add(
self,
other: SparseColMat<I, RhsE>,
) -> <SparseColMatMut<'_, I, LhsE> as Add<SparseColMat<I, RhsE>>>::Output

#### fn add( self, other: SparseColMat<I, RhsE>, ) -> <SparseColMatMut<'_, I, LhsE> as Add<SparseColMat<I, RhsE>>>::Output

`+`

operation. Read more§### impl<I, E, LhsE, RhsE> Add<SparseColMatMut<'_, I, RhsE>> for &SparseColMat<I, LhsE>

### impl<I, E, LhsE, RhsE> Add<SparseColMatMut<'_, I, RhsE>> for &SparseColMat<I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`+`

operator.§#### fn add(
self,
other: SparseColMatMut<'_, I, RhsE>,
) -> <&SparseColMat<I, LhsE> as Add<SparseColMatMut<'_, I, RhsE>>>::Output

#### fn add( self, other: SparseColMatMut<'_, I, RhsE>, ) -> <&SparseColMat<I, LhsE> as Add<SparseColMatMut<'_, I, RhsE>>>::Output

`+`

operation. Read more§### impl<I, E, LhsE, RhsE> Add<SparseColMatMut<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Add<SparseColMatMut<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`+`

operator.§#### fn add(
self,
other: SparseColMatMut<'_, I, RhsE>,
) -> <&SparseColMatMut<'_, I, LhsE> as Add<SparseColMatMut<'_, I, RhsE>>>::Output

#### fn add( self, other: SparseColMatMut<'_, I, RhsE>, ) -> <&SparseColMatMut<'_, I, LhsE> as Add<SparseColMatMut<'_, I, RhsE>>>::Output

`+`

operation. Read more§### impl<I, E, LhsE, RhsE> Add<SparseColMatMut<'_, I, RhsE>> for &SparseColMatRef<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Add<SparseColMatMut<'_, I, RhsE>> for &SparseColMatRef<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`+`

operator.§#### fn add(
self,
other: SparseColMatMut<'_, I, RhsE>,
) -> <&SparseColMatRef<'_, I, LhsE> as Add<SparseColMatMut<'_, I, RhsE>>>::Output

#### fn add( self, other: SparseColMatMut<'_, I, RhsE>, ) -> <&SparseColMatRef<'_, I, LhsE> as Add<SparseColMatMut<'_, I, RhsE>>>::Output

`+`

operation. Read more§### impl<I, E, LhsE, RhsE> Add<SparseColMatMut<'_, I, RhsE>> for SparseColMat<I, LhsE>

### impl<I, E, LhsE, RhsE> Add<SparseColMatMut<'_, I, RhsE>> for SparseColMat<I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`+`

operator.§#### fn add(
self,
other: SparseColMatMut<'_, I, RhsE>,
) -> <SparseColMat<I, LhsE> as Add<SparseColMatMut<'_, I, RhsE>>>::Output

#### fn add( self, other: SparseColMatMut<'_, I, RhsE>, ) -> <SparseColMat<I, LhsE> as Add<SparseColMatMut<'_, I, RhsE>>>::Output

`+`

operation. Read more§### impl<I, E, LhsE, RhsE> Add<SparseColMatMut<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Add<SparseColMatMut<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`+`

operator.§#### fn add(
self,
other: SparseColMatMut<'_, I, RhsE>,
) -> <SparseColMatMut<'_, I, LhsE> as Add<SparseColMatMut<'_, I, RhsE>>>::Output

#### fn add( self, other: SparseColMatMut<'_, I, RhsE>, ) -> <SparseColMatMut<'_, I, LhsE> as Add<SparseColMatMut<'_, I, RhsE>>>::Output

`+`

operation. Read more§### impl<I, E, LhsE, RhsE> Add<SparseColMatMut<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Add<SparseColMatMut<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`+`

operator.§#### fn add(
self,
other: SparseColMatMut<'_, I, RhsE>,
) -> <SparseColMatRef<'_, I, LhsE> as Add<SparseColMatMut<'_, I, RhsE>>>::Output

#### fn add( self, other: SparseColMatMut<'_, I, RhsE>, ) -> <SparseColMatRef<'_, I, LhsE> as Add<SparseColMatMut<'_, I, RhsE>>>::Output

`+`

operation. Read more§### impl<I, E, LhsE, RhsE> Add<SparseColMatRef<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Add<SparseColMatRef<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`+`

operator.§#### fn add(
self,
other: SparseColMatRef<'_, I, RhsE>,
) -> <&SparseColMatMut<'_, I, LhsE> as Add<SparseColMatRef<'_, I, RhsE>>>::Output

#### fn add( self, other: SparseColMatRef<'_, I, RhsE>, ) -> <&SparseColMatMut<'_, I, LhsE> as Add<SparseColMatRef<'_, I, RhsE>>>::Output

`+`

operation. Read more§### impl<I, E, LhsE, RhsE> Add<SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Add<SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`+`

operator.§#### fn add(
self,
other: SparseColMatRef<'_, I, RhsE>,
) -> <SparseColMatMut<'_, I, LhsE> as Add<SparseColMatRef<'_, I, RhsE>>>::Output

#### fn add( self, other: SparseColMatRef<'_, I, RhsE>, ) -> <SparseColMatMut<'_, I, LhsE> as Add<SparseColMatRef<'_, I, RhsE>>>::Output

`+`

operation. Read more§### impl<I, LhsE, RhsE> AddAssign<&SparseColMat<I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, LhsE, RhsE> AddAssign<&SparseColMat<I, RhsE>> for SparseColMatMut<'_, I, LhsE>

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

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

`+=`

operation. Read more§### impl<I, LhsE, RhsE> AddAssign<&SparseColMatMut<'_, I, RhsE>> for SparseColMat<I, LhsE>

### impl<I, LhsE, RhsE> AddAssign<&SparseColMatMut<'_, I, RhsE>> for SparseColMat<I, LhsE>

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

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

`+=`

operation. Read more§### impl<I, LhsE, RhsE> AddAssign<&SparseColMatMut<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, LhsE, RhsE> AddAssign<&SparseColMatMut<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

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

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

`+=`

operation. Read more§### impl<I, LhsE, RhsE> AddAssign<&SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, LhsE, RhsE> AddAssign<&SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

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

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

`+=`

operation. Read more§### impl<I, LhsE, RhsE> AddAssign<SparseColMat<I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, LhsE, RhsE> AddAssign<SparseColMat<I, RhsE>> for SparseColMatMut<'_, I, LhsE>

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

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

`+=`

operation. Read more§### impl<I, LhsE, RhsE> AddAssign<SparseColMatMut<'_, I, RhsE>> for SparseColMat<I, LhsE>

### impl<I, LhsE, RhsE> AddAssign<SparseColMatMut<'_, I, RhsE>> for SparseColMat<I, LhsE>

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

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

`+=`

operation. Read more§### impl<I, LhsE, RhsE> AddAssign<SparseColMatMut<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, LhsE, RhsE> AddAssign<SparseColMatMut<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

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

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

`+=`

operation. Read more§### impl<I, LhsE, RhsE> AddAssign<SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, LhsE, RhsE> AddAssign<SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

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

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

`+=`

operation. Read more§### impl<I, E> Debug for SparseColMatMut<'_, I, E>

### impl<I, E> Debug for SparseColMatMut<'_, I, E>

§### impl<I, E, LhsE, RhsE> Div<Scale<RhsE>> for &SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Div<Scale<RhsE>> for &SparseColMatMut<'_, I, LhsE>

§### impl<I, E, LhsE, RhsE> Div<Scale<RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Div<Scale<RhsE>> for SparseColMatMut<'_, I, LhsE>

§### impl<I, E, RhsE> Div<f32> for &SparseColMatMut<'_, I, RhsE>

### impl<I, E, RhsE> Div<f32> for &SparseColMatMut<'_, I, RhsE>

§### impl<I, E, RhsE> Div<f32> for SparseColMatMut<'_, I, RhsE>

### impl<I, E, RhsE> Div<f32> for SparseColMatMut<'_, I, RhsE>

§### impl<I, E, RhsE> Div<f64> for &SparseColMatMut<'_, I, RhsE>

### impl<I, E, RhsE> Div<f64> for &SparseColMatMut<'_, I, RhsE>

§### impl<I, E, RhsE> Div<f64> for SparseColMatMut<'_, I, RhsE>

### impl<I, E, RhsE> Div<f64> for SparseColMatMut<'_, I, RhsE>

§### impl<I, LhsE, RhsE> DivAssign<Scale<RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, LhsE, RhsE> DivAssign<Scale<RhsE>> for SparseColMatMut<'_, I, LhsE>

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

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

`/=`

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

### impl<I, LhsE> DivAssign<f32> for SparseColMatMut<'_, I, LhsE>where
I: Index,
LhsE: ComplexField,

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

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

`/=`

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

### impl<I, LhsE> DivAssign<f64> for SparseColMatMut<'_, I, LhsE>where
I: Index,
LhsE: ComplexField,

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

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

`/=`

operation. Read more§### impl<I, E> Index<(usize, usize)> for SparseColMatMut<'_, I, E>where
I: Index,
E: SimpleEntity,

### impl<I, E> Index<(usize, usize)> for SparseColMatMut<'_, I, E>where
I: Index,
E: SimpleEntity,

§### impl<I, E> IndexMut<(usize, usize)> for SparseColMatMut<'_, I, E>where
I: Index,
E: SimpleEntity,

### impl<I, E> IndexMut<(usize, usize)> for SparseColMatMut<'_, I, E>where
I: Index,
E: SimpleEntity,

§### impl<'a, I, E> IntoConst for SparseColMatMut<'a, I, E>

### impl<'a, I, E> IntoConst for SparseColMatMut<'a, I, E>

#### type Target = SparseColMatRef<'a, I, E>

#### fn into_const(self) -> <SparseColMatMut<'a, I, E> as IntoConst>::Target

§### impl<I, E> Matrix<E> for SparseColMatMut<'_, I, E>

### impl<I, E> Matrix<E> for SparseColMatMut<'_, I, E>

§### impl<I, E, LhsE, RhsE> Mul<&Col<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<&Col<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<&Col<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<&Col<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<&ColMut<'_, 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<&ColMut<'_, 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<&ColMut<'_, 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<&ColMut<'_, 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<&ColRef<'_, 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<&ColRef<'_, 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<&ColRef<'_, 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<&ColRef<'_, 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 &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 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 &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 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<&MatRef<'_, 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<&MatRef<'_, 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<&MatRef<'_, 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<&MatRef<'_, 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<&SparseColMat<I, 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<&SparseColMat<I, RhsE>> for &SparseColMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: &SparseColMat<I, RhsE>,
) -> <&SparseColMatMut<'_, I, LhsE> as Mul<&SparseColMat<I, RhsE>>>::Output

#### fn mul( self, other: &SparseColMat<I, RhsE>, ) -> <&SparseColMatMut<'_, I, LhsE> as Mul<&SparseColMat<I, RhsE>>>::Output

`*`

operation. Read more§### impl<I, E, LhsE, RhsE> Mul<&SparseColMat<I, 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<&SparseColMat<I, RhsE>> for SparseColMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: &SparseColMat<I, RhsE>,
) -> <SparseColMatMut<'_, I, LhsE> as Mul<&SparseColMat<I, RhsE>>>::Output

#### fn mul( self, other: &SparseColMat<I, RhsE>, ) -> <SparseColMatMut<'_, I, LhsE> as Mul<&SparseColMat<I, RhsE>>>::Output

`*`

operation. Read more§### 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 &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 &MatRef<'_, 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 &MatRef<'_, 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 &Row<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 &Row<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 &RowMut<'_, 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 &RowMut<'_, 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 &RowRef<'_, 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 &RowRef<'_, 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 &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<&SparseColMatMut<'_, I, RhsE>> for &SparseColMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: &SparseColMatMut<'_, I, RhsE>,
) -> <&SparseColMat<I, LhsE> as Mul<&SparseColMatMut<'_, I, RhsE>>>::Output

#### fn mul( self, other: &SparseColMatMut<'_, I, RhsE>, ) -> <&SparseColMat<I, LhsE> as Mul<&SparseColMatMut<'_, I, RhsE>>>::Output

`*`

operation. Read more§### impl<I, E, LhsE, RhsE> Mul<&SparseColMatMut<'_, I, 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<&SparseColMatMut<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: &SparseColMatMut<'_, I, RhsE>,
) -> <&SparseColMatMut<'_, I, LhsE> as Mul<&SparseColMatMut<'_, I, RhsE>>>::Output

#### fn mul( self, other: &SparseColMatMut<'_, I, RhsE>, ) -> <&SparseColMatMut<'_, I, LhsE> as Mul<&SparseColMatMut<'_, I, RhsE>>>::Output

`*`

operation. Read more§### impl<I, E, LhsE, RhsE> Mul<&SparseColMatMut<'_, I, 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<&SparseColMatMut<'_, I, RhsE>> for &SparseColMatRef<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: &SparseColMatMut<'_, I, RhsE>,
) -> <&SparseColMatRef<'_, I, LhsE> as Mul<&SparseColMatMut<'_, I, RhsE>>>::Output

#### fn mul( self, other: &SparseColMatMut<'_, I, RhsE>, ) -> <&SparseColMatRef<'_, I, LhsE> as Mul<&SparseColMatMut<'_, I, RhsE>>>::Output

`*`

operation. Read more§### 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 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 MatRef<'_, 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 MatRef<'_, 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 Row<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 Row<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 RowMut<'_, 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 RowMut<'_, 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 RowRef<'_, 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 RowRef<'_, 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 Scale<LhsE>

### impl<I, E, LhsE, RhsE> Mul<&SparseColMatMut<'_, I, RhsE>> for Scale<LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: &SparseColMatMut<'_, I, RhsE>,
) -> <Scale<LhsE> as Mul<&SparseColMatMut<'_, I, RhsE>>>::Output

#### fn mul( self, other: &SparseColMatMut<'_, I, RhsE>, ) -> <Scale<LhsE> as Mul<&SparseColMatMut<'_, I, RhsE>>>::Output

`*`

operation. Read more§### impl<I, E, LhsE, RhsE> Mul<&SparseColMatMut<'_, I, 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<&SparseColMatMut<'_, I, RhsE>> for SparseColMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: &SparseColMatMut<'_, I, RhsE>,
) -> <SparseColMat<I, LhsE> as Mul<&SparseColMatMut<'_, I, RhsE>>>::Output

#### fn mul( self, other: &SparseColMatMut<'_, I, RhsE>, ) -> <SparseColMat<I, LhsE> as Mul<&SparseColMatMut<'_, I, RhsE>>>::Output

`*`

operation. Read more§### impl<I, E, LhsE, RhsE> Mul<&SparseColMatMut<'_, I, 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<&SparseColMatMut<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: &SparseColMatMut<'_, I, RhsE>,
) -> <SparseColMatMut<'_, I, LhsE> as Mul<&SparseColMatMut<'_, I, RhsE>>>::Output

#### fn mul( self, other: &SparseColMatMut<'_, I, RhsE>, ) -> <SparseColMatMut<'_, I, LhsE> as Mul<&SparseColMatMut<'_, I, RhsE>>>::Output

`*`

operation. Read more§### impl<I, E, LhsE, RhsE> Mul<&SparseColMatMut<'_, I, 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<&SparseColMatMut<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: &SparseColMatMut<'_, I, RhsE>,
) -> <SparseColMatRef<'_, I, LhsE> as Mul<&SparseColMatMut<'_, I, RhsE>>>::Output

#### fn mul( self, other: &SparseColMatMut<'_, I, RhsE>, ) -> <SparseColMatRef<'_, I, LhsE> as Mul<&SparseColMatMut<'_, I, RhsE>>>::Output

`*`

operation. Read more§### impl<I, E, LhsE, RhsE> Mul<&SparseColMatRef<'_, I, 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<&SparseColMatRef<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: &SparseColMatRef<'_, I, RhsE>,
) -> <&SparseColMatMut<'_, I, LhsE> as Mul<&SparseColMatRef<'_, I, RhsE>>>::Output

#### fn mul( self, other: &SparseColMatRef<'_, I, RhsE>, ) -> <&SparseColMatMut<'_, I, LhsE> as Mul<&SparseColMatRef<'_, I, RhsE>>>::Output

`*`

operation. Read more§### impl<I, E, LhsE, RhsE> Mul<&SparseColMatRef<'_, I, 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<&SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: &SparseColMatRef<'_, I, RhsE>,
) -> <SparseColMatMut<'_, I, LhsE> as Mul<&SparseColMatRef<'_, I, RhsE>>>::Output

#### fn mul( self, other: &SparseColMatRef<'_, I, RhsE>, ) -> <SparseColMatMut<'_, I, LhsE> as Mul<&SparseColMatRef<'_, I, RhsE>>>::Output

`*`

operation. Read more§### impl<I, E, LhsE, RhsE> Mul<Col<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<Col<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<Col<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<Col<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<ColMut<'_, 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<ColMut<'_, 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<ColMut<'_, 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<ColMut<'_, 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<ColRef<'_, 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<ColRef<'_, 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<ColRef<'_, 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<ColRef<'_, 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 &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 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 &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 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<MatRef<'_, 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<MatRef<'_, 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<MatRef<'_, 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<MatRef<'_, 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<Scale<RhsE>> for &SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Mul<Scale<RhsE>> for &SparseColMatMut<'_, I, LhsE>

§### impl<I, E, LhsE, RhsE> Mul<Scale<RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Mul<Scale<RhsE>> for SparseColMatMut<'_, I, LhsE>

§### impl<I, E, LhsE, RhsE> Mul<SparseColMat<I, 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<SparseColMat<I, RhsE>> for &SparseColMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: SparseColMat<I, RhsE>,
) -> <&SparseColMatMut<'_, I, LhsE> as Mul<SparseColMat<I, RhsE>>>::Output

#### fn mul( self, other: SparseColMat<I, RhsE>, ) -> <&SparseColMatMut<'_, I, LhsE> as Mul<SparseColMat<I, RhsE>>>::Output

`*`

operation. Read more§### impl<I, E, LhsE, RhsE> Mul<SparseColMat<I, 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<SparseColMat<I, RhsE>> for SparseColMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: SparseColMat<I, RhsE>,
) -> <SparseColMatMut<'_, I, LhsE> as Mul<SparseColMat<I, RhsE>>>::Output

#### fn mul( self, other: SparseColMat<I, RhsE>, ) -> <SparseColMatMut<'_, I, LhsE> as Mul<SparseColMat<I, RhsE>>>::Output

`*`

operation. Read more§### 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 &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 &MatRef<'_, 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 &MatRef<'_, 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 &Row<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 &Row<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 &RowMut<'_, 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 &RowMut<'_, 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 &RowRef<'_, 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 &RowRef<'_, 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 &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<SparseColMatMut<'_, I, RhsE>> for &SparseColMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: SparseColMatMut<'_, I, RhsE>,
) -> <&SparseColMat<I, LhsE> as Mul<SparseColMatMut<'_, I, RhsE>>>::Output

#### fn mul( self, other: SparseColMatMut<'_, I, RhsE>, ) -> <&SparseColMat<I, LhsE> as Mul<SparseColMatMut<'_, I, RhsE>>>::Output

`*`

operation. Read more§### impl<I, E, LhsE, RhsE> Mul<SparseColMatMut<'_, I, 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<SparseColMatMut<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: SparseColMatMut<'_, I, RhsE>,
) -> <&SparseColMatMut<'_, I, LhsE> as Mul<SparseColMatMut<'_, I, RhsE>>>::Output

#### fn mul( self, other: SparseColMatMut<'_, I, RhsE>, ) -> <&SparseColMatMut<'_, I, LhsE> as Mul<SparseColMatMut<'_, I, RhsE>>>::Output

`*`

operation. Read more§### impl<I, E, LhsE, RhsE> Mul<SparseColMatMut<'_, I, 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<SparseColMatMut<'_, I, RhsE>> for &SparseColMatRef<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: SparseColMatMut<'_, I, RhsE>,
) -> <&SparseColMatRef<'_, I, LhsE> as Mul<SparseColMatMut<'_, I, RhsE>>>::Output

#### fn mul( self, other: SparseColMatMut<'_, I, RhsE>, ) -> <&SparseColMatRef<'_, I, LhsE> as Mul<SparseColMatMut<'_, I, RhsE>>>::Output

`*`

operation. Read more§### 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 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 MatRef<'_, 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 MatRef<'_, 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 Row<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 Row<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 RowMut<'_, 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 RowMut<'_, 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 RowRef<'_, 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 RowRef<'_, 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 Scale<LhsE>

### impl<I, E, LhsE, RhsE> Mul<SparseColMatMut<'_, I, RhsE>> for Scale<LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: SparseColMatMut<'_, I, RhsE>,
) -> <Scale<LhsE> as Mul<SparseColMatMut<'_, I, RhsE>>>::Output

#### fn mul( self, other: SparseColMatMut<'_, I, RhsE>, ) -> <Scale<LhsE> as Mul<SparseColMatMut<'_, I, RhsE>>>::Output

`*`

operation. Read more§### impl<I, E, LhsE, RhsE> Mul<SparseColMatMut<'_, I, 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<SparseColMatMut<'_, I, RhsE>> for SparseColMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: SparseColMatMut<'_, I, RhsE>,
) -> <SparseColMat<I, LhsE> as Mul<SparseColMatMut<'_, I, RhsE>>>::Output

#### fn mul( self, other: SparseColMatMut<'_, I, RhsE>, ) -> <SparseColMat<I, LhsE> as Mul<SparseColMatMut<'_, I, RhsE>>>::Output

`*`

operation. Read more§### impl<I, E, LhsE, RhsE> Mul<SparseColMatMut<'_, I, 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<SparseColMatMut<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: SparseColMatMut<'_, I, RhsE>,
) -> <SparseColMatMut<'_, I, LhsE> as Mul<SparseColMatMut<'_, I, RhsE>>>::Output

#### fn mul( self, other: SparseColMatMut<'_, I, RhsE>, ) -> <SparseColMatMut<'_, I, LhsE> as Mul<SparseColMatMut<'_, I, RhsE>>>::Output

`*`

operation. Read more§### impl<I, E, LhsE, RhsE> Mul<SparseColMatMut<'_, I, 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<SparseColMatMut<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: SparseColMatMut<'_, I, RhsE>,
) -> <SparseColMatRef<'_, I, LhsE> as Mul<SparseColMatMut<'_, I, RhsE>>>::Output

#### fn mul( self, other: SparseColMatMut<'_, I, RhsE>, ) -> <SparseColMatRef<'_, I, LhsE> as Mul<SparseColMatMut<'_, I, RhsE>>>::Output

`*`

operation. Read more§### impl<I, E, LhsE, RhsE> Mul<SparseColMatRef<'_, I, 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<SparseColMatRef<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: SparseColMatRef<'_, I, RhsE>,
) -> <&SparseColMatMut<'_, I, LhsE> as Mul<SparseColMatRef<'_, I, RhsE>>>::Output

#### fn mul( self, other: SparseColMatRef<'_, I, RhsE>, ) -> <&SparseColMatMut<'_, I, LhsE> as Mul<SparseColMatRef<'_, I, RhsE>>>::Output

`*`

operation. Read more§### impl<I, E, LhsE, RhsE> Mul<SparseColMatRef<'_, I, 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<SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`*`

operator.§#### fn mul(
self,
other: SparseColMatRef<'_, I, RhsE>,
) -> <SparseColMatMut<'_, I, LhsE> as Mul<SparseColMatRef<'_, I, RhsE>>>::Output

#### fn mul( self, other: SparseColMatRef<'_, I, RhsE>, ) -> <SparseColMatMut<'_, I, LhsE> as Mul<SparseColMatRef<'_, I, RhsE>>>::Output

`*`

operation. Read more§### impl<I, E, RhsE> Mul<f32> for &SparseColMatMut<'_, I, RhsE>

### impl<I, E, RhsE> Mul<f32> for &SparseColMatMut<'_, I, RhsE>

§### impl<I, E, RhsE> Mul<f32> for SparseColMatMut<'_, I, RhsE>

### impl<I, E, RhsE> Mul<f32> for SparseColMatMut<'_, I, RhsE>

§### impl<I, E, RhsE> Mul<f64> for &SparseColMatMut<'_, I, RhsE>

### impl<I, E, RhsE> Mul<f64> for &SparseColMatMut<'_, I, RhsE>

§### impl<I, E, RhsE> Mul<f64> for SparseColMatMut<'_, I, RhsE>

### impl<I, E, RhsE> Mul<f64> for SparseColMatMut<'_, I, RhsE>

§### impl<I, LhsE, RhsE> MulAssign<Scale<RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, LhsE, RhsE> MulAssign<Scale<RhsE>> for SparseColMatMut<'_, I, LhsE>

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

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

`*=`

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

### impl<I, LhsE> MulAssign<f32> for SparseColMatMut<'_, I, LhsE>where
I: Index,
LhsE: ComplexField,

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

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

`*=`

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

### impl<I, LhsE> MulAssign<f64> for SparseColMatMut<'_, I, LhsE>where
I: Index,
LhsE: ComplexField,

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

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

`*=`

operation. Read more§### impl<I, E> Neg for &SparseColMatMut<'_, I, E>

### impl<I, E> Neg for &SparseColMatMut<'_, I, E>

§### impl<I, E> Neg for SparseColMatMut<'_, I, E>

### impl<I, E> Neg for SparseColMatMut<'_, I, E>

§### impl<I, LhsE, RhsE> PartialEq<SparseColMat<I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, LhsE, RhsE> PartialEq<SparseColMat<I, RhsE>> for SparseColMatMut<'_, I, LhsE>

§### impl<I, LhsE, RhsE> PartialEq<SparseColMatMut<'_, I, RhsE>> for SparseColMat<I, LhsE>

### impl<I, LhsE, RhsE> PartialEq<SparseColMatMut<'_, I, RhsE>> for SparseColMat<I, LhsE>

§### impl<I, LhsE, RhsE> PartialEq<SparseColMatMut<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, LhsE, RhsE> PartialEq<SparseColMatMut<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

§### impl<I, LhsE, RhsE> PartialEq<SparseColMatMut<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>

### impl<I, LhsE, RhsE> PartialEq<SparseColMatMut<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>

§### impl<I, LhsE, RhsE> PartialEq<SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, LhsE, RhsE> PartialEq<SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

§### impl<'short, I, E> Reborrow<'short> for SparseColMatMut<'_, I, E>

### impl<'short, I, E> Reborrow<'short> for SparseColMatMut<'_, I, E>

#### type Target = SparseColMatRef<'short, I, E>

#### fn rb(&'short self) -> <SparseColMatMut<'_, I, E> as Reborrow<'short>>::Target

§### impl<'short, I, E> ReborrowMut<'short> for SparseColMatMut<'_, I, E>

### impl<'short, I, E> ReborrowMut<'short> for SparseColMatMut<'_, I, E>

#### type Target = SparseColMatMut<'short, I, E>

#### fn rb_mut( &'short mut self, ) -> <SparseColMatMut<'_, I, E> as ReborrowMut<'short>>::Target

§### impl<I, E> SparseAccess<E> for SparseColMatMut<'_, I, E>

### impl<I, E> SparseAccess<E> for SparseColMatMut<'_, I, E>

§### impl<I, E, LhsE, RhsE> Sub<&SparseColMat<I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Sub<&SparseColMat<I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`-`

operator.§#### fn sub(
self,
other: &SparseColMat<I, RhsE>,
) -> <&SparseColMatMut<'_, I, LhsE> as Sub<&SparseColMat<I, RhsE>>>::Output

#### fn sub( self, other: &SparseColMat<I, RhsE>, ) -> <&SparseColMatMut<'_, I, LhsE> as Sub<&SparseColMat<I, RhsE>>>::Output

`-`

operation. Read more§### impl<I, E, LhsE, RhsE> Sub<&SparseColMat<I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Sub<&SparseColMat<I, RhsE>> for SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`-`

operator.§#### fn sub(
self,
other: &SparseColMat<I, RhsE>,
) -> <SparseColMatMut<'_, I, LhsE> as Sub<&SparseColMat<I, RhsE>>>::Output

#### fn sub( self, other: &SparseColMat<I, RhsE>, ) -> <SparseColMatMut<'_, I, LhsE> as Sub<&SparseColMat<I, RhsE>>>::Output

`-`

operation. Read more§### impl<I, E, LhsE, RhsE> Sub<&SparseColMatMut<'_, I, RhsE>> for &SparseColMat<I, LhsE>

### impl<I, E, LhsE, RhsE> Sub<&SparseColMatMut<'_, I, RhsE>> for &SparseColMat<I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`-`

operator.§#### fn sub(
self,
other: &SparseColMatMut<'_, I, RhsE>,
) -> <&SparseColMat<I, LhsE> as Sub<&SparseColMatMut<'_, I, RhsE>>>::Output

#### fn sub( self, other: &SparseColMatMut<'_, I, RhsE>, ) -> <&SparseColMat<I, LhsE> as Sub<&SparseColMatMut<'_, I, RhsE>>>::Output

`-`

operation. Read more§### impl<I, E, LhsE, RhsE> Sub<&SparseColMatMut<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Sub<&SparseColMatMut<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`-`

operator.§#### fn sub(
self,
other: &SparseColMatMut<'_, I, RhsE>,
) -> <&SparseColMatMut<'_, I, LhsE> as Sub<&SparseColMatMut<'_, I, RhsE>>>::Output

#### fn sub( self, other: &SparseColMatMut<'_, I, RhsE>, ) -> <&SparseColMatMut<'_, I, LhsE> as Sub<&SparseColMatMut<'_, I, RhsE>>>::Output

`-`

operation. Read more§### impl<I, E, LhsE, RhsE> Sub<&SparseColMatMut<'_, I, RhsE>> for &SparseColMatRef<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Sub<&SparseColMatMut<'_, I, RhsE>> for &SparseColMatRef<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`-`

operator.§#### fn sub(
self,
other: &SparseColMatMut<'_, I, RhsE>,
) -> <&SparseColMatRef<'_, I, LhsE> as Sub<&SparseColMatMut<'_, I, RhsE>>>::Output

#### fn sub( self, other: &SparseColMatMut<'_, I, RhsE>, ) -> <&SparseColMatRef<'_, I, LhsE> as Sub<&SparseColMatMut<'_, I, RhsE>>>::Output

`-`

operation. Read more§### impl<I, E, LhsE, RhsE> Sub<&SparseColMatMut<'_, I, RhsE>> for SparseColMat<I, LhsE>

### impl<I, E, LhsE, RhsE> Sub<&SparseColMatMut<'_, I, RhsE>> for SparseColMat<I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`-`

operator.§#### fn sub(
self,
other: &SparseColMatMut<'_, I, RhsE>,
) -> <SparseColMat<I, LhsE> as Sub<&SparseColMatMut<'_, I, RhsE>>>::Output

#### fn sub( self, other: &SparseColMatMut<'_, I, RhsE>, ) -> <SparseColMat<I, LhsE> as Sub<&SparseColMatMut<'_, I, RhsE>>>::Output

`-`

operation. Read more§### impl<I, E, LhsE, RhsE> Sub<&SparseColMatMut<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Sub<&SparseColMatMut<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`-`

operator.§#### fn sub(
self,
other: &SparseColMatMut<'_, I, RhsE>,
) -> <SparseColMatMut<'_, I, LhsE> as Sub<&SparseColMatMut<'_, I, RhsE>>>::Output

#### fn sub( self, other: &SparseColMatMut<'_, I, RhsE>, ) -> <SparseColMatMut<'_, I, LhsE> as Sub<&SparseColMatMut<'_, I, RhsE>>>::Output

`-`

operation. Read more§### impl<I, E, LhsE, RhsE> Sub<&SparseColMatMut<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Sub<&SparseColMatMut<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`-`

operator.§#### fn sub(
self,
other: &SparseColMatMut<'_, I, RhsE>,
) -> <SparseColMatRef<'_, I, LhsE> as Sub<&SparseColMatMut<'_, I, RhsE>>>::Output

#### fn sub( self, other: &SparseColMatMut<'_, I, RhsE>, ) -> <SparseColMatRef<'_, I, LhsE> as Sub<&SparseColMatMut<'_, I, RhsE>>>::Output

`-`

operation. Read more§### impl<I, E, LhsE, RhsE> Sub<&SparseColMatRef<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Sub<&SparseColMatRef<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`-`

operator.§#### fn sub(
self,
other: &SparseColMatRef<'_, I, RhsE>,
) -> <&SparseColMatMut<'_, I, LhsE> as Sub<&SparseColMatRef<'_, I, RhsE>>>::Output

#### fn sub( self, other: &SparseColMatRef<'_, I, RhsE>, ) -> <&SparseColMatMut<'_, I, LhsE> as Sub<&SparseColMatRef<'_, I, RhsE>>>::Output

`-`

operation. Read more§### impl<I, E, LhsE, RhsE> Sub<&SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Sub<&SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`-`

operator.§#### fn sub(
self,
other: &SparseColMatRef<'_, I, RhsE>,
) -> <SparseColMatMut<'_, I, LhsE> as Sub<&SparseColMatRef<'_, I, RhsE>>>::Output

#### fn sub( self, other: &SparseColMatRef<'_, I, RhsE>, ) -> <SparseColMatMut<'_, I, LhsE> as Sub<&SparseColMatRef<'_, I, RhsE>>>::Output

`-`

operation. Read more§### impl<I, E, LhsE, RhsE> Sub<SparseColMat<I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Sub<SparseColMat<I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`-`

operator.§#### fn sub(
self,
other: SparseColMat<I, RhsE>,
) -> <&SparseColMatMut<'_, I, LhsE> as Sub<SparseColMat<I, RhsE>>>::Output

#### fn sub( self, other: SparseColMat<I, RhsE>, ) -> <&SparseColMatMut<'_, I, LhsE> as Sub<SparseColMat<I, RhsE>>>::Output

`-`

operation. Read more§### impl<I, E, LhsE, RhsE> Sub<SparseColMat<I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Sub<SparseColMat<I, RhsE>> for SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`-`

operator.§#### fn sub(
self,
other: SparseColMat<I, RhsE>,
) -> <SparseColMatMut<'_, I, LhsE> as Sub<SparseColMat<I, RhsE>>>::Output

#### fn sub( self, other: SparseColMat<I, RhsE>, ) -> <SparseColMatMut<'_, I, LhsE> as Sub<SparseColMat<I, RhsE>>>::Output

`-`

operation. Read more§### impl<I, E, LhsE, RhsE> Sub<SparseColMatMut<'_, I, RhsE>> for &SparseColMat<I, LhsE>

### impl<I, E, LhsE, RhsE> Sub<SparseColMatMut<'_, I, RhsE>> for &SparseColMat<I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`-`

operator.§#### fn sub(
self,
other: SparseColMatMut<'_, I, RhsE>,
) -> <&SparseColMat<I, LhsE> as Sub<SparseColMatMut<'_, I, RhsE>>>::Output

#### fn sub( self, other: SparseColMatMut<'_, I, RhsE>, ) -> <&SparseColMat<I, LhsE> as Sub<SparseColMatMut<'_, I, RhsE>>>::Output

`-`

operation. Read more§### impl<I, E, LhsE, RhsE> Sub<SparseColMatMut<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Sub<SparseColMatMut<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`-`

operator.§#### fn sub(
self,
other: SparseColMatMut<'_, I, RhsE>,
) -> <&SparseColMatMut<'_, I, LhsE> as Sub<SparseColMatMut<'_, I, RhsE>>>::Output

#### fn sub( self, other: SparseColMatMut<'_, I, RhsE>, ) -> <&SparseColMatMut<'_, I, LhsE> as Sub<SparseColMatMut<'_, I, RhsE>>>::Output

`-`

operation. Read more§### impl<I, E, LhsE, RhsE> Sub<SparseColMatMut<'_, I, RhsE>> for &SparseColMatRef<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Sub<SparseColMatMut<'_, I, RhsE>> for &SparseColMatRef<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`-`

operator.§#### fn sub(
self,
other: SparseColMatMut<'_, I, RhsE>,
) -> <&SparseColMatRef<'_, I, LhsE> as Sub<SparseColMatMut<'_, I, RhsE>>>::Output

#### fn sub( self, other: SparseColMatMut<'_, I, RhsE>, ) -> <&SparseColMatRef<'_, I, LhsE> as Sub<SparseColMatMut<'_, I, RhsE>>>::Output

`-`

operation. Read more§### impl<I, E, LhsE, RhsE> Sub<SparseColMatMut<'_, I, RhsE>> for SparseColMat<I, LhsE>

### impl<I, E, LhsE, RhsE> Sub<SparseColMatMut<'_, I, RhsE>> for SparseColMat<I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`-`

operator.§#### fn sub(
self,
other: SparseColMatMut<'_, I, RhsE>,
) -> <SparseColMat<I, LhsE> as Sub<SparseColMatMut<'_, I, RhsE>>>::Output

#### fn sub( self, other: SparseColMatMut<'_, I, RhsE>, ) -> <SparseColMat<I, LhsE> as Sub<SparseColMatMut<'_, I, RhsE>>>::Output

`-`

operation. Read more§### impl<I, E, LhsE, RhsE> Sub<SparseColMatMut<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Sub<SparseColMatMut<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`-`

operator.§#### fn sub(
self,
other: SparseColMatMut<'_, I, RhsE>,
) -> <SparseColMatMut<'_, I, LhsE> as Sub<SparseColMatMut<'_, I, RhsE>>>::Output

#### fn sub( self, other: SparseColMatMut<'_, I, RhsE>, ) -> <SparseColMatMut<'_, I, LhsE> as Sub<SparseColMatMut<'_, I, RhsE>>>::Output

`-`

operation. Read more§### impl<I, E, LhsE, RhsE> Sub<SparseColMatMut<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Sub<SparseColMatMut<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`-`

operator.§#### fn sub(
self,
other: SparseColMatMut<'_, I, RhsE>,
) -> <SparseColMatRef<'_, I, LhsE> as Sub<SparseColMatMut<'_, I, RhsE>>>::Output

#### fn sub( self, other: SparseColMatMut<'_, I, RhsE>, ) -> <SparseColMatRef<'_, I, LhsE> as Sub<SparseColMatMut<'_, I, RhsE>>>::Output

`-`

operation. Read more§### impl<I, E, LhsE, RhsE> Sub<SparseColMatRef<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Sub<SparseColMatRef<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`-`

operator.§#### fn sub(
self,
other: SparseColMatRef<'_, I, RhsE>,
) -> <&SparseColMatMut<'_, I, LhsE> as Sub<SparseColMatRef<'_, I, RhsE>>>::Output

#### fn sub( self, other: SparseColMatRef<'_, I, RhsE>, ) -> <&SparseColMatMut<'_, I, LhsE> as Sub<SparseColMatRef<'_, I, RhsE>>>::Output

`-`

operation. Read more§### impl<I, E, LhsE, RhsE> Sub<SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, E, LhsE, RhsE> Sub<SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

§#### type Output = SparseColMat<I, E>

#### type Output = SparseColMat<I, E>

`-`

operator.§#### fn sub(
self,
other: SparseColMatRef<'_, I, RhsE>,
) -> <SparseColMatMut<'_, I, LhsE> as Sub<SparseColMatRef<'_, I, RhsE>>>::Output

#### fn sub( self, other: SparseColMatRef<'_, I, RhsE>, ) -> <SparseColMatMut<'_, I, LhsE> as Sub<SparseColMatRef<'_, I, RhsE>>>::Output

`-`

operation. Read more§### impl<I, LhsE, RhsE> SubAssign<&SparseColMat<I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, LhsE, RhsE> SubAssign<&SparseColMat<I, RhsE>> for SparseColMatMut<'_, I, LhsE>

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

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

`-=`

operation. Read more§### impl<I, LhsE, RhsE> SubAssign<&SparseColMatMut<'_, I, RhsE>> for SparseColMat<I, LhsE>

### impl<I, LhsE, RhsE> SubAssign<&SparseColMatMut<'_, I, RhsE>> for SparseColMat<I, LhsE>

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

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

`-=`

operation. Read more§### impl<I, LhsE, RhsE> SubAssign<&SparseColMatMut<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, LhsE, RhsE> SubAssign<&SparseColMatMut<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

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

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

`-=`

operation. Read more§### impl<I, LhsE, RhsE> SubAssign<&SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, LhsE, RhsE> SubAssign<&SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

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

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

`-=`

operation. Read more§### impl<I, LhsE, RhsE> SubAssign<SparseColMat<I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, LhsE, RhsE> SubAssign<SparseColMat<I, RhsE>> for SparseColMatMut<'_, I, LhsE>

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

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

`-=`

operation. Read more§### impl<I, LhsE, RhsE> SubAssign<SparseColMatMut<'_, I, RhsE>> for SparseColMat<I, LhsE>

### impl<I, LhsE, RhsE> SubAssign<SparseColMatMut<'_, I, RhsE>> for SparseColMat<I, LhsE>

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

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

`-=`

operation. Read more§### impl<I, LhsE, RhsE> SubAssign<SparseColMatMut<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, LhsE, RhsE> SubAssign<SparseColMatMut<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

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

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

`-=`

operation. Read more§### impl<I, LhsE, RhsE> SubAssign<SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

### impl<I, LhsE, RhsE> SubAssign<SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

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

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

`-=`

operation. Read more## Auto Trait Implementations§

### impl<'a, I, E> Freeze for SparseColMatMut<'a, I, E>

### impl<'a, I, E> RefUnwindSafe for SparseColMatMut<'a, I, E>where
<<E as Entity>::Group as ForType>::FaerOf<*mut [<E as Entity>::Unit]>: RefUnwindSafe,
I: RefUnwindSafe,

### impl<'a, I, E> Send for SparseColMatMut<'a, I, E>

### impl<'a, I, E> Sync for SparseColMatMut<'a, I, E>

### impl<'a, I, E> Unpin for SparseColMatMut<'a, I, E>

### impl<'a, I, E> !UnwindSafe for SparseColMatMut<'a, I, E>

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