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 ones(nrows: usize, ncols: usize) -> Mat<E>
where E: ComplexField,

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

§Panics

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

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

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

§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 fn shape(&self) -> (usize, usize)

Returns the number of rows and 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 ptr_at( &self, row: usize, col: usize, ) -> <<E as Entity>::Group as ForType>::FaerOf<*const <E as Entity>::Unit>

Returns raw pointers to the element at the given indices.

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

Returns raw pointers to the element at the given indices.

pub unsafe fn ptr_inbounds_at( &self, row: usize, col: usize, ) -> <<E as Entity>::Group as ForType>::FaerOf<*const <E as Entity>::Unit>

Returns raw pointers to the element at the given indices, assuming the provided indices are within the matrix dimensions.

§Safety

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

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

pub unsafe fn ptr_inbounds_at_mut( &mut self, row: usize, col: usize, ) -> <<E as Entity>::Group as ForType>::FaerOf<*mut <E as Entity>::Unit>

Returns raw pointers to the element at the given indices, assuming the provided indices are within the matrix dimensions.

§Safety

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

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

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 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 fn split_first_col(&self) -> Option<(ColRef<'_, E>, MatRef<'_, E>)>

Returns a reference to the first column and a view over the remaining ones if the matrix has at least one column, otherwise None.

pub fn split_last_col(&self) -> Option<(ColRef<'_, E>, MatRef<'_, E>)>

Returns a reference to the last column and a view over the remaining ones if the matrix has at least one column, otherwise None.

pub fn split_first_row(&self) -> Option<(RowRef<'_, E>, MatRef<'_, E>)>

Returns a reference to the first row and a view over the remaining ones if the matrix has at least one row, otherwise None.

pub fn split_last_row(&self) -> Option<(RowRef<'_, E>, MatRef<'_, E>)>

Returns a reference to the last row and a view over the remaining ones if the matrix has at least one row, otherwise None.

pub fn split_first_col_mut(&mut self) -> Option<(ColMut<'_, E>, MatMut<'_, E>)>

Returns a reference to the first column and a view over the remaining ones if the matrix has at least one column, otherwise None.

pub fn split_last_col_mut(&mut self) -> Option<(ColMut<'_, E>, MatMut<'_, E>)>

Returns a reference to the last column and a view over the remaining ones if the matrix has at least one column, otherwise None.

pub fn split_first_row_mut(&mut self) -> Option<(RowMut<'_, E>, MatMut<'_, E>)>

Returns a reference to the first row and a view over the remaining ones if the matrix has at least one row, otherwise None.

pub fn split_last_row_mut(&mut self) -> Option<(RowMut<'_, E>, MatMut<'_, E>)>

Returns a reference to the last row and a view over the remaining ones if the matrix has at least one row, otherwise None.

pub fn col_iter(&self) -> ColIter<'_, E>

Returns an iterator over the columns of the matrix.

pub fn row_iter(&self) -> RowIter<'_, E>

Returns an iterator over the rows of the matrix.

pub fn col_iter_mut(&mut self) -> ColIterMut<'_, E>

Returns an iterator over the columns of the matrix.

pub fn row_iter_mut(&mut self) -> RowIterMut<'_, E>

Returns an iterator over the rows of the matrix.

pub unsafe fn split_at_unchecked( &self, row: usize, col: usize, ) -> (MatRef<'_, E>, MatRef<'_, E>, MatRef<'_, E>, MatRef<'_, E>)

Splits the matrix horizontally and vertically at the given indices into four corners and returns an array of each submatrix, in the following order:

  • top left.
  • top right.
  • bottom left.
  • bottom right.
§Safety

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

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

pub fn split_at( &self, row: usize, col: usize, ) -> (MatRef<'_, E>, MatRef<'_, E>, MatRef<'_, E>, MatRef<'_, E>)

Splits the matrix horizontally and vertically at the given indices into four corners and returns an array of each submatrix, in the following order:

  • top left.
  • top right.
  • bottom left.
  • bottom right.
§Panics

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

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

pub unsafe fn split_at_mut_unchecked( &mut self, row: usize, col: usize, ) -> (MatMut<'_, E>, MatMut<'_, E>, MatMut<'_, E>, MatMut<'_, E>)

Splits the matrix horizontally and vertically at the given indices into four corners and returns an array of each submatrix, in the following order:

  • top left.
  • top right.
  • bottom left.
  • bottom right.
§Safety

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

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

pub fn split_at_mut( &mut self, row: usize, col: usize, ) -> (MatMut<'_, E>, MatMut<'_, E>, MatMut<'_, E>, MatMut<'_, E>)

Splits the matrix horizontally and vertically at the given indices into four corners and returns an array of each submatrix, in the following order:

  • top left.
  • top right.
  • bottom left.
  • bottom right.
§Panics

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

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

pub unsafe fn split_at_row_unchecked( &self, row: usize, ) -> (MatRef<'_, E>, MatRef<'_, E>)

Splits the matrix horizontally at the given row into two parts and returns an array of each submatrix, in the following order:

  • top.
  • bottom.
§Safety

The behavior is undefined if the following condition is violated:

  • row <= self.nrows().

pub fn split_at_row(&self, row: usize) -> (MatRef<'_, E>, MatRef<'_, E>)

Splits the matrix horizontally at the given row into two parts and returns an array of each submatrix, in the following order:

  • top.
  • bottom.
§Panics

The function panics if the following condition is violated:

  • row <= self.nrows().

pub unsafe fn split_at_row_mut_unchecked( &mut self, row: usize, ) -> (MatMut<'_, E>, MatMut<'_, E>)

Splits the matrix horizontally at the given row into two parts and returns an array of each submatrix, in the following order:

  • top.
  • bottom.
§Safety

The behavior is undefined if the following condition is violated:

  • row <= self.nrows().

pub fn split_at_row_mut(&mut self, row: usize) -> (MatMut<'_, E>, MatMut<'_, E>)

Splits the matrix horizontally at the given row into two parts and returns an array of each submatrix, in the following order:

  • top.
  • bottom.
§Panics

The function panics if the following condition is violated:

  • row <= self.nrows().

pub unsafe fn split_at_col_unchecked( &self, col: usize, ) -> (MatRef<'_, E>, MatRef<'_, E>)

Splits the matrix vertically at the given row into two parts and returns an array of each submatrix, in the following order:

  • left.
  • right.
§Safety

The behavior is undefined if the following condition is violated:

  • col <= self.ncols().

pub fn split_at_col(&self, col: usize) -> (MatRef<'_, E>, MatRef<'_, E>)

Splits the matrix vertically at the given row into two parts and returns an array of each submatrix, in the following order:

  • left.
  • right.
§Panics

The function panics if the following condition is violated:

  • col <= self.ncols().

pub unsafe fn split_at_col_mut_unchecked( &mut self, col: usize, ) -> (MatMut<'_, E>, MatMut<'_, E>)

Splits the matrix vertically at the given row into two parts and returns an array of each submatrix, in the following order:

  • left.
  • right.
§Safety

The behavior is undefined if the following condition is violated:

  • col <= self.ncols().

pub fn split_at_col_mut(&mut self, col: usize) -> (MatMut<'_, E>, MatMut<'_, E>)

Splits the matrix vertically at the given row into two parts and returns an array of each submatrix, in the following order:

  • left.
  • right.
§Panics

The function panics if the following condition is violated:

  • col <= self.ncols().

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_triangular_lower<ViewE>(&mut self, other: impl AsMatRef<ViewE>)
where ViewE: Conjugate<Canonical = E>,

Copies the values from the lower triangular part of other into the lower triangular part of self. The diagonal part is included.

§Panics

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

  • self.nrows() == other.nrows().
  • self.ncols() == other.ncols().
  • self.nrows() == self.ncols().

pub fn copy_from_strict_triangular_lower<ViewE>( &mut self, other: impl AsMatRef<ViewE>, )
where ViewE: Conjugate<Canonical = E>,

Copies the values from the lower triangular part of other into the lower triangular part of self. The diagonal part is excluded.

§Panics

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

  • self.nrows() == other.nrows().
  • self.ncols() == other.ncols().
  • self.nrows() == self.ncols().

pub fn copy_from_triangular_upper<ViewE>(&mut self, other: impl AsMatRef<ViewE>)
where ViewE: Conjugate<Canonical = E>,

Copies the values from the upper triangular part of other into the upper triangular part of self. The diagonal part is included.

§Panics

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

  • self.nrows() == other.nrows().
  • self.ncols() == other.ncols().
  • self.nrows() == self.ncols().

pub fn copy_from_strict_triangular_upper<ViewE>( &mut self, other: impl AsMatRef<ViewE>, )
where ViewE: Conjugate<Canonical = E>,

Copies the values from the upper triangular part of other into the upper triangular part of self. The diagonal part is excluded.

§Panics

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

  • self.nrows() == other.nrows().
  • self.ncols() == other.ncols().
  • self.nrows() == self.ncols().

pub fn copy_from<ViewE>(&mut self, other: impl AsMatRef<ViewE>)
where ViewE: Conjugate<Canonical = 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 transpose_mut(&mut self) -> MatMut<'_, 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 conjugate_mut(&mut self) -> MatMut<'_, <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 adjoint_mut(&mut self) -> MatMut<'_, <E as Conjugate>::Conj>
where E: Conjugate,

Returns a view over the conjugate transpose of self.

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

Returns a view over the canonical representation of self, as well as a flag declaring whether self is implicitly conjugated or not.

pub fn canonicalize_mut( &mut self, ) -> (MatMut<'_, <E as Conjugate>::Canonical>, Conj)
where E: Conjugate,

Returns a view over the canonical representation of self, as well as a flag declaring whether self is implicitly conjugated or not.

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

Returns a view over the self, with the rows in reversed order.

§Example
use faer::mat;

let matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_ref();
let reversed_rows = view.reverse_rows();

let expected = mat![[4.0, 5.0, 6.0], [1.0, 2.0, 3.0]];
assert_eq!(expected.as_ref(), reversed_rows);

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

Returns a view over the self, with the rows in reversed order.

§Example
use faer::mat;

let mut matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_mut();
let reversed_rows = view.reverse_rows_mut();

let mut expected = mat![[4.0, 5.0, 6.0], [1.0, 2.0, 3.0]];
assert_eq!(expected.as_mut(), reversed_rows);

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

Returns a view over the self, with the columns in reversed order.

§Example
use faer::mat;

let matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_ref();
let reversed_cols = view.reverse_cols();

let expected = mat![[3.0, 2.0, 1.0], [6.0, 5.0, 4.0]];
assert_eq!(expected.as_ref(), reversed_cols);

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

Returns a view over the self, with the columns in reversed order.

§Example
use faer::mat;

let mut matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_mut();
let reversed_cols = view.reverse_cols_mut();

let mut expected = mat![[3.0, 2.0, 1.0], [6.0, 5.0, 4.0]];
assert_eq!(expected.as_mut(), reversed_cols);

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

Returns a view over the self, with the rows and the columns in reversed order.

§Example
use faer::mat;

let matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_ref();
let reversed = view.reverse_rows_and_cols();

let expected = mat![[6.0, 5.0, 4.0], [3.0, 2.0, 1.0]];
assert_eq!(expected.as_ref(), reversed);

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

Returns a view over the self, with the rows and the columns in reversed order.

§Example
use faer::mat;

let mut matrix = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
let view = matrix.as_mut();
let reversed = view.reverse_rows_and_cols_mut();

let mut expected = mat![[6.0, 5.0, 4.0], [3.0, 2.0, 1.0]];
assert_eq!(expected.as_mut(), reversed);

pub unsafe fn submatrix_unchecked( &self, row_start: usize, col_start: usize, nrows: usize, ncols: usize, ) -> MatRef<'_, E>

Returns a view over the submatrix starting at indices (row_start, col_start), and with dimensions (nrows, ncols).

§Safety

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

  • row_start <= self.nrows().
  • col_start <= self.ncols().
  • nrows <= self.nrows() - row_start.
  • ncols <= self.ncols() - col_start.

pub unsafe fn submatrix_mut_unchecked( &mut self, row_start: usize, col_start: usize, nrows: usize, ncols: usize, ) -> MatMut<'_, E>

Returns a view over the submatrix starting at indices (row_start, col_start), and with dimensions (nrows, ncols).

§Safety

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

  • row_start <= self.nrows().
  • col_start <= self.ncols().
  • nrows <= self.nrows() - row_start.
  • ncols <= self.ncols() - col_start.

pub fn submatrix( &self, row_start: usize, col_start: usize, nrows: usize, ncols: usize, ) -> MatRef<'_, E>

Returns a view over the submatrix starting at indices (row_start, col_start), and with dimensions (nrows, ncols).

§Panics

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

  • row_start <= self.nrows().
  • col_start <= self.ncols().
  • nrows <= self.nrows() - row_start.
  • ncols <= self.ncols() - col_start.
§Example
use faer::mat;

let matrix = mat![
    [1.0, 5.0, 9.0],
    [2.0, 6.0, 10.0],
    [3.0, 7.0, 11.0],
    [4.0, 8.0, 12.0f64],
];

let view = matrix.as_ref();
let submatrix = view.submatrix(2, 1, 2, 2);

let expected = mat![[7.0, 11.0], [8.0, 12.0f64]];
assert_eq!(expected.as_ref(), submatrix);

pub fn submatrix_mut( &mut self, row_start: usize, col_start: usize, nrows: usize, ncols: usize, ) -> MatMut<'_, E>

Returns a view over the submatrix starting at indices (row_start, col_start), and with dimensions (nrows, ncols).

§Panics

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

  • row_start <= self.nrows().
  • col_start <= self.ncols().
  • nrows <= self.nrows() - row_start.
  • ncols <= self.ncols() - col_start.
§Example
use faer::mat;

let mut matrix = mat![
    [1.0, 5.0, 9.0],
    [2.0, 6.0, 10.0],
    [3.0, 7.0, 11.0],
    [4.0, 8.0, 12.0f64],
];

let view = matrix.as_mut();
let submatrix = view.submatrix_mut(2, 1, 2, 2);

let mut expected = mat![[7.0, 11.0], [8.0, 12.0f64]];
assert_eq!(expected.as_mut(), submatrix);

pub unsafe fn subrows_unchecked( &self, row_start: usize, nrows: usize, ) -> MatRef<'_, E>

Returns a view over the submatrix starting at row row_start, and with number of rows nrows.

§Safety

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

  • row_start <= self.nrows().
  • nrows <= self.nrows() - row_start.

pub unsafe fn subrows_mut_unchecked( &mut self, row_start: usize, nrows: usize, ) -> MatMut<'_, E>

Returns a view over the submatrix starting at row row_start, and with number of rows nrows.

§Safety

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

  • row_start <= self.nrows().
  • nrows <= self.nrows() - row_start.

pub fn subrows(&self, row_start: usize, nrows: usize) -> MatRef<'_, E>

Returns a view over the submatrix starting at row row_start, and with number of rows nrows.

§Panics

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

  • row_start <= self.nrows().
  • nrows <= self.nrows() - row_start.
§Example
use faer::mat;

let matrix = mat![
    [1.0, 5.0, 9.0],
    [2.0, 6.0, 10.0],
    [3.0, 7.0, 11.0],
    [4.0, 8.0, 12.0f64],
];

let view = matrix.as_ref();
let subrows = view.subrows(1, 2);

let expected = mat![[2.0, 6.0, 10.0], [3.0, 7.0, 11.0],];
assert_eq!(expected.as_ref(), subrows);

pub fn subrows_mut(&mut self, row_start: usize, nrows: usize) -> MatMut<'_, E>

Returns a view over the submatrix starting at row row_start, and with number of rows nrows.

§Panics

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

  • row_start <= self.nrows().
  • nrows <= self.nrows() - row_start.
§Example
use faer::mat;

let mut matrix = mat![
    [1.0, 5.0, 9.0],
    [2.0, 6.0, 10.0],
    [3.0, 7.0, 11.0],
    [4.0, 8.0, 12.0f64],
];

let view = matrix.as_mut();
let subrows = view.subrows_mut(1, 2);

let mut expected = mat![[2.0, 6.0, 10.0], [3.0, 7.0, 11.0],];
assert_eq!(expected.as_mut(), subrows);

pub unsafe fn subcols_unchecked( &self, col_start: usize, ncols: usize, ) -> MatRef<'_, E>

Returns a view over the submatrix starting at column col_start, and with number of columns ncols.

§Safety

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

  • col_start <= self.ncols().
  • ncols <= self.ncols() - col_start.

pub unsafe fn subcols_mut_unchecked( &mut self, col_start: usize, ncols: usize, ) -> MatMut<'_, E>

Returns a view over the submatrix starting at column col_start, and with number of columns ncols.

§Safety

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

  • col_start <= self.ncols().
  • ncols <= self.ncols() - col_start.

pub fn subcols(&self, col_start: usize, ncols: usize) -> MatRef<'_, E>

Returns a view over the submatrix starting at column col_start, and with number of columns ncols.

§Panics

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

  • col_start <= self.ncols().
  • ncols <= self.ncols() - col_start.
§Example
use faer::mat;

let matrix = mat![
    [1.0, 5.0, 9.0],
    [2.0, 6.0, 10.0],
    [3.0, 7.0, 11.0],
    [4.0, 8.0, 12.0f64],
];

let view = matrix.as_ref();
let subcols = view.subcols(2, 1);

let expected = mat![[9.0], [10.0], [11.0], [12.0f64]];
assert_eq!(expected.as_ref(), subcols);

pub fn subcols_mut(&mut self, col_start: usize, ncols: usize) -> MatMut<'_, E>

Returns a view over the submatrix starting at column col_start, and with number of columns ncols.

§Panics

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

  • col_start <= self.ncols().
  • ncols <= self.ncols() - col_start.
§Example
use faer::mat;

let mut matrix = mat![
    [1.0, 5.0, 9.0],
    [2.0, 6.0, 10.0],
    [3.0, 7.0, 11.0],
    [4.0, 8.0, 12.0f64],
];

let view = matrix.as_mut();
let subcols = view.subcols_mut(2, 1);

let mut expected = mat![[9.0], [10.0], [11.0], [12.0f64]];
assert_eq!(expected.as_mut(), subcols);

pub unsafe fn row_unchecked(&self, row_idx: usize) -> RowRef<'_, E>

Returns a view over the row at the given index.

§Safety

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

  • row_idx < self.nrows().

pub unsafe fn row_mut_unchecked(&mut self, row_idx: usize) -> RowMut<'_, E>

Returns a view over the row at the given index.

§Safety

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

  • row_idx < self.nrows().

pub fn row(&self, row_idx: usize) -> RowRef<'_, E>

Returns a view over the row at the given index.

§Panics

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

  • row_idx < self.nrows().

pub fn row_mut(&mut self, row_idx: usize) -> RowMut<'_, E>

Returns a view over the row at the given index.

§Panics

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

  • row_idx < self.nrows().

pub fn two_rows_mut( &mut self, row_idx0: usize, row_idx1: usize, ) -> (RowMut<'_, E>, RowMut<'_, E>)

Returns views over the rows at the given indices.

§Panics

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

  • row_idx0 < self.nrows().
  • row_idx1 < self.nrows().
  • row_idx0 == row_idx1.

pub unsafe fn col_unchecked(&self, col_idx: usize) -> ColRef<'_, E>

Returns a view over the column at the given index.

§Safety

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

  • col_idx < self.ncols().

pub unsafe fn col_mut_unchecked(&mut self, col_idx: usize) -> ColMut<'_, E>

Returns a view over the column at the given index.

§Safety

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

  • col_idx < self.ncols().

pub fn col(&self, col_idx: usize) -> ColRef<'_, E>

Returns a view over the column at the given index.

§Panics

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

  • col_idx < self.ncols().

pub fn col_mut(&mut self, col_idx: usize) -> ColMut<'_, E>

Returns a view over the column at the given index.

§Panics

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

  • col_idx < self.ncols().

pub fn two_cols_mut( &mut self, col_idx0: usize, col_idx1: usize, ) -> (ColMut<'_, E>, ColMut<'_, E>)

Returns views over the columns at the given indices.

§Panics

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

  • col_idx0 < self.ncols().
  • col_idx1 < self.ncols().
  • col_idx0 == col_idx1.

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

Given a matrix with a single column, returns an object that interprets the column as a diagonal matrix, whose diagonal elements are values in the column.

pub fn column_vector_as_diagonal_mut(&mut self) -> DiagMut<'_, E>

Given a matrix with a single column, returns an object that interprets the column as a diagonal matrix, whose diagonal elements are values in the column.

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

Returns a view over the diagonal of the matrix.

pub fn diagonal_mut(&mut self) -> DiagMut<'_, 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,

Kronecker 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) -> ColChunks<'_, E>

Returns an iterator that provides successive chunks of the columns of 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_partition(&self, count: usize) -> ColPartition<'_, E>

Returns an iterator that provides exactly count successive chunks of the columns of this matrix.

§Panics

Panics if count == 0.

pub fn row_chunks(&self, chunk_size: usize) -> RowChunks<'_, E>

Returns an iterator that provides successive chunks of the rows of 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_partition(&self, count: usize) -> RowPartition<'_, E>

Returns an iterator that provides exactly count successive chunks of the rows of this matrix.

§Panics

Panics if count == 0.

pub fn col_chunks_mut(&mut self, chunk_size: usize) -> ColChunksMut<'_, E>

Returns an iterator that provides successive chunks of the columns of 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_partition_mut(&mut self, count: usize) -> ColPartitionMut<'_, E>

Returns an iterator that provides exactly count successive chunks of the columns of this matrix.

§Panics

Panics if count == 0.

pub fn row_chunks_mut(&mut self, chunk_size: usize) -> RowChunksMut<'_, E>

Returns an iterator that provides successive chunks of the rows of 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_partition_mut(&mut self, count: usize) -> RowPartitionMut<'_, E>

Returns an iterator that provides exactly count successive chunks of the rows of this matrix.

§Panics

Panics if count == 0.

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_partition(&self, count: usize) -> impl IndexedParallelIterator

Returns a parallel iterator that provides exactly count successive chunks of the columns of this matrix.

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 par_col_partition_mut( &mut self, count: usize, ) -> impl IndexedParallelIterator

Returns a parallel iterator that provides exactly count successive chunks of the columns of this matrix.

Only available with the rayon feature.

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_partition(&self, count: usize) -> impl IndexedParallelIterator

Returns a parallel iterator that provides exactly count successive chunks of the rows of this matrix.

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.

pub fn par_row_partition_mut( &mut self, count: usize, ) -> impl IndexedParallelIterator

Returns a parallel iterator that provides exactly count successive chunks of the rows of this matrix.

Only available with the rayon feature.

§

impl<E> Mat<Complex<E>>
where E: RealField,

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

Returns the real and imaginary components of self.

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

Returns the real and imaginary components of self.

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, LhsE, RhsE> Div<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 div(self, other: Scale<RhsE>) -> <&Mat<LhsE> as Div<Scale<RhsE>>>::Output

Performs the / operation. Read more
§

impl<E, LhsE, RhsE> Div<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 div(self, other: Scale<RhsE>) -> <Mat<LhsE> as Div<Scale<RhsE>>>::Output

Performs the / operation. Read more
§

impl<E, RhsE> Div<f32> for &Mat<RhsE>
where E: ComplexField, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the / operator.
§

fn div(self, other: f32) -> <&Mat<RhsE> as Div<f32>>::Output

Performs the / operation. Read more
§

impl<E, RhsE> Div<f32> for Mat<RhsE>
where E: ComplexField, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the / operator.
§

fn div(self, other: f32) -> <Mat<RhsE> as Div<f32>>::Output

Performs the / operation. Read more
§

impl<E, RhsE> Div<f64> for &Mat<RhsE>
where E: ComplexField, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the / operator.
§

fn div(self, other: f64) -> <&Mat<RhsE> as Div<f64>>::Output

Performs the / operation. Read more
§

impl<E, RhsE> Div<f64> for Mat<RhsE>
where E: ComplexField, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the / operator.
§

fn div(self, other: f64) -> <Mat<RhsE> as Div<f64>>::Output

Performs the / operation. Read more
§

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

§

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

Performs the /= operation. Read more
§

impl<LhsE> DivAssign<f32> for Mat<LhsE>
where LhsE: ComplexField,

§

fn div_assign(&mut self, other: f32)

Performs the /= operation. Read more
§

impl<LhsE> DivAssign<f64> for Mat<LhsE>
where LhsE: ComplexField,

§

fn div_assign(&mut self, other: f64)

Performs the /= operation. 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<E, RhsE> Mul<f32> for &Mat<RhsE>
where E: ComplexField, RhsE: Conjugate<Canonical = E>,

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

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

§

type Output = Mat<E>

The resulting type after applying the * operator.
§

fn mul(self, other: f64) -> <Mat<RhsE> as Mul<f64>>::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<LhsE> MulAssign<f32> for Mat<LhsE>
where LhsE: ComplexField,

§

fn mul_assign(&mut self, other: f32)

Performs the *= operation. Read more
§

impl<LhsE> MulAssign<f64> for Mat<LhsE>
where LhsE: ComplexField,

§

fn mul_assign(&mut self, other: f64)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

source§

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>

source§

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

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. 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,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

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

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

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

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

source§

type Error = Infallible

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

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

Performs the conversion.
source§

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

source§

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

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

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

Performs the conversion.
source§

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