Struct Csr 

pub struct Csr<T> {
    pub indptr: Vec<usize>,
    pub indices: Vec<usize>,
    pub data: Vec<T>,
    pub nrows: usize,
    pub ncols: usize,
}

Lightweight CSR for label propagation sparse algebra.

Fields

indptr: Vec<usize>

Row index pointers

indices: Vec<usize>

Column indices

data: Vec<T>

Data for the sparse matrix

nrows: usize

Number of rows

ncols: usize

Number of columns

Implementations

impl<T: EvocFloat> Csr<T>

pub fn new( indptr: Vec<usize>, indices: Vec<usize>, data: Vec<T>, nrows: usize, ncols: usize, ) -> Self

Construct a CSR matrix from its raw components.

No reordering or deduplication is performed; the caller is responsible for providing a valid CSR representation.

Params

• indptr - Row pointer array of length nrows + 1
• indices - Column indices of each stored entry
• data - Values corresponding to each entry in indices
• nrows - Number of rows
• ncols - Number of columns

pub fn from_coo(coo: &CoordinateList<T>) -> Self

Build a square CSR matrix from a COO coordinate list, summing duplicate entries.

Triplets are sorted by (row, column) in parallel before assembly. Consecutive entries sharing the same (row, column) pair are folded into a single stored value.

Params

• coo - Coordinate list with n_samples x n_samples logical shape

Returns

A square n_samples x n_samples CSR matrix

pub fn from_partition(partition: &[usize], n_parts: usize) -> Self

Build a partition indicator matrix of shape n_points x n_parts.

Row i contains a single 1.0 at column partition[i], encoding a hard cluster assignment as a sparse one-hot matrix.

Params

• partition - Slice of length n_points where partition[i] is the part index assigned to point i
• n_parts - Total number of parts (column count)

pub fn nnz(&self) -> usize

Number of stored non-zero entries.

pub fn transpose(&self) -> Self

Transpose into a new CSR matrix.

Constructs the transpose via a two-pass counting sort: the first pass builds column counts to allocate indptr; the second scatters each entry to its transposed position using per-column cursors.

Returns

A new ncols x nrows CSR matrix equal to self^T

pub fn matmul(&self, other: &Csr<T>) -> Self

Sparse-sparse matrix multiplication: self (m x k) * other (k x n) -> (m x n).

Params

• other - Right-hand operand; its row count must equal self.ncols

Returns

A new m x n CSR matrix

pub fn elementwise_mul(&self, other: &Csr<T>) -> Self

Element-wise (Hadamard) product of two matrices with identical shape.

Params

• other - Right-hand operand; must have the same shape as self and sorted column indices per row

Returns

A new CSR matrix containing only the entries where both operands are non-zero

pub fn normalise_cols_l2(&self) -> Self

Column-wise L2 normalisation.

Each column is scaled by the reciprocal of its L2 norm. Columns with zero norm are left unchanged (scale factor of 1).

Returns

A new CSR matrix with the same sparsity pattern and unit-norm columns

pub fn normalise_rows_l1(&self) -> Self

Row-wise L1 normalisation.

Each row is scaled by the reciprocal of the sum of absolute values of its entries. Rows with zero norm are left unchanged.

Returns

A new CSR matrix with the same sparsity pattern and unit-L1-norm rows

pub fn clip_values(&mut self, lo: T, hi: T)

Clamp all stored values to the closed interval [lo, hi].

Params

• lo - Lower bound
• hi - Upper bound

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

Convert to an adjacency list representation.

Each entry graph[i] is a Vec of (column, value) pairs for row i, suitable for consumption by evoc_embedding.

Returns

A Vec of length nrows, where graph[i] contains the neighbours and edge weights of node i

pub fn matmul_dense(&self, rhs: &MatRef<'_, T>) -> Mat<T>

Sparse-dense matrix multiplication: self (m x k) * rhs (k x d) -> (m x d).

Params

• rhs - Dense right-hand operand; its row count must equal self.ncols

Returns

A dense m x d matrix

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

Convert to a dense faer::Mat, filling structural zeros explicitly.

Returns

A dense nrows x ncols matrix

Trait Implementations

impl<T: Clone> Clone for Csr<T>

fn clone(&self) -> Csr<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Csr<T>

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

Formats the value using the given formatter.