Struct ZipEq 

pub struct ZipEq<Rows, Cols, Head, Tail>(pub Head, pub Tail, _);

zipped matrices

Tuple Fields

0: Head

1: Tail

Implementations

impl<Rows: Copy + Eq + Debug, Cols: Copy + Eq + Debug, Head: MatIndex<Rows = Rows, Cols = Cols>, Tail: MatIndex<Rows = Rows, Cols = Cols>> ZipEq<Rows, Cols, Head, Tail>

single matrix view

pub fn new(head: Head, tail: Tail) -> Self

creates a zip matrix, after asserting that the dimensions match

pub fn new_unchecked(head: Head, tail: Tail) -> Self

creates a zip matrix, assuming that the dimensions match

impl<Rows: Shape, Cols: Shape, L: MatIndex<LayoutTransform = MatLayoutTransform, Rows = Rows, Cols = Cols, Index = (Idx<Rows>, Idx<Cols>)>, R: MatIndex<LayoutTransform = MatLayoutTransform, Rows = Rows, Cols = Cols, Index = (Idx<Rows>, Idx<Cols>)>> ZipEq<Rows, Cols, L, R>

where L::Dyn: MatIndex<Rows = usize, Cols = usize, Index = (usize, usize)>, R::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, L: MatIndex<LayoutTransform = VecLayoutTransform, Rows = Rows, Cols = (), Index = Idx<Rows>>, R: MatIndex<LayoutTransform = VecLayoutTransform, Rows = Rows, Cols = (), Index = Idx<Rows>>> ZipEq<Rows, (), L, R>

where L::Dyn: MatIndex<Rows = usize, Cols = (), Index = usize>, R::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, L: MatIndex<LayoutTransform = VecLayoutTransform, Rows = (), Cols = Cols, Index = Idx<Cols>>, R: MatIndex<LayoutTransform = VecLayoutTransform, Rows = (), Cols = Cols, Index = Idx<Cols>>> ZipEq<(), Cols, L, R>

where L::Dyn: MatIndex<Rows = (), Cols = usize, Index = usize>, R::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, Head: Clone, Tail: Clone> Clone for ZipEq<Rows, Cols, Head, Tail>

fn clone(&self) -> ZipEq<Rows, Cols, Head, Tail>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Rows: Debug, Cols: Debug, Head: Debug, Tail: Debug> Debug for ZipEq<Rows, Cols, Head, Tail>

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

Formats the value using the given formatter.

impl<Rows: Copy + Eq + Debug, Cols: Copy + Eq + Debug, L: MatIndex<Rows = Rows, Cols = Cols>, R: MatIndex<Rows = Rows, Cols = Cols, Index = L::Index, LayoutTransform = L::LayoutTransform>> MatIndex for ZipEq<Rows, Cols, L, R>

where R::Dyn: MatIndex<Rows = <L::Dyn as MatIndex>::Rows, Cols = <L::Dyn as MatIndex>::Cols, Index = <L::Dyn as MatIndex>::Index>,

type Cols = <L as MatIndex>::Cols

type of columns

type Dyn = ZipEq<<<L as MatIndex>::Dyn as MatIndex>::Rows, <<L as MatIndex>::Dyn as MatIndex>::Cols, <L as MatIndex>::Dyn, <R as MatIndex>::Dyn>

matrix type with type erased dimensions

type Index = <L as MatIndex>::Index

indexing type

type Item = Zip<<L as MatIndex>::Item, <R as MatIndex>::Item>

item produced by the zip views

type LayoutTransform = <L as MatIndex>::LayoutTransform

layout transformation type

type Rows = <L as MatIndex>::Rows

type of rows

type Slice = Zip<<L as MatIndex>::Slice, <R 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, Head: Copy, Tail: Copy> Copy for ZipEq<Rows, Cols, Head, Tail>