Struct DenseMatrix 

pub struct DenseMatrix<T, V = Vec<T>> {
    pub values: V,
    pub width: usize,
    /* private fields */
}

A dense matrix stored in row-major form.

Fields

values: V

width: usize

Implementations

impl<T> DenseMatrix<T>

where T: Clone + Send + Sync + Default,

pub fn default(width: usize, height: usize) -> DenseMatrix<T>

Create a new dense matrix of the given dimensions, backed by a Vec, and filled with default values.

impl<T, S> DenseMatrix<T, S>

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

pub fn new(values: S, width: usize) -> DenseMatrix<T, S>

pub fn new_row(values: S) -> DenseMatrix<T, S>

pub fn new_col(values: S) -> DenseMatrix<T, S>

pub fn as_view(&self) -> DenseMatrix<T, &[T]>

pub fn as_view_mut(&mut self) -> DenseMatrix<T, &mut [T]>

where S: BorrowMut<[T]>,

pub fn flatten_to_base<F>(&self) -> DenseMatrix<F>

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

pub fn par_row_slices(&self) -> impl ExactSizeIterator

where T: Sync,

pub fn row_mut(&mut self, r: usize) -> &mut [T]

where S: BorrowMut<[T]>,

pub fn rows_mut(&mut self) -> impl Iterator<Item = &mut [T]>

where S: BorrowMut<[T]>,

pub fn par_rows_mut<'a>(&'a mut self) -> impl ExactSizeIterator

where T: 'a + Send, S: BorrowMut<[T]>,

pub fn horizontally_packed_row_mut<P>( &mut self, r: usize, ) -> (&mut [P], &mut [T])

where P: PackedValue<Value = T>, S: BorrowMut<[T]>,

pub fn scale_row(&mut self, r: usize, scale: T)

where T: Field, S: BorrowMut<[T]>,

pub fn scale(&mut self, scale: T)

where T: Field, S: BorrowMut<[T]>,

pub fn split_rows( &self, r: usize, ) -> (DenseMatrix<T, &[T]>, DenseMatrix<T, &[T]>)

pub fn split_rows_mut( &mut self, r: usize, ) -> (DenseMatrix<T, &mut [T]>, DenseMatrix<T, &mut [T]>)

where S: BorrowMut<[T]>,

pub fn par_row_chunks_mut( &mut self, chunk_rows: usize, ) -> impl ExactSizeIterator

where T: Send, S: BorrowMut<[T]>,

pub fn par_row_chunks_exact_mut( &mut self, chunk_rows: usize, ) -> impl ExactSizeIterator

where T: Send, S: BorrowMut<[T]>,

pub fn row_pair_mut( &mut self, row_1: usize, row_2: usize, ) -> (&mut [T], &mut [T])

where S: BorrowMut<[T]>,

pub fn packed_row_pair_mut<P>( &mut self, row_1: usize, row_2: usize, ) -> ((&mut [P], &mut [T]), (&mut [P], &mut [T]))

where S: BorrowMut<[T]>, P: PackedValue<Value = T>,

pub fn bit_reversed_zero_pad(self, added_bits: usize) -> DenseMatrix<T>

where T: Copy + Default + Send + Sync,

impl<T> DenseMatrix<T>

where T: Clone + Default + Send + Sync,

pub fn rand<R>(rng: &mut R, rows: usize, cols: usize) -> DenseMatrix<T>

where R: Rng, Standard: Distribution<T>,

pub fn rand_nonzero<R>(rng: &mut R, rows: usize, cols: usize) -> DenseMatrix<T>

where R: Rng, T: Field, Standard: Distribution<T>,

pub fn transpose(self) -> DenseMatrix<T>

Trait Implementations

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

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

type BitRev = RowIndexMappedView<BitReversalPerm, DenseMatrix<T, S>>

fn bit_reverse_rows( self, ) -> <DenseMatrix<T, S> as BitReversableMatrix<T>>::BitRev

impl<T, V> Clone for DenseMatrix<T, V>

where T: Clone, V: Clone,

fn clone(&self) -> DenseMatrix<T, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, V> Debug for DenseMatrix<T, V>

where T: Debug, V: Debug,

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

Formats the value using the given formatter.

impl<'de, T, V> Deserialize<'de> for DenseMatrix<T, V>

where V: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<DenseMatrix<T, V>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

fn width(&self) -> usize

fn height(&self) -> usize

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

fn row(&self, r: usize) -> <DenseMatrix<T, S> as Matrix<T>>::Row<'_>

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

fn to_row_major_matrix(self) -> DenseMatrix<T>

where DenseMatrix<T, S>: 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 dimensions(&self) -> Dimensions

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

fn par_rows(&self) -> impl ExactSizeIterator

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

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

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.

impl<T, V> PartialEq for DenseMatrix<T, V>

where T: PartialEq, V: PartialEq,

fn eq(&self, other: &DenseMatrix<T, V>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, V> Serialize for DenseMatrix<T, V>

where V: Serialize,

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, V> Copy for DenseMatrix<T, V>

where T: Copy, V: Copy,

impl<T, V> Eq for DenseMatrix<T, V>

where T: Eq, V: Eq,

impl<T, V> StructuralPartialEq for DenseMatrix<T, V>