Struct faer_core::Mat

#[repr(C)]
pub struct Mat<E: Entity> { /* private fields */ }

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.

Implementations

impl<E: Entity> Mat<E>

pub fn new() -> Self

pub fn with_capacity(row_capacity: usize, col_capacity: usize) -> Self

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 ) -> Self

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) -> Selfwhere E: ComplexField,

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

Panics

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

pub fn identity(nrows: usize, ncols: usize) -> Selfwhere 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 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::Group<*const E::Unit>

Returns a pointer to the data of the matrix.

pub fn as_mut_ptr(&mut self) -> E::Group<*mut E::Unit>

Returns a mutable pointer to the data of the matrix.

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 row_capacity(&self) -> usize

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

pub fn col_capacity(&self) -> usize

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

pub fn row_stride(&self) -> isize

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

pub fn col_stride(&self) -> isize

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

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

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

Panics

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

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

Resizes the matrix in-place so that the new dimensions are (new_nrows, new_ncols). Elements that are now out of bounds are dropped, while 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 col_ref(&self, col: usize) -> E::Group<&[E::Unit]>

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

pub fn col_mut(&mut self, col: usize) -> E::Group<&mut [E::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 unsafe fn get_unchecked<RowRange, ColRange>( &self, row: RowRange, col: ColRange ) -> <MatRef<'_, E> as MatIndex<RowRange, ColRange>>::Targetwhere for<'a> MatRef<'a, E>: 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.

Panics

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>>::Targetwhere for<'a> MatRef<'a, E>: 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>>::Targetwhere for<'a> MatMut<'a, E>: 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.

Panics

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>>::Targetwhere for<'a> MatMut<'a, E>: 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 clone_from(&mut self, other: impl AsMatRef<E>)

Copies the values from other into self.

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

Fills the elements of self with zeros.

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

Fills the elements of self with copies of constant.

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

Returns a view over the transpose of self.

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

Returns a view over the conjugate of self.

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

Returns a view over the conjugate transpose of self.

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

Returns an owning Mat of the data

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

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

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

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

Trait Implementations

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

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

The resulting type after applying the + operator.

fn add(self, rhs: &Mat<RhsE>) -> Self::Output

Performs the + operation.

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

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

The resulting type after applying the + operator.

fn add(self, rhs: &Mat<RhsE>) -> Self::Output

Performs the + operation.

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

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

The resulting type after applying the + operator.

fn add(self, rhs: &Mat<RhsE>) -> Self::Output

Performs the + operation.

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

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

The resulting type after applying the + operator.

fn add(self, rhs: &Mat<RhsE>) -> Self::Output

Performs the + operation.

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

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

The resulting type after applying the + operator.

fn add(self, rhs: &Mat<RhsE>) -> Self::Output

Performs the + operation.

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

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

The resulting type after applying the + operator.

fn add(self, rhs: &Mat<RhsE>) -> Self::Output

Performs the + operation.

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

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

The resulting type after applying the + operator.

fn add(self, rhs: &MatMut<'_, RhsE>) -> Self::Output

Performs the + operation.

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

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

The resulting type after applying the + operator.

fn add(self, rhs: &MatMut<'_, RhsE>) -> Self::Output

Performs the + operation.

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

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

The resulting type after applying the + operator.

fn add(self, rhs: &MatRef<'_, RhsE>) -> Self::Output

Performs the + operation.

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

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

The resulting type after applying the + operator.

fn add(self, rhs: &MatRef<'_, RhsE>) -> Self::Output

Performs the + operation.

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

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

The resulting type after applying the + operator.

fn add(self, rhs: Mat<RhsE>) -> Self::Output

Performs the + operation.

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

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

The resulting type after applying the + operator.

fn add(self, rhs: Mat<RhsE>) -> Self::Output

Performs the + operation.

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

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

The resulting type after applying the + operator.

fn add(self, rhs: Mat<RhsE>) -> Self::Output

Performs the + operation.

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

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

The resulting type after applying the + operator.

fn add(self, rhs: Mat<RhsE>) -> Self::Output

Performs the + operation.

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

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

The resulting type after applying the + operator.

fn add(self, rhs: Mat<RhsE>) -> Self::Output

Performs the + operation.

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

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

The resulting type after applying the + operator.

fn add(self, rhs: Mat<RhsE>) -> Self::Output

Performs the + operation.

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

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

The resulting type after applying the + operator.

fn add(self, rhs: MatMut<'_, RhsE>) -> Self::Output

Performs the + operation.

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

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

The resulting type after applying the + operator.

fn add(self, rhs: MatMut<'_, RhsE>) -> Self::Output

Performs the + operation.

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

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

The resulting type after applying the + operator.

fn add(self, rhs: MatRef<'_, RhsE>) -> Self::Output

Performs the + operation.

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

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

The resulting type after applying the + operator.

fn add(self, rhs: MatRef<'_, RhsE>) -> Self::Output

Performs the + operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

impl<E: Entity> AsMatMut<E> for &mut Mat<E>

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

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

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

impl<E: Entity> AsMatRef<E> for &Mat<E>

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

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

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

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

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

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

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

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

type Output = E

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

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

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

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

fn rows(&self) -> usize

fn cols(&self) -> usize

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

Expose dense or sparse access to the matrix.

impl<E: ComplexField, MatE: Conjugate<Canonical = E>> Mul<&Mat<MatE>> for Scale<E>

type Output = Mat<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: &MatMut<'_, RhsE>) -> Self::Output

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: &MatMut<'_, RhsE>) -> Self::Output

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: &MatRef<'_, RhsE>) -> Self::Output

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: &MatRef<'_, RhsE>) -> Self::Output

Performs the * operation.

impl<E: ComplexField, MatE: Conjugate<Canonical = E>> Mul<Mat<MatE>> for Scale<E>

type Output = Mat<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: MatMut<'_, RhsE>) -> Self::Output

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: MatMut<'_, RhsE>) -> Self::Output

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: MatRef<'_, RhsE>) -> Self::Output

Performs the * operation.

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

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

The resulting type after applying the * operator.

fn mul(self, rhs: MatRef<'_, RhsE>) -> Self::Output

Performs the * operation.

impl<E: ComplexField, MatE: Conjugate<Canonical = E>> Mul<Scale<E>> for &Mat<MatE>

type Output = Mat<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E: ComplexField, MatE: Conjugate<Canonical = E>> Mul<Scale<E>> for Mat<MatE>

type Output = Mat<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E: ComplexField> MulAssign<Scale<E>> for Mat<E>

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

Performs the *= operation.

impl<E: Conjugate> Neg for &Mat<E>where E::Canonical: ComplexField,

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

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E: Conjugate> Neg for Mat<E>where E::Canonical: ComplexField,

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

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The resulting type after applying the - operator.

fn sub(self, rhs: &Mat<RhsE>) -> Self::Output

Performs the - operation.

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

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

The resulting type after applying the - operator.

fn sub(self, rhs: &Mat<RhsE>) -> Self::Output

Performs the - operation.

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

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

The resulting type after applying the - operator.

fn sub(self, rhs: &Mat<RhsE>) -> Self::Output

Performs the - operation.

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

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

The resulting type after applying the - operator.

fn sub(self, rhs: &Mat<RhsE>) -> Self::Output

Performs the - operation.

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

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

The resulting type after applying the - operator.

fn sub(self, rhs: &Mat<RhsE>) -> Self::Output

Performs the - operation.

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

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

The resulting type after applying the - operator.

fn sub(self, rhs: &Mat<RhsE>) -> Self::Output

Performs the - operation.

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

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

The resulting type after applying the - operator.

fn sub(self, rhs: &MatMut<'_, RhsE>) -> Self::Output

Performs the - operation.

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

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

The resulting type after applying the - operator.

fn sub(self, rhs: &MatMut<'_, RhsE>) -> Self::Output

Performs the - operation.

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

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

The resulting type after applying the - operator.

fn sub(self, rhs: &MatRef<'_, RhsE>) -> Self::Output

Performs the - operation.

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

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

The resulting type after applying the - operator.

fn sub(self, rhs: &MatRef<'_, RhsE>) -> Self::Output

Performs the - operation.

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

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

The resulting type after applying the - operator.

fn sub(self, rhs: Mat<RhsE>) -> Self::Output

Performs the - operation.

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

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

The resulting type after applying the - operator.

fn sub(self, rhs: Mat<RhsE>) -> Self::Output

Performs the - operation.

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

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

The resulting type after applying the - operator.

fn sub(self, rhs: Mat<RhsE>) -> Self::Output

Performs the - operation.

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

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

The resulting type after applying the - operator.

fn sub(self, rhs: Mat<RhsE>) -> Self::Output

Performs the - operation.

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

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

The resulting type after applying the - operator.

fn sub(self, rhs: Mat<RhsE>) -> Self::Output

Performs the - operation.

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

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

The resulting type after applying the - operator.

fn sub(self, rhs: Mat<RhsE>) -> Self::Output

Performs the - operation.

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

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

The resulting type after applying the - operator.

fn sub(self, rhs: MatMut<'_, RhsE>) -> Self::Output

Performs the - operation.

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

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

The resulting type after applying the - operator.

fn sub(self, rhs: MatMut<'_, RhsE>) -> Self::Output

Performs the - operation.

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

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

The resulting type after applying the - operator.

fn sub(self, rhs: MatRef<'_, RhsE>) -> Self::Output

Performs the - operation.

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

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

The resulting type after applying the - operator.

fn sub(self, rhs: MatRef<'_, RhsE>) -> Self::Output

Performs the - operation.

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

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

Performs the -= operation.

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

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

Performs the -= operation.

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

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

Performs the -= operation.

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

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

Performs the -= operation.

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

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

Performs the -= operation.

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

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

Performs the -= operation.

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

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

Performs the -= operation.

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

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

Performs the -= operation.

impl<E: Entity> Send for Mat<E>

impl<E: Entity> Sync for Mat<E>