SparseColMat

faer::sparse::csc_numeric::generic

Struct SparseColMat 

Source 
#[repr(transparent)]
pub struct SparseColMat<Inner>(pub Inner);
Expand description

generic SparseColMat wrapper

Tuple Fields§

§0: Inner

Implementations§

Source§

impl<Inner> SparseColMat<Inner>

Source

pub fn from_inner_ref(inner: &Inner) -> &Self

wrap by reference

Source

pub fn from_inner_mut(inner: &mut Inner) -> &mut Self

wrap by mutable reference

Source§

impl<'a, Rows: Shape, Cols: Shape, I: Index, T> SparseColMat<Ref<'a, I, T, Rows, Cols>>

Source

pub fn new( symbolic: SymbolicSparseColMatRef<'a, I, Rows, Cols>, val: &'a [T], ) -> Self

creates a new sparse matrix view.

§panics

panics if the length of values is not equal to the length of symbolic.row_idx()

Source

pub fn parts(self) -> (SymbolicSparseColMatRef<'a, I, Rows, Cols>, &'a [T])

returns the symbolic and numeric components of the sparse matrix

Source

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

returns the symbolic component of the sparse matrix

Source

pub fn val(self) -> &'a [T]

returns the numeric component of the sparse matrix

Source

pub fn val_of_col(self, j: Idx<Cols>) -> &'a [T]

returns a view over the values of column j

Source

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

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

Source

pub fn get(self, row: Idx<Rows>, col: Idx<Cols>) -> Option<&'a T>

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 as_dyn(self) -> SparseColMatRef<'a, I, T>

returns the input matrix with dynamic shape

Source

pub fn as_ref(self) -> SparseColMatRef<'a, I, T, Rows, Cols>

returns a view over self

Source

pub fn transpose(self) -> SparseRowMatRef<'a, I, T, Cols, Rows>

returns a view over the transpose of self

Source

pub fn conjugate(self) -> SparseColMatRef<'a, I, T::Conj, Rows, Cols>
where T: Conjugate,

returns a view over the conjugate of self

Source

pub fn adjoint(self) -> SparseRowMatRef<'a, I, T::Conj, Cols, Rows>
where T: Conjugate,

returns a view over the adjoint of self

Source

pub fn canonical(self) -> SparseColMatRef<'a, I, T::Canonical, Rows, Cols>
where T: Conjugate,

returns an unconjugated view over self

Source

pub fn to_row_major( &self, ) -> Result<SparseRowMat<I, T::Canonical, Rows, Cols>, FaerError>
where T: Conjugate,

returns a newly allocated matrix holding the (possibly conjugated) values of self in row major format

Source

pub fn to_dense(&self) -> Mat<T::Canonical, Rows, Cols>
where T: Conjugate,

returns a newly allocated dense matrix holding the (possibly conjugated) values of self

Source

pub fn triplet_iter( self, ) -> impl 'a + Iterator<Item = Triplet<Idx<Rows>, Idx<Cols>, &'a T>>
where Rows: 'a, Cols: 'a,

returns an iterator over the entries of the matrix.

Source§

impl<'a, Rows: Shape, Cols: Shape, I: Index, T> SparseColMat<Mut<'a, I, T, Rows, Cols>>

Source

pub fn new( symbolic: SymbolicSparseColMatRef<'a, I, Rows, Cols>, val: &'a mut [T], ) -> Self

see SparseColMatRef::new

Source

pub fn parts(self) -> (SymbolicSparseColMatRef<'a, I, Rows, Cols>, &'a [T])

see SparseColMatRef::parts

Source

pub fn parts_mut( self, ) -> (SymbolicSparseColMatRef<'a, I, Rows, Cols>, &'a mut [T])

see SparseColMatRef::parts

Source

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

see SparseColMatRef::symbolic

Source

pub fn val(self) -> &'a [T]

see SparseColMatRef::val

Source

pub fn val_mut(self) -> &'a mut [T]

see SparseColMatRef::val

Source

pub fn val_of_col(self, j: Idx<Cols>) -> &'a [T]

see SparseColMatRef::val_of_col

Source

pub fn val_of_col_mut(self, j: Idx<Cols>) -> &'a mut [T]

see SparseColMatRef::val_of_col

Source

pub fn idx_val_of_col_mut( self, j: Idx<Cols>, ) -> (impl 'a + Clone + ExactSizeIterator + DoubleEndedIterator<Item = Idx<Rows>>, &'a mut [T])
where Rows: 'a, Cols: 'a,

see SymbolicSparseColMatRef::row_idx_of_col and SparseColMatRef::val_of_col

Source

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

see SparseColMatRef::as_shape

Source

pub fn as_shape_mut<V: Shape, H: Shape>( self, nrows: V, ncols: H, ) -> SparseColMatMut<'a, I, T, V, H>

see SparseColMatRef::as_shape

Source

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

see SparseColMatRef::as_dyn

Source

pub fn get(self, row: Idx<Rows>, col: Idx<Cols>) -> Option<&'a T>

see SparseColMatRef::get

Source

pub fn get_mut(self, row: Idx<Rows>, col: Idx<Cols>) -> Option<&'a mut T>

see SparseColMatRef::get

Source

pub fn as_dyn_mut(self) -> SparseColMatMut<'a, I, T>

see SparseColMatRef::as_dyn

Source

pub fn transpose(self) -> SparseRowMatRef<'a, I, T, Cols, Rows>

see SparseColMatRef::transpose

Source

pub fn transpose_mut(self) -> SparseRowMatMut<'a, I, T, Cols, Rows>

see SparseColMatRef::transpose

Source

pub fn conjugate(self) -> SparseColMatRef<'a, I, T::Conj, Rows, Cols>
where T: Conjugate,

see SparseColMatRef::conjugate

Source

pub fn conjugate_mut(self) -> SparseColMatMut<'a, I, T::Conj, Rows, Cols>
where T: Conjugate,

see SparseColMatRef::conjugate

Source

pub fn adjoint(self) -> SparseRowMatRef<'a, I, T::Conj, Cols, Rows>
where T: Conjugate,

see SparseColMatRef::adjoint

Source

pub fn adjoint_mut(self) -> SparseRowMatMut<'a, I, T::Conj, Cols, Rows>
where T: Conjugate,

see SparseColMatRef::adjoint

Source

pub fn canonical(self) -> SparseColMatRef<'a, I, T::Canonical, Rows, Cols>
where T: Conjugate,

see SparseColMatRef::canonical

Source

pub fn canonical_mut(self) -> SparseColMatMut<'a, I, T::Canonical, Rows, Cols>
where T: Conjugate,

see SparseColMatRef::canonical

Source

pub fn to_row_major( &self, ) -> Result<SparseRowMat<I, T::Canonical, Rows, Cols>, FaerError>
where T: Conjugate,

see SparseColMatRef::to_row_major

Source

pub fn to_dense(&self) -> Mat<T::Canonical, Rows, Cols>
where T: Conjugate,

see SparseColMatRef::to_dense

Source

pub fn triplet_iter( self, ) -> impl 'a + Iterator<Item = Triplet<Idx<Rows>, Idx<Cols>, &'a T>>
where Rows: 'a, Cols: 'a,

see SparseColMatRef::triplet_iter

Source§

impl<Rows: Shape, Cols: Shape, I: Index, T> SparseColMat<Own<I, T, Rows, Cols>>

Source

pub fn new(symbolic: SymbolicSparseColMat<I, Rows, Cols>, val: Vec<T>) -> Self

see SparseColMatRef::new

Source

pub fn parts(&self) -> (SymbolicSparseColMatRef<'_, I, Rows, Cols>, &[T])

see SparseColMatRef::parts

Source

pub fn parts_mut( &mut self, ) -> (SymbolicSparseColMatRef<'_, I, Rows, Cols>, &mut [T])

see SparseColMatRef::parts

Source

pub fn into_parts(self) -> (SymbolicSparseColMat<I, Rows, Cols>, Vec<T>)

see SparseColMatRef::parts

Source

pub fn symbolic(&self) -> SymbolicSparseColMatRef<'_, I, Rows, Cols>

see SparseColMatRef::symbolic

Source

pub fn val(&self) -> &[T]

see SparseColMatRef::val

Source

pub fn val_mut(&mut self) -> &mut [T]

see SparseColMatRef::val

Source

pub fn val_of_col(&self, j: Idx<Cols>) -> &[T]

see SparseColMatRef::val_of_col

Source

pub fn val_of_col_mut(&mut self, j: Idx<Cols>) -> &mut [T]

see SparseColMatRef::val_of_col

Source

pub fn as_shape<V: Shape, H: Shape>( &self, nrows: V, ncols: H, ) -> SparseColMatRef<'_, I, T, V, H>

see SparseColMatRef::as_shape

Source

pub fn as_shape_mut<V: Shape, H: Shape>( &mut self, nrows: V, ncols: H, ) -> SparseColMatMut<'_, I, T, V, H>

see SparseColMatRef::as_shape

Source

pub fn into_shape<V: Shape, H: Shape>( self, nrows: V, ncols: H, ) -> SparseColMat<I, T, V, H>

see SparseColMatRef::as_shape

Source

pub fn as_dyn(&self) -> SparseColMatRef<'_, I, T>

see SparseColMatRef::as_dyn

Source

pub fn as_dyn_mut(&mut self) -> SparseColMatMut<'_, I, T>

see SparseColMatRef::as_dyn

Source

pub fn into_dyn(self) -> SparseColMat<I, T>

see SparseColMatRef::as_dyn

Source

pub fn as_ref(&self) -> SparseColMatRef<'_, I, T, Rows, Cols>

see SparseColMatRef::as_ref

Source

pub fn transpose(&self) -> SparseRowMatRef<'_, I, T, Cols, Rows>

see SparseColMatRef::transpose

Source

pub fn transpose_mut(&mut self) -> SparseRowMatMut<'_, I, T, Cols, Rows>

see SparseColMatRef::transpose

Source

pub fn into_transpose(self) -> SparseRowMat<I, T, Cols, Rows>

see SparseColMatRef::transpose

Source

pub fn conjugate(&self) -> SparseColMatRef<'_, I, T::Conj, Rows, Cols>
where T: Conjugate,

see SparseColMatRef::conjugate

Source

pub fn conjugate_mut(&mut self) -> SparseColMatMut<'_, I, T::Conj, Rows, Cols>
where T: Conjugate,

see SparseColMatRef::conjugate

Source

pub fn into_conjugate(self) -> SparseColMat<I, T::Conj, Rows, Cols>
where T: Conjugate,

see SparseColMatRef::conjugate

Source

pub fn adjoint(&self) -> SparseRowMatRef<'_, I, T::Conj, Cols, Rows>
where T: Conjugate,

see SparseColMatRef::adjoint

Source

pub fn adjoint_mut(&mut self) -> SparseRowMatMut<'_, I, T::Conj, Cols, Rows>
where T: Conjugate,

see SparseColMatRef::adjoint

Source

pub fn into_adjoint(self) -> SparseRowMat<I, T::Conj, Cols, Rows>
where T: Conjugate,

see SparseColMatRef::adjoint

Source

pub fn canonical(&self) -> SparseColMatRef<'_, I, T::Canonical, Rows, Cols>
where T: Conjugate,

see SparseColMatRef::canonical

Source

pub fn canonical_mut( &mut self, ) -> SparseColMatMut<'_, I, T::Canonical, Rows, Cols>
where T: Conjugate,

see SparseColMatRef::canonical

Source

pub fn into_canonical(self) -> SparseColMat<I, T::Canonical, Rows, Cols>
where T: Conjugate,

see SparseColMatRef::canonical

Source

pub fn to_row_major( &self, ) -> Result<SparseRowMat<I, T::Canonical, Rows, Cols>, FaerError>
where T: Conjugate,

see SparseColMatRef::to_row_major

Source

pub fn to_dense(&self) -> Mat<T::Canonical, Rows, Cols>
where T: Conjugate,

see SparseColMatRef::to_dense

Source

pub fn new_from_argsort( symbolic: SymbolicSparseColMat<I, Rows, Cols>, argsort: &Argsort<I>, val: &[T], ) -> Result<Self, FaerError>
where T: ComplexField,

create a new matrix from a previously created symbolic structure and value order

the provided values must correspond to the same indices that were provided in the function call from which the order was created

Source

pub fn try_new_from_triplets( nrows: Rows, ncols: Cols, entries: &[Triplet<Idx<Rows, I>, Idx<Cols, I>, T>], ) -> Result<Self, CreationError>
where T: ComplexField,

create a new matrix from triplets

Source

pub fn try_new_from_nonnegative_triplets( nrows: Rows, ncols: Cols, entries: &[Triplet<MaybeIdx<Rows, I>, MaybeIdx<Cols, I>, T>], ) -> Result<Self, CreationError>
where T: ComplexField,

create a new matrix from triplets

negative indices are ignored

Source

pub fn get(&self, row: Idx<Rows>, col: Idx<Cols>) -> Option<&T>

see SparseColMatRef::get

Source

pub fn get_mut(&mut self, row: Idx<Rows>, col: Idx<Cols>) -> Option<&mut T>

see SparseColMatRef::get

Source

pub fn triplet_iter( &self, ) -> impl '_ + Iterator<Item = Triplet<Idx<Rows>, Idx<Cols>, &T>>

see SparseColMatRef::triplet_iter

Source§

impl<I: Index, T: ComplexField, Inner: for<'short> Reborrow<'short, Target = Ref<'short, I, T>>> SparseColMat<Inner>

Source

pub fn sp_solve_lower_triangular_in_place( &self, rhs: impl AsMatMut<T = T, Rows = usize>, )

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 AsMatMut<T = T, Rows = usize>, )

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 AsMatMut<T = T, Rows = usize>, )

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 AsMatMut<T = T, Rows = usize>, )

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<Llt<I, T>, LltError>

returns the $LL^\top$ decomposition of self. only the provided side is accessed

Source

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

returns the $LU$ decomposition of self with partial (row) pivoting

Source

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

returns the $QR$ decomposition of self

Trait Implementations§

Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Rows, Cols>>> Add<&SparseColMat<R>> for &SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the + operator.
Source§

fn add(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the + operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Rows, Cols>>> Add<&SparseColMat<R>> for SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the + operator.
Source§

fn add(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the + operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Rows, Cols>>> Add<SparseColMat<R>> for &SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the + operator.
Source§

fn add(self, rhs: SparseColMat<R>) -> Self::Output

Performs the + operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Rows, Cols>>> Add<SparseColMat<R>> for SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the + operator.
Source§

fn add(self, rhs: SparseColMat<R>) -> Self::Output

Performs the + operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, RT: Conjugate<Canonical = T>, L: for<'a> ReborrowMut<'a, Target = Mut<'a, I, T, Rows, Cols>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Rows, Cols>>> AddAssign<&SparseColMat<R>> for SparseColMat<L>

Source§

fn add_assign(&mut self, rhs: &SparseColMat<R>)

Performs the += operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, RT: Conjugate<Canonical = T>, L: for<'a> ReborrowMut<'a, Target = Mut<'a, I, T, Rows, Cols>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Rows, Cols>>> AddAssign<SparseColMat<R>> for SparseColMat<L>

Source§

fn add_assign(&mut self, rhs: SparseColMat<R>)

Performs the += operation. Read more
Source§

impl<Inner: Clone> Clone for SparseColMat<Inner>

Source§

fn clone(&self) -> SparseColMat<Inner>

Returns a duplicate 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<Inner: Debug> Debug for SparseColMat<Inner>

Source§

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

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

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>> Div<&Scale<T>> for &SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the / operator.
Source§

fn div(self, rhs: &Scale<T>) -> Self::Output

Performs the / operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>> Div<&Scale<T>> for SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the / operator.
Source§

fn div(self, rhs: &Scale<T>) -> Self::Output

Performs the / operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>> Div<&f64> for &SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the / operator.
Source§

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

Performs the / operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>> Div<&f64> for SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the / operator.
Source§

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

Performs the / operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>> Div<Scale<T>> for &SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the / operator.
Source§

fn div(self, rhs: Scale<T>) -> Self::Output

Performs the / operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>> Div<Scale<T>> for SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the / operator.
Source§

fn div(self, rhs: Scale<T>) -> Self::Output

Performs the / operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>> Div<f64> for &SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the / operator.
Source§

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

Performs the / operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>> Div<f64> for SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the / operator.
Source§

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

Performs the / operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, L: for<'a> ReborrowMut<'a, Target = Mut<'a, I, T, Rows, Cols>>> DivAssign<&Scale<T>> for SparseColMat<L>

Source§

fn div_assign(&mut self, rhs: &Scale<T>)

Performs the /= operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, L: for<'a> ReborrowMut<'a, Target = Mut<'a, I, T, Rows, Cols>>> DivAssign<&f64> for SparseColMat<L>

Source§

fn div_assign(&mut self, rhs: &f64)

Performs the /= operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, L: for<'a> ReborrowMut<'a, Target = Mut<'a, I, T, Rows, Cols>>> DivAssign<Scale<T>> for SparseColMat<L>

Source§

fn div_assign(&mut self, rhs: Scale<T>)

Performs the /= operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, L: for<'a> ReborrowMut<'a, Target = Mut<'a, I, T, Rows, Cols>>> DivAssign<f64> for SparseColMat<L>

Source§

fn div_assign(&mut self, rhs: f64)

Performs the /= operation. Read more
Source§

impl<Inner: IntoConst> IntoConst for SparseColMat<Inner>

Source§

type Target = SparseColMat<<Inner as IntoConst>::Target>

Source§

fn into_const(self) -> Self::Target

Source§

impl<I: Index, T: ComplexField, Rows: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Depth>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Depth, RRStride>>> Mul<&Col<R>> for &SparseColMat<L>

Source§

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &Col<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Depth>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Depth, RRStride>>> Mul<&Col<R>> for SparseColMat<L>

Source§

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &Col<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<&Diag<R>> for &SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &Diag<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<&Diag<R>> for SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &Diag<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, RRStride: Stride, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Depth>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Depth, Cols, RRStride, RCStride>>> Mul<&Mat<R>> for &SparseColMat<L>

Source§

type Output = Mat<Own<T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &Mat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, RRStride: Stride, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Depth>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Depth, Cols, RRStride, RCStride>>> Mul<&Mat<R>> for SparseColMat<L>

Source§

type Output = Mat<Own<T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &Mat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>> Mul<&Perm<R>> for &SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &Perm<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>> Mul<&Perm<R>> for SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &Perm<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>> Mul<&Scale<T>> for &SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

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

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>> Mul<&Scale<T>> for SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

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

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<&SparseColMat<R>> for &Diag<L>

Source§

type Output = SparseColMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, LCStride: Stride, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, Depth, LRStride, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Depth, Cols>>> Mul<&SparseColMat<R>> for &Mat<L>

Source§

type Output = Mat<Own<T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<&SparseColMat<R>> for &Perm<L>

Source§

type Output = SparseColMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Depth, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Depth, Cols>>> Mul<&SparseColMat<R>> for &Row<L>

Source§

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, RT: Conjugate<Canonical = T>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Rows, Cols>>> Mul<&SparseColMat<R>> for &Scale<T>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Depth>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Depth, Cols>>> Mul<&SparseColMat<R>> for &SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, RT: Conjugate<Canonical = T>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Rows, Cols>>> Mul<&SparseColMat<R>> for &f64

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<&SparseColMat<R>> for Diag<L>

Source§

type Output = SparseColMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, LCStride: Stride, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, Depth, LRStride, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Depth, Cols>>> Mul<&SparseColMat<R>> for Mat<L>

Source§

type Output = Mat<Own<T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<&SparseColMat<R>> for Perm<L>

Source§

type Output = SparseColMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Depth, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Depth, Cols>>> Mul<&SparseColMat<R>> for Row<L>

Source§

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, RT: Conjugate<Canonical = T>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Rows, Cols>>> Mul<&SparseColMat<R>> for Scale<T>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Depth>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Depth, Cols>>> Mul<&SparseColMat<R>> for SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, RT: Conjugate<Canonical = T>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Rows, Cols>>> Mul<&SparseColMat<R>> for f64

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>> Mul<&f64> for &SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

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

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>> Mul<&f64> for SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

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

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Depth>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Depth, RRStride>>> Mul<Col<R>> for &SparseColMat<L>

Source§

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: Col<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Depth>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Depth, RRStride>>> Mul<Col<R>> for SparseColMat<L>

Source§

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: Col<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<Diag<R>> for &SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: Diag<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<Diag<R>> for SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: Diag<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, RRStride: Stride, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Depth>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Depth, Cols, RRStride, RCStride>>> Mul<Mat<R>> for &SparseColMat<L>

Source§

type Output = Mat<Own<T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: Mat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, RRStride: Stride, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Depth>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Depth, Cols, RRStride, RCStride>>> Mul<Mat<R>> for SparseColMat<L>

Source§

type Output = Mat<Own<T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: Mat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>> Mul<Perm<R>> for &SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: Perm<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>> Mul<Perm<R>> for SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Dim>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: Perm<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>> Mul<Scale<T>> for &SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

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

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>> Mul<Scale<T>> for SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

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

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<SparseColMat<R>> for &Diag<L>

Source§

type Output = SparseColMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, LCStride: Stride, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, Depth, LRStride, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Depth, Cols>>> Mul<SparseColMat<R>> for &Mat<L>

Source§

type Output = Mat<Own<T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<SparseColMat<R>> for &Perm<L>

Source§

type Output = SparseColMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Depth, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Depth, Cols>>> Mul<SparseColMat<R>> for &Row<L>

Source§

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, RT: Conjugate<Canonical = T>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Rows, Cols>>> Mul<SparseColMat<R>> for &Scale<T>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Depth>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Depth, Cols>>> Mul<SparseColMat<R>> for &SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, RT: Conjugate<Canonical = T>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Rows, Cols>>> Mul<SparseColMat<R>> for &f64

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, LStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<SparseColMat<R>> for Diag<L>

Source§

type Output = SparseColMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, LCStride: Stride, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, Depth, LRStride, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Depth, Cols>>> Mul<SparseColMat<R>> for Mat<L>

Source§

type Output = Mat<Own<T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Cols: Shape, Dim: Shape, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Dim>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Dim, Cols>>> Mul<SparseColMat<R>> for Perm<L>

Source§

type Output = SparseColMat<Own<I, T, Dim, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Depth, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Depth, Cols>>> Mul<SparseColMat<R>> for Row<L>

Source§

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, RT: Conjugate<Canonical = T>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Rows, Cols>>> Mul<SparseColMat<R>> for Scale<T>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Depth>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Depth, Cols>>> Mul<SparseColMat<R>> for SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, RT: Conjugate<Canonical = T>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Rows, Cols>>> Mul<SparseColMat<R>> for f64

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: SparseColMat<R>) -> Self::Output

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>> Mul<f64> for &SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

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

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>> Mul<f64> for SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the * operator.
Source§

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

Performs the * operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, L: for<'a> ReborrowMut<'a, Target = Mut<'a, I, T, Rows, Cols>>> MulAssign<&Scale<T>> for SparseColMat<L>

Source§

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

Performs the *= operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, L: for<'a> ReborrowMut<'a, Target = Mut<'a, I, T, Rows, Cols>>> MulAssign<&f64> for SparseColMat<L>

Source§

fn mul_assign(&mut self, rhs: &f64)

Performs the *= operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, L: for<'a> ReborrowMut<'a, Target = Mut<'a, I, T, Rows, Cols>>> MulAssign<Scale<T>> for SparseColMat<L>

Source§

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

Performs the *= operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, L: for<'a> ReborrowMut<'a, Target = Mut<'a, I, T, Rows, Cols>>> MulAssign<f64> for SparseColMat<L>

Source§

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation. Read more
Source§

impl<I: Index, T: Conjugate, Rows: Shape, Cols: Shape, Inner: for<'a> Reborrow<'a, Target = Ref<'a, I, T, Rows, Cols>>> Neg for &SparseColMat<Inner>

Source§

type Output = SparseColMat<Own<I, <T as Conjugate>::Canonical, Rows, Cols>>

The resulting type after applying the - operator.
Source§

fn neg(self) -> Self::Output

Performs the unary - operation. Read more
Source§

impl<I: Index, T: Conjugate, Rows: Shape, Cols: Shape, Inner: for<'a> Reborrow<'a, Target = Ref<'a, I, T, Rows, Cols>>> Neg for SparseColMat<Inner>

Source§

type Output = SparseColMat<Own<I, <T as Conjugate>::Canonical, Rows, Cols>>

The resulting type after applying the - operator.
Source§

fn neg(self) -> Self::Output

Performs the unary - operation. Read more
Source§

impl<'short, Inner: Reborrow<'short>> Reborrow<'short> for SparseColMat<Inner>

Source§

type Target = SparseColMat<<Inner as Reborrow<'short>>::Target>

Source§

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

Source§

impl<'short, Inner: ReborrowMut<'short>> ReborrowMut<'short> for SparseColMat<Inner>

Source§

type Target = SparseColMat<<Inner as ReborrowMut<'short>>::Target>

Source§

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

Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Rows, Cols>>> Sub<&SparseColMat<R>> for &SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the - operator.
Source§

fn sub(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the - operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Rows, Cols>>> Sub<&SparseColMat<R>> for SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the - operator.
Source§

fn sub(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the - operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Rows, Cols>>> Sub<SparseColMat<R>> for &SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the - operator.
Source§

fn sub(self, rhs: SparseColMat<R>) -> Self::Output

Performs the - operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, I, LT, Rows, Cols>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Rows, Cols>>> Sub<SparseColMat<R>> for SparseColMat<L>

Source§

type Output = SparseColMat<Own<I, T, Rows, Cols>>

The resulting type after applying the - operator.
Source§

fn sub(self, rhs: SparseColMat<R>) -> Self::Output

Performs the - operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, RT: Conjugate<Canonical = T>, L: for<'a> ReborrowMut<'a, Target = Mut<'a, I, T, Rows, Cols>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Rows, Cols>>> SubAssign<&SparseColMat<R>> for SparseColMat<L>

Source§

fn sub_assign(&mut self, rhs: &SparseColMat<R>)

Performs the -= operation. Read more
Source§

impl<I: Index, T: ComplexField, Rows: Shape, Cols: Shape, RT: Conjugate<Canonical = T>, L: for<'a> ReborrowMut<'a, Target = Mut<'a, I, T, Rows, Cols>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Rows, Cols>>> SubAssign<SparseColMat<R>> for SparseColMat<L>

Source§

fn sub_assign(&mut self, rhs: SparseColMat<R>)

Performs the -= operation. Read more
Source§

impl<Inner: Copy> Copy for SparseColMat<Inner>

Auto Trait Implementations§

§

impl<Inner> Freeze for SparseColMat<Inner>
where Inner: Freeze,

§

impl<Inner> RefUnwindSafe for SparseColMat<Inner>
where Inner: RefUnwindSafe,

§

impl<Inner> Send for SparseColMat<Inner>
where Inner: Send,

§

impl<Inner> Sync for SparseColMat<Inner>
where Inner: Sync,

§

impl<Inner> Unpin for SparseColMat<Inner>
where Inner: Unpin,

§

impl<Inner> UnwindSafe for SparseColMat<Inner>
where Inner: UnwindSafe,

Blanket Implementations§

Source§

impl<Rhs, Lhs, Output> AddByRef<Rhs> for Lhs
where &'a Lhs: for<'a> Add<&'a Rhs, Output = Output>,

Source§

type Output = Output

Source§

fn add_by_ref(&self, rhs: &Rhs) -> <Lhs as AddByRef<Rhs>>::Output

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> ByRef<T> for T

Source§

fn by_ref(&self) -> &T

Source§

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

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

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

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

Source§

fn rand<T>(&self, rng: &mut (impl ?Sized + Rng)) -> T
where Self: Distribution<T>,

Source§

impl<Rhs, Lhs, Output> DivByRef<Rhs> for Lhs
where &'a Lhs: for<'a> Div<&'a Rhs, Output = Output>,

Source§

type Output = Output

Source§

fn div_by_ref(&self, rhs: &Rhs) -> <Lhs as DivByRef<Rhs>>::Output

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<Rhs, Lhs, Output> MulByRef<Rhs> for Lhs
where &'a Lhs: for<'a> Mul<&'a Rhs, Output = Output>,

Source§

type Output = Output

Source§

fn mul_by_ref(&self, rhs: &Rhs) -> <Lhs as MulByRef<Rhs>>::Output

Source§

impl<T, Output> NegByRef for T
where &'a T: for<'a> Neg<Output = Output>,

Source§

type Output = Output

Source§

fn neg_by_ref(&self) -> <T as NegByRef>::Output

Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

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<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

Source§

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)
The target type on which the method may be called.
Source§

impl<Rhs, Lhs, Output> SubByRef<Rhs> for Lhs
where &'a Lhs: for<'a> Sub<&'a Rhs, Output = Output>,

Source§

type Output = Output

Source§

fn sub_by_ref(&self, rhs: &Rhs) -> <Lhs as SubByRef<Rhs>>::Output

Source§

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

Source§

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

Source§

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

Source§

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<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V