Trait Matrix 

pub trait Matrix<T>: Send + Sync
where
    T: Send + Sync,
{
    type Row<'a>: Iterator<Item = T> + Send + Sync
       where Self: 'a;

    // Required methods
    fn width(&self) -> usize;
    fn height(&self) -> usize;
    fn row(&self, r: usize) -> Self::Row<'_>;

    // Provided methods
    fn dimensions(&self) -> Dimensions { ... }
    fn get(&self, r: usize, c: usize) -> T { ... }
    fn rows(&self) -> impl Iterator<Item = Self::Row<'_>> { ... }
    fn par_rows(&self) -> impl ExactSizeIterator { ... }
    fn row_slice(&self, r: usize) -> impl Deref<Target = [T]> { ... }
    fn first_row(&self) -> Self::Row<'_> { ... }
    fn last_row(&self) -> Self::Row<'_> { ... }
    fn to_row_major_matrix(self) -> DenseMatrix<T>
       where Self: Sized,
             T: Clone { ... }
    fn horizontally_packed_row<'a, P>(
        &'a self,
        r: usize,
    ) -> (impl Iterator<Item = P>, impl Iterator<Item = T>)
       where P: PackedValue<Value = T>,
             T: Clone + 'a { ... }
    fn vertically_packed_row<P>(&self, r: usize) -> impl Iterator<Item = P>
       where P: PackedValue<Value = T> { ... }
    fn vertically_strided(
        self,
        stride: usize,
        offset: usize,
    ) -> RowIndexMappedView<VerticallyStridedRowIndexMap, Self>
       where Self: Sized { ... }
    fn columnwise_dot_product<EF>(&self, v: &[EF]) -> Vec<EF>
       where T: Field,
             EF: ExtensionField<T> { ... }
}

Required Associated Types

type Row<'a>: Iterator<Item = T> + Send + Sync where Self: 'a

Required Methods

fn width(&self) -> usize

fn height(&self) -> usize

fn row(&self, r: usize) -> Self::Row<'_>

Provided Methods

fn dimensions(&self) -> Dimensions

fn get(&self, r: usize, c: usize) -> T

fn rows(&self) -> impl Iterator<Item = Self::Row<'_>>

fn par_rows(&self) -> impl ExactSizeIterator

fn row_slice(&self, r: usize) -> impl Deref<Target = [T]>

fn first_row(&self) -> Self::Row<'_>

fn last_row(&self) -> Self::Row<'_>

fn to_row_major_matrix(self) -> DenseMatrix<T>

where Self: Sized, T: Clone,

fn horizontally_packed_row<'a, P>( &'a self, r: usize, ) -> (impl Iterator<Item = P>, impl Iterator<Item = T>)

where P: PackedValue<Value = T>, T: Clone + 'a,

fn vertically_packed_row<P>(&self, r: usize) -> impl Iterator<Item = P>

where P: PackedValue<Value = T>,

Wraps at the end.

fn vertically_strided( self, stride: usize, offset: usize, ) -> RowIndexMappedView<VerticallyStridedRowIndexMap, Self>

where Self: Sized,

fn columnwise_dot_product<EF>(&self, v: &[EF]) -> Vec<EF>

where T: Field, EF: ExtensionField<T>,

Compute Mᵀv, aka premultiply this matrix by the given vector, aka scale each row by the corresponding entry in v and take the row-wise sum. v can be a vector of extension elements.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<F, EF, Inner> Matrix<F> for FlatMatrixView<F, EF, Inner>

where F: Field, EF: ExtensionField<F>, Inner: Matrix<EF>,

type Row<'a> = FlatIter<F, <Inner as Matrix<EF>>::Row<'a>> where FlatMatrixView<F, EF, Inner>: 'a

impl<T> Matrix<T> for CsrMatrix<T>

where T: Clone + Default + Send + Sync,

type Row<'a> = <Vec<T> as IntoIterator>::IntoIter where CsrMatrix<T>: 'a

impl<T, First, Second> Matrix<T> for VerticalPair<First, Second>

where T: Send + Sync, First: Matrix<T>, Second: Matrix<T>,

type Row<'a> = EitherRow<<First as Matrix<T>>::Row<'a>, <Second as Matrix<T>>::Row<'a>> where VerticalPair<First, Second>: 'a

impl<T, IndexMap, Inner> Matrix<T> for RowIndexMappedView<IndexMap, Inner>

where T: Send + Sync, IndexMap: RowIndexMap, Inner: Matrix<T>,

type Row<'a> = <Inner as Matrix<T>>::Row<'a> where RowIndexMappedView<IndexMap, Inner>: 'a

impl<T, S> Matrix<T> for DenseMatrix<T, S>

where T: Clone + Send + Sync, S: DenseStorage<T>,

type Row<'a> = Cloned<Iter<'a, T>> where DenseMatrix<T, S>: 'a