Struct CsrMatrix 

pub struct CsrMatrix<T: ComplexField> {
    pub num_rows: usize,
    pub num_cols: usize,
    pub values: Vec<T>,
    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<T>

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<T: ComplexField> CsrMatrix<T>

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_raw_parts( num_rows: usize, num_cols: usize, row_ptrs: Vec<usize>, col_indices: Vec<usize>, values: Vec<T>, ) -> Self

Create a CSR matrix from raw components

This is useful for converting between different CSR matrix representations that share the same internal structure.

Panics

Panics if the input arrays are inconsistent:

• row_ptrs must have length num_rows + 1
• col_indices and values must have the same length
• row_ptrs[num_rows] must equal values.len()

pub fn from_dense(dense: &Array2<T>, threshold: T::Real) -> 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, T)>, ) -> 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, T)> + '_

Get the (col, value) pairs for a row

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

Matrix-vector product: y = A * x

Uses parallel processing when the rayon feature is enabled and the matrix is large enough to benefit from parallelization.

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

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

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

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

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

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

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

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

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

Extract diagonal elements

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

Scale all values by a scalar

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

Add a scalar to the diagonal

pub fn identity(n: usize) -> Self

Create identity matrix in CSR format

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

Create diagonal matrix from vector

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

Convert to dense matrix (for debugging/small matrices)

Trait Implementations

impl<T: Clone + ComplexField> 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 + ComplexField> Debug for CsrMatrix<T>

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

Formats the value using the given formatter.

impl<T: ComplexField> LinearOperator<T> for CsrMatrix<T>

fn num_rows(&self) -> usize

Number of rows in the operator

fn num_cols(&self) -> usize

Number of columns in the operator

fn apply(&self, x: &Array1<T>) -> Array1<T>

Apply the operator: y = A * x

fn apply_transpose(&self, x: &Array1<T>) -> Array1<T>

Apply the transpose: y = A^T * x

fn apply_hermitian(&self, x: &Array1<T>) -> Array1<T>

Apply the Hermitian (conjugate transpose): y = A^H * x

fn is_square(&self) -> bool

Check if the operator is square