# Struct extendr_api::prelude::modules::core::RowMut

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

## Expand description

Mutable view over a row vector, similar to a mutable reference to a strided slice.

## §Note

Unlike a slice, the data pointed to by `RowMut<'_, E>`

is allowed to be partially or fully
uninitialized under certain conditions. In this case, care must be taken to not perform any
operations that read the uninitialized values, or form references to them, either directly
through `RowMut::read`

, or indirectly through any of the numerical library routines, unless
it is explicitly permitted.

## §Move semantics

See `faer::Mat`

for information about reborrowing when using this type.

## Fields§

§`inner: VecImpl<E>`

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

## Implementations§

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

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

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

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

Returns pointers to the matrix data.

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

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

Returns pointers to the matrix data.

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

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

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

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

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

Returns raw pointers to the element at the given index.

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

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

Returns raw pointers to the element at the given index.

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

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

Returns raw pointers to the element at the given index, assuming the provided index is within the size of the vector.

##### §Safety

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

`col < self.ncols()`

.

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

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

Returns raw pointers to the element at the given index, assuming the provided index is within the size of the vector.

##### §Safety

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

`col < self.ncols()`

.

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

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

Splits the column vector at the given index into two parts and returns an array of each subvector, in the following order:

- left.
- right.

##### §Safety

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

`col <= self.ncols()`

.

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

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

Splits the column vector at the given index into two parts and returns an array of each subvector, in the following order:

- left.
- right.

##### §Safety

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

`col <= self.ncols()`

.

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

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

Splits the column vector at the given index into two parts and returns an array of each subvector, in the following order:

- top.
- bottom.

##### §Panics

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

`col <= self.ncols()`

.

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

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

- top.
- bottom.

##### §Panics

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

`col <= self.ncols()`

.

#### pub unsafe fn get_unchecked<ColRange>(
self,
col: ColRange,
) -> <RowRef<'a, E> as RowIndex<ColRange>>::Target

#### pub unsafe fn get_unchecked<ColRange>( self, col: ColRange, ) -> <RowRef<'a, E> as RowIndex<ColRange>>::Target

Returns references to the element at the given index, or subvector if `row`

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:

`col`

must be contained in`[0, self.ncols())`

.

#### pub fn get<ColRange>(
self,
col: ColRange,
) -> <RowRef<'a, E> as RowIndex<ColRange>>::Target

#### pub fn get<ColRange>( self, col: ColRange, ) -> <RowRef<'a, E> as RowIndex<ColRange>>::Target

Returns references to the element at the given index, or subvector if `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:

`col`

must be contained in`[0, self.ncols())`

.

#### pub unsafe fn get_mut_unchecked<ColRange>(
self,
col: ColRange,
) -> <RowMut<'a, E> as RowIndex<ColRange>>::Target

#### pub unsafe fn get_mut_unchecked<ColRange>( self, col: ColRange, ) -> <RowMut<'a, E> as RowIndex<ColRange>>::Target

Returns references to the element at the given index, or subvector if `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:

`col`

must be contained in`[0, self.ncols())`

.

#### pub fn get_mut<ColRange>(
self,
col: ColRange,
) -> <RowMut<'a, E> as RowIndex<ColRange>>::Target

#### pub fn get_mut<ColRange>( self, col: ColRange, ) -> <RowMut<'a, E> as RowIndex<ColRange>>::Target

Returns references to the element at the given index, or subvector if `col`

is a
range, with bound checks.

##### §Note

##### §Panics

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

`col`

must be contained in`[0, self.ncols())`

.

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

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

Reads the value of the element at the given index.

##### §Safety

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

`col < self.ncols()`

.

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

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

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

##### §Panics

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

`col < self.ncols()`

.

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

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

Writes the value to the element at the given index.

##### §Safety

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

`col < self.ncols()`

.

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

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

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

##### §Panics

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

`col < self.ncols()`

.

#### pub fn copy_from<ViewE>(&mut self, other: impl AsRowRef<ViewE>)where
ViewE: Conjugate<Canonical = E>,

#### pub fn copy_from<ViewE>(&mut self, other: impl AsRowRef<ViewE>)where
ViewE: Conjugate<Canonical = E>,

Copies the values from `other`

into `self`

.

##### §Panics

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

`self.ncols() == other.ncols()`

.

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

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

Fills the elements of `self`

with zeros.

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

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

Fills the elements of `self`

with copies of `constant`

.

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

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

Returns a view over the transpose of `self`

.

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

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

Returns a view over the conjugate of `self`

.

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

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

Returns a view over the conjugate of `self`

.

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

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

Returns a view over the conjugate transpose of `self`

.

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

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

Returns a view over the conjugate transpose of `self`

.

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

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

Returns a view over the canonical representation of `self`

, as well as a flag declaring
whether `self`

is implicitly conjugated or not.

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

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

Returns a view over the canonical representation of `self`

, as well as a flag declaring
whether `self`

is implicitly conjugated or not.

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

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

Returns a view over the `self`

, with the columns in reversed order.

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

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

Returns a view over the `self`

, with the columns in reversed order.

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

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

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

, and with number of
columns `ncols`

.

##### §Safety

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

`col_start <= self.ncols()`

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

.

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

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

Returns a view over the subvector starting at col `col_start`

, and with number of cols
`ncols`

.

##### §Panics

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

`col_start <= self.ncols()`

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

.

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

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

Returns a view over the subvector starting at col `col_start`

, and with number of
columns `ncols`

.

##### §Safety

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

`col_start <= self.ncols()`

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

.

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

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

Returns a view over the subvector starting at col `col_start`

, and with number of
columns `ncols`

.

##### §Safety

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

`col_start <= self.ncols()`

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

.

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

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

Returns an owning `Row`

of the data.

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

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

Returns `true`

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

.

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

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

Returns `true`

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

.

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

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

Returns the maximum norm of `self`

.

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

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

Returns the L1 norm of `self`

.

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

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

Returns the L2 norm of `self`

.

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

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

Returns the squared L2 norm of `self`

.

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

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

Returns the sum of `self`

.

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

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

Kronecker product of `self`

and `rhs`

.

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

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

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

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

Returns the row as a contiguous slice if its column stride is equal to `1`

.

##### §Note

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

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

Returns the row as a contiguous slice if its column stride is equal to `1`

.

##### §Note

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

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

Returns the row as a contiguous potentially uninitialized slice if its column stride is
equal to `1`

.

##### §Safety

If uninit data is written to the slice, it must not be read at some later point.

#### pub fn split_first(
self,
) -> Option<(<<E as Entity>::Group as ForType>::FaerOf<&'a <E as Entity>::Unit>, RowRef<'a, E>)>

#### pub fn split_first( self, ) -> Option<(<<E as Entity>::Group as ForType>::FaerOf<&'a <E as Entity>::Unit>, RowRef<'a, E>)>

Returns a reference to the first element and a view over the remaining ones if the row is
non-empty, otherwise `None`

.

#### pub fn split_last(
self,
) -> Option<(<<E as Entity>::Group as ForType>::FaerOf<&'a <E as Entity>::Unit>, RowRef<'a, E>)>

#### pub fn split_last( self, ) -> Option<(<<E as Entity>::Group as ForType>::FaerOf<&'a <E as Entity>::Unit>, RowRef<'a, E>)>

Returns a reference to the last element and a view over the remaining ones if the row is
non-empty, otherwise `None`

.

#### pub fn split_first_mut(
self,
) -> Option<(<<E as Entity>::Group as ForType>::FaerOf<&'a mut <E as Entity>::Unit>, RowMut<'a, E>)>

#### pub fn split_first_mut( self, ) -> Option<(<<E as Entity>::Group as ForType>::FaerOf<&'a mut <E as Entity>::Unit>, RowMut<'a, E>)>

Returns a reference to the first element and a view over the remaining ones if the row is
non-empty, otherwise `None`

.

#### pub fn split_last_mut(
self,
) -> Option<(<<E as Entity>::Group as ForType>::FaerOf<&'a mut <E as Entity>::Unit>, RowMut<'a, E>)>

#### pub fn split_last_mut( self, ) -> Option<(<<E as Entity>::Group as ForType>::FaerOf<&'a mut <E as Entity>::Unit>, RowMut<'a, E>)>

Returns a reference to the last element and a view over the remaining ones if the row is
non-empty, otherwise `None`

.

#### pub fn iter(self) -> ElemIter<'a, E>

#### pub fn iter(self) -> ElemIter<'a, E>

Returns an iterator over the elements of the row.

#### pub fn iter_mut(self) -> ElemIterMut<'a, E>

#### pub fn iter_mut(self) -> ElemIterMut<'a, E>

Returns an iterator over the elements of the row.

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

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

Returns an iterator that provides successive chunks of the elements of this row, with
each having at most `chunk_size`

elements.

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

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

Returns an iterator that provides exactly `count`

successive chunks of the elements of this
row.

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

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

Returns an iterator that provides successive chunks of the elements of this row, with
each having at most `chunk_size`

elements.

Only available with the `rayon`

feature.

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

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

Returns an iterator that provides exactly `count`

successive chunks of the elements of this
row.

Only available with the `rayon`

feature.

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

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

Returns an iterator that provides successive chunks of the elements of this row, with
each having at most `chunk_size`

elements.

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

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

Returns an iterator that provides exactly `count`

successive chunks of the elements of this
row.

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

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

`chunk_size`

elements.

Only available with the `rayon`

feature.

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

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

Returns an iterator that provides exactly `count`

successive chunks of the elements of this
row.

Only available with the `rayon`

feature.

## Trait Implementations§

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

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

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

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

`+=`

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

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

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

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

`+=`

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

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

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

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

`+=`

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

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

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

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

`+=`

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

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

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

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

`+=`

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

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

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

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

`+=`

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

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

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

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

`+=`

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

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

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

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

`+=`

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

### impl<E> AsRowMut<E> for RowMut<'_, E>where
E: Entity,

§#### fn as_row_mut(&mut self) -> RowMut<'_, E>

#### fn as_row_mut(&mut self) -> RowMut<'_, E>

§### impl<E> AsRowRef<E> for RowMut<'_, E>where
E: Entity,

### impl<E> AsRowRef<E> for RowMut<'_, E>where
E: Entity,

§#### fn as_row_ref(&self) -> RowRef<'_, E>

#### fn as_row_ref(&self) -> RowRef<'_, E>

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

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

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

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

`/=`

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

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

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

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

`/=`

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

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

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

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

`/=`

operation. Read more§### impl<E> Index<usize> for RowMut<'_, E>where
E: SimpleEntity,

### impl<E> Index<usize> for RowMut<'_, E>where
E: SimpleEntity,

§### impl<E> IndexMut<usize> for RowMut<'_, E>where
E: SimpleEntity,

### impl<E> IndexMut<usize> for RowMut<'_, E>where
E: SimpleEntity,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

§#### type LayoutTransform = VecLayoutTransform

#### type LayoutTransform = VecLayoutTransform

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

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

`n_elems`

.§### impl<I, E, LhsE, RhsE> Mul<&SparseColMat<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<&SparseColMat<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<&SparseColMat<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<&SparseColMat<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 &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 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<&SparseColMatRef<'_, 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<&SparseColMatRef<'_, 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<&SparseColMatRef<'_, 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<&SparseColMatRef<'_, 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<&SparseRowMat<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<&SparseRowMat<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<&SparseRowMat<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<&SparseRowMat<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<&SparseRowMatMut<'_, 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<&SparseRowMatMut<'_, 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<&SparseRowMatMut<'_, 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<&SparseRowMatMut<'_, 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<&SparseRowMatRef<'_, 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<&SparseRowMatRef<'_, 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<&SparseRowMatRef<'_, 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<&SparseRowMatRef<'_, 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<SparseColMat<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<SparseColMat<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<SparseColMat<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<SparseColMat<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 &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 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<SparseColMatRef<'_, 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<SparseColMatRef<'_, 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<SparseColMatRef<'_, 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<SparseColMatRef<'_, 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<SparseRowMat<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<SparseRowMat<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<SparseRowMat<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<SparseRowMat<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<SparseRowMatMut<'_, 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<SparseRowMatMut<'_, 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<SparseRowMatMut<'_, 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<SparseRowMatMut<'_, 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<SparseRowMatRef<'_, 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<SparseRowMatRef<'_, 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<SparseRowMatRef<'_, 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<SparseRowMatRef<'_, I, RhsE>> for RowMut<'_, 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 RowMut<'_, LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

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

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

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

`*=`

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

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

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

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

`*=`

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

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

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

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

`*=`

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

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

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

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

§### impl<'a, E> RowIndex<usize> for RowMut<'a, E>where
E: Entity,

### impl<'a, E> RowIndex<usize> for RowMut<'a, E>where
E: Entity,

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

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

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

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

`-=`

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

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

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

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

`-=`

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

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

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

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

`-=`

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

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

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

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

`-=`

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

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

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

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

`-=`

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

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

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

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

`-=`

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

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

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

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

`-=`

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

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

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

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

`-=`

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

## Auto Trait Implementations§

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

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

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

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

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

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

## Blanket Implementations§

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

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

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

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

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

### impl<T> IntoEither for T

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

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

`self`

into a `Left`

variant of `Either<Self, Self>`

if `into_left`

is `true`

.
Converts `self`

into a `Right`

variant of `Either<Self, Self>`

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

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

`self`

into a `Left`

variant of `Either<Self, Self>`

if `into_left(&self)`

returns `true`

.
Converts `self`

into a `Right`

variant of `Either<Self, Self>`

otherwise. Read more