Struct CsrMatrix 

pub struct CsrMatrix {
    pub num_rows: usize,
    pub num_cols: usize,
    pub values: Vec<Complex64>,
    pub col_indices: Vec<usize>,
    pub row_ptrs: Vec<usize>,
}

Compressed Sparse Row (CSR) matrix format

Memory-efficient storage for sparse matrices with O(nnz) space complexity. Matrix-vector products are O(nnz) instead of O(n²) for dense matrices.

Fields

num_rows: usize

Number of rows

num_cols: usize

Number of columns

values: Vec<Complex64>

Non-zero values in row-major order

col_indices: Vec<usize>

Column indices for each value

row_ptrs: Vec<usize>

Row pointers: row_ptrs[i] is the start index in values/col_indices for row i row_ptrs[num_rows] = nnz (total number of non-zeros)

Implementations

impl CsrMatrix

pub fn new(num_rows: usize, num_cols: usize) -> Self

Create a new empty CSR matrix

pub fn with_capacity( num_rows: usize, num_cols: usize, nnz_estimate: usize, ) -> Self

Create a CSR matrix with pre-allocated capacity

pub fn from_dense(dense: &Array2<Complex64>, threshold: f64) -> Self

Create a CSR matrix from a dense matrix

Only stores entries with magnitude > threshold

pub fn from_triplets( num_rows: usize, num_cols: usize, triplets: Vec<(usize, usize, Complex64)>, ) -> Self

Create a CSR matrix from COO (Coordinate) format triplets

Triplets are (row, col, value). Duplicate entries are summed.

pub fn nnz(&self) -> usize

Number of non-zero entries

pub fn sparsity(&self) -> f64

Sparsity ratio (fraction of non-zero entries)

pub fn row_range(&self, row: usize) -> Range<usize>

Get the range of indices in values/col_indices for a given row

pub fn row_entries( &self, row: usize, ) -> impl Iterator<Item = (usize, Complex64)> + '_

Get the (col, value) pairs for a row

pub fn matvec(&self, x: &Array1<Complex64>) -> Array1<Complex64>

Matrix-vector product: y = A * x

pub fn matvec_add(&self, x: &Array1<Complex64>, y: &mut Array1<Complex64>)

Matrix-vector product with accumulation: y += A * x

pub fn matvec_transpose(&self, x: &Array1<Complex64>) -> Array1<Complex64>

Transpose matrix-vector product: y = A^T * x

pub fn matvec_hermitian(&self, x: &Array1<Complex64>) -> Array1<Complex64>

Hermitian (conjugate transpose) matrix-vector product: y = A^H * x

pub fn get(&self, i: usize, j: usize) -> Complex64

Get element at (i, j), returns 0 if not stored

pub fn diagonal(&self) -> Array1<Complex64>

Extract diagonal elements

pub fn scale(&mut self, scalar: Complex64)

Scale all values by a scalar

pub fn add_diagonal(&mut self, scalar: Complex64)

Add a scalar to the diagonal

pub fn identity(n: usize) -> Self

Create identity matrix in CSR format

pub fn from_diagonal(diag: &Array1<Complex64>) -> Self

Create diagonal matrix from vector

pub fn to_dense(&self) -> Array2<Complex64>

Convert to dense matrix (for debugging/small matrices)

Trait Implementations

impl Clone for CsrMatrix

fn clone(&self) -> CsrMatrix

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CsrMatrix

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

Formats the value using the given formatter.