Struct extendr_api::prelude::sparse::SparseColMatRef

source · 
pub struct SparseColMatRef<'a, I, E>
where
    I: Index,
    E: Entity,
{ /* private fields */ }
Expand description

Sparse matrix view in column-major format, either compressed or uncompressed.

Implementations§

source§

impl<'a, I, E> SparseColMatRef<'a, I, E>
where I: Index, E: Entity,

source

pub fn new( symbolic: SymbolicSparseColMatRef<'a, I>, values: <<E as Entity>::Group as ForType>::FaerOf<&'a [<E as Entity>::Unit]>, ) -> SparseColMatRef<'a, I, E>

Creates a new sparse matrix view.

§Panics

Panics if the length of values is not equal to the length of symbolic.row_indices().

source

pub fn nrows(&self) -> usize

Returns the number of rows of the matrix.

source

pub fn ncols(&self) -> usize

Returns the number of columns of the matrix.

source

pub fn shape(&self) -> (usize, usize)

Returns the number of rows and columns of the matrix.

source

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

Returns a view over self.

source

pub fn to_owned( &self, ) -> Result<SparseColMat<I, <E as Conjugate>::Canonical>, FaerError>
where E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

Copies self into a newly allocated matrix.

§Note

Allows unsorted matrices, producing an unsorted output.

source

pub fn to_sorted( &self, ) -> Result<SparseColMat<I, <E as Conjugate>::Canonical>, FaerError>
where E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

Copies self into a newly allocated matrix with sorted indices.

§Note

Allows unsorted matrices, producing a sorted output.

source

pub fn to_dense(&self) -> Mat<<E as Conjugate>::Canonical>
where E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

Copies self into a newly allocated dense matrix

source

pub fn to_row_major( &self, ) -> Result<SparseRowMat<I, <E as Conjugate>::Canonical>, FaerError>
where E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

Copies self into a newly allocated matrix, with row-major order.

§Note

Allows unsorted matrices, producing a sorted output.

source

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

Returns a view over the transpose of self in row-major format.

source

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

Returns a view over the conjugate of self.

source

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

Returns a view over the canonical view of self, along with whether it has been conjugated or not.

source

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

Returns a view over the conjugate transpose of self.

source

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

Returns the numerical values of the matrix.

source

pub fn values_of_col( self, j: usize, ) -> <<E as Entity>::Group as ForType>::FaerOf<&'a [<E as Entity>::Unit]>

Returns the numerical values of column j of the matrix.

§Panics:

Panics if j >= ncols.

source

pub fn symbolic(&self) -> SymbolicSparseColMatRef<'a, I>

Returns the symbolic structure of the matrix.

source

pub fn parts( self, ) -> (SymbolicSparseColMatRef<'a, I>, <<E as Entity>::Group as ForType>::FaerOf<&'a [<E as Entity>::Unit]>)

Decomposes the matrix into the symbolic part and the numerical values.

source

pub fn compute_nnz(&self) -> usize

Returns the number of symbolic non-zeros in the matrix.

The value is guaranteed to be less than I::Signed::MAX.

§Note

Allows unsorted matrices, but the output is a count of all the entries, including the duplicate ones.

source

pub fn col_ptrs(&self) -> &'a [I]

Returns the column pointers.

source

pub fn nnz_per_col(&self) -> Option<&'a [I]>

Returns the count of non-zeros per column of the matrix.

source

pub fn row_indices(&self) -> &'a [I]

Returns the row indices.

source

pub fn row_indices_of_col_raw(&self, j: usize) -> &'a [I]

Returns the row indices of column j.

§Panics

Panics if j >= self.ncols().

source

pub fn row_indices_of_col( &self, j: usize, ) -> impl ExactSizeIterator + DoubleEndedIterator + 'a

Returns the row indices of column j.

§Panics

Panics if j >= self.ncols().

source

pub fn col_range(&self, j: usize) -> Range<usize>

Returns the range that the column j occupies in self.row_indices().

§Panics

Panics if j >= self.ncols().

source

pub unsafe fn col_range_unchecked(&self, j: usize) -> Range<usize>

Returns the range that the column j occupies in self.row_indices().

§Safety

The behavior is undefined if j >= self.ncols().

source

pub fn get( self, row: usize, col: usize, ) -> Option<<<E as Entity>::Group as ForType>::FaerOf<&'a <E as Entity>::Unit>>

Returns a reference to the value at the given index, or None if the symbolic structure doesn’t contain it, or contains multiple indices with the given index.

§Panics

Panics if row >= self.nrows().
Panics if col >= self.ncols().

source

pub fn get_all( self, row: usize, col: usize, ) -> <<E as Entity>::Group as ForType>::FaerOf<&'a [<E as Entity>::Unit]>

Returns a reference to a slice containing the values at the given index using a binary search.

§Panics

Panics if row >= self.nrows().
Panics if col >= self.ncols().

source§

impl<I, E> SparseColMatRef<'_, I, E>
where I: Index, E: ComplexField,

source

pub fn sp_solve_lower_triangular_in_place(&self, rhs: impl ColBatchMut<E>)

Assuming self is a lower triangular matrix, solves the equation self * X = rhs, and stores the result in rhs.

§Note

The matrix indices need not be sorted, but the diagonal element is assumed to be the first stored element in each column.

source

pub fn sp_solve_upper_triangular_in_place(&self, rhs: impl ColBatchMut<E>)

Assuming self is an upper triangular matrix, solves the equation self * X = rhs, and stores the result in rhs.

§Note

The matrix indices need not be sorted, but the diagonal element is assumed to be the last stored element in each column.

source

pub fn sp_solve_unit_lower_triangular_in_place(&self, rhs: impl ColBatchMut<E>)

Assuming self is a unit lower triangular matrix, solves the equation self * X = rhs, and stores the result in rhs.

§Note

The matrix indices need not be sorted, but the diagonal element is assumed to be the first stored element in each column.

source

pub fn sp_solve_unit_upper_triangular_in_place(&self, rhs: impl ColBatchMut<E>)

Assuming self is a unit upper triangular matrix, solves the equation self * X = rhs, and stores the result in rhs.

§Note

The matrix indices need not be sorted, but the diagonal element is assumed to be the last stored element in each column.

source

pub fn sp_cholesky(&self, side: Side) -> Result<Cholesky<I, E>, CholeskyError>

Returns the Cholesky decomposition of self. Only the provided side is accessed.

source

pub fn sp_lu(&self) -> Result<Lu<I, E>, LuError>

Returns the LU decomposition of self with partial (row) pivoting.

source

pub fn sp_qr(&self) -> Result<Qr<I, E>, FaerError>

Returns the QR decomposition of self.

Trait Implementations§

source§

impl<I, E, LhsE, RhsE> Add<&SparseColMat<I, RhsE>> for &SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<I, E, LhsE, RhsE> Add<&SparseColMat<I, RhsE>> for SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<I, E, LhsE, RhsE> Add<&SparseColMatMut<'_, I, RhsE>> for &SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<I, E, LhsE, RhsE> Add<&SparseColMatMut<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<I, E, LhsE, RhsE> Add<&SparseColMatRef<'_, I, RhsE>> for &SparseColMat<I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<I, E, LhsE, RhsE> Add<&SparseColMatRef<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<I, E, LhsE, RhsE> Add<&SparseColMatRef<'_, I, RhsE>> for &SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<I, E, LhsE, RhsE> Add<&SparseColMatRef<'_, I, RhsE>> for SparseColMat<I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<I, E, LhsE, RhsE> Add<&SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<I, E, LhsE, RhsE> Add<&SparseColMatRef<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<I, E, LhsE, RhsE> Add<SparseColMat<I, RhsE>> for &SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<I, E, LhsE, RhsE> Add<SparseColMat<I, RhsE>> for SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<I, E, LhsE, RhsE> Add<SparseColMatMut<'_, I, RhsE>> for &SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<I, E, LhsE, RhsE> Add<SparseColMatMut<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<I, E, LhsE, RhsE> Add<SparseColMatRef<'_, I, RhsE>> for &SparseColMat<I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<I, E, LhsE, RhsE> Add<SparseColMatRef<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<I, E, LhsE, RhsE> Add<SparseColMatRef<'_, I, RhsE>> for &SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<I, E, LhsE, RhsE> Add<SparseColMatRef<'_, I, RhsE>> for SparseColMat<I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<I, E, LhsE, RhsE> Add<SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<I, E, LhsE, RhsE> Add<SparseColMatRef<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.
source§

fn add( self, rhs: SparseColMatRef<'_, I, RhsE>, ) -> <SparseColMatRef<'_, I, LhsE> as Add<SparseColMatRef<'_, I, RhsE>>>::Output

Performs the + operation. Read more
source§

impl<I, LhsE, RhsE> AddAssign<&SparseColMatRef<'_, I, RhsE>> for SparseColMat<I, LhsE>
where I: Index, LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

source§

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

Performs the += operation. Read more
source§

impl<I, LhsE, RhsE> AddAssign<&SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>
where I: Index, LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

source§

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

Performs the += operation. Read more
source§

impl<I, LhsE, RhsE> AddAssign<SparseColMatRef<'_, I, RhsE>> for SparseColMat<I, LhsE>
where I: Index, LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

source§

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

Performs the += operation. Read more
source§

impl<I, LhsE, RhsE> AddAssign<SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>
where I: Index, LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

source§

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

Performs the += operation. Read more
source§

impl<I, E> Clone for SparseColMatRef<'_, I, E>
where I: Index, E: Entity,

source§

fn clone(&self) -> SparseColMatRef<'_, I, E>

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl<I, E> Debug for SparseColMatRef<'_, I, E>
where I: Index, E: Entity,

source§

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

Formats the value using the given formatter. Read more
source§

impl<I, E> Index<(usize, usize)> for SparseColMatRef<'_, I, E>
where I: Index, E: SimpleEntity,

§

type Output = E

The returned type after indexing.
source§

fn index( &self, _: (usize, usize), ) -> &<SparseColMatRef<'_, I, E> as Index<(usize, usize)>>::Output

Performs the indexing (container[index]) operation. Read more
source§

impl<'a, I, E> IntoConst for SparseColMatRef<'a, I, E>
where I: Index, E: Entity,

§

type Target = SparseColMatRef<'a, I, E>

source§

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

source§

impl<I, E> Matrix<E> for SparseColMatRef<'_, I, E>
where I: Index, E: Entity,

source§

fn rows(&self) -> usize

source§

fn cols(&self) -> usize

source§

fn access(&self) -> Access<'_, E>

Expose dense or sparse access to the matrix.
source§

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

§

type Output = Col<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Col<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

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

Performs the * operation. Read more
source§

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

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&ColRef<'_, 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.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&ColRef<'_, 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.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&Mat<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 = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&Mat<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 = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, 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 = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&MatMut<'_, 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 = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&MatRef<'_, 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 = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&MatRef<'_, 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 = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&SparseColMat<I, 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 = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&SparseColMat<I, 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 = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&SparseColMatMut<'_, I, 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 = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&SparseColMatMut<'_, I, 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 = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

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

Performs the * operation. Read more
source§

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

§

type Output = Row<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&SparseColMatRef<'_, I, RhsE>> for &RowRef<'_, 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.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&SparseColMatRef<'_, I, 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 = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&SparseColMatRef<'_, I, 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 = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&SparseColMatRef<'_, I, 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 = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

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

Performs the * operation. Read more
source§

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

§

type Output = Row<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&SparseColMatRef<'_, I, RhsE>> for RowRef<'_, 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.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&SparseColMatRef<'_, I, RhsE>> for Scale<LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&SparseColMatRef<'_, I, 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 = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&SparseColMatRef<'_, I, 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 = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<&SparseColMatRef<'_, I, 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 = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Col<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Col<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

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

Performs the * operation. Read more
source§

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

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<ColRef<'_, 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.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<ColRef<'_, RhsE>> for SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Col<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<Mat<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 = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<Mat<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 = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<MatMut<'_, 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 = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<MatMut<'_, 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 = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<MatRef<'_, 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 = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<MatRef<'_, RhsE>> for SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<Scale<RhsE>> for &SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<Scale<RhsE>> for SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<SparseColMat<I, 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 = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<SparseColMat<I, 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 = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<SparseColMatMut<'_, I, 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 = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<SparseColMatMut<'_, I, 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 = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

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

Performs the * operation. Read more
source§

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

§

type Output = Row<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<SparseColMatRef<'_, I, RhsE>> for &RowRef<'_, 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.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<SparseColMatRef<'_, I, 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 = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<SparseColMatRef<'_, I, 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 = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<SparseColMatRef<'_, I, 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 = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<SparseColMatRef<'_, I, RhsE>> for MatRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

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

Performs the * operation. Read more
source§

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

§

type Output = Row<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<SparseColMatRef<'_, I, RhsE>> for RowRef<'_, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Row<E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<SparseColMatRef<'_, I, RhsE>> for Scale<LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<SparseColMatRef<'_, I, 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 = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<SparseColMatRef<'_, I, 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 = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E, LhsE, RhsE> Mul<SparseColMatRef<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl<I, E> Neg for &SparseColMatRef<'_, I, E>
where I: Index, E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

§

type Output = SparseColMat<I, <E as Conjugate>::Canonical>

The resulting type after applying the - operator.
source§

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

Performs the unary - operation. Read more
source§

impl<I, E> Neg for SparseColMatRef<'_, I, E>
where I: Index, E: Conjugate, <E as Conjugate>::Canonical: ComplexField,

§

type Output = SparseColMat<I, <E as Conjugate>::Canonical>

The resulting type after applying the - operator.
source§

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

Performs the unary - operation. Read more
source§

impl<I, LhsE, RhsE> PartialEq<SparseColMat<I, RhsE>> for SparseColMatRef<'_, I, LhsE>
where I: Index, LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

source§

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

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<I, LhsE, RhsE> PartialEq<SparseColMatMut<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>
where I: Index, LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

source§

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

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<I, LhsE, RhsE> PartialEq<SparseColMatRef<'_, I, RhsE>> for SparseColMat<I, LhsE>
where I: Index, LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

source§

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

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<I, LhsE, RhsE> PartialEq<SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>
where I: Index, LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

source§

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

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<I, LhsE, RhsE> PartialEq<SparseColMatRef<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>
where I: Index, LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

source§

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

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'short, I, E> Reborrow<'short> for SparseColMatRef<'_, I, E>
where I: Index, E: Entity,

§

type Target = SparseColMatRef<'short, I, E>

source§

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

source§

impl<'short, I, E> ReborrowMut<'short> for SparseColMatRef<'_, I, E>
where I: Index, E: Entity,

§

type Target = SparseColMatRef<'short, I, E>

source§

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

source§

impl<I, E> SparseAccess<E> for SparseColMatRef<'_, I, E>
where I: Index, E: Entity,

source§

fn nnz(&self) -> usize

Number of non-zero elements in the matrix.
source§

fn fetch_triplets(&self) -> Vec<(usize, usize, E)>

Retrieve the triplets that identify the coefficients of the sparse matrix.
source§

impl<I, E, LhsE, RhsE> Sub<&SparseColMat<I, RhsE>> for &SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

impl<I, E, LhsE, RhsE> Sub<&SparseColMat<I, RhsE>> for SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

impl<I, E, LhsE, RhsE> Sub<&SparseColMatMut<'_, I, RhsE>> for &SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

impl<I, E, LhsE, RhsE> Sub<&SparseColMatMut<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

impl<I, E, LhsE, RhsE> Sub<&SparseColMatRef<'_, I, RhsE>> for &SparseColMat<I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

impl<I, E, LhsE, RhsE> Sub<&SparseColMatRef<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

impl<I, E, LhsE, RhsE> Sub<&SparseColMatRef<'_, I, RhsE>> for &SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

impl<I, E, LhsE, RhsE> Sub<&SparseColMatRef<'_, I, RhsE>> for SparseColMat<I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

impl<I, E, LhsE, RhsE> Sub<&SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

impl<I, E, LhsE, RhsE> Sub<&SparseColMatRef<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

impl<I, E, LhsE, RhsE> Sub<SparseColMat<I, RhsE>> for &SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

impl<I, E, LhsE, RhsE> Sub<SparseColMat<I, RhsE>> for SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

impl<I, E, LhsE, RhsE> Sub<SparseColMatMut<'_, I, RhsE>> for &SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

impl<I, E, LhsE, RhsE> Sub<SparseColMatMut<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

impl<I, E, LhsE, RhsE> Sub<SparseColMatRef<'_, I, RhsE>> for &SparseColMat<I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

impl<I, E, LhsE, RhsE> Sub<SparseColMatRef<'_, I, RhsE>> for &SparseColMatMut<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

impl<I, E, LhsE, RhsE> Sub<SparseColMatRef<'_, I, RhsE>> for &SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

impl<I, E, LhsE, RhsE> Sub<SparseColMatRef<'_, I, RhsE>> for SparseColMat<I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

impl<I, E, LhsE, RhsE> Sub<SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

impl<I, E, LhsE, RhsE> Sub<SparseColMatRef<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>
where I: Index, E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.
source§

fn sub( self, rhs: SparseColMatRef<'_, I, RhsE>, ) -> <SparseColMatRef<'_, I, LhsE> as Sub<SparseColMatRef<'_, I, RhsE>>>::Output

Performs the - operation. Read more
source§

impl<I, LhsE, RhsE> SubAssign<&SparseColMatRef<'_, I, RhsE>> for SparseColMat<I, LhsE>
where I: Index, LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

source§

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

Performs the -= operation. Read more
source§

impl<I, LhsE, RhsE> SubAssign<&SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>
where I: Index, LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

source§

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

Performs the -= operation. Read more
source§

impl<I, LhsE, RhsE> SubAssign<SparseColMatRef<'_, I, RhsE>> for SparseColMat<I, LhsE>
where I: Index, LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

source§

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

Performs the -= operation. Read more
source§

impl<I, LhsE, RhsE> SubAssign<SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>
where I: Index, LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

source§

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

Performs the -= operation. Read more
source§

impl<I, E> Copy for SparseColMatRef<'_, I, E>
where I: Index, E: Entity,

Auto Trait Implementations§

§

impl<'a, I, E> Freeze for SparseColMatRef<'a, I, E>
where <<E as Entity>::Group as ForCopyType>::FaerOfCopy<*const [<E as Entity>::Unit]>: Freeze,

§

impl<'a, I, E> RefUnwindSafe for SparseColMatRef<'a, I, E>
where <<E as Entity>::Group as ForCopyType>::FaerOfCopy<*const [<E as Entity>::Unit]>: RefUnwindSafe, I: RefUnwindSafe,

§

impl<'a, I, E> Send for SparseColMatRef<'a, I, E>

§

impl<'a, I, E> Sync for SparseColMatRef<'a, I, E>

§

impl<'a, I, E> Unpin for SparseColMatRef<'a, I, E>
where <<E as Entity>::Group as ForCopyType>::FaerOfCopy<*const [<E as Entity>::Unit]>: Unpin,

§

impl<'a, I, E> UnwindSafe for SparseColMatRef<'a, I, E>
where <<E as Entity>::Group as ForCopyType>::FaerOfCopy<*const [<E as Entity>::Unit]>: UnwindSafe, I: RefUnwindSafe,

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

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

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where T: Clone,

source§

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

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> CloneToUninit for T
where T: Copy,

source§

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

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> IntoEither for T

source§

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

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

impl<T> Pointable for T

source§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T> Boilerplate for T
where T: Copy + Send + Sync + Debug + PartialEq + 'static,

source§

impl<T> UniversalReborrow for T
where T: for<'a> Reborrow<'a>,

source§

impl<T> UniversalReborrowMut for T
where T: for<'a> ReborrowMut<'a>,