Struct faer_core::MatRef

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

Implementations

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

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

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

pub fn nrows(&self) -> usize

pub fn ncols(&self) -> usize

pub fn row_stride(&self) -> isize

pub fn col_stride(&self) -> isize

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

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

pub fn split_at(self, row: usize, col: usize) -> [Self; 4]

pub fn split_at_row(self, row: usize) -> [Self; 2]

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

pub unsafe fn get_unchecked( self, row: usize, col: usize ) -> E::Group<&'a E::Unit>

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

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

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

pub fn transpose(self) -> Self

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

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

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

pub fn reverse_rows(self) -> Self

pub fn reverse_cols(self) -> Self

pub fn reverse_rows_and_cols(self) -> Self

pub fn submatrix( self, row_start: usize, col_start: usize, nrows: usize, ncols: usize ) -> Self

pub fn subrows(self, row_start: usize, nrows: usize) -> Self

pub fn subcols(self, col_start: usize, ncols: usize) -> Self

pub fn row(self, row_idx: usize) -> Self

pub fn col(self, col_idx: usize) -> Self

pub fn diagonal(self) -> Self

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

Returns an owning Mat of the data

pub fn cwise(self) -> Zip<(Self,)>

Returns a thin wrapper that can be used to execute coefficientwise operations on matrices.

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

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

Trait Implementations

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<'a, 'short, E: Entity> Mat<'short, &'short MatRef<'a, E>> for MatRef<'a, E>

type Item = Read<'short, E>

type RawSlice = <E as Entity>::Group<&'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

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

unsafe fn get_slice_elem(slice: &mut Self::RawSlice, idx: usize) -> Self::Item

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<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 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<'a, U: Conjugate, T: Conjugate<Canonical = U::Canonical>> PartialEq<MatRef<'a, U>> for MatRef<'a, T>where T::Canonical: ComplexField,

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

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

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