Struct extendr_api::prelude::Mat

#[repr(C)]
pub struct Mat<E>
where E: Entity,
{ inner: MatOwnImpl<E>, row_capacity: usize, col_capacity: usize, __marker: PhantomData<E>, }
Expand description

Heap allocated resizable matrix, similar to a 2D Vec.

§Note

The memory layout of Mat is guaranteed to be column-major, meaning that it has a row stride of 1, and an unspecified column stride that can be queried with Mat::col_stride.

This implies that while each individual column is stored contiguously in memory, the matrix as a whole may not necessarily be contiguous. The implementation may add padding at the end of each column when overaligning each column can provide a performance gain.

Let us consider a 3×4 matrix

 0 │ 3 │ 6 │  9
───┼───┼───┼───
 1 │ 4 │ 7 │ 10
───┼───┼───┼───
 2 │ 5 │ 8 │ 11

The memory representation of the data held by such a matrix could look like the following:

0 1 2 X 3 4 5 X 6 7 8 X 9 10 11 X

where X represents padding elements.

Fields§

§inner: MatOwnImpl<E>§row_capacity: usize§col_capacity: usize§__marker: PhantomData<E>

Implementations§

§

impl<E> Mat<E>

pub fn solve_lower_triangular_in_place( &self, rhs: impl ColBatchMut<<E as Conjugate>::Canonical>, )

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

pub fn solve_upper_triangular_in_place( &self, rhs: impl ColBatchMut<<E as Conjugate>::Canonical>, )

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

pub fn solve_unit_lower_triangular_in_place( &self, rhs: impl ColBatchMut<<E as Conjugate>::Canonical>, )

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

The diagonal of the matrix is not accessed.

pub fn solve_unit_upper_triangular_in_place( &self, rhs: impl ColBatchMut<<E as Conjugate>::Canonical>, )

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

The diagonal of the matrix is not accessed.

pub fn solve_lower_triangular<ViewE, B>( &self, rhs: B, ) -> <B as ColBatch<ViewE>>::Owned
where ViewE: Conjugate<Canonical = <E as Conjugate>::Canonical>, B: ColBatch<ViewE>,

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

pub fn solve_upper_triangular<ViewE, B>( &self, rhs: B, ) -> <B as ColBatch<ViewE>>::Owned
where ViewE: Conjugate<Canonical = <E as Conjugate>::Canonical>, B: ColBatch<ViewE>,

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

pub fn solve_unit_lower_triangular<ViewE, B>( &self, rhs: B, ) -> <B as ColBatch<ViewE>>::Owned
where ViewE: Conjugate<Canonical = <E as Conjugate>::Canonical>, B: ColBatch<ViewE>,

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

The diagonal of the matrix is not accessed.

pub fn solve_unit_upper_triangular<ViewE, B>( &self, rhs: B, ) -> <B as ColBatch<ViewE>>::Owned
where ViewE: Conjugate<Canonical = <E as Conjugate>::Canonical>, B: ColBatch<ViewE>,

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

The diagonal of the matrix is not accessed.

pub fn cholesky( &self, side: Side, ) -> Result<Cholesky<<E as Conjugate>::Canonical>, CholeskyError>

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

pub fn lblt(&self, side: Side) -> Lblt<<E as Conjugate>::Canonical>

Returns the Bunch-Kaufman decomposition of self. Only the provided side is accessed.

pub fn partial_piv_lu(&self) -> PartialPivLu<<E as Conjugate>::Canonical>

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

pub fn full_piv_lu(&self) -> FullPivLu<<E as Conjugate>::Canonical>

Returns the LU decomposition of self with full pivoting.

pub fn qr(&self) -> Qr<<E as Conjugate>::Canonical>

Returns the QR decomposition of self.

pub fn col_piv_qr(&self) -> ColPivQr<<E as Conjugate>::Canonical>

Returns the QR decomposition of self with column pivoting.

pub fn svd(&self) -> Svd<<E as Conjugate>::Canonical>

Returns the SVD of self.

pub fn thin_svd(&self) -> ThinSvd<<E as Conjugate>::Canonical>

Returns the thin SVD of self.

pub fn selfadjoint_eigendecomposition( &self, side: Side, ) -> SelfAdjointEigendecomposition<<E as Conjugate>::Canonical>

Returns the eigendecomposition of self, assuming it is self-adjoint. Only the provided side is accessed.

pub fn eigendecomposition<ComplexE>(&self) -> Eigendecomposition<ComplexE>
where ComplexE: ComplexField<Real = <<E as Conjugate>::Canonical as ComplexField>::Real>,

Returns the eigendecomposition of self, as a complex matrix.

pub fn complex_eigendecomposition( &self, ) -> Eigendecomposition<<E as Conjugate>::Canonical>

Returns the eigendecomposition of self, when E is in the complex domain.

pub fn determinant(&self) -> <E as Conjugate>::Canonical

Returns the determinant of self.

pub fn selfadjoint_eigenvalues( &self, side: Side, ) -> Vec<<<E as Conjugate>::Canonical as ComplexField>::Real>

Returns the eigenvalues of self, assuming it is self-adjoint. Only the provided side is accessed. The order of the eigenvalues is currently unspecified.

pub fn singular_values( &self, ) -> Vec<<<E as Conjugate>::Canonical as ComplexField>::Real>

Returns the singular values of self, in nonincreasing order.

pub fn eigenvalues<ComplexE>(&self) -> Vec<ComplexE>
where ComplexE: ComplexField<Real = <<E as Conjugate>::Canonical as ComplexField>::Real>,

Returns the eigenvalues of self, as complex values. The order of the eigenvalues is currently unspecified.

pub fn complex_eigenvalues(&self) -> Vec<<E as Conjugate>::Canonical>

Returns the eigenvalues of self, when E is in the complex domain. The order of the eigenvalues is currently unspecified.

§

impl<E> Mat<E>
where E: Entity,

pub fn new() -> Mat<E>

Returns an empty matrix of dimension 0×0.

pub fn with_capacity(row_capacity: usize, col_capacity: usize) -> Mat<E>

Returns a new matrix with dimensions (0, 0), with enough capacity to hold a maximum of row_capacity rows and col_capacity columns without reallocating. If either is 0, the matrix will not allocate.

§Panics

The function panics if the total capacity in bytes exceeds isize::MAX.

pub fn from_fn( nrows: usize, ncols: usize, f: impl FnMut(usize, usize) -> E, ) -> Mat<E>

Returns a new matrix with dimensions (nrows, ncols), filled with the provided function.

§Panics

The function panics if the total capacity in bytes exceeds isize::MAX.

pub fn zeros(nrows: usize, ncols: usize) -> Mat<E>

Returns a new matrix with dimensions (nrows, ncols), filled with zeros.

§Panics

The function panics if the total capacity in bytes exceeds isize::MAX.

pub fn identity(nrows: usize, ncols: usize) -> Mat<E>
where E: ComplexField,

Returns a new matrix with dimensions (nrows, ncols), filled with zeros, except the main diagonal which is filled with ones.

§Panics

The function panics if the total capacity in bytes exceeds isize::MAX.

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 unsafe fn set_dims(&mut self, nrows: usize, ncols: usize)

Set the dimensions of the matrix.

§Safety

The behavior is undefined if any of the following conditions are violated:

  • nrows < self.row_capacity().
  • ncols < self.col_capacity().
  • The elements that were previously out of bounds but are now in bounds must be initialized.

pub fn as_ptr( &self, ) -> <<E as Entity>::Group as ForType>::FaerOf<*const <E as Entity>::Unit>

Returns a pointer to the data of the matrix.

pub fn as_ptr_mut( &mut self, ) -> <<E as Entity>::Group as ForType>::FaerOf<*mut <E as Entity>::Unit>

Returns a mutable pointer to the data of the matrix.

pub fn row_capacity(&self) -> usize

Returns the row capacity, that is, the number of rows that the matrix is able to hold without needing to reallocate, excluding column insertions.

pub fn col_capacity(&self) -> usize

Returns the column capacity, that is, the number of columns that the matrix is able to hold without needing to reallocate, excluding row insertions.

pub fn row_stride(&self) -> isize

Returns the offset between the first elements of two successive rows in the matrix. Always returns 1 since the matrix is column major.

pub fn col_stride(&self) -> isize

Returns the offset between the first elements of two successive columns in the matrix.

pub fn reserve_exact(&mut self, row_capacity: usize, col_capacity: usize)

Reserves the minimum capacity for row_capacity rows and col_capacity columns without reallocating. Does nothing if the capacity is already sufficient.

§Panics

The function panics if the new total capacity in bytes exceeds isize::MAX.

pub fn resize_with( &mut self, new_nrows: usize, new_ncols: usize, f: impl FnMut(usize, usize) -> E, )

Resizes the matrix in-place so that the new dimensions are (new_nrows, new_ncols). New elements are created with the given function f, so that elements at indices (i, j) are created by calling f(i, j).

pub fn truncate(&mut self, new_nrows: usize, new_ncols: usize)

Truncates the matrix so that its new dimensions are new_nrows and new_ncols.
Both of the new dimensions must be smaller than or equal to the current dimensions.

§Panics
  • Panics if new_nrows > self.nrows().
  • Panics if new_ncols > self.ncols().

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

Returns a reference to a slice over the column at the given index.

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

Returns a mutable reference to a slice over the column at the given index.

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

👎Deprecated: replaced by Mat::col_as_slice

Returns a reference to a slice over the column at the given index.

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

👎Deprecated: replaced by Mat::col_as_slice_mut

Returns a mutable reference to a slice over the column at the given index.

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

Returns a view over the matrix.

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

Returns a mutable view over the matrix.

pub unsafe fn get_unchecked<RowRange, ColRange>( &self, row: RowRange, col: ColRange, ) -> <MatRef<'_, E> as MatIndex<RowRange, ColRange>>::Target
where MatRef<'a, E>: for<'a> MatIndex<RowRange, ColRange>,

Returns references to the element at the given indices, or submatrices if either row or col is a range.

§Note

The values pointed to by the references are expected to be initialized, even if the pointed-to value is not read, otherwise the behavior is undefined.

§Safety

The behavior is undefined if any of the following conditions are violated:

  • row must be contained in [0, self.nrows()).
  • col must be contained in [0, self.ncols()).

pub fn get<RowRange, ColRange>( &self, row: RowRange, col: ColRange, ) -> <MatRef<'_, E> as MatIndex<RowRange, ColRange>>::Target
where MatRef<'a, E>: for<'a> MatIndex<RowRange, ColRange>,

Returns references to the element at the given indices, or submatrices if either row or col is a range, with bound checks.

§Note

The values pointed to by the references are expected to be initialized, even if the pointed-to value is not read, otherwise the behavior is undefined.

§Panics

The function panics if any of the following conditions are violated:

  • row must be contained in [0, self.nrows()).
  • col must be contained in [0, self.ncols()).

pub unsafe fn get_mut_unchecked<RowRange, ColRange>( &mut self, row: RowRange, col: ColRange, ) -> <MatMut<'_, E> as MatIndex<RowRange, ColRange>>::Target
where MatMut<'a, E>: for<'a> MatIndex<RowRange, ColRange>,

Returns mutable references to the element at the given indices, or submatrices if either row or col is a range.

§Note

The values pointed to by the references are expected to be initialized, even if the pointed-to value is not read, otherwise the behavior is undefined.

§Safety

The behavior is undefined if any of the following conditions are violated:

  • row must be contained in [0, self.nrows()).
  • col must be contained in [0, self.ncols()).

pub fn get_mut<RowRange, ColRange>( &mut self, row: RowRange, col: ColRange, ) -> <MatMut<'_, E> as MatIndex<RowRange, ColRange>>::Target
where MatMut<'a, E>: for<'a> MatIndex<RowRange, ColRange>,

Returns mutable references to the element at the given indices, or submatrices if either row or col is a range, with bound checks.

§Note

The values pointed to by the references are expected to be initialized, even if the pointed-to value is not read, otherwise the behavior is undefined.

§Panics

The function panics if any of the following conditions are violated:

  • row must be contained in [0, self.nrows()).
  • col must be contained in [0, self.ncols()).

pub unsafe fn read_unchecked(&self, row: usize, col: usize) -> E

Reads the value of the element at the given indices.

§Safety

The behavior is undefined if any of the following conditions are violated:

  • row < self.nrows().
  • col < self.ncols().

pub fn read(&self, row: usize, col: usize) -> E

Reads the value of the element at the given indices, with bound checks.

§Panics

The function panics if any of the following conditions are violated:

  • row < self.nrows().
  • col < self.ncols().

pub unsafe fn write_unchecked(&mut self, row: usize, col: usize, value: E)

Writes the value to the element at the given indices.

§Safety

The behavior is undefined if any of the following conditions are violated:

  • row < self.nrows().
  • col < self.ncols().

pub fn write(&mut self, row: usize, col: usize, value: E)

Writes the value to the element at the given indices, with bound checks.

§Panics

The function panics if any of the following conditions are violated:

  • row < self.nrows().
  • col < self.ncols().

pub fn copy_from(&mut self, other: impl AsMatRef<E>)

Copies the values from other into self.

pub fn fill_zero(&mut self)
where E: ComplexField,

Fills the elements of self with zeros.

pub fn fill(&mut self, constant: E)

Fills the elements of self with copies of constant.

pub fn transpose(&self) -> MatRef<'_, E>

Returns a view over the transpose of self.

pub fn conjugate(&self) -> MatRef<'_, <E as Conjugate>::Conj>
where E: Conjugate,

Returns a view over the conjugate of self.

pub fn adjoint(&self) -> MatRef<'_, <E as Conjugate>::Conj>
where E: Conjugate,

Returns a view over the conjugate transpose of self.

pub fn diagonal(&self) -> DiagRef<'_, E>

Returns a view over the diagonal of the matrix.

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

Returns an owning Mat of the data

pub fn has_nan(&self) -> bool
where E: ComplexField,

Returns true if any of the elements is NaN, otherwise returns false.

pub fn is_all_finite(&self) -> bool
where E: ComplexField,

Returns true if all of the elements are finite, otherwise returns false.

pub fn norm_max(&self) -> <E as ComplexField>::Real
where E: ComplexField,

Returns the maximum norm of self.

pub fn norm_l1(&self) -> <E as ComplexField>::Real
where E: ComplexField,

Returns the L1 norm of self.

pub fn norm_l2(&self) -> <E as ComplexField>::Real
where E: ComplexField,

Returns the L2 norm of self.

pub fn squared_norm_l2(&self) -> <E as ComplexField>::Real
where E: ComplexField,

Returns the squared L2 norm of self.

pub fn sum(&self) -> E
where E: ComplexField,

Returns the sum of self.

pub fn kron(&self, rhs: impl As2D<E>) -> Mat<E>
where E: ComplexField,

Kroneckor product of self and rhs.

This is an allocating operation; see faer::linalg::kron for the allocation-free version or more info in general.

pub fn col_chunks(&self, chunk_size: usize) -> impl DoubleEndedIterator

Returns an iterator that provides successive chunks of the columns of a view over this matrix, with each having at most chunk_size columns.

If the number of columns is a multiple of chunk_size, then all chunks have chunk_size columns.

pub fn col_chunks_mut(&mut self, chunk_size: usize) -> impl DoubleEndedIterator

Returns an iterator that provides successive chunks of the columns of a mutable view over this matrix, with each having at most chunk_size columns.

If the number of columns is a multiple of chunk_size, then all chunks have chunk_size columns.

pub fn par_col_chunks(&self, chunk_size: usize) -> impl IndexedParallelIterator

Returns a parallel iterator that provides successive chunks of the columns of a view over this matrix, with each having at most chunk_size columns.

If the number of columns is a multiple of chunk_size, then all chunks have chunk_size columns.

Only available with the rayon feature.

pub fn par_col_chunks_mut( &mut self, chunk_size: usize, ) -> impl IndexedParallelIterator

Returns a parallel iterator that provides successive chunks of the columns of a mutable view over this matrix, with each having at most chunk_size columns.

If the number of columns is a multiple of chunk_size, then all chunks have chunk_size columns.

Only available with the rayon feature.

pub fn row_chunks(&self, chunk_size: usize) -> impl DoubleEndedIterator

Returns an iterator that provides successive chunks of the rows of a view over this matrix, with each having at most chunk_size rows.

If the number of rows is a multiple of chunk_size, then all chunks have chunk_size rows.

pub fn row_chunks_mut(&mut self, chunk_size: usize) -> impl DoubleEndedIterator

Returns an iterator that provides successive chunks of the rows of a mutable view over this matrix, with each having at most chunk_size rows.

If the number of rows is a multiple of chunk_size, then all chunks have chunk_size rows.

pub fn par_row_chunks(&self, chunk_size: usize) -> impl IndexedParallelIterator

Returns a parallel iterator that provides successive chunks of the rows of a view over this matrix, with each having at most chunk_size rows.

If the number of rows is a multiple of chunk_size, then all chunks have chunk_size rows.

Only available with the rayon feature.

pub fn par_row_chunks_mut( &mut self, chunk_size: usize, ) -> impl IndexedParallelIterator

Returns a parallel iterator that provides successive chunks of the rows of a mutable view over this matrix, with each having at most chunk_size rows.

If the number of rows is a multiple of chunk_size, then all chunks have chunk_size rows.

Only available with the rayon feature.

Trait Implementations§

§

impl<E, LhsE, RhsE> Add<&Mat<RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the + operator.
§

fn add(self, other: &Mat<RhsE>) -> <&Mat<LhsE> as Add<&Mat<RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<&Mat<RhsE>> for &MatMut<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<&Mat<RhsE>> for &MatRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<&Mat<RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the + operator.
§

fn add(self, other: &Mat<RhsE>) -> <Mat<LhsE> as Add<&Mat<RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<&Mat<RhsE>> for MatMut<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<&Mat<RhsE>> for MatRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<&MatMut<'_, RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<&MatMut<'_, RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<&MatRef<'_, RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<&MatRef<'_, RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<Mat<RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the + operator.
§

fn add(self, other: Mat<RhsE>) -> <&Mat<LhsE> as Add<Mat<RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<Mat<RhsE>> for &MatMut<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<Mat<RhsE>> for &MatRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<Mat<RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the + operator.
§

fn add(self, other: Mat<RhsE>) -> <Mat<LhsE> as Add<Mat<RhsE>>>::Output

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<Mat<RhsE>> for MatMut<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<Mat<RhsE>> for MatRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<MatMut<'_, RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<MatMut<'_, RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<MatRef<'_, RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

impl<E, LhsE, RhsE> Add<MatRef<'_, RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the + operator.
§

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

Performs the + operation. Read more
§

impl<LhsE, RhsE> AddAssign<&Mat<RhsE>> for Mat<LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the += operation. Read more
§

impl<LhsE, RhsE> AddAssign<&Mat<RhsE>> for MatMut<'_, LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the += operation. Read more
§

impl<LhsE, RhsE> AddAssign<&MatMut<'_, RhsE>> for Mat<LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the += operation. Read more
§

impl<LhsE, RhsE> AddAssign<&MatRef<'_, RhsE>> for Mat<LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the += operation. Read more
§

impl<LhsE, RhsE> AddAssign<Mat<RhsE>> for Mat<LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the += operation. Read more
§

impl<LhsE, RhsE> AddAssign<Mat<RhsE>> for MatMut<'_, LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the += operation. Read more
§

impl<LhsE, RhsE> AddAssign<MatMut<'_, RhsE>> for Mat<LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the += operation. Read more
§

impl<LhsE, RhsE> AddAssign<MatRef<'_, RhsE>> for Mat<LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the += operation. Read more
§

impl<E> As2D<E> for Mat<E>
where E: Entity,

§

fn as_2d_ref(&self) -> MatRef<'_, E>

Convert to a 2D matrix view.
§

impl<E> As2DMut<E> for Mat<E>
where E: Entity,

§

fn as_2d_mut(&mut self) -> MatMut<'_, E>

Convert to a mutable 2D matrix view.
§

impl<E> AsMatMut<E> for Mat<E>
where E: Entity,

§

fn as_mat_mut(&mut self) -> MatMut<'_, E>

Convert to a mutable matrix view.
§

impl<E> AsMatRef<E> for Mat<E>
where E: Entity,

§

fn as_mat_ref(&self) -> MatRef<'_, E>

Convert to a matrix view.
§

impl<E> Clone for Mat<E>
where E: Entity,

§

fn clone(&self) -> Mat<E>

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

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

Performs copy-assignment from source. Read more
§

impl<E> ColBatch<E> for Mat<E>
where E: Conjugate,

§

type Owned = Mat<<E as Conjugate>::Canonical>

Corresponding owning type.
§

fn new_owned_zeros(nrows: usize, ncols: usize) -> <Mat<E> as ColBatch<E>>::Owned

Constructor of the owned type that initializes the values to zero.
§

fn new_owned_copied(src: &Mat<E>) -> <Mat<E> as ColBatch<E>>::Owned

Constructor of the owned type that copies the values.
§

fn resize_owned( owned: &mut <Mat<E> as ColBatch<E>>::Owned, nrows: usize, ncols: usize, )

Resize an owned column or matrix.
§

impl<E> Debug for Mat<E>
where E: Entity,

§

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

Formats the value using the given formatter. Read more
§

impl<E> Default for Mat<E>
where E: Entity,

§

fn default() -> Mat<E>

Returns the “default value” for a type. Read more
§

impl<E> DenseAccess<E> for Mat<E>
where E: Entity,

§

fn fetch_single(&self, row: usize, col: usize) -> E

§

impl<'a, E> Deserialize<'a> for Mat<E>
where E: Entity + Deserialize<'a>,

§

fn deserialize<D>(d: D) -> Result<Mat<E>, <D as Deserializer<'a>>::Error>
where D: Deserializer<'a>,

Deserialize this value from the given Serde deserializer. Read more
§

impl<E> Distribution<Mat<E>> for NormalMat<E>

§

fn sample<R>(&self, rng: &mut R) -> Mat<E>
where R: Rng + ?Sized,

Generate a random value of T, using rng as the source of randomness.
source§

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>
where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness. Read more
source§

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>
where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F Read more
§

impl<E> Distribution<Mat<E>> for StandardMat

§

fn sample<R>(&self, rng: &mut R) -> Mat<E>
where R: Rng + ?Sized,

Generate a random value of T, using rng as the source of randomness.
source§

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>
where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness. Read more
source§

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>
where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F Read more
§

impl<E> Distribution<Mat<E>> for StandardNormalMat

§

fn sample<R>(&self, rng: &mut R) -> Mat<E>
where R: Rng + ?Sized,

Generate a random value of T, using rng as the source of randomness.
source§

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>
where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness. Read more
source§

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>
where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F Read more
§

impl<E> Distribution<Mat<E>> for UnitaryMat

§

fn sample<R>(&self, rng: &mut R) -> Mat<E>
where R: Rng + ?Sized,

Generate a random value of T, using rng as the source of randomness.
source§

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>
where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness. Read more
source§

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>
where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F Read more
§

impl<E> Drop for Mat<E>
where E: Entity,

§

fn drop(&mut self)

Executes the destructor for this type. Read more
source§

impl From<Mat<f64>> for RMatrix<Rfloat>

source§

fn from(value: Mat<f64>) -> Self

Converts to this type from the input type.
source§

impl From<Mat<f64>> for RMatrix<f64>

Convert a faer::Mat<f64> into an RMatrix<f64> which is not NA aware.

source§

fn from(value: Mat<f64>) -> Self

Converts to this type from the input type.
source§

impl From<Mat<f64>> for Robj

source§

fn from(value: Mat<f64>) -> Self

Converts to this type from the input type.
source§

impl From<RArray<f64, [usize; 2]>> for Mat<f64>

source§

fn from(value: RMatrix<f64>) -> Self

Converts to this type from the input type.
source§

impl From<RArray<i32, [usize; 2]>> for Mat<f64>

source§

fn from(value: RMatrix<i32>) -> Self

Converts to this type from the input type.
§

impl<E> Index<(usize, usize)> for Mat<E>
where E: SimpleEntity,

§

type Output = E

The returned type after indexing.
§

fn index(&self, _: (usize, usize)) -> &E

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

impl<E> IndexMut<(usize, usize)> for Mat<E>
where E: SimpleEntity,

§

fn index_mut(&mut self, _: (usize, usize)) -> &mut E

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

impl<E> Matrix<E> for Mat<E>
where E: Entity,

§

fn rows(&self) -> usize

§

fn cols(&self) -> usize

§

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

Expose dense or sparse access to the matrix.
§

impl<E, LhsE, RhsE> Mul<&Col<RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Col<E>

The resulting type after applying the * operator.
§

fn mul(self, other: &Col<RhsE>) -> <&Mat<LhsE> as Mul<&Col<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Col<RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Col<E>

The resulting type after applying the * operator.
§

fn mul(self, other: &Col<RhsE>) -> <Mat<LhsE> as Mul<&Col<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Col<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&ColMut<'_, RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Col<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&ColRef<'_, RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Col<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&ColRef<'_, RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Col<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Diag<RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

fn mul(self, other: &Diag<RhsE>) -> <&Mat<LhsE> as Mul<&Diag<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Diag<RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

fn mul(self, other: &Diag<RhsE>) -> <Mat<LhsE> as Mul<&Diag<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&DiagMut<'_, RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&DiagMut<'_, RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&DiagRef<'_, RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E> Mul<&Mat<E>> for &Perm<I>

§

type Output = Mat<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.
§

fn mul(self, other: &Mat<E>) -> <&Perm<I> as Mul<&Mat<E>>>::Output

Performs the * operation. Read more
§

impl<I, E> Mul<&Mat<E>> for &PermRef<'_, I>

§

type Output = Mat<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.
§

fn mul(self, other: &Mat<E>) -> <&PermRef<'_, I> as Mul<&Mat<E>>>::Output

Performs the * operation. Read more
§

impl<I, E> Mul<&Mat<E>> for Perm<I>

§

type Output = Mat<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.
§

fn mul(self, other: &Mat<E>) -> <Perm<I> as Mul<&Mat<E>>>::Output

Performs the * operation. Read more
§

impl<I, E> Mul<&Mat<E>> for PermRef<'_, I>

§

type Output = Mat<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.
§

fn mul(self, other: &Mat<E>) -> <PermRef<'_, I> as Mul<&Mat<E>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for &Diag<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

fn mul(self, other: &Mat<RhsE>) -> <&Diag<LhsE> as Mul<&Mat<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for &DiagMut<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for &DiagRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for &MatMut<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for &MatRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for &Row<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

fn mul(self, other: &Mat<RhsE>) -> <&Row<LhsE> as Mul<&Mat<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for &RowMut<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for &RowRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

The resulting type after applying the * operator.
§

fn mul( self, other: &Mat<RhsE>, ) -> <&SparseRowMat<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<&Mat<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 = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for Diag<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

fn mul(self, other: &Mat<RhsE>) -> <Diag<LhsE> as Mul<&Mat<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for DiagMut<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for DiagRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for MatMut<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for MatRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for Row<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

fn mul(self, other: &Mat<RhsE>) -> <Row<LhsE> as Mul<&Mat<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for RowMut<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for RowRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&Mat<RhsE>> for Scale<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

fn mul(self, other: &Mat<RhsE>) -> <Scale<LhsE> as Mul<&Mat<RhsE>>>::Output

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

The resulting type after applying the * operator.
§

fn mul( self, other: &Mat<RhsE>, ) -> <SparseRowMat<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<&Mat<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 = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&MatMut<'_, RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&MatRef<'_, RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<&MatRef<'_, RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E> Mul<&Perm<I>> for &Mat<E>

§

type Output = Mat<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.
§

fn mul(self, other: &Perm<I>) -> <&Mat<E> as Mul<&Perm<I>>>::Output

Performs the * operation. Read more
§

impl<I, E> Mul<&Perm<I>> for Mat<E>

§

type Output = Mat<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.
§

fn mul(self, other: &Perm<I>) -> <Mat<E> as Mul<&Perm<I>>>::Output

Performs the * operation. Read more
§

impl<I, E> Mul<&PermRef<'_, I>> for &Mat<E>

§

type Output = Mat<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.
§

fn mul( self, other: &PermRef<'_, I>, ) -> <&Mat<E> as Mul<&PermRef<'_, I>>>::Output

Performs the * operation. Read more
§

impl<I, E> Mul<&PermRef<'_, I>> for Mat<E>

§

type Output = Mat<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.
§

fn mul(self, other: &PermRef<'_, I>) -> <Mat<E> as Mul<&PermRef<'_, I>>>::Output

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<&SparseColMat<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: &SparseColMat<I, RhsE>, ) -> <&Mat<LhsE> as Mul<&SparseColMat<I, RhsE>>>::Output

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<&SparseColMat<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: &SparseColMat<I, RhsE>, ) -> <Mat<LhsE> as Mul<&SparseColMat<I, RhsE>>>::Output

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<&SparseColMatMut<'_, 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: &SparseColMatMut<'_, I, RhsE>, ) -> <&Mat<LhsE> as Mul<&SparseColMatMut<'_, I, RhsE>>>::Output

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<&SparseColMatMut<'_, 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: &SparseColMatMut<'_, I, RhsE>, ) -> <Mat<LhsE> as Mul<&SparseColMatMut<'_, I, RhsE>>>::Output

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<&SparseRowMat<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: &SparseRowMat<I, RhsE>, ) -> <&Mat<LhsE> as Mul<&SparseRowMat<I, RhsE>>>::Output

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<&SparseRowMat<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: &SparseRowMat<I, RhsE>, ) -> <Mat<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 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<&SparseRowMatRef<'_, 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: &SparseRowMatRef<'_, I, RhsE>, ) -> <&Mat<LhsE> as Mul<&SparseRowMatRef<'_, I, RhsE>>>::Output

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<&SparseRowMatRef<'_, 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: &SparseRowMatRef<'_, I, RhsE>, ) -> <Mat<LhsE> as Mul<&SparseRowMatRef<'_, I, RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Col<RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Col<E>

The resulting type after applying the * operator.
§

fn mul(self, other: Col<RhsE>) -> <&Mat<LhsE> as Mul<Col<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Col<RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Col<E>

The resulting type after applying the * operator.
§

fn mul(self, other: Col<RhsE>) -> <Mat<LhsE> as Mul<Col<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Col<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<ColMut<'_, RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Col<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<ColRef<'_, RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Col<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Col<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Diag<RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

fn mul(self, other: Diag<RhsE>) -> <&Mat<LhsE> as Mul<Diag<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Diag<RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

fn mul(self, other: Diag<RhsE>) -> <Mat<LhsE> as Mul<Diag<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<DiagMut<'_, RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<DiagMut<'_, RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<DiagRef<'_, RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E> Mul<Mat<E>> for &Perm<I>

§

type Output = Mat<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.
§

fn mul(self, other: Mat<E>) -> <&Perm<I> as Mul<Mat<E>>>::Output

Performs the * operation. Read more
§

impl<I, E> Mul<Mat<E>> for &PermRef<'_, I>

§

type Output = Mat<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.
§

fn mul(self, other: Mat<E>) -> <&PermRef<'_, I> as Mul<Mat<E>>>::Output

Performs the * operation. Read more
§

impl<I, E> Mul<Mat<E>> for Perm<I>

§

type Output = Mat<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.
§

fn mul(self, other: Mat<E>) -> <Perm<I> as Mul<Mat<E>>>::Output

Performs the * operation. Read more
§

impl<I, E> Mul<Mat<E>> for PermRef<'_, I>

§

type Output = Mat<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.
§

fn mul(self, other: Mat<E>) -> <PermRef<'_, I> as Mul<Mat<E>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for &Diag<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

fn mul(self, other: Mat<RhsE>) -> <&Diag<LhsE> as Mul<Mat<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for &DiagMut<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for &DiagRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for &MatMut<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for &MatRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for &Row<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

fn mul(self, other: Mat<RhsE>) -> <&Row<LhsE> as Mul<Mat<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for &RowMut<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for &RowRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

The resulting type after applying the * operator.
§

fn mul( self, other: Mat<RhsE>, ) -> <&SparseRowMat<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<Mat<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 = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for Diag<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

fn mul(self, other: Mat<RhsE>) -> <Diag<LhsE> as Mul<Mat<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for DiagMut<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for DiagRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for MatMut<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for Row<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

fn mul(self, other: Mat<RhsE>) -> <Row<LhsE> as Mul<Mat<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for RowMut<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Row<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Mat<RhsE>> for Scale<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

fn mul(self, other: Mat<RhsE>) -> <Scale<LhsE> as Mul<Mat<RhsE>>>::Output

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

The resulting type after applying the * operator.
§

fn mul( self, other: Mat<RhsE>, ) -> <SparseRowMat<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<Mat<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 = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<MatMut<'_, RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<MatRef<'_, RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E> Mul<Perm<I>> for &Mat<E>

§

type Output = Mat<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.
§

fn mul(self, other: Perm<I>) -> <&Mat<E> as Mul<Perm<I>>>::Output

Performs the * operation. Read more
§

impl<I, E> Mul<Perm<I>> for Mat<E>

§

type Output = Mat<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.
§

fn mul(self, other: Perm<I>) -> <Mat<E> as Mul<Perm<I>>>::Output

Performs the * operation. Read more
§

impl<I, E> Mul<PermRef<'_, I>> for &Mat<E>

§

type Output = Mat<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.
§

fn mul(self, other: PermRef<'_, I>) -> <&Mat<E> as Mul<PermRef<'_, I>>>::Output

Performs the * operation. Read more
§

impl<I, E> Mul<PermRef<'_, I>> for Mat<E>

§

type Output = Mat<<E as Conjugate>::Canonical>

The resulting type after applying the * operator.
§

fn mul(self, other: PermRef<'_, I>) -> <Mat<E> as Mul<PermRef<'_, I>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Scale<RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

fn mul(self, other: Scale<RhsE>) -> <&Mat<LhsE> as Mul<Scale<RhsE>>>::Output

Performs the * operation. Read more
§

impl<E, LhsE, RhsE> Mul<Scale<RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

fn mul(self, other: Scale<RhsE>) -> <Mat<LhsE> as Mul<Scale<RhsE>>>::Output

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<SparseColMat<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: SparseColMat<I, RhsE>, ) -> <&Mat<LhsE> as Mul<SparseColMat<I, RhsE>>>::Output

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<SparseColMat<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: SparseColMat<I, RhsE>, ) -> <Mat<LhsE> as Mul<SparseColMat<I, RhsE>>>::Output

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<SparseColMatMut<'_, 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: SparseColMatMut<'_, I, RhsE>, ) -> <&Mat<LhsE> as Mul<SparseColMatMut<'_, I, RhsE>>>::Output

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<SparseColMatMut<'_, 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: SparseColMatMut<'_, I, RhsE>, ) -> <Mat<LhsE> as Mul<SparseColMatMut<'_, I, RhsE>>>::Output

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<SparseRowMat<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: SparseRowMat<I, RhsE>, ) -> <&Mat<LhsE> as Mul<SparseRowMat<I, RhsE>>>::Output

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<SparseRowMat<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: SparseRowMat<I, RhsE>, ) -> <Mat<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 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<SparseRowMatRef<'_, 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: SparseRowMatRef<'_, I, RhsE>, ) -> <&Mat<LhsE> as Mul<SparseRowMatRef<'_, I, RhsE>>>::Output

Performs the * operation. Read more
§

impl<I, E, LhsE, RhsE> Mul<SparseRowMatRef<'_, 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: SparseRowMatRef<'_, I, RhsE>, ) -> <Mat<LhsE> as Mul<SparseRowMatRef<'_, I, RhsE>>>::Output

Performs the * operation. Read more
§

impl<LhsE, RhsE> MulAssign<Scale<RhsE>> for Mat<LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the *= operation. Read more
§

impl<E> Neg for &Mat<E>

§

type Output = Mat<<E as Conjugate>::Canonical>

The resulting type after applying the - operator.
§

fn neg(self) -> <&Mat<E> as Neg>::Output

Performs the unary - operation. Read more
§

impl<E> Neg for Mat<E>

§

type Output = Mat<<E as Conjugate>::Canonical>

The resulting type after applying the - operator.
§

fn neg(self) -> <Mat<E> as Neg>::Output

Performs the unary - operation. Read more
§

impl<LhsE, RhsE> PartialEq<Mat<RhsE>> for Mat<LhsE>
where LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

§

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

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

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

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

impl<LhsE, RhsE> PartialEq<Mat<RhsE>> for MatMut<'_, LhsE>
where LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

§

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

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

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

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

impl<LhsE, RhsE> PartialEq<Mat<RhsE>> for MatRef<'_, LhsE>
where LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

§

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

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

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

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

impl<LhsE, RhsE> PartialEq<MatMut<'_, RhsE>> for Mat<LhsE>
where LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

§

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

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

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

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

impl<LhsE, RhsE> PartialEq<MatRef<'_, RhsE>> for Mat<LhsE>
where LhsE: Conjugate, RhsE: Conjugate<Canonical = <LhsE as Conjugate>::Canonical>,

§

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

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

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

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

impl<E> RowBatch<E> for Mat<E>
where E: Conjugate,

§

type Owned = Mat<<E as Conjugate>::Canonical>

Corresponding owning type.
§

fn new_owned_zeros(nrows: usize, ncols: usize) -> <Mat<E> as RowBatch<E>>::Owned

Constructor of the owned type that initializes the values to zero.
§

fn new_owned_copied(src: &Mat<E>) -> <Mat<E> as RowBatch<E>>::Owned

Constructor of the owned type that copies the values.
§

fn resize_owned( owned: &mut <Mat<E> as RowBatch<E>>::Owned, nrows: usize, ncols: usize, )

Resize an owned column or matrix.
§

impl<E> Serialize for Mat<E>
where E: Entity + Serialize,

§

fn serialize<S>( &self, s: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where S: Serializer,

Serialize this value into the given Serde serializer. Read more
§

impl<E, LhsE, RhsE> Sub<&Mat<RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the - operator.
§

fn sub(self, other: &Mat<RhsE>) -> <&Mat<LhsE> as Sub<&Mat<RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<&Mat<RhsE>> for &MatMut<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<&Mat<RhsE>> for &MatRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<&Mat<RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the - operator.
§

fn sub(self, other: &Mat<RhsE>) -> <Mat<LhsE> as Sub<&Mat<RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<&Mat<RhsE>> for MatMut<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<&Mat<RhsE>> for MatRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<&MatMut<'_, RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<&MatMut<'_, RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<&MatRef<'_, RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<&MatRef<'_, RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<Mat<RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the - operator.
§

fn sub(self, other: Mat<RhsE>) -> <&Mat<LhsE> as Sub<Mat<RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<Mat<RhsE>> for &MatMut<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<Mat<RhsE>> for &MatRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<Mat<RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the - operator.
§

fn sub(self, other: Mat<RhsE>) -> <Mat<LhsE> as Sub<Mat<RhsE>>>::Output

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<Mat<RhsE>> for MatMut<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<Mat<RhsE>> for MatRef<'_, LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<MatMut<'_, RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<MatMut<'_, RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<MatRef<'_, RhsE>> for &Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

impl<E, LhsE, RhsE> Sub<MatRef<'_, RhsE>> for Mat<LhsE>
where E: ComplexField, LhsE: Conjugate<Canonical = E>, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the - operator.
§

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

Performs the - operation. Read more
§

impl<LhsE, RhsE> SubAssign<&Mat<RhsE>> for Mat<LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the -= operation. Read more
§

impl<LhsE, RhsE> SubAssign<&Mat<RhsE>> for MatMut<'_, LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the -= operation. Read more
§

impl<LhsE, RhsE> SubAssign<&MatMut<'_, RhsE>> for Mat<LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the -= operation. Read more
§

impl<LhsE, RhsE> SubAssign<&MatRef<'_, RhsE>> for Mat<LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the -= operation. Read more
§

impl<LhsE, RhsE> SubAssign<Mat<RhsE>> for Mat<LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the -= operation. Read more
§

impl<LhsE, RhsE> SubAssign<Mat<RhsE>> for MatMut<'_, LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the -= operation. Read more
§

impl<LhsE, RhsE> SubAssign<MatMut<'_, RhsE>> for Mat<LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the -= operation. Read more
§

impl<LhsE, RhsE> SubAssign<MatRef<'_, RhsE>> for Mat<LhsE>
where LhsE: ComplexField, RhsE: Conjugate<Canonical = LhsE>,

§

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

Performs the -= operation. Read more
source§

impl TryFrom<&Robj> for Mat<f64>

§

type Error = Error

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

fn try_from(robj: &Robj) -> Result<Self>

Performs the conversion.
source§

impl TryFrom<Robj> for Mat<f64>

§

type Error = Error

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

fn try_from(robj: Robj) -> Result<Self>

Performs the conversion.
§

impl<E> ViewMut for &Mat<E>
where E: Entity,

§

type Target<'a> = MatRef<'a, E> where &Mat<E>: 'a

View type.
§

fn view_mut(&mut self) -> <&Mat<E> as ViewMut>::Target<'_>

Returns the view over self.
§

impl<E> ViewMut for &mut Mat<E>
where E: Entity,

§

type Target<'a> = MatMut<'a, E> where &mut Mat<E>: 'a

View type.
§

fn view_mut(&mut self) -> <&mut Mat<E> as ViewMut>::Target<'_>

Returns the view over self.
§

impl<E> ViewMut for Mat<E>
where E: Entity,

§

type Target<'a> = MatRef<'a, E> where Mat<E>: 'a

View type.
§

fn view_mut(&mut self) -> <Mat<E> as ViewMut>::Target<'_>

Returns the view over self.
§

impl<E> ColBatchMut<E> for Mat<E>
where E: Conjugate,

§

impl<E> RowBatchMut<E> for Mat<E>
where E: Conjugate,

Auto Trait Implementations§

§

impl<E> Freeze for Mat<E>
where <<E as Entity>::Group as ForCopyType>::FaerOfCopy<NonNull<<E as Entity>::Unit>>: Freeze,

§

impl<E> RefUnwindSafe for Mat<E>
where <<E as Entity>::Group as ForCopyType>::FaerOfCopy<NonNull<<E as Entity>::Unit>>: RefUnwindSafe, E: RefUnwindSafe,

§

impl<E> Send for Mat<E>

§

impl<E> Sync for Mat<E>

§

impl<E> Unpin for Mat<E>
where <<E as Entity>::Group as ForCopyType>::FaerOfCopy<NonNull<<E as Entity>::Unit>>: Unpin, E: Unpin,

§

impl<E> UnwindSafe for Mat<E>
where <<E as Entity>::Group as ForCopyType>::FaerOfCopy<NonNull<<E as Entity>::Unit>>: UnwindSafe, E: UnwindSafe,

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

impl<T> IntoRobj for T
where Robj: From<T>,

§

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> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

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

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

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

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

§

type Error = Infallible

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

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

Performs the conversion.
source§

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

§

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

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

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

Performs the conversion.
source§

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,