Struct faer_core::MatRef

pub struct MatRef<'a, E: Entity> { /* private fields */ }

Immutable view over a matrix, similar to an immutable reference to a 2D strided slice.

Note

Unlike a slice, the data pointed to by MatRef<'_, E> is allowed to be partially or fully uninitialized under certain conditions. In this case, care must be taken to not perform any operations that read the uninitialized values, or form references to them, either directly through MatRef::read, or indirectly through any of the numerical library routines, unless it is explicitly permitted.

Implementations

impl<'a, E: Entity> MatRef<'a, E>

pub fn from_column_major_slice( slice: GroupFor<E, &'a [E::Unit]>, nrows: usize, ncols: usize ) -> Self

Creates a MatRef from slice views over the matrix data, and the matrix dimensions. The data is interpreted in a column-major format, so that the first chunk of nrows values from the slices goes in the first column of the matrix, the second chunk of nrows values goes in the second column, and so on.

Panics

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

• nrows * ncols == slice.len()

Example

use faer_core::{mat, MatRef};

let slice = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0_f64];
let view = MatRef::<f64>::from_column_major_slice(&slice, 3, 2);

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

pub fn from_row_major_slice( slice: GroupFor<E, &'a [E::Unit]>, nrows: usize, ncols: usize ) -> Self

Creates a MatRef from slice views over the matrix data, and the matrix dimensions. The data is interpreted in a row-major format, so that the first chunk of ncols values from the slices goes in the first column of the matrix, the second chunk of ncols values goes in the second column, and so on.

Panics

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

• nrows * ncols == slice.len()

Example

use faer_core::{mat, MatRef};

let slice = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0_f64];
let view = MatRef::<f64>::from_row_major_slice(&slice, 3, 2);

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

pub unsafe fn from_raw_parts( ptr: GroupFor<E, *const E::Unit>, nrows: usize, ncols: usize, row_stride: isize, col_stride: isize ) -> Self

Creates a MatRef from pointers to the matrix data, dimensions, and strides.

The row (resp. column) stride is the offset from the memory address of a given matrix element at indices (row: i, col: j), to the memory address of the matrix element at indices (row: i + 1, col: 0) (resp. (row: 0, col: i + 1)). This offset is specified in number of elements, not in bytes.

Safety

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

• For each matrix unit, the entire memory region addressed by the matrix must be contained within a single allocation, accessible in its entirety by the corresponding pointer in ptr.
• For each matrix unit, the corresponding pointer must be properly aligned, even for a zero-sized matrix.
• The values accessible by the matrix must be initialized at some point before they are read, or references to them are formed.
• No mutable aliasing is allowed. In other words, none of the elements accessible by any matrix unit may be accessed for writes by any other means for the duration of the lifetime 'a.

Example

use faer_core::{mat, MatRef};

// row major matrix with 2 rows, 3 columns, with a column at the end that we want to skip.
// the row stride is the pointer offset from the address of 1.0 to the address of 4.0,
// which is 4.
// the column stride is the pointer offset from the address of 1.0 to the address of 2.0,
// which is 1.
let data = [[1.0, 2.0, 3.0, f64::NAN], [4.0, 5.0, 6.0, f64::NAN]];
let matrix = unsafe { MatRef::<f64>::from_raw_parts(data.as_ptr() as *const f64, 2, 3, 4, 1) };

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

pub fn as_ptr(self) -> GroupFor<E, *const E::Unit>

Returns pointers to the matrix data.

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_stride(&self) -> isize

Returns the row stride of the matrix, specified in number of elements, not in bytes.

pub fn col_stride(&self) -> isize

Returns the column stride of the matrix, specified in number of elements, not in bytes.

pub fn ptr_at(self, row: usize, col: usize) -> GroupFor<E, *const E::Unit>

Returns raw pointers to the element at the given indices.

pub unsafe fn ptr_inbounds_at( self, row: usize, col: usize ) -> GroupFor<E, *const E::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 split_at(self, row: usize, col: usize) -> [Self; 4]

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 fn split_at_row(self, row: usize) -> [Self; 2]

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

• top.
• bottom.

pub fn split_at_col(self, col: usize) -> [Self; 2]

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

• left.
• right.

pub unsafe fn get_unchecked<RowRange, ColRange>( self, row: RowRange, col: ColRange ) -> <Self as MatIndex<RowRange, ColRange>>::Target

where Self: 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 ) -> <Self as MatIndex<RowRange, ColRange>>::Target

where Self: 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 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 fn transpose(self) -> Self

Returns a view over the transpose of self.

Example

use faer_core::mat;

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

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

pub fn conjugate(self) -> MatRef<'a, E::Conj>

where E: Conjugate,

Returns a view over the conjugate of self.

pub fn adjoint(self) -> MatRef<'a, E::Conj>

where E: Conjugate,

Returns a view over the conjugate transpose of self.

pub fn canonicalize(self) -> (MatRef<'a, E::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) -> Self

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

Example

use faer_core::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_cols(self) -> Self

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

Example

use faer_core::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_rows_and_cols(self) -> Self

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

Example

use faer_core::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 submatrix( self, row_start: usize, col_start: usize, nrows: usize, ncols: usize ) -> Self

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_core::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 subrows(self, row_start: usize, nrows: usize) -> Self

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_core::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 subcols(self, col_start: usize, ncols: usize) -> Self

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_core::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 row(self, row_idx: usize) -> Self

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 col(self, col_idx: usize) -> Self

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 diagonal(self) -> Self

Returns a view over the main diagonal of the matrix.

Example

use faer_core::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 diagonal = view.diagonal();

let expected = mat![[1.0], [6.0], [11.0]];
assert_eq!(expected.as_ref(), diagonal);

pub fn to_owned(&self) -> Mat<E::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 cwise(self) -> Zip<(Self,)>

Returns a thin wrapper that can be used to execute coefficient-wise operations on matrices.

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

Returns a view over the matrix.

pub fn into_col_chunks( self, chunk_size: usize ) -> impl 'a + DoubleEndedIterator<Item = MatRef<'a, 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 into_row_chunks( self, chunk_size: usize ) -> impl 'a + DoubleEndedIterator<Item = MatRef<'a, 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 into_par_col_chunks( self, chunk_size: usize ) -> impl 'a + IndexedParallelIterator<Item = MatRef<'a, E>>

Returns a parallel 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.

Only available with the rayon feature.

pub fn into_par_row_chunks( self, chunk_size: usize ) -> impl 'a + IndexedParallelIterator<Item = MatRef<'a, E>>

Returns a parallel 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.

Only available with the rayon feature.

impl<'a, E: RealField> MatRef<'a, Complex<E>>

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

Trait Implementations

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 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 &MatRef<'_, 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 MatRef<'_, 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 &MatMut<'_, 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 &MatRef<'_, 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<&MatRef<'_, 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: &MatRef<'_, RhsE>) -> Self::Output

Performs the + operation.

impl<LhsE: Conjugate, RhsE: Conjugate<Canonical = LhsE::Canonical>> Add<&MatRef<'_, 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: &MatRef<'_, 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 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 &MatRef<'_, 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 MatRef<'_, 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 &MatMut<'_, 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 &MatRef<'_, 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<MatRef<'_, 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: MatRef<'_, RhsE>) -> Self::Output

Performs the + operation.

impl<LhsE: Conjugate, RhsE: Conjugate<Canonical = LhsE::Canonical>> Add<MatRef<'_, 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: MatRef<'_, RhsE>) -> Self::Output

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<&MatRef<'_, RhsE>> for MatMut<'_, LhsE>

fn add_assign(&mut self, rhs: &MatRef<'_, 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<MatRef<'_, RhsE>> for MatMut<'_, LhsE>

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

Performs the += operation.

impl<E: Entity> AsMatRef<E> for &MatRef<'_, E>

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

impl<E: Entity> AsMatRef<E> for MatRef<'_, E>

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

impl<E: Entity> Clone for MatRef<'_, E>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, FromE: Entity, ToE: Entity> Coerce<MatRef<'a, ToE>> for MatRef<'a, FromE>

fn coerce(self) -> MatRef<'a, ToE>

impl<'a, E: Entity> Debug for MatRef<'a, E>

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

Formats the value using the given formatter.

impl<E: Entity> DenseAccess<E> for MatRef<'_, E>

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

impl<E: SimpleEntity> Index<(usize, usize)> for MatRef<'_, E>

type Output = E

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a, E: Entity> IntoConst for MatRef<'a, E>

type Target = MatRef<'a, E>

fn into_const(self) -> Self::Target

impl<'a, 'short, E: Entity> Mat<'short> for MatRef<'a, E>

type Item = Read<'short, E>

type RawSlice = <<E as Entity>::Group as ForType>::FaerOf<&'a [MaybeUninit<<E as Entity>::Unit>]>

fn transpose(self) -> Self

fn reverse_rows(self) -> Self

fn reverse_cols(self) -> Self

fn nrows(&self) -> usize

fn ncols(&self) -> usize

fn row_stride(&self) -> isize

fn col_stride(&self) -> isize

unsafe fn get(&mut self, i: usize, j: usize) -> Self::Item

Safety

unsafe fn get_column_slice( &mut self, i: usize, j: usize, n_elems: usize ) -> Self::RawSlice

Safety

impl<E: Entity> MatIndex<Range<usize>, Range<usize>> for MatRef<'_, E>

type Target = MatRef<'_, E>

fn get(this: Self, row: Range<usize>, col: Range<usize>) -> Self

unsafe fn get_unchecked( this: Self, row: RowRange, col: ColRange ) -> Self::Target

impl<E: Entity> MatIndex<Range<usize>, usize> for MatRef<'_, E>

type Target = MatRef<'_, E>

fn get(this: Self, row: Range<usize>, col: usize) -> Self

unsafe fn get_unchecked( this: Self, row: RowRange, col: ColRange ) -> Self::Target

impl<E: Entity> MatIndex<RangeFull, Range<usize>> for MatRef<'_, E>

type Target = MatRef<'_, E>

fn get(this: Self, row: RangeFull, col: Range<usize>) -> Self

unsafe fn get_unchecked( this: Self, row: RowRange, col: ColRange ) -> Self::Target

impl<E: Entity> MatIndex<RangeFull, usize> for MatRef<'_, E>

type Target = MatRef<'_, E>

fn get(this: Self, row: RangeFull, col: usize) -> Self

unsafe fn get_unchecked( this: Self, row: RowRange, col: ColRange ) -> Self::Target

impl<E: Entity> MatIndex<RangeInclusive<usize>, Range<usize>> for MatRef<'_, E>

type Target = MatRef<'_, E>

fn get(this: Self, row: RangeInclusive<usize>, col: Range<usize>) -> Self

unsafe fn get_unchecked( this: Self, row: RowRange, col: ColRange ) -> Self::Target

impl<E: Entity> MatIndex<RangeInclusive<usize>, usize> for MatRef<'_, E>

type Target = MatRef<'_, E>

fn get(this: Self, row: RangeInclusive<usize>, col: usize) -> Self

unsafe fn get_unchecked( this: Self, row: RowRange, col: ColRange ) -> Self::Target

impl<E: Entity> MatIndex<RangeTo<usize>, Range<usize>> for MatRef<'_, E>

type Target = MatRef<'_, E>

fn get(this: Self, row: RangeTo<usize>, col: Range<usize>) -> Self

unsafe fn get_unchecked( this: Self, row: RowRange, col: ColRange ) -> Self::Target

impl<E: Entity> MatIndex<RangeTo<usize>, usize> for MatRef<'_, E>

type Target = MatRef<'_, E>

fn get(this: Self, row: RangeTo<usize>, col: usize) -> Self

unsafe fn get_unchecked( this: Self, row: RowRange, col: ColRange ) -> Self::Target

impl<E: Entity> MatIndex<RangeToInclusive<usize>, Range<usize>> for MatRef<'_, E>

type Target = MatRef<'_, E>

fn get(this: Self, row: RangeToInclusive<usize>, col: Range<usize>) -> Self

unsafe fn get_unchecked( this: Self, row: RowRange, col: ColRange ) -> Self::Target

impl<E: Entity> MatIndex<RangeToInclusive<usize>, usize> for MatRef<'_, E>

type Target = MatRef<'_, E>

fn get(this: Self, row: RangeToInclusive<usize>, col: usize) -> Self

unsafe fn get_unchecked( this: Self, row: RowRange, col: ColRange ) -> Self::Target

impl<E: Entity, RowRange> MatIndex<RowRange, RangeFull> for MatRef<'_, E>

where Self: MatIndex<RowRange, Range<usize>>,

type Target = <MatRef<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

fn get( this: Self, row: RowRange, col: RangeFull ) -> <Self as MatIndex<RowRange, Range<usize>>>::Target

unsafe fn get_unchecked( this: Self, row: RowRange, col: ColRange ) -> Self::Target

impl<E: Entity, RowRange> MatIndex<RowRange, RangeInclusive<usize>> for MatRef<'_, E>

where Self: MatIndex<RowRange, Range<usize>>,

type Target = <MatRef<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

fn get( this: Self, row: RowRange, col: RangeInclusive<usize> ) -> <Self as MatIndex<RowRange, Range<usize>>>::Target

unsafe fn get_unchecked( this: Self, row: RowRange, col: ColRange ) -> Self::Target

impl<E: Entity, RowRange> MatIndex<RowRange, RangeTo<usize>> for MatRef<'_, E>

where Self: MatIndex<RowRange, Range<usize>>,

type Target = <MatRef<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

fn get( this: Self, row: RowRange, col: RangeTo<usize> ) -> <Self as MatIndex<RowRange, Range<usize>>>::Target

unsafe fn get_unchecked( this: Self, row: RowRange, col: ColRange ) -> Self::Target

impl<E: Entity, RowRange> MatIndex<RowRange, RangeToInclusive<usize>> for MatRef<'_, E>

where Self: MatIndex<RowRange, Range<usize>>,

type Target = <MatRef<'_, E> as MatIndex<RowRange, Range<usize>>>::Target

fn get( this: Self, row: RowRange, col: RangeToInclusive<usize> ) -> <Self as MatIndex<RowRange, Range<usize>>>::Target

unsafe fn get_unchecked( this: Self, row: RowRange, col: ColRange ) -> Self::Target

impl<E: Entity> MatIndex<usize, Range<usize>> for MatRef<'_, E>

type Target = MatRef<'_, E>

fn get(this: Self, row: usize, col: Range<usize>) -> Self

unsafe fn get_unchecked( this: Self, row: RowRange, col: ColRange ) -> Self::Target

impl<'a, E: Entity> MatIndex<usize, usize> for MatRef<'a, E>

type Target = <<E as Entity>::Group as ForType>::FaerOf<&'a <E as Entity>::Unit>

unsafe fn get_unchecked(this: Self, row: usize, col: usize) -> Self::Target

fn get(this: Self, row: usize, col: usize) -> Self::Target

impl<E: Entity> Matrix<E> for MatRef<'_, E>

fn rows(&self) -> usize

fn cols(&self) -> usize

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

Expose dense or sparse access to the matrix.

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 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 &MatRef<'_, 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 MatRef<'_, 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<E: ComplexField, MatE: Conjugate<Canonical = E>> Mul<&MatRef<'_, MatE>> for Scale<E>

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &MatRef<'_, MatE>) -> 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 &MatMut<'_, 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 &MatRef<'_, 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<LhsE: Conjugate, RhsE: Conjugate<Canonical = LhsE::Canonical>> Mul<&MatRef<'_, 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: &MatRef<'_, RhsE>) -> Self::Output

Performs the * operation.

impl<LhsE: Conjugate, RhsE: Conjugate<Canonical = LhsE::Canonical>> Mul<&MatRef<'_, 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: &MatRef<'_, 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 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 &MatRef<'_, 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 MatRef<'_, 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<E: ComplexField, MatE: Conjugate<Canonical = E>> Mul<MatRef<'_, MatE>> for Scale<E>

type Output = Mat<E>

The resulting type after applying the * operator.

fn mul(self, rhs: MatRef<'_, MatE>) -> 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 &MatMut<'_, 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 &MatRef<'_, 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<LhsE: Conjugate, RhsE: Conjugate<Canonical = LhsE::Canonical>> Mul<MatRef<'_, 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: MatRef<'_, RhsE>) -> Self::Output

Performs the * operation.

impl<LhsE: Conjugate, RhsE: Conjugate<Canonical = LhsE::Canonical>> Mul<MatRef<'_, 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: MatRef<'_, RhsE>) -> Self::Output

Performs the * operation.

impl<E: ComplexField, MatE: Conjugate<Canonical = E>> Mul<Scale<E>> for &MatRef<'_, 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 MatRef<'_, 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: Conjugate> Neg for &MatRef<'_, 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 MatRef<'_, 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 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 MatRef<'_, 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 MatMut<'_, 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 MatRef<'_, 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 &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 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 &MatRef<'_, 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 MatRef<'_, 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 &MatMut<'_, 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 &MatRef<'_, 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>> PartialEq<MatRef<'_, RhsE>> for MatMut<'_, 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<U: Conjugate, T: Conjugate<Canonical = U::Canonical>> PartialEq<MatRef<'_, U>> for MatRef<'_, T>

where T::Canonical: ComplexField,

fn eq(&self, other: &MatRef<'_, U>) -> 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<'short, 'a, E: Entity> Reborrow<'short> for MatRef<'a, E>

type Target = MatRef<'short, E>

fn rb(&'short self) -> Self::Target

impl<'short, 'a, E: Entity> ReborrowMut<'short> for MatRef<'a, E>

type Target = MatRef<'short, E>

fn rb_mut(&'short mut self) -> Self::Target

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 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 &MatRef<'_, 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 MatRef<'_, 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 &MatMut<'_, 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 &MatRef<'_, 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<&MatRef<'_, 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: &MatRef<'_, RhsE>) -> Self::Output

Performs the - operation.

impl<LhsE: Conjugate, RhsE: Conjugate<Canonical = LhsE::Canonical>> Sub<&MatRef<'_, 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: &MatRef<'_, 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 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 &MatRef<'_, 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 MatRef<'_, 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 &MatMut<'_, 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 &MatRef<'_, 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<MatRef<'_, 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: MatRef<'_, RhsE>) -> Self::Output

Performs the - operation.

impl<LhsE: Conjugate, RhsE: Conjugate<Canonical = LhsE::Canonical>> Sub<MatRef<'_, 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: MatRef<'_, RhsE>) -> Self::Output

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<&MatRef<'_, RhsE>> for MatMut<'_, LhsE>

fn sub_assign(&mut self, rhs: &MatRef<'_, 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<MatRef<'_, RhsE>> for MatMut<'_, LhsE>

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

Performs the -= operation.

impl<E: Entity> Copy for MatRef<'_, E>

impl<E: Entity> Send for MatRef<'_, E>

impl<E: Entity> Sync for MatRef<'_, E>