extendr_api::prelude::sparse

Struct SparseRowMatMut

pub struct SparseRowMatMut<'a, I, E>
where
    I: Index,
    E: Entity,
{
    pub(crate) symbolic: SymbolicSparseRowMatRef<'a, I>,
    pub(crate) values: SliceGroupMut<'a, E>,
}
Expand description

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

Fields§

§symbolic: SymbolicSparseRowMatRef<'a, I>§values: SliceGroupMut<'a, E>

Implementations§

§

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

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

Creates a new sparse matrix view.

§Panics

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

pub fn nrows(&self) -> usize

Returns the number of rows of the matrix.

pub fn ncols(&self) -> usize

Returns the number of columns of the matrix.

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

Returns the number of rows and columns of the matrix.

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

Returns a view over self.

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

Returns a mutable view over self.

Note that the symbolic structure cannot be changed through this view.

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

Copies self into a newly allocated matrix.

§Note

Allows unsorted matrices, producing an unsorted output.

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

Copies self into a newly allocated matrix with sorted indices.

§Note

Allows unsorted matrices, producing a sorted output.

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

Copies self into a newly allocated dense matrix

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

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

§Note

Allows unsorted matrices, producing a sorted output.

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

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

pub fn transpose_mut(self) -> SparseColMatMut<'a, I, E>

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

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

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

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

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

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

Returns a view over the conjugate of self.

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

Returns a view over the conjugate of self.

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

Returns a view over the conjugate transpose of self.

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

Returns a view over the conjugate transpose of self.

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

Returns the numerical values of the matrix.

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

Returns the numerical values of the matrix.

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

Returns the numerical values of row i of the matrix.

§Panics:

Panics if i >= nrows.

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

Returns the numerical values of row i of the matrix.

§Panics:

Panics if i >= nrows.

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

Returns the symbolic structure of the matrix.

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

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

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

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

pub fn compute_nnz(&self) -> usize

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

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

§Note

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

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

Returns the column pointers.

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

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

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

Returns the column indices.

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

Returns the column indices of row i.

§Panics

Panics if i >= self.nrows().

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

Returns the column indices of row i.

§Panics

Panics if i >= self.ncols().

pub fn row_range(&self, i: usize) -> Range<usize>

Returns the range that the row i occupies in self.col_indices().

§Panics

Panics if i >= self.nrows().

pub unsafe fn row_range_unchecked(&self, i: usize) -> Range<usize>

Returns the range that the row i occupies in self.col_indices().

§Safety

The behavior is undefined if i >= self.nrows().

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

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

§Panics

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

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

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

§Panics

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

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

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

§Panics

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

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

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

§Panics

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

§

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

pub fn fill_from_order_and_values( &mut self, order: &ValuesOrder<I>, values: <<E as Entity>::Group as ForType>::FaerOf<&[<E as Entity>::Unit]>, mode: FillMode, )

Fill the matrix from a previously created value order. The provided values must correspond to the same indices that were provided in the function call from which the order was created.

§Note

The symbolic structure is not changed.

§

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

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

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

§Note

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

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

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

§Note

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

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

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

§Note

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

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

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

§Note

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

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

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

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

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

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

Returns the QR decomposition of self.

Trait Implementations§

§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

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

§

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

Performs the += operation. Read more
§

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

§

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

Performs the += operation. Read more
§

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

§

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

Performs the += operation. Read more
§

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

§

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

Performs the += operation. Read more
§

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

§

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

Performs the += operation. Read more
§

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

§

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

Performs the += operation. Read more
§

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

§

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

Performs the += operation. Read more
§

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

§

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

Performs the += operation. Read more
§

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

§

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

Formats the value using the given formatter. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the / operator.
§

fn div( self, other: Scale<RhsE>, ) -> <&SparseRowMatMut<'_, I, LhsE> as Div<Scale<RhsE>>>::Output

Performs the / operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the / operator.
§

fn div( self, other: Scale<RhsE>, ) -> <SparseRowMatMut<'_, I, LhsE> as Div<Scale<RhsE>>>::Output

Performs the / operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the / operator.
§

fn div(self, other: f32) -> <&SparseRowMatMut<'_, I, RhsE> as Div<f32>>::Output

Performs the / operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the / operator.
§

fn div(self, other: f32) -> <SparseRowMatMut<'_, I, RhsE> as Div<f32>>::Output

Performs the / operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the / operator.
§

fn div(self, other: f64) -> <&SparseRowMatMut<'_, I, RhsE> as Div<f64>>::Output

Performs the / operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the / operator.
§

fn div(self, other: f64) -> <SparseRowMatMut<'_, I, RhsE> as Div<f64>>::Output

Performs the / operation. Read more
§

impl<I, LhsE, RhsE> DivAssign<Scale<RhsE>> for SparseRowMatMut<'_, I, LhsE>
where I: Index, LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the /= operation. Read more
§

impl<I, LhsE> DivAssign<f32> for SparseRowMatMut<'_, I, LhsE>
where I: Index, LhsE: ComplexField,

§

fn div_assign(&mut self, other: f32)

Performs the /= operation. Read more
§

impl<I, LhsE> DivAssign<f64> for SparseRowMatMut<'_, I, LhsE>
where I: Index, LhsE: ComplexField,

§

fn div_assign(&mut self, other: f64)

Performs the /= operation. Read more
§

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

§

type Output = E

The returned type after indexing.
§

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

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

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

§

fn index_mut( &mut self, _: (usize, usize), ) -> &mut <SparseRowMatMut<'_, I, E> as Index<(usize, usize)>>::Output

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

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

§

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

§

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

§

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

§

fn rows(&self) -> usize

§

fn cols(&self) -> usize

§

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

Expose dense or sparse access to the matrix.
§

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

§

type Output = Col<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Col<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Col<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Col<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Col<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Col<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Col<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Col<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Col<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Col<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Col<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Col<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, LhsE, RhsE> MulAssign<Scale<RhsE>> for SparseRowMatMut<'_, I, LhsE>
where I: Index, LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the *= operation. Read more
§

impl<I, LhsE> MulAssign<f32> for SparseRowMatMut<'_, I, LhsE>
where I: Index, LhsE: ComplexField,

§

fn mul_assign(&mut self, other: f32)

Performs the *= operation. Read more
§

impl<I, LhsE> MulAssign<f64> for SparseRowMatMut<'_, I, LhsE>
where I: Index, LhsE: ComplexField,

§

fn mul_assign(&mut self, other: f64)

Performs the *= operation. Read more
§

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

§

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

The resulting type after applying the - operator.
§

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

Performs the unary - operation. Read more
§

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

§

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

The resulting type after applying the - operator.
§

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

Performs the unary - operation. Read more
§

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

§

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

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

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

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

§

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

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

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

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

§

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

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

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

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

§

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

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

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

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

§

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

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

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

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

§

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

§

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

§

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

§

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

§

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

§

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

§

fn nnz(&self) -> usize

Number of non-zero elements in the matrix.
§

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

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

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

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

§

type Output = SparseRowMat<I, E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

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

§

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

Performs the -= operation. Read more
§

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

§

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

Performs the -= operation. Read more
§

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

§

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

Performs the -= operation. Read more
§

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

§

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

Performs the -= operation. Read more
§

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

§

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

Performs the -= operation. Read more
§

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

§

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

Performs the -= operation. Read more
§

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

§

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

Performs the -= operation. Read more
§

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

§

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

Performs the -= operation. Read more

Auto Trait Implementations§

§

impl<'a, I, E> Freeze for SparseRowMatMut<'a, I, E>
where <<E as Entity>::Group as ForType>::FaerOf<*mut [<E as Entity>::Unit]>: Freeze,

§

impl<'a, I, E> RefUnwindSafe for SparseRowMatMut<'a, I, E>
where <<E as Entity>::Group as ForType>::FaerOf<*mut [<E as Entity>::Unit]>: RefUnwindSafe, I: RefUnwindSafe,

§

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

§

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

§

impl<'a, I, E> Unpin for SparseRowMatMut<'a, I, E>
where <<E as Entity>::Group as ForType>::FaerOf<*mut [<E as Entity>::Unit]>: Unpin,

§

impl<'a, I, E> !UnwindSafe for SparseRowMatMut<'a, I, E>

Blanket Implementations§

Source§

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

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

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

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

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

Source§

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

Mutably borrows from an owned value. Read more
Source§

impl<T> 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
§

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

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

§

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