Struct Sparse ColMat &nbsp; Copy item path

impl<Inner> SparseColMat<Inner>

pub fn from_inner_ref(inner: &Inner) -> &SparseColMat<Inner>

wrap by reference

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

wrap by mutable reference

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

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

creates a new sparse matrix view.

§panics

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

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

returns the symbolic and numeric components of the sparse matrix

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

returns the symbolic component of the sparse matrix

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

returns the numeric component of the sparse matrix

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

returns a view over the values of column j

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

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

pub fn get( self, row: <Rows as ShapeIdx>::Idx<usize>, col: <Cols as ShapeIdx>::Idx<usize>, ) -> 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()

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

returns the input matrix with dynamic shape

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

returns a view over self

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

returns a view over the transpose of self

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

returns a view over the conjugate of self

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

returns a view over the adjoint of self

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

returns an unconjugated view over self

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

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

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

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

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

returns an iterator over the entries of the matrix.

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

pub fn new( symbolic: SymbolicSparseColMat<Ref<'a, I, Rows, Cols>>, val: &'a mut [T], ) -> SparseColMat<Mut<'a, I, T, Rows, Cols>>

see SparseColMatRef::new

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

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

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

see SymbolicSparseColMatRef::row_idx_of_col and SparseColMatRef::val_of_col

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

see SparseColMatRef::to_row_major

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

see SparseColMatRef::to_dense

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

see SparseColMatRef::triplet_iter

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

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

see SparseColMatRef::new

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

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

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

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

see SparseColMatRef::symbolic

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

see SparseColMatRef::val

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

see SparseColMatRef::val

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

see SparseColMatRef::val_of_col

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

see SparseColMatRef::val_of_col

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

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

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

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

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

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

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

see SparseColMatRef::as_ref

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

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

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

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

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

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

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

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

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

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

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

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

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

see SparseColMatRef::to_row_major

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

see SparseColMatRef::to_dense

pub fn new_from_argsort( symbolic: SymbolicSparseColMat<Own<I, Rows, Cols>>, argsort: &Argsort, val: &[T], ) -> Result<SparseColMat<Own<I, T, Rows, Cols>>, 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

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

create a new matrix from triplets

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

create a new matrix from triplets

negative indices are ignored

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

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

pub fn triplet_iter( &self, ) -> impl Iterator<Item = Triplet<<Rows as ShapeIdx>::Idx<usize>, <Cols as ShapeIdx>::Idx<usize>, &T>>

see SparseColMatRef::triplet_iter

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

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

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

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

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

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

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

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

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

returns the $QR$ decomposition of self

Methods from Deref<Target = SymbolicSparseColMat<Ref<'a, I, Rows, Cols>>>§

pub fn nrows(&self) -> Rows

returns the number of rows of the matrix

pub fn ncols(&self) -> Cols

returns the number of columns of the matrix

pub fn shape(&self) -> (Rows, Cols)

returns the number of rows and columns of the matrix

pub fn to_owned( &self, ) -> Result<SymbolicSparseColMat<Own<I, Rows, Cols>>, FaerError>

returns a newly allocated matrix holding the values of self

pub fn to_row_major( &self, ) -> Result<SymbolicSparseRowMat<Own<I, Rows, Cols>>, FaerError>

returns a newly allocated matrix holding the values of self in row major format

pub fn compute_nnz(&self) -> usize

returns the number of non-zero elements in the matrix

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

returns the column pointers

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

returns the column non-zero counts

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

returns the row indices

pub fn col_range(&self, j: <Cols as ShapeIdx>::Idx<usize>) -> Range<usize> ⓘ

returns the range specifying the indices of column j

pub unsafe fn col_range_unchecked( &self, j: <Cols as ShapeIdx>::Idx<usize>, ) -> Range<usize> ⓘ

returns the range specifying the indices of column j, without bound checks

pub fn row_idx_of_col_raw( &self, j: <Cols as ShapeIdx>::Idx<usize>, ) -> &'a [<Rows as ShapeIdx>::Idx]

returns the row indices of column j

pub fn row_idx_of_col( &self, j: <Cols as ShapeIdx>::Idx<usize>, ) -> impl Clone + ExactSizeIterator + DoubleEndedIterator + 'a
where Rows: 'a, Cols: 'a,

returns the row indices of column j

Trait Implementations§

impl<I, T, Rows, Cols, LT, RT, L, R> Add<&SparseColMat<R>> for &SparseColMat<L>
where 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>>,

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

The resulting type after applying the + operator.

fn add( self, rhs: &SparseColMat<R>, ) -> <&SparseColMat<L> as Add<&SparseColMat<R>>>::Output

Performs the + operation. Read more

impl<I, T, Rows, Cols, LT, RT, L, R> Add<&SparseColMat<R>> for SparseColMat<L>
where 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>>,

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

The resulting type after applying the + operator.

fn add( self, rhs: &SparseColMat<R>, ) -> <SparseColMat<L> as Add<&SparseColMat<R>>>::Output

Performs the + operation. Read more

impl<I, T, Rows, Cols, LT, RT, L, R> Add<SparseColMat<R>> for &SparseColMat<L>
where 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>>,

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

The resulting type after applying the + operator.

fn add( self, rhs: SparseColMat<R>, ) -> <&SparseColMat<L> as Add<SparseColMat<R>>>::Output

Performs the + operation. Read more

impl<I, T, Rows, Cols, LT, RT, L, R> Add<SparseColMat<R>> for SparseColMat<L>
where 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>>,

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

The resulting type after applying the + operator.

fn add( self, rhs: SparseColMat<R>, ) -> <SparseColMat<L> as Add<SparseColMat<R>>>::Output

Performs the + operation. Read more

impl<I, T, Rows, Cols, RT, L, R> AddAssign<&SparseColMat<R>> for SparseColMat<L>
where 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>>,

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

Performs the += operation. Read more

impl<I, T, Rows, Cols, RT, L, R> AddAssign<SparseColMat<R>> for SparseColMat<L>
where 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>>,

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

Performs the += operation. Read more

impl<I, T, ViewT> BiLinOp<T> for SparseColMat<Mut<'_, I, ViewT>>
where I: Index, T: ComplexField, ViewT: Conjugate<Canonical = T>,

fn transpose_apply_scratch(&self, rhs_ncols: usize, par: Par) -> StackReq

computes the workspace layout required to apply the transpose or adjoint o self to a matrix with rhs_ncols columns

fn transpose_apply( &self, out: Mat<Mut<'_, T>>, rhs: Mat<Ref<'_, T>>, par: Par, stack: &mut MemStack, )

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

fn adjoint_apply( &self, out: Mat<Mut<'_, T>>, rhs: Mat<Ref<'_, T>>, par: Par, stack: &mut MemStack, )

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

impl<I, T, ViewT> BiLinOp<T> for SparseColMat<Own<I, ViewT>>
where I: Index, T: ComplexField, ViewT: Conjugate<Canonical = T>,

fn transpose_apply_scratch(&self, rhs_ncols: usize, par: Par) -> StackReq

computes the workspace layout required to apply the transpose or adjoint o self to a matrix with rhs_ncols columns

fn transpose_apply( &self, out: Mat<Mut<'_, T>>, rhs: Mat<Ref<'_, T>>, par: Par, stack: &mut MemStack, )

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

fn adjoint_apply( &self, out: Mat<Mut<'_, T>>, rhs: Mat<Ref<'_, T>>, par: Par, stack: &mut MemStack, )

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

impl<T, I, ViewT> BiLinOp<T> for SparseColMat<Ref<'_, I, ViewT>>
where T: ComplexField, I: Index, ViewT: Conjugate<Canonical = T>,

fn transpose_apply_scratch(&self, rhs_ncols: usize, par: Par) -> StackReq

computes the workspace layout required to apply the transpose or adjoint o self to a matrix with rhs_ncols columns

fn transpose_apply( &self, out: Mat<Mut<'_, T>>, rhs: Mat<Ref<'_, T>>, par: Par, stack: &mut MemStack, )

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

fn adjoint_apply( &self, out: Mat<Mut<'_, T>>, rhs: Mat<Ref<'_, T>>, par: Par, stack: &mut MemStack, )

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

impl<I, T, ViewT> BiPrecond<T> for SparseColMat<Mut<'_, I, ViewT>>
where I: Index, T: ComplexField, ViewT: Conjugate<Canonical = T>,

fn transpose_apply_in_place_scratch( &self, rhs_ncols: usize, par: Par, ) -> StackReq

computes the workspace layout 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: Mat<Mut<'_, T>>, par: Par, stack: &mut MemStack, )

applies the transpose of self to rhs, and stores the result in rhs

fn adjoint_apply_in_place( &self, rhs: Mat<Mut<'_, T>>, par: Par, stack: &mut MemStack, )

applies the adjoint of self to rhs, and stores the result in rhs

impl<I, T, ViewT> BiPrecond<T> for SparseColMat<Own<I, ViewT>>
where I: Index, T: ComplexField, ViewT: Conjugate<Canonical = T>,

fn transpose_apply_in_place_scratch( &self, rhs_ncols: usize, par: Par, ) -> StackReq

computes the workspace layout 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: Mat<Mut<'_, T>>, par: Par, stack: &mut MemStack, )

applies the transpose of self to rhs, and stores the result in rhs

fn adjoint_apply_in_place( &self, rhs: Mat<Mut<'_, T>>, par: Par, stack: &mut MemStack, )

applies the adjoint of self to rhs, and stores the result in rhs

impl<T, I, ViewT> BiPrecond<T> for SparseColMat<Ref<'_, I, ViewT>>
where T: ComplexField, I: Index, ViewT: Conjugate<Canonical = T>,

fn transpose_apply_in_place_scratch( &self, rhs_ncols: usize, par: Par, ) -> StackReq

computes the workspace layout 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: Mat<Mut<'_, T>>, par: Par, stack: &mut MemStack, )

applies the transpose of self to rhs, and stores the result in rhs

fn adjoint_apply_in_place( &self, rhs: Mat<Mut<'_, T>>, par: Par, stack: &mut MemStack, )

applies the adjoint of self to rhs, and stores the result in rhs

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

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

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

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

Formats the value using the given formatter. Read more

impl<Rows, Cols, I, T> Debug for SparseColMat<Mut<'_, I, T, Rows, Cols>>
where Rows: Shape, Cols: Shape, I: Index, T: Debug,

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

Formats the value using the given formatter. Read more

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

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

Formats the value using the given formatter. Read more

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

type Target = SymbolicSparseColMat<Ref<'a, I, Rows, Cols>>

The resulting type after dereferencing.

fn deref(&self) -> &<SparseColMat<Mut<'a, I, T, Rows, Cols>> as Deref>::Target

Dereferences the value.

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

type Target = SymbolicSparseColMat<Own<I, Rows, Cols>>

The resulting type after dereferencing.

fn deref(&self) -> &<SparseColMat<Own<I, T, Rows, Cols>> as Deref>::Target

Dereferences the value.

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

type Target = SymbolicSparseColMat<Ref<'a, I, Rows, Cols>>

The resulting type after dereferencing.

fn deref(&self) -> &<SparseColMat<Ref<'a, I, T, Rows, Cols>> as Deref>::Target

Dereferences the value.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: &Scale<T>) -> <&SparseColMat<L> as Div<&Scale<T>>>::Output

Performs the / operation. Read more

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

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

The resulting type after applying the / operator.

fn div(self, rhs: &Scale<T>) -> <SparseColMat<L> as Div<&Scale<T>>>::Output

Performs the / operation. Read more

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

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

The resulting type after applying the / operator.

fn div(self, rhs: &f64) -> <&SparseColMat<L> as Div<&f64>>::Output

Performs the / operation. Read more

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

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

The resulting type after applying the / operator.

fn div(self, rhs: &f64) -> <SparseColMat<L> as Div<&f64>>::Output

Performs the / operation. Read more

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Scale<T>) -> <&SparseColMat<L> as Div<Scale<T>>>::Output

Performs the / operation. Read more

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

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

The resulting type after applying the / operator.

fn div(self, rhs: Scale<T>) -> <SparseColMat<L> as Div<Scale<T>>>::Output

Performs the / operation. Read more

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

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

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> <&SparseColMat<L> as Div<f64>>::Output

Performs the / operation. Read more

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

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

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> <SparseColMat<L> as Div<f64>>::Output

Performs the / operation. Read more

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

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

Performs the /= operation. Read more

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

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

Performs the /= operation. Read more

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

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

Performs the /= operation. Read more

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

fn div_assign(&mut self, rhs: f64)

Performs the /= operation. Read more

impl<I, T> Index<(usize, usize)> for SparseColMat<Mut<'_, I, T>>
where I: Index,

type Output = T

The returned type after indexing.

fn index( &self, _: (usize, usize), ) -> &<SparseColMat<Mut<'_, I, T>> as Index<(usize, usize)>>::Output

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

impl<I, T> Index<(usize, usize)> for SparseColMat<Own<I, T>>
where I: Index,

type Output = T

The returned type after indexing.

fn index( &self, _: (usize, usize), ) -> &<SparseColMat<Own<I, T>> as Index<(usize, usize)>>::Output

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

impl<I, T> Index<(usize, usize)> for SparseColMat<Ref<'_, I, T>>
where I: Index,

type Output = T

The returned type after indexing.

fn index( &self, _: (usize, usize), ) -> &<SparseColMat<Ref<'_, I, T>> as Index<(usize, usize)>>::Output

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

impl<I, T> IndexMut<(usize, usize)> for SparseColMat<Mut<'_, I, T>>
where I: Index,

fn index_mut( &mut self, _: (usize, usize), ) -> &mut <SparseColMat<Mut<'_, I, T>> as Index<(usize, usize)>>::Output

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

impl<I, T> IndexMut<(usize, usize)> for SparseColMat<Own<I, T>>
where I: Index,

fn index_mut( &mut self, _: (usize, usize), ) -> &mut <SparseColMat<Own<I, T>> as Index<(usize, usize)>>::Output

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

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

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

fn into_const(self) -> <SparseColMat<Inner> as IntoConst>::Target

impl<I, T, ViewT> LinOp<T> for SparseColMat<Mut<'_, I, ViewT>>
where I: Index, T: ComplexField, ViewT: Conjugate<Canonical = T>,

fn nrows(&self) -> usize

output dimension of the operator

fn ncols(&self) -> usize

input dimension of the operator

fn apply_scratch(&self, rhs_ncols: usize, par: Par) -> StackReq

computes the workspace layout required to apply self or the conjugate o self to a matrix with rhs_ncols columns

fn apply( &self, out: Mat<Mut<'_, T>>, rhs: Mat<Ref<'_, T>>, par: Par, stack: &mut MemStack, )

applies self to rhs, and stores the result in out

fn conj_apply( &self, out: Mat<Mut<'_, T>>, rhs: Mat<Ref<'_, T>>, par: Par, stack: &mut MemStack, )

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

impl<I, T, ViewT> LinOp<T> for SparseColMat<Own<I, ViewT>>
where I: Index, T: ComplexField, ViewT: Conjugate<Canonical = T>,

fn nrows(&self) -> usize

output dimension of the operator

fn ncols(&self) -> usize

input dimension of the operator

fn apply_scratch(&self, rhs_ncols: usize, par: Par) -> StackReq

computes the workspace layout required to apply self or the conjugate o self to a matrix with rhs_ncols columns

fn apply( &self, out: Mat<Mut<'_, T>>, rhs: Mat<Ref<'_, T>>, par: Par, stack: &mut MemStack, )

applies self to rhs, and stores the result in out

fn conj_apply( &self, out: Mat<Mut<'_, T>>, rhs: Mat<Ref<'_, T>>, par: Par, stack: &mut MemStack, )

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

impl<T, I, ViewT> LinOp<T> for SparseColMat<Ref<'_, I, ViewT>>
where T: ComplexField, I: Index, ViewT: Conjugate<Canonical = T>,

fn nrows(&self) -> usize

output dimension of the operator

fn ncols(&self) -> usize

input dimension of the operator

fn apply_scratch(&self, rhs_ncols: usize, par: Par) -> StackReq

computes the workspace layout required to apply self or the conjugate o self to a matrix with rhs_ncols columns

fn apply( &self, out: Mat<Mut<'_, T>>, rhs: Mat<Ref<'_, T>>, par: Par, stack: &mut MemStack, )

applies self to rhs, and stores the result in out

fn conj_apply( &self, out: Mat<Mut<'_, T>>, rhs: Mat<Ref<'_, T>>, par: Par, stack: &mut MemStack, )

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

impl<I, T, Rows, Depth, LT, RT, RRStride, L, R> Mul<&Col<R>> for &SparseColMat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: &Col<R>) -> <&SparseColMat<L> as Mul<&Col<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Depth, LT, RT, RRStride, L, R> Mul<&Col<R>> for SparseColMat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: &Col<R>) -> <SparseColMat<L> as Mul<&Col<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Dim, LT, RT, RStride, L, R> Mul<&Diag<R>> for &SparseColMat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: &Diag<R>) -> <&SparseColMat<L> as Mul<&Diag<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Dim, LT, RT, RStride, L, R> Mul<&Diag<R>> for SparseColMat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: &Diag<R>) -> <SparseColMat<L> as Mul<&Diag<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Cols, Depth, LT, RT, RRStride, RCStride, L, R> Mul<&Mat<R>> for &SparseColMat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: &Mat<R>) -> <&SparseColMat<L> as Mul<&Mat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Cols, Depth, LT, RT, RRStride, RCStride, L, R> Mul<&Mat<R>> for SparseColMat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: &Mat<R>) -> <SparseColMat<L> as Mul<&Mat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Dim, LT, L, R> Mul<&Perm<R>> for &SparseColMat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: &Perm<R>) -> <&SparseColMat<L> as Mul<&Perm<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Dim, LT, L, R> Mul<&Perm<R>> for SparseColMat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: &Perm<R>) -> <SparseColMat<L> as Mul<&Perm<R>>>::Output

Performs the * operation. Read more

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: &Scale<T>) -> <&SparseColMat<L> as Mul<&Scale<T>>>::Output

Performs the * operation. Read more

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: &Scale<T>) -> <SparseColMat<L> as Mul<&Scale<T>>>::Output

Performs the * operation. Read more

impl<I, T, Cols, Dim, LT, RT, LStride, L, R> Mul<&SparseColMat<R>> for &Diag<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul( self, rhs: &SparseColMat<R>, ) -> <&Diag<L> as Mul<&SparseColMat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Cols, Depth, LT, LRStride, LCStride, RT, L, R> Mul<&SparseColMat<R>> for &Mat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul( self, rhs: &SparseColMat<R>, ) -> <&Mat<L> as Mul<&SparseColMat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Cols, Dim, RT, L, R> Mul<&SparseColMat<R>> for &Perm<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul( self, rhs: &SparseColMat<R>, ) -> <&Perm<L> as Mul<&SparseColMat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Cols, Depth, LT, LCStride, RT, L, R> Mul<&SparseColMat<R>> for &Row<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul( self, rhs: &SparseColMat<R>, ) -> <&Row<L> as Mul<&SparseColMat<R>>>::Output

Performs the * operation. Read more

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

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

The resulting type after applying the * operator.

fn mul( self, rhs: &SparseColMat<R>, ) -> <&Scale<T> as Mul<&SparseColMat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Cols, Depth, LT, RT, L, R> Mul<&SparseColMat<R>> for &SparseColMat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul( self, rhs: &SparseColMat<R>, ) -> <&SparseColMat<L> as Mul<&SparseColMat<R>>>::Output

Performs the * operation. Read more

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: &SparseColMat<R>) -> <&f64 as Mul<&SparseColMat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Cols, Dim, LT, RT, LStride, L, R> Mul<&SparseColMat<R>> for Diag<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul( self, rhs: &SparseColMat<R>, ) -> <Diag<L> as Mul<&SparseColMat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Cols, Depth, LT, LRStride, LCStride, RT, L, R> Mul<&SparseColMat<R>> for Mat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: &SparseColMat<R>) -> <Mat<L> as Mul<&SparseColMat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Cols, Dim, RT, L, R> Mul<&SparseColMat<R>> for Perm<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul( self, rhs: &SparseColMat<R>, ) -> <Perm<L> as Mul<&SparseColMat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Cols, Depth, LT, LCStride, RT, L, R> Mul<&SparseColMat<R>> for Row<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: &SparseColMat<R>) -> <Row<L> as Mul<&SparseColMat<R>>>::Output

Performs the * operation. Read more

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

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

The resulting type after applying the * operator.

fn mul( self, rhs: &SparseColMat<R>, ) -> <Scale<T> as Mul<&SparseColMat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Cols, Depth, LT, RT, L, R> Mul<&SparseColMat<R>> for SparseColMat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul( self, rhs: &SparseColMat<R>, ) -> <SparseColMat<L> as Mul<&SparseColMat<R>>>::Output

Performs the * operation. Read more

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: &SparseColMat<R>) -> <f64 as Mul<&SparseColMat<R>>>::Output

Performs the * operation. Read more

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: &f64) -> <&SparseColMat<L> as Mul<&f64>>::Output

Performs the * operation. Read more

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: &f64) -> <SparseColMat<L> as Mul<&f64>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Depth, LT, RT, RRStride, L, R> Mul<Col<R>> for &SparseColMat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: Col<R>) -> <&SparseColMat<L> as Mul<Col<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Depth, LT, RT, RRStride, L, R> Mul<Col<R>> for SparseColMat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: Col<R>) -> <SparseColMat<L> as Mul<Col<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Dim, LT, RT, RStride, L, R> Mul<Diag<R>> for &SparseColMat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: Diag<R>) -> <&SparseColMat<L> as Mul<Diag<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Dim, LT, RT, RStride, L, R> Mul<Diag<R>> for SparseColMat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: Diag<R>) -> <SparseColMat<L> as Mul<Diag<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Cols, Depth, LT, RT, RRStride, RCStride, L, R> Mul<Mat<R>> for &SparseColMat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: Mat<R>) -> <&SparseColMat<L> as Mul<Mat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Cols, Depth, LT, RT, RRStride, RCStride, L, R> Mul<Mat<R>> for SparseColMat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: Mat<R>) -> <SparseColMat<L> as Mul<Mat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Dim, LT, L, R> Mul<Perm<R>> for &SparseColMat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: Perm<R>) -> <&SparseColMat<L> as Mul<Perm<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Dim, LT, L, R> Mul<Perm<R>> for SparseColMat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: Perm<R>) -> <SparseColMat<L> as Mul<Perm<R>>>::Output

Performs the * operation. Read more

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Scale<T>) -> <&SparseColMat<L> as Mul<Scale<T>>>::Output

Performs the * operation. Read more

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: Scale<T>) -> <SparseColMat<L> as Mul<Scale<T>>>::Output

Performs the * operation. Read more

impl<I, T, Cols, Dim, LT, RT, LStride, L, R> Mul<SparseColMat<R>> for &Diag<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: SparseColMat<R>) -> <&Diag<L> as Mul<SparseColMat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Cols, Depth, LT, LRStride, LCStride, RT, L, R> Mul<SparseColMat<R>> for &Mat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: SparseColMat<R>) -> <&Mat<L> as Mul<SparseColMat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Cols, Dim, RT, L, R> Mul<SparseColMat<R>> for &Perm<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: SparseColMat<R>) -> <&Perm<L> as Mul<SparseColMat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Cols, Depth, LT, LCStride, RT, L, R> Mul<SparseColMat<R>> for &Row<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: SparseColMat<R>) -> <&Row<L> as Mul<SparseColMat<R>>>::Output

Performs the * operation. Read more

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

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

The resulting type after applying the * operator.

fn mul( self, rhs: SparseColMat<R>, ) -> <&Scale<T> as Mul<SparseColMat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Cols, Depth, LT, RT, L, R> Mul<SparseColMat<R>> for &SparseColMat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul( self, rhs: SparseColMat<R>, ) -> <&SparseColMat<L> as Mul<SparseColMat<R>>>::Output

Performs the * operation. Read more

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: SparseColMat<R>) -> <&f64 as Mul<SparseColMat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Cols, Dim, LT, RT, LStride, L, R> Mul<SparseColMat<R>> for Diag<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: SparseColMat<R>) -> <Diag<L> as Mul<SparseColMat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Cols, Depth, LT, LRStride, LCStride, RT, L, R> Mul<SparseColMat<R>> for Mat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: SparseColMat<R>) -> <Mat<L> as Mul<SparseColMat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Cols, Dim, RT, L, R> Mul<SparseColMat<R>> for Perm<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: SparseColMat<R>) -> <Perm<L> as Mul<SparseColMat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Cols, Depth, LT, LCStride, RT, L, R> Mul<SparseColMat<R>> for Row<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul(self, rhs: SparseColMat<R>) -> <Row<L> as Mul<SparseColMat<R>>>::Output

Performs the * operation. Read more

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: SparseColMat<R>) -> <Scale<T> as Mul<SparseColMat<R>>>::Output

Performs the * operation. Read more

impl<I, T, Rows, Cols, Depth, LT, RT, L, R> Mul<SparseColMat<R>> for SparseColMat<L>
where 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>>,

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

The resulting type after applying the * operator.

fn mul( self, rhs: SparseColMat<R>, ) -> <SparseColMat<L> as Mul<SparseColMat<R>>>::Output

Performs the * operation. Read more

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: SparseColMat<R>) -> <f64 as Mul<SparseColMat<R>>>::Output

Performs the * operation. Read more

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> <&SparseColMat<L> as Mul<f64>>::Output

Performs the * operation. Read more

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> <SparseColMat<L> as Mul<f64>>::Output

Performs the * operation. Read more

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

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

Performs the *= operation. Read more

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

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

Performs the *= operation. Read more

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

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

Performs the *= operation. Read more

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

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation. Read more

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

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

The resulting type after applying the - operator.

fn neg(self) -> <&SparseColMat<Inner> as Neg>::Output

Performs the unary - operation. Read more

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

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

The resulting type after applying the - operator.

fn neg(self) -> <SparseColMat<Inner> as Neg>::Output

Performs the unary - operation. Read more

impl<I, T, ViewT> Precond<T> for SparseColMat<Mut<'_, I, ViewT>>
where I: Index, T: ComplexField, ViewT: Conjugate<Canonical = T>,

fn apply_in_place_scratch(&self, rhs_ncols: usize, par: Par) -> StackReq

computes the workspace layout required to apply self or the conjugate of self to a matrix with rhs_ncols columns in place

fn apply_in_place(&self, rhs: Mat<Mut<'_, T>>, par: Par, stack: &mut MemStack)

applies self to rhs, and stores the result in rhs

fn conj_apply_in_place( &self, rhs: Mat<Mut<'_, T>>, par: Par, stack: &mut MemStack, )

applies the conjugate of self to rhs, and stores the result in rhs

impl<I, T, ViewT> Precond<T> for SparseColMat<Own<I, ViewT>>
where I: Index, T: ComplexField, ViewT: Conjugate<Canonical = T>,

fn apply_in_place_scratch(&self, rhs_ncols: usize, par: Par) -> StackReq

computes the workspace layout required to apply self or the conjugate of self to a matrix with rhs_ncols columns in place

fn apply_in_place(&self, rhs: Mat<Mut<'_, T>>, par: Par, stack: &mut MemStack)

applies self to rhs, and stores the result in rhs

fn conj_apply_in_place( &self, rhs: Mat<Mut<'_, T>>, par: Par, stack: &mut MemStack, )

applies the conjugate of self to rhs, and stores the result in rhs

impl<T, I, ViewT> Precond<T> for SparseColMat<Ref<'_, I, ViewT>>
where T: ComplexField, I: Index, ViewT: Conjugate<Canonical = T>,

fn apply_in_place_scratch(&self, rhs_ncols: usize, par: Par) -> StackReq

computes the workspace layout required to apply self or the conjugate of self to a matrix with rhs_ncols columns in place

fn apply_in_place(&self, rhs: Mat<Mut<'_, T>>, par: Par, stack: &mut MemStack)

applies self to rhs, and stores the result in rhs

fn conj_apply_in_place( &self, rhs: Mat<Mut<'_, T>>, par: Par, stack: &mut MemStack, )

applies the conjugate of self to rhs, and stores the result in rhs

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

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

fn rb(&'short self) -> <SparseColMat<Inner> as Reborrow<'short>>::Target

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

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

fn rb_mut( &'short mut self, ) -> <SparseColMat<Inner> as ReborrowMut<'short>>::Target

impl<I, T, Rows, Cols, LT, RT, L, R> Sub<&SparseColMat<R>> for &SparseColMat<L>
where 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>>,

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

The resulting type after applying the - operator.

fn sub( self, rhs: &SparseColMat<R>, ) -> <&SparseColMat<L> as Sub<&SparseColMat<R>>>::Output

Performs the - operation. Read more

impl<I, T, Rows, Cols, LT, RT, L, R> Sub<&SparseColMat<R>> for SparseColMat<L>
where 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>>,

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

The resulting type after applying the - operator.

fn sub( self, rhs: &SparseColMat<R>, ) -> <SparseColMat<L> as Sub<&SparseColMat<R>>>::Output

Performs the - operation. Read more

impl<I, T, Rows, Cols, LT, RT, L, R> Sub<SparseColMat<R>> for &SparseColMat<L>
where 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>>,

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

The resulting type after applying the - operator.

fn sub( self, rhs: SparseColMat<R>, ) -> <&SparseColMat<L> as Sub<SparseColMat<R>>>::Output

Performs the - operation. Read more

impl<I, T, Rows, Cols, LT, RT, L, R> Sub<SparseColMat<R>> for SparseColMat<L>
where 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>>,

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

The resulting type after applying the - operator.

fn sub( self, rhs: SparseColMat<R>, ) -> <SparseColMat<L> as Sub<SparseColMat<R>>>::Output

Performs the - operation. Read more

impl<I, T, Rows, Cols, RT, L, R> SubAssign<&SparseColMat<R>> for SparseColMat<L>
where 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>>,

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

Performs the -= operation. Read more

impl<I, T, Rows, Cols, RT, L, R> SubAssign<SparseColMat<R>> for SparseColMat<L>
where 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>>,

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

Performs the -= operation. Read more

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

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§

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

type Output = Output

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

impl<T> AlignerFor<1> for T

type Aligner = AlignTo1<T>

The AlignTo* type which aligns Self to ALIGNMENT.

impl<T> AlignerFor<1024> for T

type Aligner = AlignTo1024<T>

The AlignTo* type which aligns Self to ALIGNMENT.

impl<T> AlignerFor<128> for T

type Aligner = AlignTo128<T>

The AlignTo* type which aligns Self to ALIGNMENT.

impl<T> AlignerFor<16> for T

type Aligner = AlignTo16<T>

The AlignTo* type which aligns Self to ALIGNMENT.

impl<T> AlignerFor<16384> for T

type Aligner = AlignTo16384<T>

The AlignTo* type which aligns Self to ALIGNMENT.

impl<T> AlignerFor<2> for T

type Aligner = AlignTo2<T>

The AlignTo* type which aligns Self to ALIGNMENT.

impl<T> AlignerFor<2048> for T

type Aligner = AlignTo2048<T>

The AlignTo* type which aligns Self to ALIGNMENT.

impl<T> AlignerFor<256> for T

type Aligner = AlignTo256<T>

The AlignTo* type which aligns Self to ALIGNMENT.

impl<T> AlignerFor<32> for T

type Aligner = AlignTo32<T>

The AlignTo* type which aligns Self to ALIGNMENT.

impl<T> AlignerFor<32768> for T

type Aligner = AlignTo32768<T>

The AlignTo* type which aligns Self to ALIGNMENT.

impl<T> AlignerFor<4> for T

type Aligner = AlignTo4<T>

The AlignTo* type which aligns Self to ALIGNMENT.

impl<T> AlignerFor<4096> for T

type Aligner = AlignTo4096<T>

The AlignTo* type which aligns Self to ALIGNMENT.

impl<T> AlignerFor<512> for T

type Aligner = AlignTo512<T>

The AlignTo* type which aligns Self to ALIGNMENT.

impl<T> AlignerFor<64> for T

type Aligner = AlignTo64<T>

The AlignTo* type which aligns Self to ALIGNMENT.

impl<T> AlignerFor<8> for T

type Aligner = AlignTo8<T>

The AlignTo* type which aligns Self to ALIGNMENT.

impl<T> AlignerFor<8192> for T

type Aligner = AlignTo8192<T>

The AlignTo* type which aligns Self to ALIGNMENT.

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

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

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

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

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

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

Mutably borrows from an owned value. Read more

impl<T> ByRef<T> for T

fn by_ref(&self) -> &T

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

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

impl<C, T> CoordTranslate for T
where C: CoordTranslate, T: Deref<Target = C>,

type From = <C as CoordTranslate>::From

Specifies the object to be translated from

fn translate(&self, from: &<T as CoordTranslate>::From) -> (i32, i32)

Translate the guest coordinate to the guest coordinate

fn depth(&self, _from: &Self::From) -> i32

Get the Z-value of current coordinate

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

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

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

type Output = Output

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

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, W> HasTypeWitness<W> for T
where W: MakeTypeWitness<Arg = T>, T: ?Sized,

const WITNESS: W = W::MAKE

A constant of the type witness

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

const TYPE_EQ: TypeEq<T, <T as Identity>::Type> = TypeEq::NEW

Proof that Self is the same type as Self::Type, provides methods for casting between Self and Self::Type.

type Type = T

The same type as Self, used to emulate type equality bounds (T == U) with associated type equality constraints (T: Identity<Type = U>).

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

fn into(self) -> U

Calls U::from(self).

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

impl<T> IntoEither for T

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

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

impl<N, A, B> MulAcc<A, B> for N
where &'x A: for<'x> Mul<&'x B, Output = N>, N: AddAssign,

fn mul_acc(&mut self, a: &A, b: &B)

Multiply and accumulate in this variable, formally *self += a * b.

impl<Rhs, Lhs, Output> MulByRef<Rhs> for Lhs
where &'a Lhs: for<'a> Mul<&'a Rhs, Output = Output>,

type Output = Output

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

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

type Output = Output

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

impl<T> Pointable for T

const ALIGN: usize

The alignment of pointer.

type Init = T

The type for initializers.

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

Initializes a with the given initializer. Read more

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

Dereferences the given pointer. Read more

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

Mutably dereferences the given pointer. Read more

unsafe fn drop(ptr: usize)

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

impl<'a, T> RCowCompatibleRef<'a> for T
where T: Clone + 'a,

type RefC = &'a T

The (preferably) ffi-safe equivalent of &Self.

type ROwned = T

The owned version of Self::RefC.

fn as_c_ref(from: &'a T) -> <T as RCowCompatibleRef<'a>>::RefC

Converts a reference to an FFI-safe type

fn as_rust_ref(from: <T as RCowCompatibleRef<'a>>::RefC) -> &'a T

Converts an FFI-safe type to a reference

impl<S> ROExtAcc for S

fn f_get<F>(&self, offset: FieldOffset<S, F, Aligned>) -> &F

Gets a reference to a field, determined by offset. Read more

fn f_get_mut<F>(&mut self, offset: FieldOffset<S, F, Aligned>) -> &mut F

Gets a muatble reference to a field, determined by offset. Read more

fn f_get_ptr<F, A>(&self, offset: FieldOffset<S, F, A>) -> *const F

Gets a const pointer to a field, the field is determined by offset. Read more

fn f_get_mut_ptr<F, A>(&mut self, offset: FieldOffset<S, F, A>) -> *mut F

Gets a mutable pointer to a field, determined by offset. Read more

impl<S> ROExtOps<Aligned> for S

fn f_replace<F>(&mut self, offset: FieldOffset<S, F, Aligned>, value: F) -> F

Replaces a field (determined by offset) with value, returning the previous value of the field. Read more

fn f_swap<F>(&mut self, offset: FieldOffset<S, F, Aligned>, right: &mut S)

Swaps a field (determined by offset) with the same field in right. Read more

fn f_get_copy<F>(&self, offset: FieldOffset<S, F, Aligned>) -> F
where F: Copy,

Gets a copy of a field (determined by offset). The field is determined by offset. Read more

impl<S> ROExtOps<Unaligned> for S

fn f_replace<F>(&mut self, offset: FieldOffset<S, F, Unaligned>, value: F) -> F

Replaces a field (determined by offset) with value, returning the previous value of the field. Read more

fn f_swap<F>(&mut self, offset: FieldOffset<S, F, Unaligned>, right: &mut S)

Swaps a field (determined by offset) with the same field in right. Read more

fn f_get_copy<F>(&self, offset: FieldOffset<S, F, Unaligned>) -> F
where F: Copy,

Gets a copy of a field (determined by offset). The field is determined by offset. Read more

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)

The target type on which the method may be called.

impl<T> Same for T

type Output = T

Should always be Self

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

fn eq_id(&self, other: &Self) -> bool

Compares the address of self with the address of other. Read more

fn piped<F, U>(self, f: F) -> U
where F: FnOnce(Self) -> U, Self: Sized,

Emulates the pipeline operator, allowing method syntax in more places. Read more

fn piped_ref<'a, F, U>(&'a self, f: F) -> U
where F: FnOnce(&'a Self) -> U,

The same as piped except that the function takes &Self Useful for functions that take &Self instead of Self. Read more

fn piped_mut<'a, F, U>(&'a mut self, f: F) -> U
where F: FnOnce(&'a mut Self) -> U,

The same as piped, except that the function takes &mut Self. Useful for functions that take &mut Self instead of Self.

fn mutated<F>(self, f: F) -> Self
where F: FnOnce(&mut Self), Self: Sized,

Mutates self using a closure taking self by mutable reference, passing it along the method chain. Read more

fn observe<F>(self, f: F) -> Self
where F: FnOnce(&Self), Self: Sized,

Observes the value of self, passing it along unmodified. Useful in long method chains. Read more

fn into_<T>(self) -> T
where Self: Into<T>,

Performs a conversion with Into. using the turbofish .into_::<_>() syntax. Read more

fn as_ref_<T>(&self) -> &T
where Self: AsRef<T>, T: ?Sized,

Performs a reference to reference conversion with AsRef, using the turbofish .as_ref_::<_>() syntax. Read more

fn as_mut_<T>(&mut self) -> &mut T
where Self: AsMut<T>, T: ?Sized,

Performs a mutable reference to mutable reference conversion with AsMut, using the turbofish .as_mut_::<_>() syntax. Read more

fn drop_(self)
where Self: Sized,

Drops self using method notation. Alternative to std::mem::drop. Read more

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

type Output = Output

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

impl<SS, SP> SupersetOf<SS> for SP
where SS: SubsetOf<SP>,

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.

impl<SS, SP> SupersetOf<SS> for SP
where SS: SubsetOf<SP>,

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).

unsafe fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.

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

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

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

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

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

impl<This> TransmuteElement for This
where This: ?Sized,

unsafe fn transmute_element<T>(self) -> Self::TransmutedPtr
where Self: CanTransmuteElement<T>,

Transmutes the element type of this pointer.. Read more

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

type Error = Infallible

The type returned in the event of a conversion error.

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

Performs the conversion.

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

type Error = >::Error

The type returned in the event of a conversion error.

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

Performs the conversion.

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

type Type = T

This is always Self.

fn into_type(self) -> Self::Type
where Self: Sized, Self::Type: Sized,

Converts a value back to the original type.

fn as_type(&self) -> &Self::Type

Converts a reference back to the original type.

fn as_type_mut(&mut self) -> &mut Self::Type

Converts a mutable reference back to the original type.

fn into_type_box(self: Box<Self>) -> Box<Self::Type>

Converts a box back to the original type.

fn into_type_arc(this: Arc<Self>) -> Arc<Self::Type>

Converts an Arc back to the original type. Read more

fn into_type_rc(this: Rc<Self>) -> Rc<Self::Type>

Converts an Rc back to the original type. Read more

fn from_type(this: Self::Type) -> Self
where Self: Sized, Self::Type: Sized,

Converts a value back to the original type.

fn from_type_ref(this: &Self::Type) -> &Self

Converts a reference back to the original type.

fn from_type_mut(this: &mut Self::Type) -> &mut Self

Converts a mutable reference back to the original type.

fn from_type_box(this: Box<Self::Type>) -> Box<Self>

Converts a box back to the original type.

fn from_type_arc(this: Arc<Self::Type>) -> Arc<Self>

Converts an Arc back to the original type.

fn from_type_rc(this: Rc<Self::Type>) -> Rc<Self>

Converts an Rc back to the original type.

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn vzip(self) -> V

impl<T, Right> ClosedAdd<Right> for T
where T: Add<Right, Output = T> + AddAssign<Right>,

impl<T, Right> ClosedAdd<Right> for T
where T: Add<Right, Output = T> + AddAssign<Right>,

impl<T, Right> ClosedAddAssign<Right> for T
where T: ClosedAdd<Right> + AddAssign<Right>,

impl<T, Right> ClosedDiv<Right> for T
where T: Div<Right, Output = T> + DivAssign<Right>,

impl<T, Right> ClosedDiv<Right> for T
where T: Div<Right, Output = T> + DivAssign<Right>,

impl<T, Right> ClosedDivAssign<Right> for T
where T: ClosedDiv<Right> + DivAssign<Right>,

impl<T, Right> ClosedMul<Right> for T
where T: Mul<Right, Output = T> + MulAssign<Right>,

impl<T, Right> ClosedMul<Right> for T
where T: Mul<Right, Output = T> + MulAssign<Right>,

impl<T, Right> ClosedMulAssign<Right> for T
where T: ClosedMul<Right> + MulAssign<Right>,

impl<T> ClosedNeg for T
where T: Neg<Output = T>,

impl<T> ClosedNeg for T
where T: Neg<Output = T>,

impl<T, Right> ClosedSub<Right> for T
where T: Sub<Right, Output = T> + SubAssign<Right>,

impl<T, Right> ClosedSub<Right> for T
where T: Sub<Right, Output = T> + SubAssign<Right>,

impl<T, Right> ClosedSubAssign<Right> for T
where T: ClosedSub<Right> + SubAssign<Right>,

impl<T> SendAlias for T