Struct SparseColMatRef

pub struct SparseColMatRef<'a, I: Index, E: Entity, R: Shape = usize, C: Shape = usize> { /* private fields */ }

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

Implementations

impl<'a, I: Index, E: Entity, R: Shape, C: Shape> SparseColMatRef<'a, I, E, R, C>

pub fn new( symbolic: SymbolicSparseColMatRef<'a, I, R, C>, values: Slice<'a, E>, ) -> Self

Creates a new sparse matrix view.

Panics

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

pub fn nrows(&self) -> R

Returns the number of rows of the matrix.

pub fn ncols(&self) -> C

Returns the number of columns of the matrix.

pub fn shape(&self) -> (R, C)

Returns the number of rows and columns of the matrix.

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

Returns a view over self.

pub fn to_owned(&self) -> Result<SparseColMat<I, E::Canonical, R, C>, FaerError>

where E: Conjugate<Canonical: ComplexField>,

Copies self into a newly allocated matrix.

Note

Allows unsorted matrices, producing an unsorted output.

pub fn to_sorted( &self, ) -> Result<SparseColMat<I, E::Canonical, R, C>, FaerError>

where E: Conjugate, E::Canonical: ComplexField,

Copies self into a newly allocated matrix with sorted indices.

Note

Allows unsorted matrices, producing a sorted output.

pub fn to_dense(&self) -> Mat<E::Canonical, R, C>

where E: Conjugate<Canonical: ComplexField>,

Copies self into a newly allocated dense matrix

pub fn to_row_major( &self, ) -> Result<SparseRowMat<I, E::Canonical, R, C>, FaerError>

where E: Conjugate, E::Canonical: ComplexField,

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

Note

Allows unsorted matrices, producing a sorted output.

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

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

pub fn conjugate(self) -> SparseColMatRef<'a, I, E::Conj, R, C>

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn canonicalize(self) -> (SparseColMatRef<'a, I, E::Canonical, R, C>, Conj)

where E: Conjugate,

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

pub fn adjoint(self) -> SparseRowMatRef<'a, I, E::Conj, C, R>

where E: Conjugate,

Returns a view over the conjugate transpose of self.

pub fn values(self) -> Slice<'a, E>

Returns the numerical values of the matrix.

pub fn values_of_col(self, j: Idx<C>) -> Slice<'a, E>

Returns the numerical values of column j of the matrix.

Panics:

Panics if j >= ncols.

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

Returns the symbolic structure of the matrix.

pub fn parts(self) -> (SymbolicSparseColMatRef<'a, I, R, C>, Slice<'a, E>)

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

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.

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

Returns the column pointers.

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

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

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

Returns the row indices.

pub fn row_indices_of_col_raw(&self, j: Idx<C>) -> &'a [Idx<R, I>]

Returns the row indices of column j.

Panics

Panics if j >= self.ncols().

pub fn row_indices_of_col( &self, j: Idx<C>, ) -> impl 'a + ExactSizeIterator + DoubleEndedIterator<Item = Idx<R>>

Returns the row indices of column j.

Panics

Panics if j >= self.ncols().

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

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

Panics

Panics if j >= self.ncols().

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

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

Safety

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

pub fn get(self, row: Idx<R>, col: Idx<C>) -> Option<Ref<'a, E>>

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

pub fn get_all(self, row: Idx<R>, col: Idx<C>) -> Slice<'a, E>

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

pub fn as_shape<V: Shape, H: Shape>( self, nrows: V, ncols: H, ) -> SparseColMatRef<'a, I, E, V, H>

Returns the input matrix with the given shape after checking that it matches the current shape.

pub fn as_dyn(self) -> SparseColMatRef<'a, I, E>

Returns the input matrix with dynamic shape.

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

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.

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.

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.

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.

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

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

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

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

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

Returns the QR decomposition of self.

Trait Implementations

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

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.

fn add(self, other: &SparseColMat<I, RhsE>) -> Self::Output

Performs the + operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.

fn add(self, other: &SparseColMat<I, RhsE>) -> Self::Output

Performs the + operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.

fn add(self, other: &SparseColMatMut<'_, I, RhsE>) -> Self::Output

Performs the + operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.

fn add(self, other: &SparseColMatMut<'_, I, RhsE>) -> Self::Output

Performs the + operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.

fn add(self, other: SparseColMat<I, RhsE>) -> Self::Output

Performs the + operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.

fn add(self, other: SparseColMat<I, RhsE>) -> Self::Output

Performs the + operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.

fn add(self, other: SparseColMatMut<'_, I, RhsE>) -> Self::Output

Performs the + operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.

fn add(self, other: SparseColMatMut<'_, I, RhsE>) -> Self::Output

Performs the + operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.

fn add(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the + operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.

fn add(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the + operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.

fn add(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the + operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.

fn add(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the + operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.

fn add(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the + operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

impl<E: ComplexField, I: Index, ViewE: Conjugate<Canonical = E>> BiLinOp<E> for SparseColMatRef<'_, I, ViewE>

Available on crate feature unstable only.

fn transpose_apply_req( &self, rhs_ncols: usize, parallelism: Parallelism<'_>, ) -> Result<StackReq, SizeOverflow>

Computes the workspace size and alignment required to apply the transpose or adjoint of self to a matrix with rhs_ncols columns.

fn transpose_apply( &self, out: MatMut<'_, E>, rhs: MatRef<'_, E>, parallelism: Parallelism<'_>, stack: &mut PodStack, )

Applies the transpose of self to rhs, and stores the result in out.

fn adjoint_apply( &self, out: MatMut<'_, E>, rhs: MatRef<'_, E>, parallelism: Parallelism<'_>, stack: &mut PodStack, )

Applies the adjoint of self to rhs, and stores the result in out.

impl<E: ComplexField, I: Index, ViewE: Conjugate<Canonical = E>> BiPrecond<E> for SparseColMatRef<'_, I, ViewE>

Available on crate feature unstable only.

fn transpose_apply_in_place_req( &self, rhs_ncols: usize, parallelism: Parallelism<'_>, ) -> Result<StackReq, SizeOverflow>

Computes the workspace size and alignment required to apply the transpose or adjoint of self to a matrix with rhs_ncols columns in place.

fn transpose_apply_in_place( &self, rhs: MatMut<'_, E>, parallelism: Parallelism<'_>, stack: &mut PodStack, )

Applies the transpose of self to rhs, and stores the result in rhs.

fn adjoint_apply_in_place( &self, rhs: MatMut<'_, E>, parallelism: Parallelism<'_>, stack: &mut PodStack, )

Applies the adjoint of self to rhs, and stores the result in rhs.

impl<I: Index, E: Entity, R: Shape, C: Shape> Clone for SparseColMatRef<'_, I, E, R, C>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: Index, E: Entity, R: Shape, C: Shape> Debug for SparseColMatRef<'_, I, E, R, C>

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

Formats the value using the given formatter.

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

type Output = SparseColMat<I, E>

The resulting type after applying the / operator.

fn div(self, other: Scale<RhsE>) -> Self::Output

Performs the / operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the / operator.

fn div(self, other: Scale<RhsE>) -> Self::Output

Performs the / operation.

impl<I: Index, E: ComplexField, RhsE: Conjugate<Canonical = E>> Div<f32> for &SparseColMatRef<'_, I, RhsE>

type Output = SparseColMat<I, E>

The resulting type after applying the / operator.

fn div(self, other: f32) -> Self::Output

Performs the / operation.

impl<I: Index, E: ComplexField, RhsE: Conjugate<Canonical = E>> Div<f32> for SparseColMatRef<'_, I, RhsE>

type Output = SparseColMat<I, E>

The resulting type after applying the / operator.

fn div(self, other: f32) -> Self::Output

Performs the / operation.

impl<I: Index, E: ComplexField, RhsE: Conjugate<Canonical = E>> Div<f64> for &SparseColMatRef<'_, I, RhsE>

type Output = SparseColMat<I, E>

The resulting type after applying the / operator.

fn div(self, other: f64) -> Self::Output

Performs the / operation.

impl<I: Index, E: ComplexField, RhsE: Conjugate<Canonical = E>> Div<f64> for SparseColMatRef<'_, I, RhsE>

type Output = SparseColMat<I, E>

The resulting type after applying the / operator.

fn div(self, other: f64) -> Self::Output

Performs the / operation.

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

type Output = E

The returned type after indexing.

fn index(&self, (row, col): (usize, usize)) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, I: Index, E: Entity, R: Shape, C: Shape> IntoConst for SparseColMatRef<'a, I, E, R, C>

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

fn into_const(self) -> Self::Target

impl<E: ComplexField, I: Index, ViewE: Conjugate<Canonical = E>> LinOp<E> for SparseColMatRef<'_, I, ViewE>

Available on crate feature unstable only.

fn nrows(&self) -> usize

Output dimension of the operator.

fn ncols(&self) -> usize

Input dimension of the operator.

fn apply_req( &self, rhs_ncols: usize, parallelism: Parallelism<'_>, ) -> Result<StackReq, SizeOverflow>

Computes the workspace size and alignment required to apply self or the conjugate of self to a matrix with rhs_ncols columns.

fn apply( &self, out: MatMut<'_, E>, rhs: MatRef<'_, E>, parallelism: Parallelism<'_>, stack: &mut PodStack, )

Applies self to rhs, and stores the result in out.

fn conj_apply( &self, out: MatMut<'_, E>, rhs: MatRef<'_, E>, parallelism: Parallelism<'_>, stack: &mut PodStack, )

Applies the conjugate of self to rhs, and stores the result in out.

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

Available on crate feature std only.

fn rows(&self) -> usize

fn cols(&self) -> usize

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

Expose dense or sparse access to the matrix.

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

where E::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul(self, other: &Col<RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul(self, other: &Col<RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul(self, other: &ColRef<'_, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul(self, other: &ColRef<'_, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: &Mat<RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: &Mat<RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: &MatMut<'_, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: &MatMut<'_, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: &MatRef<'_, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: &MatRef<'_, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, other: &SparseColMat<I, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, other: &SparseColMat<I, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, other: &SparseColMatMut<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, other: &SparseColMatMut<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul(self, other: Col<RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul(self, other: Col<RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Col<E>

The resulting type after applying the * operator.

fn mul(self, other: ColRef<'_, RhsE>) -> Self::Output

Performs the * operation.

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

type Output = Col<E>

The resulting type after applying the * operator.

fn mul(self, rhs: ColRef<'_, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: Mat<RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: Mat<RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: MatMut<'_, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: MatMut<'_, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: MatRef<'_, RhsE>) -> Self::Output

Performs the * operation.

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

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, rhs: MatRef<'_, RhsE>) -> Self::Output

Performs the * operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, other: Scale<RhsE>) -> Self::Output

Performs the * operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, rhs: Scale<RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMat<I, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMat<I, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMatMut<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMatMut<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Row<E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Row<E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Row<E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

type Output = Mat<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Row<E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = Row<E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

type Output = Row<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

where E::Canonical: ComplexField,

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the * operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, other: f32) -> Self::Output

Performs the * operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, other: f32) -> Self::Output

Performs the * operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, other: f64) -> Self::Output

Performs the * operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the * operator.

fn mul(self, other: f64) -> Self::Output

Performs the * operation.

impl<I: Index, E: Conjugate> Neg for &SparseColMatRef<'_, I, E>

where E::Canonical: ComplexField,

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

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<I: Index, E: Conjugate> Neg for SparseColMatRef<'_, I, E>

where E::Canonical: ComplexField,

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

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

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

fn eq(&self, other: &SparseColMat<I, 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<I: Index, LhsE: Conjugate, RhsE: Conjugate<Canonical = LhsE::Canonical>> PartialEq<SparseColMatMut<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>

fn eq(&self, other: &SparseColMatMut<'_, I, 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<I: Index, LhsE: Conjugate, RhsE: Conjugate<Canonical = LhsE::Canonical>> PartialEq<SparseColMatRef<'_, I, RhsE>> for SparseColMat<I, LhsE>

fn eq(&self, other: &SparseColMatRef<'_, I, 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<I: Index, LhsE: Conjugate, RhsE: Conjugate<Canonical = LhsE::Canonical>> PartialEq<SparseColMatRef<'_, I, RhsE>> for SparseColMatMut<'_, I, LhsE>

fn eq(&self, other: &SparseColMatRef<'_, I, 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<I: Index, LhsE: Conjugate, RhsE: Conjugate<Canonical = LhsE::Canonical>> PartialEq<SparseColMatRef<'_, I, RhsE>> for SparseColMatRef<'_, I, LhsE>

fn eq(&self, other: &SparseColMatRef<'_, I, 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: ComplexField, I: Index, ViewE: Conjugate<Canonical = E>> Precond<E> for SparseColMatRef<'_, I, ViewE>

Available on crate feature unstable only.

fn apply_in_place_req( &self, rhs_ncols: usize, parallelism: Parallelism<'_>, ) -> Result<StackReq, SizeOverflow>

Computes the workspace size and alignment required to apply self or the conjugate of self to a matrix with rhs_ncols columns in place.

fn apply_in_place( &self, rhs: MatMut<'_, E>, parallelism: Parallelism<'_>, stack: &mut PodStack, )

Applies self to rhs, and stores the result in rhs.

fn conj_apply_in_place( &self, rhs: MatMut<'_, E>, parallelism: Parallelism<'_>, stack: &mut PodStack, )

Applies the conjugate of self to rhs, and stores the result in rhs.

impl<'short, I: Index, E: Entity, R: Shape, C: Shape> Reborrow<'short> for SparseColMatRef<'_, I, E, R, C>

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

fn rb(&'short self) -> Self::Target

impl<'short, I: Index, E: Entity, R: Shape, C: Shape> ReborrowMut<'short> for SparseColMatRef<'_, I, E, R, C>

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

fn rb_mut(&'short mut self) -> Self::Target

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

Available on crate feature std only.

fn nnz(&self) -> usize

Number of non-zero elements in the matrix.

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

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

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

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.

fn sub(self, other: &SparseColMat<I, RhsE>) -> Self::Output

Performs the - operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.

fn sub(self, other: &SparseColMat<I, RhsE>) -> Self::Output

Performs the - operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.

fn sub(self, other: &SparseColMatMut<'_, I, RhsE>) -> Self::Output

Performs the - operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.

fn sub(self, other: &SparseColMatMut<'_, I, RhsE>) -> Self::Output

Performs the - operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.

fn sub(self, other: SparseColMat<I, RhsE>) -> Self::Output

Performs the - operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.

fn sub(self, other: SparseColMat<I, RhsE>) -> Self::Output

Performs the - operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.

fn sub(self, other: SparseColMatMut<'_, I, RhsE>) -> Self::Output

Performs the - operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.

fn sub(self, other: SparseColMatMut<'_, I, RhsE>) -> Self::Output

Performs the - operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.

fn sub(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the - operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.

fn sub(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the - operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.

fn sub(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the - operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.

fn sub(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the - operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.

fn sub(self, other: SparseColMatRef<'_, I, RhsE>) -> Self::Output

Performs the - operation.

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

type Output = SparseColMat<I, E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

Performs the -= operation.

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

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

Performs the -= operation.

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

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

Performs the -= operation.

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

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

Performs the -= operation.

impl<I: Index, E: Entity, R: Shape, C: Shape> Copy for SparseColMatRef<'_, I, E, R, C>