Struct CompressedSparseData2 

pub struct CompressedSparseData2<T, U = T>
where
    T: Clone,
    U: Clone,
{
    pub data: Vec<T>,
    pub indices: Vec<u32>,
    pub indptr: Vec<u32>,
    pub cs_type: CompressedSparseFormat,
    pub data_2: Option<Vec<U>>,
    pub shape: (usize, usize),
}

Structure to store compressed sparse data with two potential data layers. Think for example in single cell raw counts and normalised counts.

Fields

data: Vec<T>

The first data slot for this compressed sparse data format

indices: Vec<u32>

The indices of the data points

indptr: Vec<u32>

The indptr of the data points

cs_type: CompressedSparseFormat

Enum defining if the data is stored in CSC or CSR, see CompressedSparseFormat

data_2: Option<Vec<U>>

Optional second data slot for a different layer of the data (for example raw and normalised counts)

shape: (usize, usize)

Shape of the data (rows, cols)

Implementations

impl<T, U> CompressedSparseData2<T, U>

where T: BixverseNumeric, U: BixverseNumeric,

pub fn new_csc( data: &[T], indices: &[u32], indptr: &[u32], data2: Option<&[U]>, shape: (usize, usize), ) -> CompressedSparseData2<T, U>

Generate a nes CSC version of the matrix

Params

• data - The underlying data
• indices - The index positions (in this case row indices)
• indptr - The index pointer (in this case the column index pointers)
• data2 - An optional second layer
• shape - (nrow, ncol).

Returns

Self as a CSC-type matrix

pub fn new_csr( data: &[T], indices: &[u32], indptr: &[u32], data2: Option<&[U]>, shape: (usize, usize), ) -> CompressedSparseData2<T, U>

Generate a nes CSR version of the matrix

Params

• data - The underlying data
• indices - The index positions (in this case row indices)
• indptr - The index pointer (in this case the column index pointers)
• data2 - An optional second layer
• shape - (nrow, ncol).

Returns

Self as a CSR-type matrix

pub fn from_parts( data: Vec<T>, indices: Vec<u32>, indptr: Vec<u32>, data2: Option<Vec<U>>, cs_type: CompressedSparseFormat, shape: (usize, usize), ) -> CompressedSparseData2<T, U>

Take ownership of buffers that were built for this matrix

CompressedSparseData2::new_csr and its CSC sibling copy all three buffers, which doubles peak memory for any caller that assembled them itself and then throws the originals away.

Params

• data - The underlying data, moved.
• indices - The minor-axis indices, moved.
• indptr - The major-axis pointers, moved.
• data2 - An optional second layer, moved.
• cs_type - Which orientation the buffers describe.
• shape - (nrow, ncol).

Returns

The matrix, with no buffer copied.

pub fn transform(&self) -> CompressedSparseData2<T, U>

Transform from CSC to CSR or vice versa

Returns

The transformed/transposed version

pub fn transform_single_layer( &self, use_second_layer: bool, ) -> Result<CompressedSparseData2<T, U>, CoreErrors>

Transform from CSC to CSR or vice versa, keeping only one data layer.

Params

• use_second_layer - If true, the output keeps data_2 and data is empty. If false, the output keeps data and data_2 is None.

Returns

The transformed/transposed version with only the requested layer.

pub fn transpose_and_convert(&self) -> CompressedSparseData2<T, U>

Transpose and convert

Returns

The transformed/transposed version

pub fn from_dense_matrix( mat: Mat<Ref<'_, T>>, format: CompressedSparseFormat, ) -> CompressedSparseData2<T, U>

where T: BixverseFloat,

Generates a sparse matrix from a dense matrix

Params

• mat: The dense matrix to convert to a sparse matrix
• format: The format of the sparse matrix to generate

Returns

• Self: The sparse matrix generated from the dense matrix

pub fn from_upper_triangle_sym( upper_triangle: &[T], n: usize, include_diagonal: bool, format: CompressedSparseFormat, ) -> CompressedSparseData2<T, U>

where T: BixverseFloat,

Create a sparse matrix from an upper triangular matrix.

Params

• upper_triangle - The upper triangular matrix.
• n - The number of rows and columns in the matrix.
• include_diagonal - Whether to include the diagonal elements.
• format - The format of the sparse matrix, see CompressedSparseFormat.

Returns

A sparse matrix.

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

Returns the shape of the matrix

Returns

A tuple of (n_row, n_col)

pub fn nrows(&self) -> usize

Return the number of rows

Returns

Number of rows

pub fn ncols(&self) -> usize

Return the number of columns

Returns

Number of columns

pub fn get_nnz(&self) -> usize

Returns the NNZ

Returns

The number of NNZ

pub fn get_data2_unsafe(&self) -> Vec<U>

Return the second layer

If this does not exist, the function will panic

Returns

Vector of the second layer

pub fn to_sparse_axes(&self) -> Vec<SparseAxis<T, U>>

Split into one owned SparseAxis per major-axis run.

Columns of a CSC or rows of a CSR. A layer that is empty (not populated) stays empty on every axis.

Returns

The axes in order, each sized to the minor dimension.

pub fn slice_rows( &self, rows: &[usize], ) -> Result<CompressedSparseData2<T, U>, CoreErrors>

Slice the rows of the matrix

Params

• rows - The row indices to keep

Returns

Self with the rows to keep

pub fn slice_cols( &self, cols: &[usize], ) -> Result<CompressedSparseData2<T, U>, CoreErrors>

Slice the columns of the matrix

Params

• cols - The column indices to keep

Returns

Self with the cols to keep

pub fn slice( &self, rows: &[usize], cols: &[usize], ) -> Result<CompressedSparseData2<T, U>, CoreErrors>

Slice across rows and columns

Params

• rows - The row indices to keep
• cols - The column indices to keep

Returns

Self with the rows and columns to keep

pub fn validate(&self) -> Result<(), CoreErrors>

Check every invariant that indexing this matrix relies on.

Self::assert_invariants is a debug_assert helper and compiles out in release, and it never checks the indices against the minor axis. This is the release-mode counterpart, for input that crossed an FFI boundary: the fields are public, so a caller can hand over an indptr that disagrees with shape or an index past the minor axis, and any consumer that scatters into a dense buffer sized from shape would then panic inside a worker thread or, worse, silently process fewer major runs than the shape declares.

A layer that is empty is treated as absent rather than as a length mismatch, since Self::transform_single_layer deliberately leaves the unused layer empty.

Returns

Ok(()), or the first invariant that failed: CoreErrors::SparseIndptrInvalid for an indptr that disagrees with shape or with the number of stored values, CoreErrors::DimensionMisMatchSparse for a populated layer whose length does not match indices, and CoreErrors::SliceIndexOutOfBounds for an index past the minor axis.

pub fn assert_invariants(&self)

Assertion helper for invariants

Trait Implementations

impl<T, U> Clone for CompressedSparseData2<T, U>

where T: Clone, U: Clone,

fn clone(&self) -> CompressedSparseData2<T, U>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, U> Debug for CompressedSparseData2<T, U>

where T: Debug + Clone, U: Debug + Clone,

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

Formats the value using the given formatter.