Struct CsrMatrix 

pub struct CsrMatrix<T> {
    pub row_ptr: Vec<usize>,
    pub col_indices: Vec<usize>,
    pub values: Vec<T>,
    pub rows: usize,
    pub cols: usize,
}

Compressed Sparse Row (CSR) matrix.

Stores only non-zero entries for efficient sparse matrix-vector multiplication in O(nnz) time with excellent cache locality.

Layout

For a matrix with m rows and nnz non-zeros:

• row_ptr has length m + 1
• col_indices and values each have length nnz
• Row i spans indices row_ptr[i]..row_ptr[i+1]

Fields

row_ptr: Vec<usize>

Row pointers: row_ptr[i] is the start index in col_indices/values for row i.

col_indices: Vec<usize>

Column indices for each non-zero entry.

values: Vec<T>

Values for each non-zero entry.

rows: usize

Number of rows.

cols: usize

Number of columns.

Implementations

impl<T: Copy + Default + Mul<Output = T> + AddAssign> CsrMatrix<T>

pub fn spmv(&self, x: &[T], y: &mut [T])

Sparse matrix-vector multiply: y = A * x.

Panics

Debug-asserts that x.len() >= self.cols and y.len() >= self.rows.

impl CsrMatrix<f32>

pub fn spmv_unchecked(&self, x: &[f32], y: &mut [f32])

High-performance SpMV with bounds-check elimination.

Identical to spmv but uses unsafe indexing to eliminate per-element bounds checks in the inner loop, which is the single hottest path in all iterative solvers.

Safety contract

The caller must ensure the CSR structure is valid (use validate_csr_matrix once before entering the solve loop). The x and y slices must have lengths >= cols and >= rows respectively.

pub fn fused_residual_norm_sq( &self, x: &[f32], rhs: &[f32], residual: &mut [f32], ) -> f64

Fused SpMV + residual computation: computes r[j] = rhs[j] - (A*x)[j] and returns ||r||^2 in a single pass, avoiding a separate allocation for Ax.

This eliminates one full memory traversal per iteration compared to separate spmv + vector subtraction.

impl CsrMatrix<f64>

pub fn spmv_unchecked(&self, x: &[f64], y: &mut [f64])

High-performance SpMV for f64 with bounds-check elimination.

impl<T> CsrMatrix<T>

pub fn nnz(&self) -> usize

Number of non-zero entries.

pub fn row_degree(&self, row: usize) -> usize

Number of non-zeros in a specific row (i.e. the row degree for an adjacency matrix).

pub fn row_entries(&self, row: usize) -> impl Iterator<Item = (usize, &T)>

Iterate over (col_index, &value) pairs for the given row.

impl<T: Copy + Default> CsrMatrix<T>

pub fn transpose(&self) -> CsrMatrix<T>

Transpose: produces A^T in CSR form.

Uses a two-pass counting sort in O(nnz + rows + cols) time and O(nnz) extra memory. Required by backward push which operates on the reversed adjacency structure.

impl<T: Copy + Default + AddAssign> CsrMatrix<T>

pub fn from_coo_generic( rows: usize, cols: usize, entries: impl IntoIterator<Item = (usize, usize, T)>, ) -> Self

Build a CSR matrix from COO (coordinate) triplets.

Entries are sorted by (row, col) internally. Duplicate positions at the same (row, col) are kept as separate entries (caller should pre-merge if needed).

impl CsrMatrix<f32>

pub fn from_coo( rows: usize, cols: usize, entries: impl IntoIterator<Item = (usize, usize, f32)>, ) -> Self

Build a CSR matrix from COO (coordinate) triplets.

Entries are sorted by (row, col) internally. Duplicate positions are summed.

pub fn identity(n: usize) -> Self

Build a square identity matrix of dimension n in CSR format.

impl CsrMatrix<f64>

pub fn from_coo( rows: usize, cols: usize, entries: impl IntoIterator<Item = (usize, usize, f64)>, ) -> Self

Build a CSR matrix from COO (coordinate) triplets (f64 variant).

Entries are sorted by (row, col) internally.

pub fn identity(n: usize) -> Self

Build a square identity matrix of dimension n in CSR format (f64).

Trait Implementations

impl<T: Clone> Clone for CsrMatrix<T>

fn clone(&self) -> CsrMatrix<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for CsrMatrix<T>

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

Formats the value using the given formatter.