Struct CsrMatrix 

pub struct CsrMatrix<I, D>
where
    I: Idx,
{ /* private fields */ }

Compressed Sparse Row matrix mapping row indices to variable-length data.

For row i, its data is at data[indptr[i]..indptr[i+1]].

Type Parameters

• I: The row index type, must implement Idx.
• D: The data type stored in each row.

Example

use miden_utils_indexing::{CsrMatrix, newtype_id};

newtype_id!(NodeId);

let mut csr = CsrMatrix::<NodeId, u32>::new();
csr.push_row([1, 2, 3]);       // Row 0: [1, 2, 3]
csr.push_empty_row();          // Row 1: []
csr.push_row([4, 5]);          // Row 2: [4, 5]

assert_eq!(csr.row(NodeId::from(0)), Some(&[1, 2, 3][..]));
assert_eq!(csr.row(NodeId::from(1)), Some(&[][..]));
assert_eq!(csr.row(NodeId::from(2)), Some(&[4, 5][..]));

Implementations

impl<I, D> CsrMatrix<I, D>

where I: Idx,

pub fn new() -> CsrMatrix<I, D>

Creates a new empty CsrMatrix.

pub fn with_capacity(num_rows: usize, num_elements: usize) -> CsrMatrix<I, D>

Creates a CsrMatrix with pre-allocated capacity.

Arguments

• num_rows: Expected number of rows.
• num_elements: Expected total number of data elements across all rows.

pub fn push_row( &mut self, values: impl IntoIterator<Item = D>, ) -> Result<I, IndexedVecError>

Appends a new row with the given data values and returns the index of the newly added row.

Rows must be added in sequential order starting from row 0.

Errors

Returns an error if the number of rows would exceed u32::MAX.

pub fn push_empty_row(&mut self) -> Result<I, IndexedVecError>

Appends an empty row (no data for this row index).

Errors

Returns an error if the number of rows would exceed u32::MAX.

pub fn fill_to_row(&mut self, target_row: I) -> Result<(), IndexedVecError>

Appends empty rows to fill gaps up to (but not including) target_row.

If target_row is less than or equal to the current number of rows, this is a no-op.

Errors

Returns an error if the number of rows would exceed u32::MAX.

pub fn is_empty(&self) -> bool

Returns true if this matrix has no rows.

pub fn num_rows(&self) -> usize

Returns the number of rows in this matrix.

pub fn num_elements(&self) -> usize

Returns the total number of data elements across all rows.

pub fn row(&self, row: I) -> Option<&[D]>

Returns the data slice for the given row, or None if the row doesn’t exist.

pub fn row_expect(&self, row: I) -> &[D]

Returns the data slice for the given row, panicking if the row doesn’t exist.

Panics

Panics if row is out of bounds.

pub fn iter(&self) -> impl Iterator<Item = (I, &[D])>

Returns an iterator over all (row_index, data_slice) pairs.

pub fn iter_enumerated(&self) -> impl Iterator<Item = (I, usize, &D)>

Returns an iterator over all data elements with their (row_index, position_in_row, &data).

pub fn data(&self) -> &[D]

Returns the underlying data slice.

pub fn indptr(&self) -> &IndexVec<I, usize>

Returns the underlying indptr.

pub fn validate(&self) -> Result<(), CsrValidationError>

Validates the CSR structural invariants.

Checks:

• indptr starts at 0 (if non-empty)
• indptr is monotonically increasing
• indptr ends at data.len()

For domain-specific validation of data values, use validate_with.

pub fn validate_with<F>(&self, f: F) -> Result<(), CsrValidationError>

where F: Fn(&D) -> bool,

Validates structural invariants plus domain-specific data constraints.

The callback is invoked for each data element. Return false to indicate an invalid value.

Arguments

• f: A function that returns true if the data value is valid.

Trait Implementations

impl<I, D> Clone for CsrMatrix<I, D>

where I: Clone + Idx, D: Clone,

fn clone(&self) -> CsrMatrix<I, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I, D> Debug for CsrMatrix<I, D>

where I: Debug + Idx, D: Debug,

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

Formats the value using the given formatter.

impl<I, D> Default for CsrMatrix<I, D>

where I: Idx,

fn default() -> CsrMatrix<I, D>

Returns the “default value” for a type.

impl<I, D> Deserializable for CsrMatrix<I, D>

where I: Idx, D: Deserializable,

fn min_serialized_size() -> usize

Returns the minimum serialized size for a CsrMatrix.

A CsrMatrix serializes as:

• data_len (vint, minimum 1 byte)
• data elements (minimum 0 if empty)
• indptr_len (vint, minimum 1 byte)
• indptr elements (minimum 0 if empty)

Total minimum: 2 bytes (two vint length prefixes for empty matrix)

fn read_from<R>(source: &mut R) -> Result<CsrMatrix<I, D>, DeserializationError>

where R: ByteReader,

Reads a sequence of bytes from the provided source, attempts to deserialize these bytes into Self, and returns the result.

fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

Attempts to deserialize the provided bytes into Self and returns the result.

fn read_from_bytes_with_budget( bytes: &[u8], budget: usize, ) -> Result<Self, DeserializationError>

Deserializes Self from bytes with a byte budget limit.

impl<'de, I, D> Deserialize<'de> for CsrMatrix<I, D>

where I: Idx + Deserialize<'de>, D: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<CsrMatrix<I, D>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<I, D> PartialEq for CsrMatrix<I, D>

where I: PartialEq + Idx, D: PartialEq,

fn eq(&self, other: &CsrMatrix<I, D>) -> 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<I, D> Serializable for CsrMatrix<I, D>

where I: Idx, D: Serializable,

fn write_into<W>(&self, target: &mut W)

where W: ByteWriter,

Serializes self into bytes and writes these bytes into the target.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

impl<I, D> Serialize for CsrMatrix<I, D>

where I: Idx + Serialize, D: 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<I, D> Eq for CsrMatrix<I, D>

where I: Eq + Idx, D: Eq,

impl<I, D> StructuralPartialEq for CsrMatrix<I, D>

where I: Idx,