Struct LastEq 

pub struct LastEq<Rows, Cols, Mat>(pub Mat, pub PhantomData<(Rows, Cols)>);

single matrix

Tuple Fields

0: Mat

1: PhantomData<(Rows, Cols)>

Implementations

impl<Rows: Shape, Cols: Shape, M: MatIndex<LayoutTransform = MatLayoutTransform, Rows = Rows, Cols = Cols, Index = (Idx<Rows>, Idx<Cols>)>> LastEq<Rows, Cols, M>

where M::Dyn: MatIndex<Rows = usize, Cols = usize, Index = (usize, usize)>,

pub fn for_each(self, f: impl FnMut(<Self as MatIndex>::Item))

applies f to each element of self

pub fn for_each_with_index( self, f: impl FnMut(Idx<Rows>, Idx<Cols>, <Self as MatIndex>::Item), )

applies f to each element of self, while passing the indices of the position of the current element

pub fn for_each_triangular_lower_with_index( self, diag: Diag, f: impl FnMut(Idx<Rows>, Idx<Cols>, <Self as MatIndex>::Item), )

applies f to each element of the lower triangular half of self, while passing the indices of the position of the current element

diag specifies whether the diagonal should be included or excluded

pub fn for_each_triangular_upper_with_index( self, diag: Diag, f: impl FnMut(Idx<Rows>, Idx<Cols>, <Self as MatIndex>::Item), )

applies f to each element of the upper triangular half of self, while passing the indices of the position of the current element

diag specifies whether the diagonal should be included or excluded

pub fn for_each_triangular_lower( self, diag: Diag, f: impl FnMut(<Self as MatIndex>::Item), )

applies f to each element of the lower triangular half of self

diag specifies whether the diagonal should be included or excluded

pub fn for_each_triangular_upper( self, diag: Diag, f: impl FnMut(<Self as MatIndex>::Item), )

applies f to each element of the upper triangular half of self

diag specifies whether the diagonal should be included or excluded

pub fn map<T>( self, f: impl FnMut(<Self as MatIndex>::Item) -> T, ) -> Mat<T, Rows, Cols>

applies f to each element of self and collect its result into a new matrix

pub fn map_with_index<T>( self, f: impl FnMut(Idx<Rows>, Idx<Cols>, <Self as MatIndex>::Item) -> T, ) -> Mat<T, Rows, Cols>

applies f to each element of self and collect its result into a new matrix

impl<Rows: Shape, M: MatIndex<LayoutTransform = VecLayoutTransform, Rows = Rows, Cols = (), Index = Idx<Rows>>> LastEq<Rows, (), M>

where M::Dyn: MatIndex<Rows = usize, Cols = (), Index = usize>,

pub fn for_each(self, f: impl FnMut(<Self as MatIndex>::Item))

applies f to each element of self

pub fn for_each_with_index( self, f: impl FnMut(Idx<Rows>, <Self as MatIndex>::Item), )

applies f to each element of self, while passing the indices of the position of the current element

pub fn map<T>( self, f: impl FnMut(<Self as MatIndex>::Item) -> T, ) -> Col<T, Rows>

applies f to each element of self and collect its result into a new matrix

pub fn map_with_index<T>( self, f: impl FnMut(Idx<Rows>, <Self as MatIndex>::Item) -> T, ) -> Col<T, Rows>

applies f to each element of self and collect its result into a new matrix

impl<Cols: Shape, M: MatIndex<LayoutTransform = VecLayoutTransform, Rows = (), Cols = Cols, Index = Idx<Cols>>> LastEq<(), Cols, M>

where M::Dyn: MatIndex<Rows = (), Cols = usize, Index = usize>,

pub fn for_each(self, f: impl FnMut(<Self as MatIndex>::Item))

applies f to each element of self

pub fn for_each_with_index( self, f: impl FnMut(Idx<Cols>, <Self as MatIndex>::Item), )

applies f to each element of self, while passing the indices of the position of the current element

pub fn map<T>( self, f: impl FnMut(<Self as MatIndex>::Item) -> T, ) -> Row<T, Cols>

applies f to each element of self and collect its result into a new matrix

pub fn map_with_index<T>( self, f: impl FnMut(Idx<Cols>, <Self as MatIndex>::Item) -> T, ) -> Row<T, Cols>

applies f to each element of self and collect its result into a new matrix

Trait Implementations

impl<Rows: Clone, Cols: Clone, Mat: Clone> Clone for LastEq<Rows, Cols, Mat>

fn clone(&self) -> LastEq<Rows, Cols, Mat>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Rows: Debug, Cols: Debug, Mat: Debug> Debug for LastEq<Rows, Cols, Mat>

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

Formats the value using the given formatter.

impl<Rows: Copy + Eq + Debug, Cols: Copy + Eq + Debug, Mat: MatIndex<Rows = Rows, Cols = Cols>> MatIndex for LastEq<Rows, Cols, Mat>

type Cols = <Mat as MatIndex>::Cols

type of columns

type Dyn = LastEq<<<Mat as MatIndex>::Dyn as MatIndex>::Rows, <<Mat as MatIndex>::Dyn as MatIndex>::Cols, <Mat as MatIndex>::Dyn>

matrix type with type erased dimensions

type Index = <Mat as MatIndex>::Index

indexing type

type Item = Last<<Mat as MatIndex>::Item>

item produced by the zip views

type LayoutTransform = <Mat as MatIndex>::LayoutTransform

layout transformation type

type Rows = <Mat as MatIndex>::Rows

type of rows

type Slice = Last<<Mat as MatIndex>::Slice>

fn nrows(this: &Self) -> Self::Rows

returns the number of rows

fn ncols(this: &Self) -> Self::Cols

returns the number of columns

unsafe fn get_slice_unchecked<'a>( this: &'a mut Self, idx: Self::Index, n_elems: usize, ) -> <Self::Slice as SliceFamily<'a, Self::Item>>::Slice

returns slice at index of length n_elems

unsafe fn from_dyn_idx(idx: <Self::Dyn as MatIndex>::Index) -> Self::Index

converts a type erased index back to its original representation

unsafe fn get_unchecked(this: &mut Self, index: Self::Index) -> Self::Item

get the item at the given index, skipping bound checks

unsafe fn next_unchecked<'a>( slice: &mut <Self::Slice as SliceFamily<'a, Self::Item>>::Slice, ) -> Self::Item

get the item at the given slice position, skipping bound checks

fn is_contiguous(this: &Self) -> bool

checks if the zip matrices are contiguous

fn preferred_layout(this: &Self) -> Self::LayoutTransform

computes the preferred iteration layout of the matrices

fn with_layout(this: Self, layout: Self::LayoutTransform) -> Self::Dyn

applies the layout transformation to the matrices

impl<Rows: Copy, Cols: Copy, Mat: Copy> Copy for LastEq<Rows, Cols, Mat>