Struct extendr_api::prelude::modules::core::ColMut

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

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

Note

Unlike a slice, the data pointed to by ColMut<'_, 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 ColMut::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> ColMut<'a, E>

where E: Entity,

pub fn nrows(&self) -> usize

Returns the number of rows of the column.

pub fn ncols(&self) -> usize

Returns the number of columns of the column. This is always equal to 1.

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>

Returns pointers to the matrix data.

pub fn row_stride(&self) -> isize

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

pub fn as_2d(self) -> MatRef<'a, E>

Returns self as a matrix view.

pub fn as_2d_mut(self) -> MatMut<'a, E>

Returns self as a mutable matrix view.

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

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( 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<'a, E>, ColRef<'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.

Safety

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

• row <= self.nrows().

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

Safety

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

• row <= self.nrows().

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

• row <= self.nrows().

pub fn split_at_mut(self, row: usize) -> (ColMut<'a, E>, ColMut<'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:

• row <= self.nrows().

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

where ColRef<'a, E>: ColIndex<RowRange>,

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:

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

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

where ColMut<'a, E>: ColIndex<RowRange>,

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:

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

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

where ColRef<'a, E>: ColIndex<RowRange>,

Returns references to the element at the given index, or subvector 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 fn get_mut<RowRange>( self, row: RowRange, ) -> <ColMut<'a, E> as ColIndex<RowRange>>::Target

where ColMut<'a, E>: ColIndex<RowRange>,

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

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)

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)

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

Copies the values from other into self.

Panics

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

• self.nrows() == other.nrows().
• self.ncols() == other.ncols().

pub fn fill_zero(&mut self)

where E: ComplexField,

Fills the elements of self with zeros.

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

Fills the elements of self with copies of constant.

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

Returns a view over the transpose of self.

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

Returns a view over the transpose of self.

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

where E: Conjugate,

Returns a view over the conjugate of self.

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

where E: Conjugate,

Returns a view over the conjugate of self.

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

where E: Conjugate,

Returns a view over the conjugate transpose of self.

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

where E: Conjugate,

Returns a view over the conjugate transpose of self.

pub fn canonicalize(self) -> (ColRef<'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) -> (ColMut<'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_rows(self) -> ColRef<'a, E>

Returns a view over the self, with the rows in reversed order.

pub fn reverse_rows_mut(self) -> ColMut<'a, 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<'a, 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( self, row_start: usize, nrows: usize, ) -> ColMut<'a, 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<'a, 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(self, row_start: usize, nrows: usize) -> ColMut<'a, 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<'a, 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(self) -> DiagMut<'a, 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,

Returns an owning Col of the data.

pub fn has_nan(&self) -> bool

where E: ComplexField,

Returns true if any of the elements is NaN, otherwise returns false.

pub fn is_all_finite(&self) -> bool

where E: ComplexField,

Returns true if all of the elements are finite, otherwise returns false.

pub fn norm_max(&self) -> <E as ComplexField>::Real

where E: ComplexField,

Returns the maximum norm of self.

pub fn norm_l1(&self) -> <E as ComplexField>::Real

where E: ComplexField,

Returns the L1 norm of self.

pub fn norm_l2(&self) -> <E as ComplexField>::Real

where E: ComplexField,

Returns the L2 norm of self.

pub fn squared_norm_l2(&self) -> <E as ComplexField>::Real

where E: ComplexField,

Returns the squared L2 norm of self.

pub fn sum(&self) -> E

where E: ComplexField,

Returns the sum of self.

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

Returns the column as a contiguous slice if its row 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( self, ) -> Option<<<E as Entity>::Group as ForType>::FaerOf<&'a mut [<E as Entity>::Unit]>>

Returns the column as a contiguous slice if its row 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( self, ) -> Option<<<E as Entity>::Group as ForType>::FaerOf<&'a 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 read at some later point.

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

Returns a view over the matrix.

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

Returns a mutable view over the matrix.

pub fn split_first( self, ) -> Option<(<<E as Entity>::Group as ForType>::FaerOf<&'a <E as Entity>::Unit>, ColRef<'a, 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<&'a <E as Entity>::Unit>, ColRef<'a, 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( self, ) -> Option<(<<E as Entity>::Group as ForType>::FaerOf<&'a mut <E as Entity>::Unit>, ColMut<'a, 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( self, ) -> Option<(<<E as Entity>::Group as ForType>::FaerOf<&'a mut <E as Entity>::Unit>, ColMut<'a, 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<'a, E>

Returns an iterator over the elements of the column.

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

Returns an iterator over the elements of the column.

pub fn chunks(self, chunk_size: usize) -> ColElemChunks<'a, 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<'a, 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 + 'a

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 + 'a

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(self, chunk_size: usize) -> ColElemChunksMut<'a, 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(self, count: usize) -> ColElemPartitionMut<'a, E>

Returns an iterator that provides exactly count successive chunks of the elements of this column.

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

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_mut( self, count: usize, ) -> impl IndexedParallelIterator + 'a

Returns an iterator that provides exactly count successive chunks of the elements of this column.

Only available with the rayon feature.

Trait Implementations

impl<E, LhsE, RhsE> Add<&Col<RhsE>> for &ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the + operator.

fn add( self, other: &Col<RhsE>, ) -> <&ColMut<'_, LhsE> as Add<&Col<RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<&Col<RhsE>> for ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the + operator.

fn add(self, other: &Col<RhsE>) -> <ColMut<'_, LhsE> as Add<&Col<RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<&ColMut<'_, RhsE>> for &Col<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the + operator.

fn add( self, other: &ColMut<'_, RhsE>, ) -> <&Col<LhsE> as Add<&ColMut<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<&ColMut<'_, RhsE>> for &ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E, LhsE, RhsE> Add<&ColMut<'_, RhsE>> for &ColRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the + operator.

fn add( self, other: &ColMut<'_, RhsE>, ) -> <&ColRef<'_, LhsE> as Add<&ColMut<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<&ColMut<'_, RhsE>> for Col<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the + operator.

fn add( self, other: &ColMut<'_, RhsE>, ) -> <Col<LhsE> as Add<&ColMut<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<&ColMut<'_, RhsE>> for ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E, LhsE, RhsE> Add<&ColMut<'_, RhsE>> for ColRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the + operator.

fn add( self, other: &ColMut<'_, RhsE>, ) -> <ColRef<'_, LhsE> as Add<&ColMut<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<&ColRef<'_, RhsE>> for &ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the + operator.

fn add( self, other: &ColRef<'_, RhsE>, ) -> <&ColMut<'_, LhsE> as Add<&ColRef<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<&ColRef<'_, RhsE>> for ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the + operator.

fn add( self, other: &ColRef<'_, RhsE>, ) -> <ColMut<'_, LhsE> as Add<&ColRef<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<Col<RhsE>> for &ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the + operator.

fn add(self, other: Col<RhsE>) -> <&ColMut<'_, LhsE> as Add<Col<RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<Col<RhsE>> for ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the + operator.

fn add(self, other: Col<RhsE>) -> <ColMut<'_, LhsE> as Add<Col<RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<ColMut<'_, RhsE>> for &Col<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the + operator.

fn add( self, other: ColMut<'_, RhsE>, ) -> <&Col<LhsE> as Add<ColMut<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<ColMut<'_, RhsE>> for &ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E, LhsE, RhsE> Add<ColMut<'_, RhsE>> for &ColRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the + operator.

fn add( self, other: ColMut<'_, RhsE>, ) -> <&ColRef<'_, LhsE> as Add<ColMut<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<ColMut<'_, RhsE>> for Col<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the + operator.

fn add( self, other: ColMut<'_, RhsE>, ) -> <Col<LhsE> as Add<ColMut<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<ColMut<'_, RhsE>> for ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E, LhsE, RhsE> Add<ColMut<'_, RhsE>> for ColRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the + operator.

fn add( self, other: ColMut<'_, RhsE>, ) -> <ColRef<'_, LhsE> as Add<ColMut<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<ColRef<'_, RhsE>> for &ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the + operator.

fn add( self, other: ColRef<'_, RhsE>, ) -> <&ColMut<'_, LhsE> as Add<ColRef<'_, RhsE>>>::Output

Performs the + operation.

impl<E, LhsE, RhsE> Add<ColRef<'_, RhsE>> for ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the + operator.

fn add( self, other: ColRef<'_, RhsE>, ) -> <ColMut<'_, LhsE> as Add<ColRef<'_, RhsE>>>::Output

Performs the + operation.

impl<LhsE, RhsE> AddAssign<&Col<RhsE>> for ColMut<'_, LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

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

Performs the += operation.

impl<LhsE, RhsE> AddAssign<&ColMut<'_, RhsE>> for Col<LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

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

Performs the += operation.

impl<LhsE, RhsE> AddAssign<&ColMut<'_, RhsE>> for ColMut<'_, LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

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

Performs the += operation.

impl<LhsE, RhsE> AddAssign<&ColRef<'_, RhsE>> for ColMut<'_, LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

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

Performs the += operation.

impl<LhsE, RhsE> AddAssign<Col<RhsE>> for ColMut<'_, LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

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

Performs the += operation.

impl<LhsE, RhsE> AddAssign<ColMut<'_, RhsE>> for Col<LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

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

Performs the += operation.

impl<LhsE, RhsE> AddAssign<ColMut<'_, RhsE>> for ColMut<'_, LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

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

Performs the += operation.

impl<LhsE, RhsE> AddAssign<ColRef<'_, RhsE>> for ColMut<'_, LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

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

Performs the += operation.

impl<E> As2D<E> for ColMut<'_, E>

where E: Entity,

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

Convert to a 2D matrix view.

impl<E> As2DMut<E> for ColMut<'_, E>

where E: Entity,

fn as_2d_mut(&mut self) -> MatMut<'_, E>

Convert to a mutable 2D matrix view.

impl<E> AsColMut<E> for ColMut<'_, E>

where E: Entity,

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

Convert to a mutable column view.

impl<E> AsColRef<E> for ColMut<'_, E>

where E: Entity,

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

Convert to a column view.

impl<'a, FromE, ToE> Coerce<ColMut<'a, ToE>> for ColMut<'a, FromE>

where FromE: Entity, ToE: Entity,

fn coerce(self) -> ColMut<'a, ToE>

impl<E> ColBatch<E> for ColMut<'_, E>

where E: Conjugate,

type Owned = Col<<E as Conjugate>::Canonical>

Corresponding owning type.

fn new_owned_zeros( nrows: usize, ncols: usize, ) -> <ColMut<'_, E> as ColBatch<E>>::Owned

Constructor of the owned type that initializes the values to zero.

fn new_owned_copied( src: &ColMut<'_, E>, ) -> <ColMut<'_, E> as ColBatch<E>>::Owned

Constructor of the owned type that copies the values.

fn resize_owned( owned: &mut <ColMut<'_, E> as ColBatch<E>>::Owned, nrows: usize, ncols: usize, )

Resize an owned column or matrix.

impl<E> ColIndex<Range<usize>> for ColMut<'_, E>

where E: Entity,

type Target = ColMut<'_, E>

Resulting type of the indexing operation.

fn get(this: ColMut<'_, E>, row: Range<usize>) -> ColMut<'_, E>

Index the column at row.

unsafe fn get_unchecked(this: Self, row: RowRange) -> Self::Target

Index the column at row, without bound checks.

impl<E> ColIndex<RangeFrom<usize>> for ColMut<'_, E>

where E: Entity,

type Target = ColMut<'_, E>

Resulting type of the indexing operation.

fn get(this: ColMut<'_, E>, row: RangeFrom<usize>) -> ColMut<'_, E>

Index the column at row.

unsafe fn get_unchecked(this: Self, row: RowRange) -> Self::Target

Index the column at row, without bound checks.

impl<E> ColIndex<RangeFull> for ColMut<'_, E>

where E: Entity,

type Target = ColMut<'_, E>

Resulting type of the indexing operation.

fn get(this: ColMut<'_, E>, row: RangeFull) -> ColMut<'_, E>

Index the column at row.

unsafe fn get_unchecked(this: Self, row: RowRange) -> Self::Target

Index the column at row, without bound checks.

impl<E> ColIndex<RangeInclusive<usize>> for ColMut<'_, E>

where E: Entity,

type Target = ColMut<'_, E>

Resulting type of the indexing operation.

fn get(this: ColMut<'_, E>, row: RangeInclusive<usize>) -> ColMut<'_, E>

Index the column at row.

unsafe fn get_unchecked(this: Self, row: RowRange) -> Self::Target

Index the column at row, without bound checks.

impl<E> ColIndex<RangeTo<usize>> for ColMut<'_, E>

where E: Entity,

type Target = ColMut<'_, E>

Resulting type of the indexing operation.

fn get(this: ColMut<'_, E>, row: RangeTo<usize>) -> ColMut<'_, E>

Index the column at row.

unsafe fn get_unchecked(this: Self, row: RowRange) -> Self::Target

Index the column at row, without bound checks.

impl<E> ColIndex<RangeToInclusive<usize>> for ColMut<'_, E>

where E: Entity,

type Target = ColMut<'_, E>

Resulting type of the indexing operation.

fn get(this: ColMut<'_, E>, row: RangeToInclusive<usize>) -> ColMut<'_, E>

Index the column at row.

unsafe fn get_unchecked(this: Self, row: RowRange) -> Self::Target

Index the column at row, without bound checks.

impl<'a, E> ColIndex<usize> for ColMut<'a, E>

where E: Entity,

type Target = <<E as Entity>::Group as ForType>::FaerOf<&'a mut <E as Entity>::Unit>

Resulting type of the indexing operation.

unsafe fn get_unchecked( this: ColMut<'a, E>, row: usize, ) -> <ColMut<'a, E> as ColIndex<usize>>::Target

Index the column at row, without bound checks.

fn get( this: ColMut<'a, E>, row: usize, ) -> <ColMut<'a, E> as ColIndex<usize>>::Target

Index the column at row.

impl<'a, E> Debug for ColMut<'a, E>

where E: Entity,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<E> Default for ColMut<'_, E>

where E: Entity,

fn default() -> ColMut<'_, E>

Returns the “default value” for a type.

impl<E, LhsE, RhsE> Div<Scale<RhsE>> for &ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the / operator.

fn div( self, other: Scale<RhsE>, ) -> <&ColMut<'_, LhsE> as Div<Scale<RhsE>>>::Output

Performs the / operation.

impl<E, LhsE, RhsE> Div<Scale<RhsE>> for ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the / operator.

fn div( self, other: Scale<RhsE>, ) -> <ColMut<'_, LhsE> as Div<Scale<RhsE>>>::Output

Performs the / operation.

impl<E, RhsE> Div<f32> for &ColMut<'_, RhsE>

where E: ComplexField, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the / operator.

fn div(self, other: f32) -> <&ColMut<'_, RhsE> as Div<f32>>::Output

Performs the / operation.

impl<E, RhsE> Div<f32> for ColMut<'_, RhsE>

where E: ComplexField, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the / operator.

fn div(self, other: f32) -> <ColMut<'_, RhsE> as Div<f32>>::Output

Performs the / operation.

impl<E, RhsE> Div<f64> for &ColMut<'_, RhsE>

where E: ComplexField, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the / operator.

fn div(self, other: f64) -> <&ColMut<'_, RhsE> as Div<f64>>::Output

Performs the / operation.

impl<E, RhsE> Div<f64> for ColMut<'_, RhsE>

where E: ComplexField, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the / operator.

fn div(self, other: f64) -> <ColMut<'_, RhsE> as Div<f64>>::Output

Performs the / operation.

impl<LhsE, RhsE> DivAssign<Scale<RhsE>> for ColMut<'_, LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

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

Performs the /= operation.

impl<LhsE> DivAssign<f32> for ColMut<'_, LhsE>

where LhsE: ComplexField,

fn div_assign(&mut self, other: f32)

Performs the /= operation.

impl<LhsE> DivAssign<f64> for ColMut<'_, LhsE>

where LhsE: ComplexField,

fn div_assign(&mut self, other: f64)

Performs the /= operation.

impl<E> Index<usize> for ColMut<'_, E>

where E: SimpleEntity,

type Output = E

The returned type after indexing.

fn index(&self, row: usize) -> &E

Performs the indexing (container[index]) operation.

impl<E> IndexMut<usize> for ColMut<'_, E>

where E: SimpleEntity,

fn index_mut(&mut self, row: usize) -> &mut E

Performs the mutable indexing (container[index]) operation.

impl<'a, E> IntoConst for ColMut<'a, E>

where E: Entity,

type Target = ColRef<'a, E>

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

impl<'a, E> MatIndex<'a> for ColMut<'_, E>

where E: Entity,

type Item = ReadWrite<'a, E>

Item produced by the zipped views.

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

Get the item at the given index, skipping bound checks.

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

Get the item at the given slice position, skipping bound checks.

fn is_contiguous(&self) -> bool

Checks if the zipped matrices are contiguous.

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

Computes the preferred iteration layout of the matrices.

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

Applies the layout transformation to the matrices.

impl<E> MatShape for ColMut<'_, E>

where E: Entity,

type Rows = usize

Type of rows.

type Cols = ()

Type of columns.

fn nrows(&self) -> <ColMut<'_, E> as MatShape>::Rows

Returns the number of rows.

fn ncols(&self) -> <ColMut<'_, E> as MatShape>::Cols

Returns the number of columns.

impl<E> MaybeContiguous for ColMut<'_, E>

where E: Entity,

type Index = (usize, ())

Indexing type.

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

Contiguous slice type.

type LayoutTransform = VecLayoutTransform

Layout transformation type.

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

Returns slice at index of length n_elems.

impl<I, E> Mul<&ColMut<'_, E>> for &Perm<I>

where I: Index, E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.

fn mul(self, other: &ColMut<'_, E>) -> <&Perm<I> as Mul<&ColMut<'_, E>>>::Output

Performs the * operation.

impl<I, E> Mul<&ColMut<'_, E>> for &PermRef<'_, I>

where I: Index, E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, E>, ) -> <&PermRef<'_, I> as Mul<&ColMut<'_, E>>>::Output

Performs the * operation.

impl<I, E> Mul<&ColMut<'_, E>> for Perm<I>

where I: Index, E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.

fn mul(self, other: &ColMut<'_, E>) -> <Perm<I> as Mul<&ColMut<'_, E>>>::Output

Performs the * operation.

impl<I, E> Mul<&ColMut<'_, E>> for PermRef<'_, I>

where I: Index, E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, E>, ) -> <PermRef<'_, I> as Mul<&ColMut<'_, E>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for &Diag<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, RhsE>, ) -> <&Diag<LhsE> as Mul<&ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for &DiagMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, RhsE>, ) -> <&DiagMut<'_, LhsE> as Mul<&ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Mul<&ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for &Mat<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, RhsE>, ) -> <&Mat<LhsE> as Mul<&ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for &MatMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, RhsE>, ) -> <&MatMut<'_, LhsE> as Mul<&ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for &MatRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, RhsE>, ) -> <&MatRef<'_, LhsE> as Mul<&ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for &Row<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = E

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, RhsE>, ) -> <&Row<LhsE> as Mul<&ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for &RowMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = E

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, RhsE>, ) -> <&RowMut<'_, LhsE> as Mul<&ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for &RowRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = E

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, RhsE>, ) -> <&RowRef<'_, LhsE> as Mul<&ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for &SparseColMat<I, LhsE>

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for &SparseColMatRef<'_, I, LhsE>

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for &SparseRowMat<I, LhsE>

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for &SparseRowMatMut<'_, I, LhsE>

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for &SparseRowMatRef<'_, I, LhsE>

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for Diag<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, RhsE>, ) -> <Diag<LhsE> as Mul<&ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for DiagMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, RhsE>, ) -> <DiagMut<'_, LhsE> as Mul<&ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Mul<&ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for Mat<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, RhsE>, ) -> <Mat<LhsE> as Mul<&ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for MatMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, RhsE>, ) -> <MatMut<'_, LhsE> as Mul<&ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for MatRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, RhsE>, ) -> <MatRef<'_, LhsE> as Mul<&ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for Row<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = E

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, RhsE>, ) -> <Row<LhsE> as Mul<&ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for RowMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = E

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, RhsE>, ) -> <RowMut<'_, LhsE> as Mul<&ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for RowRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = E

The resulting type after applying the * operator.

fn mul( self, other: &ColMut<'_, RhsE>, ) -> <RowRef<'_, LhsE> as Mul<&ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for Scale<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for SparseColMat<I, LhsE>

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for SparseColMatRef<'_, I, LhsE>

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for SparseRowMat<I, LhsE>

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for SparseRowMatMut<'_, I, LhsE>

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for SparseRowMatRef<'_, I, LhsE>

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&Row<RhsE>> for &ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: &Row<RhsE>, ) -> <&ColMut<'_, LhsE> as Mul<&Row<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&Row<RhsE>> for ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: &Row<RhsE>) -> <ColMut<'_, LhsE> as Mul<&Row<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&RowMut<'_, RhsE>> for &ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: &RowMut<'_, RhsE>, ) -> <&ColMut<'_, LhsE> as Mul<&RowMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&RowMut<'_, RhsE>> for ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: &RowMut<'_, RhsE>, ) -> <ColMut<'_, LhsE> as Mul<&RowMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&RowRef<'_, RhsE>> for &ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: &RowRef<'_, RhsE>, ) -> <&ColMut<'_, LhsE> as Mul<&RowRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&RowRef<'_, RhsE>> for ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: &RowRef<'_, RhsE>, ) -> <ColMut<'_, LhsE> as Mul<&RowRef<'_, RhsE>>>::Output

Performs the * operation.

impl<I, E> Mul<ColMut<'_, E>> for &Perm<I>

where I: Index, E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.

fn mul(self, other: ColMut<'_, E>) -> <&Perm<I> as Mul<ColMut<'_, E>>>::Output

Performs the * operation.

impl<I, E> Mul<ColMut<'_, E>> for &PermRef<'_, I>

where I: Index, E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, E>, ) -> <&PermRef<'_, I> as Mul<ColMut<'_, E>>>::Output

Performs the * operation.

impl<I, E> Mul<ColMut<'_, E>> for Perm<I>

where I: Index, E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.

fn mul(self, other: ColMut<'_, E>) -> <Perm<I> as Mul<ColMut<'_, E>>>::Output

Performs the * operation.

impl<I, E> Mul<ColMut<'_, E>> for PermRef<'_, I>

where I: Index, E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, E>, ) -> <PermRef<'_, I> as Mul<ColMut<'_, E>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for &Diag<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, RhsE>, ) -> <&Diag<LhsE> as Mul<ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for &DiagMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, RhsE>, ) -> <&DiagMut<'_, LhsE> as Mul<ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for &DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, RhsE>, ) -> <&DiagRef<'_, LhsE> as Mul<ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for &Mat<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, RhsE>, ) -> <&Mat<LhsE> as Mul<ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for &MatMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, RhsE>, ) -> <&MatMut<'_, LhsE> as Mul<ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for &MatRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, RhsE>, ) -> <&MatRef<'_, LhsE> as Mul<ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for &Row<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = E

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, RhsE>, ) -> <&Row<LhsE> as Mul<ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for &RowMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = E

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, RhsE>, ) -> <&RowMut<'_, LhsE> as Mul<ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for &RowRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = E

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, RhsE>, ) -> <&RowRef<'_, LhsE> as Mul<ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for &SparseColMat<I, LhsE>

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for &SparseColMatRef<'_, I, LhsE>

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for &SparseRowMat<I, LhsE>

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for &SparseRowMatMut<'_, I, LhsE>

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for &SparseRowMatRef<'_, I, LhsE>

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for Diag<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, RhsE>, ) -> <Diag<LhsE> as Mul<ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for DiagMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, RhsE>, ) -> <DiagMut<'_, LhsE> as Mul<ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for DiagRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, RhsE>, ) -> <DiagRef<'_, LhsE> as Mul<ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for Mat<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, RhsE>, ) -> <Mat<LhsE> as Mul<ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for MatMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, RhsE>, ) -> <MatMut<'_, LhsE> as Mul<ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for MatRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, RhsE>, ) -> <MatRef<'_, LhsE> as Mul<ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for Row<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = E

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, RhsE>, ) -> <Row<LhsE> as Mul<ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for RowMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = E

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, RhsE>, ) -> <RowMut<'_, LhsE> as Mul<ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for RowRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = E

The resulting type after applying the * operator.

fn mul( self, other: ColMut<'_, RhsE>, ) -> <RowRef<'_, LhsE> as Mul<ColMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for Scale<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for SparseColMat<I, LhsE>

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for SparseColMatRef<'_, I, LhsE>

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for SparseRowMat<I, LhsE>

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for SparseRowMatMut<'_, I, LhsE>

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for SparseRowMatRef<'_, I, LhsE>

where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Row<RhsE>> for &ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: Row<RhsE>) -> <&ColMut<'_, LhsE> as Mul<Row<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Row<RhsE>> for ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: Row<RhsE>) -> <ColMut<'_, LhsE> as Mul<Row<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<RowMut<'_, RhsE>> for &ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: RowMut<'_, RhsE>, ) -> <&ColMut<'_, LhsE> as Mul<RowMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<RowMut<'_, RhsE>> for ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: RowMut<'_, RhsE>, ) -> <ColMut<'_, LhsE> as Mul<RowMut<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<RowRef<'_, RhsE>> for &ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: RowRef<'_, RhsE>, ) -> <&ColMut<'_, LhsE> as Mul<RowRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<RowRef<'_, RhsE>> for ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul( self, other: RowRef<'_, RhsE>, ) -> <ColMut<'_, LhsE> as Mul<RowRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Scale<RhsE>> for &ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Scale<RhsE>> for ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, RhsE> Mul<f32> for &ColMut<'_, RhsE>

where E: ComplexField, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul(self, other: f32) -> <&ColMut<'_, RhsE> as Mul<f32>>::Output

Performs the * operation.

impl<E, RhsE> Mul<f32> for ColMut<'_, RhsE>

where E: ComplexField, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul(self, other: f32) -> <ColMut<'_, RhsE> as Mul<f32>>::Output

Performs the * operation.

impl<E, RhsE> Mul<f64> for &ColMut<'_, RhsE>

where E: ComplexField, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul(self, other: f64) -> <&ColMut<'_, RhsE> as Mul<f64>>::Output

Performs the * operation.

impl<E, RhsE> Mul<f64> for ColMut<'_, RhsE>

where E: ComplexField, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul(self, other: f64) -> <ColMut<'_, RhsE> as Mul<f64>>::Output

Performs the * operation.

impl<LhsE, RhsE> MulAssign<Scale<RhsE>> for ColMut<'_, LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

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

Performs the *= operation.

impl<LhsE> MulAssign<f32> for ColMut<'_, LhsE>

where LhsE: ComplexField,

fn mul_assign(&mut self, other: f32)

Performs the *= operation.

impl<LhsE> MulAssign<f64> for ColMut<'_, LhsE>

where LhsE: ComplexField,

fn mul_assign(&mut self, other: f64)

Performs the *= operation.

impl<E> Neg for &ColMut<'_, E>

where E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<<E as Conjugate>::Canonical>

The resulting type after applying the - operator.

fn neg(self) -> <&ColMut<'_, E> as Neg>::Output

Performs the unary - operation.

impl<E> Neg for ColMut<'_, E>

where E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

type Output = Col<<E as Conjugate>::Canonical>

The resulting type after applying the - operator.

fn neg(self) -> <ColMut<'_, E> as Neg>::Output

Performs the unary - operation.

impl<LhsE, RhsE> PartialEq<Col<RhsE>> for ColMut<'_, LhsE>

where LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

fn eq(&self, other: &Col<RhsE>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<LhsE, RhsE> PartialEq<ColMut<'_, RhsE>> for Col<LhsE>

where LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

fn eq(&self, other: &ColMut<'_, RhsE>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<LhsE, RhsE> PartialEq<ColMut<'_, RhsE>> for ColMut<'_, LhsE>

where LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

fn eq(&self, other: &ColMut<'_, RhsE>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<LhsE, RhsE> PartialEq<ColMut<'_, RhsE>> for ColRef<'_, LhsE>

where LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

fn eq(&self, other: &ColMut<'_, RhsE>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<LhsE, RhsE> PartialEq<ColRef<'_, RhsE>> for ColMut<'_, LhsE>

where LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

fn eq(&self, other: &ColRef<'_, RhsE>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'short, E> Reborrow<'short> for ColMut<'_, E>

where E: Entity,

type Target = ColRef<'short, E>

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

impl<'short, E> ReborrowMut<'short> for ColMut<'_, E>

where E: Entity,

type Target = ColMut<'short, E>

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

impl<E, LhsE, RhsE> Sub<&Col<RhsE>> for &ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the - operator.

fn sub( self, other: &Col<RhsE>, ) -> <&ColMut<'_, LhsE> as Sub<&Col<RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<&Col<RhsE>> for ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the - operator.

fn sub(self, other: &Col<RhsE>) -> <ColMut<'_, LhsE> as Sub<&Col<RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<&ColMut<'_, RhsE>> for &Col<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the - operator.

fn sub( self, other: &ColMut<'_, RhsE>, ) -> <&Col<LhsE> as Sub<&ColMut<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<&ColMut<'_, RhsE>> for &ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E, LhsE, RhsE> Sub<&ColMut<'_, RhsE>> for &ColRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the - operator.

fn sub( self, other: &ColMut<'_, RhsE>, ) -> <&ColRef<'_, LhsE> as Sub<&ColMut<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<&ColMut<'_, RhsE>> for Col<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the - operator.

fn sub( self, other: &ColMut<'_, RhsE>, ) -> <Col<LhsE> as Sub<&ColMut<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<&ColMut<'_, RhsE>> for ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E, LhsE, RhsE> Sub<&ColMut<'_, RhsE>> for ColRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the - operator.

fn sub( self, other: &ColMut<'_, RhsE>, ) -> <ColRef<'_, LhsE> as Sub<&ColMut<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<&ColRef<'_, RhsE>> for &ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the - operator.

fn sub( self, other: &ColRef<'_, RhsE>, ) -> <&ColMut<'_, LhsE> as Sub<&ColRef<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<&ColRef<'_, RhsE>> for ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the - operator.

fn sub( self, other: &ColRef<'_, RhsE>, ) -> <ColMut<'_, LhsE> as Sub<&ColRef<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<Col<RhsE>> for &ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the - operator.

fn sub(self, other: Col<RhsE>) -> <&ColMut<'_, LhsE> as Sub<Col<RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<Col<RhsE>> for ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the - operator.

fn sub(self, other: Col<RhsE>) -> <ColMut<'_, LhsE> as Sub<Col<RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<ColMut<'_, RhsE>> for &Col<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the - operator.

fn sub( self, other: ColMut<'_, RhsE>, ) -> <&Col<LhsE> as Sub<ColMut<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<ColMut<'_, RhsE>> for &ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E, LhsE, RhsE> Sub<ColMut<'_, RhsE>> for &ColRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the - operator.

fn sub( self, other: ColMut<'_, RhsE>, ) -> <&ColRef<'_, LhsE> as Sub<ColMut<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<ColMut<'_, RhsE>> for Col<LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the - operator.

fn sub( self, other: ColMut<'_, RhsE>, ) -> <Col<LhsE> as Sub<ColMut<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<ColMut<'_, RhsE>> for ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E, LhsE, RhsE> Sub<ColMut<'_, RhsE>> for ColRef<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the - operator.

fn sub( self, other: ColMut<'_, RhsE>, ) -> <ColRef<'_, LhsE> as Sub<ColMut<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<ColRef<'_, RhsE>> for &ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the - operator.

fn sub( self, other: ColRef<'_, RhsE>, ) -> <&ColMut<'_, LhsE> as Sub<ColRef<'_, RhsE>>>::Output

Performs the - operation.

impl<E, LhsE, RhsE> Sub<ColRef<'_, RhsE>> for ColMut<'_, LhsE>

where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

type Output = Col<E>

The resulting type after applying the - operator.

fn sub( self, other: ColRef<'_, RhsE>, ) -> <ColMut<'_, LhsE> as Sub<ColRef<'_, RhsE>>>::Output

Performs the - operation.

impl<LhsE, RhsE> SubAssign<&Col<RhsE>> for ColMut<'_, LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

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

Performs the -= operation.

impl<LhsE, RhsE> SubAssign<&ColMut<'_, RhsE>> for Col<LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

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

Performs the -= operation.

impl<LhsE, RhsE> SubAssign<&ColMut<'_, RhsE>> for ColMut<'_, LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

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

Performs the -= operation.

impl<LhsE, RhsE> SubAssign<&ColRef<'_, RhsE>> for ColMut<'_, LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

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

Performs the -= operation.

impl<LhsE, RhsE> SubAssign<Col<RhsE>> for ColMut<'_, LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

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

Performs the -= operation.

impl<LhsE, RhsE> SubAssign<ColMut<'_, RhsE>> for Col<LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

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

Performs the -= operation.

impl<LhsE, RhsE> SubAssign<ColMut<'_, RhsE>> for ColMut<'_, LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

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

Performs the -= operation.

impl<LhsE, RhsE> SubAssign<ColRef<'_, RhsE>> for ColMut<'_, LhsE>

where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

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

Performs the -= operation.

impl<E> ViewMut for &ColMut<'_, E>

where E: Entity,

type Target<'a> = ColRef<'a, E> where &ColMut<'_, E>: 'a

View type.

fn view_mut(&mut self) -> <&ColMut<'_, E> as ViewMut>::Target<'_>

Returns the view over self.

impl<E> ViewMut for &mut ColMut<'_, E>

where E: Entity,

type Target<'a> = ColMut<'a, E> where &mut ColMut<'_, E>: 'a

View type.

fn view_mut(&mut self) -> <&mut ColMut<'_, E> as ViewMut>::Target<'_>

Returns the view over self.

impl<E> ViewMut for ColMut<'_, E>

where E: Entity,

type Target<'a> = ColMut<'a, E> where ColMut<'_, E>: 'a

View type.

fn view_mut(&mut self) -> <ColMut<'_, E> as ViewMut>::Target<'_>

Returns the view over self.

impl<E> ColBatchMut<E> for ColMut<'_, E>

where E: Conjugate,