# Struct extendr_api::prelude::modules::core::Col

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

## Expand description

Heap allocated resizable column vector.

## §Note

The memory layout of `Col`

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

.

## Fields§

§`inner: VecOwnImpl<E>`

§`row_capacity: usize`

§`__marker: PhantomData<E>`

## Implementations§

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

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

#### pub fn with_capacity(row_capacity: usize) -> Col<E>

#### pub fn with_capacity(row_capacity: usize) -> Col<E>

Returns a new column vector with 0 rows, with enough capacity to hold a maximum of
`row_capacity`

rows columns without reallocating. If `row_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(nrows: usize, f: impl FnMut(usize) -> E) -> Col<E>

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

Returns a new matrix with number of rows `nrows`

, filled with the provided function.

##### §Panics

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

.

#### pub fn zeros(nrows: usize) -> Col<E>

#### pub fn zeros(nrows: usize) -> Col<E>

Returns a new matrix with number of rows `nrows`

, filled with zeros.

##### §Panics

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

.

#### pub fn ones(nrows: usize) -> Col<E>where
E: ComplexField,

#### pub fn ones(nrows: usize) -> Col<E>where
E: ComplexField,

Returns a new matrix with number of rows `nrows`

, filled with ones.

##### §Panics

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

.

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

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

Returns a new matrix with number of rows `nrows`

, filled with a constant value.

##### §Panics

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

.

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

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

Set the dimensions of the matrix.

##### §Safety

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

`nrows < self.row_capacity()`

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

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

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

Returns a pointer to the data of the matrix.

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

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

Returns a mutable pointer to the data of the matrix.

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

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

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

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

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

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

since the matrix is column major.

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

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

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

#### pub unsafe fn ptr_inbounds_at( &self, row: 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:

`row < self.nrows()`

.

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

#### pub unsafe fn ptr_inbounds_at_mut( &mut self, row: 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:

`row < self.nrows()`

.

#### pub unsafe fn split_at_unchecked(
&self,
row: usize,
) -> (ColRef<'_, E>, ColRef<'_, E>)

#### pub unsafe fn split_at_unchecked( &self, row: usize, ) -> (ColRef<'_, E>, ColRef<'_, 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.

##### §Safety

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

`row <= self.nrows()`

.

#### pub unsafe fn split_at_mut_unchecked(
&mut self,
row: usize,
) -> (ColMut<'_, E>, ColMut<'_, E>)

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

##### §Safety

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

`row <= self.nrows()`

.

#### pub fn split_at(&self, row: usize) -> (ColRef<'_, E>, ColRef<'_, E>)

#### pub fn split_at(&self, row: usize) -> (ColRef<'_, E>, ColRef<'_, 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:

`row <= self.nrows()`

.

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

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

- top.
- bottom.

##### §Panics

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

`row <= self.nrows()`

.

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

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

Reserves the minimum capacity for `row_capacity`

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

##### §Panics

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

.

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

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

Resizes the vector in-place so that the new number of rows is `new_nrows`

.
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_nrows: usize)

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

Truncates the matrix so that its new number of rows is `new_nrows`

.

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

##### §Panics

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

.

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

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

#### 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 get_unchecked<RowRange>(
&self,
row: RowRange,
) -> <ColRef<'_, E> as ColIndex<RowRange>>::Target

#### pub unsafe fn get_unchecked<RowRange>( &self, row: RowRange, ) -> <ColRef<'_, E> as ColIndex<RowRange>>::Target

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

`row`

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

.

#### pub fn get<RowRange>(
&self,
row: RowRange,
) -> <ColRef<'_, E> as ColIndex<RowRange>>::Target

#### pub fn get<RowRange>( &self, row: RowRange, ) -> <ColRef<'_, E> as ColIndex<RowRange>>::Target

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

is a range,
with bound checks.

##### §Note

The values pointed to by the references are expected to be initialized, even if the pointed-to value is not read, otherwise the behavior is undefined.

##### §Panics

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

`row`

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

.

#### pub unsafe fn get_mut_unchecked<RowRange>(
&mut self,
row: RowRange,
) -> <ColMut<'_, E> as ColIndex<RowRange>>::Target

#### pub unsafe fn get_mut_unchecked<RowRange>( &mut self, row: RowRange, ) -> <ColMut<'_, E> as ColIndex<RowRange>>::Target

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

`row`

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

.

#### pub fn get_mut<RowRange>(
&mut self,
row: RowRange,
) -> <ColMut<'_, E> as ColIndex<RowRange>>::Target

#### pub fn get_mut<RowRange>( &mut self, row: RowRange, ) -> <ColMut<'_, E> as ColIndex<RowRange>>::Target

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

is a range, with bound checks.

##### §Note

##### §Panics

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

`row`

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

.

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

#### pub unsafe fn read_unchecked(&self, row: 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:

`row < self.nrows()`

.

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

#### pub fn read(&self, row: 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:

`row < self.nrows()`

.

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

#### pub unsafe fn write_unchecked(&mut self, row: 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:

`row < self.nrows()`

.

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

#### pub fn write(&mut self, row: 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:

`row < self.nrows()`

.

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

#### pub fn copy_from<ViewE>(&mut self, other: impl AsColRef<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) -> RowMut<'_, E>

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

Returns a view over the transpose of `self`

.

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

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

Returns a view over the conjugate of `self`

.

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

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

Returns a view over the conjugate of `self`

.

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

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

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

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

Returns a view over the conjugate transpose of `self`

.

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

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

Returns a view over the conjugate transpose of `self`

.

#### pub fn reverse_rows(&self) -> ColRef<'_, E>

#### pub fn reverse_rows(&self) -> ColRef<'_, E>

Returns a view over the `self`

, with the rows in reversed order.

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

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

Returns a view over the `self`

, with the rows in reversed order.

#### pub unsafe fn subrows_unchecked(
&self,
row_start: usize,
nrows: usize,
) -> ColRef<'_, E>

#### pub unsafe fn subrows_unchecked( &self, row_start: usize, nrows: usize, ) -> ColRef<'_, E>

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

, and with number of rows
`nrows`

.

##### §Safety

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

`row_start <= self.nrows()`

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

.

#### pub unsafe fn subrows_mut_unchecked(
&mut self,
row_start: usize,
nrows: usize,
) -> ColMut<'_, E>

#### pub unsafe fn subrows_mut_unchecked( &mut self, row_start: usize, nrows: usize, ) -> ColMut<'_, E>

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

, and with number of rows
`nrows`

.

##### §Safety

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

`row_start <= self.nrows()`

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

.

#### pub fn subrows(&self, row_start: usize, nrows: usize) -> ColRef<'_, E>

#### pub fn subrows(&self, row_start: usize, nrows: usize) -> ColRef<'_, E>

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

, and with number of rows
`nrows`

.

##### §Panics

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

`row_start <= self.nrows()`

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

.

#### pub fn subrows_mut(&mut self, row_start: usize, nrows: usize) -> ColMut<'_, E>

#### pub fn subrows_mut(&mut self, row_start: usize, nrows: usize) -> ColMut<'_, E>

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

, and with number of rows
`nrows`

.

##### §Panics

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

`row_start <= self.nrows()`

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

.

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

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

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

#### pub fn column_vector_as_diagonal_mut(&mut self) -> DiagMut<'_, E>

#### pub fn column_vector_as_diagonal_mut(&mut self) -> DiagMut<'_, E>

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

#### pub fn column_vector_into_diagonal(self) -> Diag<E>

#### pub fn column_vector_into_diagonal(self) -> Diag<E>

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

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

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

Returns an owning `Col`

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 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 column as a contiguous slice if its row stride is equal to `1`

.

##### §Note

#### 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 column as a contiguous slice if its row stride is equal to `1`

.

##### §Note

#### 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 column as a contiguous potentially uninitialized slice if its row stride is
equal to `1`

.

##### §Safety

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

#### 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>, ColRef<'_, E>)>

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

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

.

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

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

Returns a reference to the last element and a view over the remaining ones if the column 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>, ColMut<'_, E>)>

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

Returns a reference to the first element and a view over the remaining ones if the column 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>, ColMut<'_, E>)>

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

Returns a reference to the last element and a view over the remaining ones if the column 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 column.

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

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

Returns an iterator over the elements of the column.

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

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

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

elements.

#### pub fn partition(&self, count: usize) -> ColElemPartition<'_, E>

#### pub fn partition(&self, count: usize) -> ColElemPartition<'_, E>

Returns an iterator that provides exactly `count`

successive chunks of the elements of this
column.

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

Only available with the `rayon`

feature.

#### pub fn chunks_mut(&mut self, chunk_size: usize) -> ColElemChunksMut<'_, E>

#### pub fn chunks_mut(&mut self, chunk_size: usize) -> ColElemChunksMut<'_, E>

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

elements.

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

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

Returns an iterator that provides exactly `count`

successive chunks of the elements of this
column.

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

Only available with the `rayon`

feature.

## Trait Implementations§

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

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

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

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

`+=`

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

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

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

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

`+=`

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

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

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

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

`+=`

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

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

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

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

`+=`

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

### impl<LhsE, RhsE> AddAssign<Col<RhsE>> for Col<LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

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

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

`+=`

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

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

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

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

`+=`

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

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

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

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

`+=`

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

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

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

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

`+=`

operation. Read more§### impl<E> AsColMut<E> for Col<E>where
E: Entity,

### impl<E> AsColMut<E> for Col<E>where
E: Entity,

§#### fn as_col_mut(&mut self) -> ColMut<'_, E>

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

§### impl<E> AsColRef<E> for Col<E>where
E: Entity,

### impl<E> AsColRef<E> for Col<E>where
E: Entity,

§#### fn as_col_ref(&self) -> ColRef<'_, E>

#### fn as_col_ref(&self) -> ColRef<'_, E>

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

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

§### impl<E> Distribution<Col<E>> for NormalCol<E>

### impl<E> Distribution<Col<E>> for NormalCol<E>

§### impl<E> Distribution<Col<E>> for StandardCol

### impl<E> Distribution<Col<E>> for StandardCol

§### impl<E> Distribution<Col<E>> for StandardNormalCol

### impl<E> Distribution<Col<E>> for StandardNormalCol

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

§### impl<I, E, LhsE, RhsE> Mul<Col<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<Col<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<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 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<Col<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<Col<RhsE>> for SparseRowMat<I, LhsE>where
I: Index,
E: ComplexField,
LhsE: Conjugate<Canonical = E>,
RhsE: Conjugate<Canonical = E>,
<E as Conjugate>::Canonical: ComplexField,

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

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

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

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

### impl<I, E, LhsE, RhsE> Mul<Col<RhsE>> for SparseRowMatRef<'_, I, 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 Col<LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

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

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

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

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

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

`*=`

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

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

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

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

`-=`

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

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

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

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

`-=`

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

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

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

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

`-=`

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

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

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

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

`-=`

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

### impl<LhsE, RhsE> SubAssign<Col<RhsE>> for Col<LhsE>where
LhsE: ComplexField,
RhsE: Conjugate<Canonical = LhsE>,

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

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

`-=`

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

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

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

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

`-=`

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

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

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

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

`-=`

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

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

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

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

`-=`

operation. Read more### impl<E> ColBatchMut<E> for Col<E>where
E: Conjugate,

## Auto Trait Implementations§

### impl<E> Freeze for Col<E>

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

### impl<E> Send for Col<E>

### impl<E> Sync for Col<E>

### impl<E> Unpin for Col<E>

### impl<E> UnwindSafe for Col<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