Struct faer_core::MatMut

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

Implementations

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

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

pub fn as_ptr(self) -> E::Group<*mut 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<*mut E::Unit>

pub unsafe fn ptr_inbounds_at( self, row: usize, col: usize ) -> E::Group<*mut 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 mut E::Unit>

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

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

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

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

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

pub fn clone_from(&mut self, other: MatRef<'_, E>)

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

pub fn set_constant(&mut self, c: E)

pub fn transpose(self) -> Self

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

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

pub fn canonicalize(self) -> (MatMut<'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> MatMut<'a, Complex<E>>

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

Trait Implementations

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

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

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

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

Formats the value using the given formatter.

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

type Target = MatRef<'a, E>

fn into_const(self) -> Self::Target

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

type Item = ReadWrite<'short, E>

type RawSlice = <E as Entity>::Group<&'a mut [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<'a, U: Conjugate, T: Conjugate<Canonical = U::Canonical>> PartialEq<MatMut<'a, U>> for MatMut<'a, T>where T::Canonical: ComplexField,

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

type Target = MatRef<'short, E>

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

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

type Target = MatMut<'short, E>

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

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

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