# Struct extendr_api::prelude::Row

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

## Expand description

Heap allocated resizable row vector.

## §Note

The memory layout of `Col`

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

.

## Fields§

§`inner: VecOwnImpl<E>`

§`col_capacity: usize`

§`__marker: PhantomData<E>`

## Implementations§

§### impl<E> Row<E>where
E: Entity,

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

#### pub fn with_capacity(col_capacity: usize) -> Row<E>

#### pub fn with_capacity(col_capacity: usize) -> Row<E>

Returns a new column vector with 0 columns, with enough capacity to hold a maximum of
`col_capacity`

columns without reallocating. If `col_capacity`

is `0`

,
the function will not allocate.

##### §Panics

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

.

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

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

Returns a new matrix with number of columns `ncols`

, filled with the provided function.

##### §Panics

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

.

#### pub fn zeros(ncols: usize) -> Row<E>

#### pub fn zeros(ncols: usize) -> Row<E>

Returns a new matrix with number of columns `ncols`

, filled with zeros.

##### §Panics

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

.

#### pub fn ones(ncols: usize) -> Row<E>where
E: ComplexField,

#### pub fn ones(ncols: usize) -> Row<E>where
E: ComplexField,

Returns a new matrix with number of columns `ncols`

, filled with ones.

##### §Panics

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

.

#### pub fn full(ncols: usize, constant: E) -> Row<E>where
E: ComplexField,

#### pub fn full(ncols: usize, constant: E) -> Row<E>where
E: ComplexField,

Returns a new matrix with number of columns `ncols`

, filled with a constant value.

##### §Panics

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

.

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

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

Set the dimensions of the matrix.

##### §Safety

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

`ncols < self.col_capacity()`

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

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

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

Returns a pointer to the data of the matrix.

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

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

Returns a mutable pointer to the data of the matrix.

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

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

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

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

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

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

since the matrix is column major.

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

#### pub fn ptr_at_mut( &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(
&mut self,
col: usize,
) -> <<E as Entity>::Group as ForType>::FaerOf<*mut <E as Entity>::Unit>

#### pub unsafe fn ptr_inbounds_at_mut( &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<'_, E>, RowRef<'_, E>)

#### pub unsafe fn split_at_unchecked( &self, col: usize, ) -> (RowRef<'_, E>, RowRef<'_, 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(
&mut self,
col: usize,
) -> (RowMut<'_, E>, RowMut<'_, E>)

#### pub unsafe fn split_at_mut_unchecked( &mut self, col: usize, ) -> (RowMut<'_, E>, RowMut<'_, 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(&self, col: usize) -> (RowRef<'_, E>, RowRef<'_, E>)

#### pub unsafe fn split_at(&self, col: usize) -> (RowRef<'_, E>, RowRef<'_, 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(&mut self, col: usize) -> (RowMut<'_, E>, RowMut<'_, E>)

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

- top.
- bottom.

##### §Panics

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

`col <= self.ncols()`

.

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

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

Reserves the minimum capacity for `col_capacity`

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

##### §Panics

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

.

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

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

Resizes the vector in-place so that the new number of columns is `new_ncols`

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

, so that elements at index `i`

are created by calling `f(i)`

.

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

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

Truncates the matrix so that its new number of columns is `new_ncols`

.

The new dimension must be smaller than the current dimension of the vector.

##### §Panics

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

.

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

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

Returns a reference to a slice over the row.

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

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

Returns a mutable reference to a slice over the row.

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

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

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

.

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

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

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

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

.

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

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

#### pub unsafe fn try_as_uninit_slice_mut( &mut self, ) -> Option<<<E as Entity>::Group as ForType>::FaerOf<&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 unsafe fn as_uninit_slice_mut(
&mut self,
) -> <<E as Entity>::Group as ForType>::FaerOf<&mut [MaybeUninit<<E as Entity>::Unit>]>

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

Returns a mutable reference to a potentially uninitialized slice over the column.

##### §Safety

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

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

#### pub unsafe fn subcols_unchecked( &self, col_start: usize, ncols: usize, ) -> RowRef<'_, 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<'_, E>

#### pub fn subcols(&self, col_start: usize, ncols: usize) -> RowRef<'_, 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(
&mut self,
col_start: usize,
ncols: usize,
) -> RowMut<'_, E>

#### pub unsafe fn subcols_mut_unchecked( &mut self, col_start: usize, ncols: usize, ) -> RowMut<'_, 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(&mut self, col_start: usize, ncols: usize) -> RowMut<'_, E>

#### pub fn subcols_mut(&mut self, col_start: usize, ncols: usize) -> RowMut<'_, 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 unsafe fn get_unchecked<ColRange>(
&self,
col: ColRange,
) -> <RowRef<'_, E> as RowIndex<ColRange>>::Target

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

Returns references to the element at the given index, or submatrices 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<ColRange>(
&self,
col: ColRange,
) -> <RowRef<'_, E> as RowIndex<ColRange>>::Target

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

Returns references to the element at the given index, or submatrices 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 get_mut_unchecked<ColRange>(
&mut self,
col: ColRange,
) -> <RowMut<'_, E> as RowIndex<ColRange>>::Target

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

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

is a range.

##### §Note

##### §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>(
&mut self,
col: ColRange,
) -> <RowMut<'_, E> as RowIndex<ColRange>>::Target

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

Returns mutable references to the element at the given index, or submatrices 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`

.

#### 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(&mut self) -> ColMut<'_, E>

#### pub fn transpose_mut(&mut self) -> ColMut<'_, E>

Returns a view over the transpose of `self`

.

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

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

Returns a view over the conjugate of `self`

.

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

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

Returns a view over the conjugate of `self`

.

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

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

Returns a view over the conjugate transpose of `self`

.

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

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

Returns a view over the conjugate transpose of `self`

.

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

#### pub fn canonicalize(&self) -> (RowRef<'_, <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(
&mut self,
) -> (RowMut<'_, <E as Conjugate>::Canonical>, Conj)where
E: Conjugate,

#### pub fn canonicalize_mut(
&mut self,
) -> (RowMut<'_, <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<'_, E>

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

Returns a view over the `self`

, with the columns in reversed order.

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

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

Returns a view over the `self`

, with the columns in reversed order.

#### 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 split_first(
&self,
) -> Option<(<<E as Entity>::Group as ForType>::FaerOf<&<E as Entity>::Unit>, RowRef<'_, E>)>

#### pub fn split_first( &self, ) -> Option<(<<E as Entity>::Group as ForType>::FaerOf<&<E as Entity>::Unit>, RowRef<'_, 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<&<E as Entity>::Unit>, RowRef<'_, E>)>

#### pub fn split_last( &self, ) -> Option<(<<E as Entity>::Group as ForType>::FaerOf<&<E as Entity>::Unit>, RowRef<'_, 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(
&mut self,
) -> Option<(<<E as Entity>::Group as ForType>::FaerOf<&mut <E as Entity>::Unit>, RowMut<'_, E>)>

#### pub fn split_first_mut( &mut self, ) -> Option<(<<E as Entity>::Group as ForType>::FaerOf<&mut <E as Entity>::Unit>, RowMut<'_, 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(
&mut self,
) -> Option<(<<E as Entity>::Group as ForType>::FaerOf<&mut <E as Entity>::Unit>, RowMut<'_, E>)>

#### pub fn split_last_mut( &mut self, ) -> Option<(<<E as Entity>::Group as ForType>::FaerOf<&mut <E as Entity>::Unit>, RowMut<'_, 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<'_, E>

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

Returns an iterator over the elements of the row.

#### pub fn iter_mut(&mut self) -> ElemIterMut<'_, E>

#### pub fn iter_mut(&mut self) -> ElemIterMut<'_, E>

Returns an iterator over the elements of the row.

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

#### pub fn chunks(&self, chunk_size: usize) -> RowElemChunks<'_, 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<'_, E>

#### pub fn partition(&self, count: usize) -> RowElemPartition<'_, 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

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

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

#### pub fn par_partition(&self, count: usize) -> impl IndexedParallelIterator

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(&mut self, chunk_size: usize) -> RowElemChunksMut<'_, E>

#### pub fn chunks_mut(&mut self, chunk_size: usize) -> RowElemChunksMut<'_, 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(&mut self, count: usize) -> RowElemPartitionMut<'_, E>

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

Returns an iterator that provides exactly `count`

successive chunks of the elements of this
row.

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

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

`chunk_size`

elements.

Only available with the `rayon`

feature.

#### pub fn par_partition_mut(
&mut self,
count: usize,
) -> impl IndexedParallelIterator

#### pub fn par_partition_mut( &mut self, count: usize, ) -> impl IndexedParallelIterator

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 Row<LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

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

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

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

### impl<LhsE, RhsE> AddAssign<RowRef<'_, RhsE>> for Row<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<E> AsRowMut<E> for Row<E>where
E: Entity,

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

### impl<E> AsRowRef<E> for Row<E>where
E: Entity,

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

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

§### impl<E> Distribution<Row<E>> for NormalRow<E>

### impl<E> Distribution<Row<E>> for NormalRow<E>

§### impl<E> Distribution<Row<E>> for StandardNormalRow

### impl<E> Distribution<Row<E>> for StandardNormalRow

§### impl<E> Distribution<Row<E>> for StandardRow

### impl<E> Distribution<Row<E>> for StandardRow

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

### impl<LhsE, RhsE> DivAssign<Scale<RhsE>> for Row<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 Row<LhsE>where
LhsE: ComplexField,

### impl<LhsE> DivAssign<f32> for Row<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 Row<LhsE>where
LhsE: ComplexField,

### impl<LhsE> DivAssign<f64> for Row<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 Row<E>where
E: SimpleEntity,

### impl<E> Index<usize> for Row<E>where
E: SimpleEntity,

§### impl<E> IndexMut<usize> for Row<E>where
E: SimpleEntity,

### impl<E> IndexMut<usize> for Row<E>where
E: SimpleEntity,

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

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

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

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

`*=`

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

### impl<LhsE> MulAssign<f32> for Row<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 Row<LhsE>where
LhsE: ComplexField,

### impl<LhsE> MulAssign<f64> for Row<LhsE>where
LhsE: ComplexField,

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

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

`*=`

operation. Read more§### impl<E> RowBatch<E> for Row<E>where
E: Conjugate,

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

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

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

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

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

### impl<LhsE, RhsE> SubAssign<RowRef<'_, RhsE>> for Row<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<E> RowBatchMut<E> for Row<E>where
E: Conjugate,

## Auto Trait Implementations§

### impl<E> Freeze for Row<E>

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

### impl<E> Send for Row<E>

### impl<E> Sync for Row<E>

### impl<E> Unpin for Row<E>

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

## Blanket Implementations§

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

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

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

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

source§### impl<T> CloneToUninit for Twhere
T: Clone,

### impl<T> CloneToUninit for Twhere
T: Clone,

source§#### unsafe fn clone_to_uninit(&self, dst: *mut T)

#### unsafe fn clone_to_uninit(&self, dst: *mut T)

`clone_to_uninit`

)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