Struct CsrMatrix 

pub struct CsrMatrix<T> {
    pub indptr: Vec<usize>,
    pub indices: Vec<usize>,
    pub data: Vec<T>,
    /* private fields */
}

Compressed Sparse Row (CSR) matrix

A sparse matrix format that compresses rows, making it efficient for row operations and matrix-vector multiplication.

Fields

indptr: Vec<usize>

Row pointers (size rows+1)

indices: Vec<usize>

Column indices

data: Vec<T>

Data values

Implementations

impl<T> CsrMatrix<T>

where T: Clone + Copy + Zero + PartialEq,

pub fn get(&self, row: usize, col: usize) -> T

Get the value at the specified position

pub fn get_triplets(&self) -> (Vec<usize>, Vec<usize>, Vec<T>)

Get the triplets (row indices, column indices, data)

pub fn new( data: Vec<T>, rowindices: Vec<usize>, colindices: Vec<usize>, shape: (usize, usize), ) -> SparseResult<Self>

Create a new CSR matrix from raw data

Arguments

• data - Vector of non-zero values
• rowindices - Vector of row indices for each non-zero value
• colindices - Vector of column indices for each non-zero value
• shape - Tuple containing the matrix dimensions (rows, cols)

Returns

• A new CSR matrix

Examples

use scirs2_sparse::csr::CsrMatrix;

// Create a 3x3 sparse matrix with 5 non-zero elements
let rows = vec![0, 0, 1, 2, 2];
let cols = vec![0, 2, 2, 0, 1];
let data = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let shape = (3, 3);

let matrix = CsrMatrix::new(data.clone(), rows, cols, shape).unwrap();

pub fn from_raw_csr( data: Vec<T>, indptr: Vec<usize>, indices: Vec<usize>, shape: (usize, usize), ) -> SparseResult<Self>

Create a new CSR matrix from raw CSR format

Arguments

• data - Vector of non-zero values
• indptr - Vector of row pointers (size rows+1)
• indices - Vector of column indices
• shape - Tuple containing the matrix dimensions (rows, cols)

Returns

• A new CSR matrix

pub fn empty(shape: (usize, usize)) -> Self

Create a new empty CSR matrix

Arguments

• shape - Tuple containing the matrix dimensions (rows, cols)

Returns

• A new empty CSR matrix

pub fn rows(&self) -> usize

Get the number of rows in the matrix

pub fn cols(&self) -> usize

Get the number of columns in the matrix

pub fn shape(&self) -> (usize, usize)

Get the shape (dimensions) of the matrix

pub fn nnz(&self) -> usize

Get the number of non-zero elements in the matrix

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

where T: Zero + Copy,

Convert to dense matrix (as Vec<Vec>)

pub fn transpose(&self) -> Self

Transpose the matrix

impl<T: Clone + Copy + AddAssign + MulAssign + PartialEq + Debug + Zero + Add<Output = T> + Mul<Output = T>> CsrMatrix<T>

pub fn is_symmetric(&self) -> bool

Check if matrix is symmetric

Returns

• true if the matrix is symmetric, false otherwise

pub fn matmul(&self, other: &CsrMatrix<T>) -> SparseResult<CsrMatrix<T>>

Matrix-matrix multiplication

Arguments

• other - Matrix to multiply with

Returns

• Result containing the product matrix

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

Get row range for iterating over elements in a row

Arguments

• row - Row index

Returns

• Range of indices in the data and indices arrays for this row

pub fn colindices(&self) -> &[usize]

Get column indices array

impl CsrMatrix<f64>

pub fn dot(&self, vec: &[f64]) -> SparseResult<Vec<f64>>

Matrix-vector multiplication

Arguments

• vec - Vector to multiply with

Returns

• Result of matrix-vector multiplication

pub fn gpu_dot(&self, vec: &[f64]) -> SparseResult<Vec<f64>>

GPU-accelerated matrix-vector multiplication

This method automatically uses GPU acceleration when beneficial, falling back to optimized CPU implementation when appropriate.

Arguments

• vec - Vector to multiply with

Returns

• Result of matrix-vector multiplication

Examples

use scirs2_sparse::csr::CsrMatrix;

let rows = vec![0, 0, 1, 2, 2];
let cols = vec![0, 2, 2, 0, 1];
let data = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let shape = (3, 3);

let matrix = CsrMatrix::new(data, rows, cols, shape).unwrap();
let vec = vec![1.0, 2.0, 3.0];
let result = matrix.gpu_dot(&vec).unwrap();

pub fn gpu_dot_with_backend( &self, vec: &[f64], backend: GpuBackend, ) -> SparseResult<Vec<f64>>

GPU-accelerated matrix-vector multiplication with backend selection

Arguments

• vec - Vector to multiply with
• backend - Preferred GPU backend

Returns

• Result of matrix-vector multiplication

impl<T> CsrMatrix<T>

where T: Float + Debug + Copy + Default + GpuDataType + Send + Sync + 'static,

pub fn gpu_dot_generic(&self, vec: &[T]) -> SparseResult<Vec<T>>

where T: Float + AddAssign + Copy + Default + Sum,

GPU-accelerated matrix-vector multiplication for generic floating-point types

Arguments

• vec - Vector to multiply with

Returns

• Result of matrix-vector multiplication

pub fn should_use_gpu(&self) -> bool

Check if this matrix should benefit from GPU acceleration

Returns

• true if GPU acceleration is likely to provide benefits

pub fn gpu_backend_info() -> SparseResult<(GpuBackend, String)>

Get GPU backend information

Returns

• Information about available GPU backends

Trait Implementations

impl<F: Float + NumAssign + Sum + 'static + Debug> AsLinearOperator<F> for CsrMatrix<F>

fn as_linear_operator(&self) -> Box<dyn LinearOperator<F>>

Convert to a linear operator

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.