Struct Row

#[repr(C)]
pub struct Row<E>
where
    E: Entity,
{ /* private fields */ }

Heap allocated resizable row vector.

Note

The memory layout of Col is guaranteed to be row-major, meaning that it has a column stride of 1.

Implementations

impl<E> Row<E>

where E: Entity,

pub fn new() -> Row<E>

Returns an empty row of dimension 0.

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

Returns a new column vector with 0 columns, with enough capacity to hold a maximum of col_capacity columns without reallocating. If col_capacity is 0, the function will not allocate.

Panics

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

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

Returns a new matrix with number of columns ncols, filled with the provided function.

Panics

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

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

Returns a new matrix with number of columns ncols, filled with zeros.

Panics

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

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

where E: ComplexField,

Returns a new matrix with number of columns ncols, filled with ones.

Panics

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

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

where E: ComplexField,

Returns a new matrix with number of columns ncols, filled with a constant value.

Panics

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

pub fn nrows(&self) -> usize

Returns the number of rows of the row. This is always equal to 1.

pub fn ncols(&self) -> usize

Returns the number of columns of the row.

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

Set the dimensions of the matrix.

Safety

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

• ncols < self.col_capacity().
• The elements that were previously out of bounds but are now in bounds must be initialized.

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

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>

Returns a mutable pointer to the data of the matrix.

pub fn col_capacity(&self) -> usize

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

pub fn col_stride(&self) -> isize

Returns the offset between the first elements of two successive columns in the matrix. Always returns 1 since the matrix is column major.

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

Returns self as a matrix view.

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

Returns self as a mutable matrix view.

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

Returns raw pointers to the element at the given index.

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

Returns raw pointers to the element at the given index.

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

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

Safety

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

• col < self.ncols().

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

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

Safety

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

• col < self.ncols().

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

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

• left.
• right.

Safety

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

• col <= self.ncols().

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

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

• left.
• right.

Safety

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

• col <= self.ncols().

pub unsafe fn split_at(&self, col: usize) -> (RowRef<'_, E>, RowRef<'_, E>)

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

• top.
• bottom.

Panics

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

• col <= self.ncols().

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

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

• top.
• bottom.

Panics

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

• col <= self.ncols().

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

Reserves the minimum capacity for col_capacity columns without reallocating. Does nothing if the capacity is already sufficient.

Panics

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

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

Resizes the vector in-place so that the new number of columns is new_ncols. New elements are created with the given function f, so that elements at index i are created by calling f(i).

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

Truncates the matrix so that its new number of columns is new_ncols.
The new dimension must be smaller than the current dimension of the vector.

Panics

• Panics if new_ncols > self.ncols().

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

Returns a reference to a slice over the row.

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

Returns a mutable reference to a slice over the row.

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

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

Note

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

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

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

Note

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

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

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

Safety

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

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

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

Safety

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

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

Returns a view over the subvector starting at column col_start, and with number of columns ncols.

Safety

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

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

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

Returns a view over the subvector starting at col col_start, and with number of cols ncols.

Panics

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

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

pub unsafe fn subcols_mut_unchecked( &mut self, col_start: usize, ncols: usize, ) -> RowMut<'_, E>

Returns a view over the subvector starting at col col_start, and with number of columns ncols.

Safety

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

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

pub fn subcols_mut(&mut self, col_start: usize, ncols: usize) -> RowMut<'_, E>

Returns a view over the subvector starting at col col_start, and with number of columns ncols.

Safety

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

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

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

Returns a view over the vector.

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

Returns a mutable view over the vector.

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

where RowRef<'a, E>: for<'a> RowIndex<ColRange>,

Returns references to the element at the given index, or submatrices if col is a range.

Note

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

Safety

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

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

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

where RowRef<'a, E>: for<'a> RowIndex<ColRange>,

Returns references to the element at the given index, or submatrices if col is a range, with bound checks.

Note

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

Panics

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

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

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

where RowMut<'a, E>: for<'a> RowIndex<ColRange>,

Returns mutable references to the element at the given index, or submatrices if col is a range.

Note

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

Safety

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

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

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

where RowMut<'a, E>: for<'a> RowIndex<ColRange>,

Returns mutable references to the element at the given index, or submatrices if col is a range, with bound checks.

Note

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

Panics

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

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

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

Reads the value of the element at the given index.

Safety

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

• col < self.ncols().

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

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

Panics

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

• col < self.ncols().

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

Writes the value to the element at the given index.

Safety

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

• col < self.ncols().

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

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

Panics

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

• col < self.ncols().

pub fn copy_from<ViewE>(&mut self, other: impl AsRowRef<ViewE>)

where ViewE: Conjugate<Canonical = E>,

Copies the values from other into self.

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

Returns a view over the transpose of self.

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

Returns a view over the transpose of self.

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

where E: Conjugate,

Returns a view over the conjugate of self.

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

where E: Conjugate,

Returns a view over the conjugate of self.

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

where E: Conjugate,

Returns a view over the conjugate transpose of self.

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

where E: Conjugate,

Returns a view over the conjugate transpose of self.

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

where E: Conjugate,

Returns a view over the canonical representation of self, as well as a flag declaring whether self is implicitly conjugated or not.

pub fn canonicalize_mut( &mut self, ) -> (RowMut<'_, <E as Conjugate>::Canonical>, Conj)

where E: Conjugate,

Returns a view over the canonical representation of self, as well as a flag declaring whether self is implicitly conjugated or not.

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

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

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

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

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

where E: Conjugate,

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

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

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

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

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

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

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

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

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

Returns an iterator over the elements of the row.

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

Returns an iterator over the elements of the row.

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

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

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

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

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

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

Only available with the rayon feature.

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

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

Only available with the rayon feature.

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

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

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

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

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

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

Only available with the rayon feature.

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

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

Only available with the rayon feature.

Trait Implementations

impl<E, LhsE, RhsE> Add<&Row<RhsE>> for &Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

type Output = Row<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

type Output = Row<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E, LhsE, RhsE> Add<&Row<RhsE>> for Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

type Output = Row<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

type Output = Row<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

type Output = Row<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

type Output = Row<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

type Output = Row<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

type Output = Row<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E, LhsE, RhsE> Add<Row<RhsE>> for &Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

type Output = Row<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

type Output = Row<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E, LhsE, RhsE> Add<Row<RhsE>> for Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E, LhsE, RhsE> Add<Row<RhsE>> for RowMut<'_, LhsE>

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

type Output = Row<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E, LhsE, RhsE> Add<Row<RhsE>> for RowRef<'_, LhsE>

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

type Output = Row<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

type Output = Row<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E, LhsE, RhsE> Add<RowMut<'_, RhsE>> for Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

type Output = Row<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E, LhsE, RhsE> Add<RowRef<'_, RhsE>> for Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<LhsE, RhsE> AddAssign<&Row<RhsE>> for Row<LhsE>

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

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

Performs the += operation.

impl<LhsE, RhsE> AddAssign<&Row<RhsE>> for RowMut<'_, LhsE>

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

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

Performs the += operation.

impl<LhsE, RhsE> AddAssign<&RowMut<'_, RhsE>> for Row<LhsE>

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

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

Performs the += operation.

impl<LhsE, RhsE> AddAssign<&RowRef<'_, RhsE>> for Row<LhsE>

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

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

Performs the += operation.

impl<LhsE, RhsE> AddAssign<Row<RhsE>> for Row<LhsE>

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

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

Performs the += operation.

impl<LhsE, RhsE> AddAssign<Row<RhsE>> for RowMut<'_, LhsE>

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

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

Performs the += operation.

impl<LhsE, RhsE> AddAssign<RowMut<'_, RhsE>> for Row<LhsE>

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

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

Performs the += operation.

impl<LhsE, RhsE> AddAssign<RowRef<'_, RhsE>> for Row<LhsE>

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

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

Performs the += operation.

impl<E> As2D<E> for Row<E>

where E: Entity,

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

Convert to a 2D matrix view.

impl<E> As2DMut<E> for Row<E>

where E: Entity,

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

Convert to a mutable 2D matrix view.

impl<E> AsRowMut<E> for Row<E>

where E: Entity,

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

Convert to a mutable row view.

impl<E> AsRowRef<E> for Row<E>

where E: Entity,

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

Convert to a row view.

impl<E> Clone for Row<E>

where E: Entity,

fn clone(&self) -> Row<E>

Returns a copy of the value.

fn clone_from(&mut self, other: &Row<E>)

Performs copy-assignment from source.

impl<E> Debug for Row<E>

where E: Entity,

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

Formats the value using the given formatter.

impl<E> Default for Row<E>

where E: Entity,

fn default() -> Row<E>

Returns the “default value” for a type.

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

where E: ComplexField, StandardNormal: Distribution<E>,

fn sample<R>(&self, rng: &mut R) -> Row<E>

where R: Rng + ?Sized,

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

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

where E: ComplexField, StandardNormal: Distribution<E>,

fn sample<R>(&self, rng: &mut R) -> Row<E>

where R: Rng + ?Sized,

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

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

where E: ComplexField, Standard: Distribution<E>,

fn sample<R>(&self, rng: &mut R) -> Row<E>

where R: Rng + ?Sized,

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl<E, LhsE, RhsE> Div<Scale<RhsE>> for &Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<E, LhsE, RhsE> Div<Scale<RhsE>> for Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<E, RhsE> Div<f32> for &Row<RhsE>

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

type Output = Row<E>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<E, RhsE> Div<f32> for Row<RhsE>

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

type Output = Row<E>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<E, RhsE> Div<f64> for &Row<RhsE>

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

type Output = Row<E>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<E, RhsE> Div<f64> for Row<RhsE>

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

type Output = Row<E>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<LhsE, RhsE> DivAssign<Scale<RhsE>> for Row<LhsE>

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

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

Performs the /= operation.

impl<LhsE> DivAssign<f32> for Row<LhsE>

where LhsE: ComplexField,

fn div_assign(&mut self, other: f32)

Performs the /= operation.

impl<LhsE> DivAssign<f64> for Row<LhsE>

where LhsE: ComplexField,

fn div_assign(&mut self, other: f64)

Performs the /= operation.

impl<E> Drop for Row<E>

where E: Entity,

fn drop(&mut self)

Executes the destructor for this type.

impl<E> Index<usize> for Row<E>

where E: SimpleEntity,

type Output = E

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<E> IndexMut<usize> for Row<E>

where E: SimpleEntity,

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

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

impl<E, LhsE, RhsE> Mul<&Col<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: &Col<RhsE>) -> <&Row<LhsE> as Mul<&Col<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&Col<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: &Col<RhsE>) -> <Row<LhsE> as Mul<&Col<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 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<&ColRef<'_, 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: &ColRef<'_, RhsE>, ) -> <&Row<LhsE> as Mul<&ColRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&ColRef<'_, 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: &ColRef<'_, RhsE>, ) -> <Row<LhsE> as Mul<&ColRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&Diag<RhsE>> for &Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&Diag<RhsE>> for Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for &Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E> Mul<&Perm<I>> for &Row<E>

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E> Mul<&Perm<I>> for Row<E>

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&Row<RhsE>> for &Col<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>) -> <&Col<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<&Row<RhsE>> for &ColRef<'_, 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>, ) -> <&ColRef<'_, LhsE> as Mul<&Row<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&Row<RhsE>> for Col<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>) -> <Col<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<&Row<RhsE>> for ColRef<'_, 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>) -> <ColRef<'_, LhsE> as Mul<&Row<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<&Row<RhsE>> for Scale<LhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<&SparseColMat<I, RhsE>> for &Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<&SparseColMat<I, RhsE>> for Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<&SparseRowMat<I, RhsE>> for &Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<&SparseRowMat<I, RhsE>> for Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Col<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: Col<RhsE>) -> <&Row<LhsE> as Mul<Col<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Col<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: Col<RhsE>) -> <Row<LhsE> as Mul<Col<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 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<ColRef<'_, 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: ColRef<'_, RhsE>, ) -> <&Row<LhsE> as Mul<ColRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<ColRef<'_, 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: ColRef<'_, RhsE>, ) -> <Row<LhsE> as Mul<ColRef<'_, RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Diag<RhsE>> for &Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Diag<RhsE>> for Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for &Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E> Mul<Perm<I>> for &Row<E>

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E> Mul<Perm<I>> for Row<E>

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Row<RhsE>> for &Col<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>) -> <&Col<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<Row<RhsE>> for &ColRef<'_, 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>) -> <&ColRef<'_, LhsE> as Mul<Row<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Row<RhsE>> for Col<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>) -> <Col<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<Row<RhsE>> for ColRef<'_, 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>) -> <ColRef<'_, LhsE> as Mul<Row<RhsE>>>::Output

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Row<RhsE>> for Scale<LhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Scale<RhsE>> for &Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, LhsE, RhsE> Mul<Scale<RhsE>> for Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<SparseColMat<I, RhsE>> for &Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<SparseColMat<I, RhsE>> for Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<SparseRowMat<I, RhsE>> for &Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, E, LhsE, RhsE> Mul<SparseRowMat<I, RhsE>> for Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, RhsE> Mul<f32> for &Row<RhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, RhsE> Mul<f32> for Row<RhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, RhsE> Mul<f64> for &Row<RhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, RhsE> Mul<f64> for Row<RhsE>

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<LhsE, RhsE> MulAssign<Scale<RhsE>> for Row<LhsE>

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

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

Performs the *= operation.

impl<LhsE> MulAssign<f32> for Row<LhsE>

where LhsE: ComplexField,

fn mul_assign(&mut self, other: f32)

Performs the *= operation.

impl<LhsE> MulAssign<f64> for Row<LhsE>

where LhsE: ComplexField,

fn mul_assign(&mut self, other: f64)

Performs the *= operation.

impl<E> Neg for &Row<E>

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

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

The resulting type after applying the - operator.

fn neg(self) -> <&Row<E> as Neg>::Output

Performs the unary - operation.

impl<E> Neg for Row<E>

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

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

The resulting type after applying the - operator.

fn neg(self) -> <Row<E> as Neg>::Output

Performs the unary - operation.

impl<LhsE, RhsE> PartialEq<Row<RhsE>> for Row<LhsE>

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

fn eq(&self, other: &Row<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<Row<RhsE>> for RowMut<'_, LhsE>

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

fn eq(&self, other: &Row<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<Row<RhsE>> for RowRef<'_, LhsE>

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

fn eq(&self, other: &Row<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<RowMut<'_, RhsE>> for Row<LhsE>

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

fn eq(&self, other: &RowMut<'_, 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<RowRef<'_, RhsE>> for Row<LhsE>

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

fn eq(&self, other: &RowRef<'_, 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<E> RowBatch<E> for Row<E>

where E: Conjugate,

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

Corresponding owning type.

fn new_owned_zeros(nrows: usize, ncols: usize) -> <Row<E> as RowBatch<E>>::Owned

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

fn new_owned_copied(src: &Row<E>) -> <Row<E> as RowBatch<E>>::Owned

Constructor of the owned type that copies the values.

fn resize_owned( owned: &mut <Row<E> as RowBatch<E>>::Owned, nrows: usize, ncols: usize, )

Resize an owned column or matrix.

impl<E, LhsE, RhsE> Sub<&Row<RhsE>> for &Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

type Output = Row<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

type Output = Row<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E, LhsE, RhsE> Sub<&Row<RhsE>> for Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

type Output = Row<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

type Output = Row<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

type Output = Row<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

type Output = Row<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

type Output = Row<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

type Output = Row<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E, LhsE, RhsE> Sub<Row<RhsE>> for &Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

type Output = Row<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

type Output = Row<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E, LhsE, RhsE> Sub<Row<RhsE>> for Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E, LhsE, RhsE> Sub<Row<RhsE>> for RowMut<'_, LhsE>

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

type Output = Row<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E, LhsE, RhsE> Sub<Row<RhsE>> for RowRef<'_, LhsE>

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

type Output = Row<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

type Output = Row<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E, LhsE, RhsE> Sub<RowMut<'_, RhsE>> for Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

type Output = Row<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E, LhsE, RhsE> Sub<RowRef<'_, RhsE>> for Row<LhsE>

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

type Output = Row<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<LhsE, RhsE> SubAssign<&Row<RhsE>> for Row<LhsE>

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

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

Performs the -= operation.

impl<LhsE, RhsE> SubAssign<&Row<RhsE>> for RowMut<'_, LhsE>

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

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

Performs the -= operation.

impl<LhsE, RhsE> SubAssign<&RowMut<'_, RhsE>> for Row<LhsE>

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

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

Performs the -= operation.

impl<LhsE, RhsE> SubAssign<&RowRef<'_, RhsE>> for Row<LhsE>

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

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

Performs the -= operation.

impl<LhsE, RhsE> SubAssign<Row<RhsE>> for Row<LhsE>

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

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

Performs the -= operation.

impl<LhsE, RhsE> SubAssign<Row<RhsE>> for RowMut<'_, LhsE>

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

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

Performs the -= operation.

impl<LhsE, RhsE> SubAssign<RowMut<'_, RhsE>> for Row<LhsE>

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

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

Performs the -= operation.

impl<LhsE, RhsE> SubAssign<RowRef<'_, RhsE>> for Row<LhsE>

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

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

Performs the -= operation.

impl<E> ViewMut for &Row<E>

where E: Entity,

type Target<'a> = RowRef<'a, E> where &Row<E>: 'a

View type.

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

Returns the view over self.

impl<E> ViewMut for &mut Row<E>

where E: Entity,

type Target<'a> = RowMut<'a, E> where &mut Row<E>: 'a

View type.

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

Returns the view over self.

impl<E> ViewMut for Row<E>

where E: Entity,

type Target<'a> = RowRef<'a, E> where Row<E>: 'a

View type.

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

Returns the view over self.

impl<E> RowBatchMut<E> for Row<E>

where E: Conjugate,