Struct CscMatrix 

pub struct CscMatrix<T> { /* private fields */ }

Compressed Sparse Column (CSC) matrix

A sparse matrix format that compresses columns, making it efficient for column operations and matrix operations.

Implementations

impl<T> CscMatrix<T>

where T: Clone + Copy + Zero + PartialEq,

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

Create a new CSC 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 CSC matrix

Examples

use scirs2_sparse::csc::CscMatrix;

// 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 = CscMatrix::new(data.clone(), rows, cols, shape).unwrap();

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

Create a new CSC matrix from raw CSC format

Arguments

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

Returns

• A new CSC matrix

pub fn from_csc_data( values: Vec<T>, rowindices: Vec<usize>, col_ptrs: Vec<usize>, shape: (usize, usize), ) -> SparseResult<Self>

Create a new empty CSC matrix

Arguments

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

Returns

• A new empty CSC matrix Create a CSC matrix from CSC data (values, row indices, column pointers)

Arguments

• values - Values
• rowindices - Row indices
• col_ptrs - Column pointers
• shape - Shape of the matrix (rows, cols)

Returns

• Result containing the CSC matrix

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

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 col_range(&self, col: usize) -> Range<usize>

Get column range for iterating over elements in a column

Arguments

• col - Column index

Returns

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

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

Get row indices array

pub fn data(&self) -> &[T]

Get data array

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

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

Convert to CSR format

impl CscMatrix<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 converts the CSC matrix to CSR format and uses GPU acceleration. CSR format is generally more GPU-friendly for SpMV operations.

Arguments

• vec - Vector to multiply with

Returns

• Result of matrix-vector multiplication

Examples

use scirs2_sparse::csc::CscMatrix;

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 = CscMatrix::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> CscMatrix<T>

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

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