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 + SparseElement,

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_triplets( nrows: usize, ncols: usize, row_indices: Vec<usize>, col_indices: Vec<usize>, values: Vec<T>, ) -> SparseResult<Self>

Create a CSR matrix from triplet format (COO-like construction)

This is a convenience constructor that builds a CSR matrix from separate row indices, column indices, and values vectors.

Arguments

• nrows - Number of rows in the matrix
• ncols - Number of columns in the matrix
• row_indices - Vector of row indices for each non-zero value
• col_indices - Vector of column indices for each non-zero value
• values - Vector of non-zero values

Returns

• Ok(CsrMatrix) - A new CSR matrix
• Err(SparseError) - If input is invalid

Examples

use scirs2_sparse::csr::CsrMatrix;

let row_indices = vec![0, 0, 1, 2, 2];
let col_indices = vec![0, 2, 2, 0, 1];
let values = vec![1.0, 2.0, 3.0, 4.0, 5.0];

let matrix = CsrMatrix::from_triplets(3, 3, row_indices, col_indices, values).unwrap();
assert_eq!(matrix.nnz(), 5);

pub fn try_from_triplets( nrows: usize, ncols: usize, triplets: &[(usize, usize, T)], ) -> SparseResult<Self>

Create a CSR matrix from triplet tuples

This constructor accepts a slice of (row, col, value) tuples, which is convenient for constructing matrices from coordinate lists.

Arguments

• nrows - Number of rows in the matrix
• ncols - Number of columns in the matrix
• triplets - Slice of (row_index, col_index, value) tuples

Returns

• Ok(CsrMatrix) - A new CSR matrix
• Err(SparseError) - If input is invalid

Examples

use scirs2_sparse::csr::CsrMatrix;

let triplets = vec![
    (0, 0, 1.0),
    (0, 2, 2.0),
    (1, 2, 3.0),
    (2, 0, 4.0),
    (2, 1, 5.0),
];

let matrix = CsrMatrix::try_from_triplets(3, 3, &triplets).unwrap();
assert_eq!(matrix.nnz(), 5);
assert_eq!(matrix.get(0, 0), 1.0);
assert_eq!(matrix.get(2, 1), 5.0);

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 + SparseElement,

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> + SparseElement> 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 + SparseElement + AddAssign + Mul<Output = T> + 'static,

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

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 + SparseElement + 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.