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 + Serialize + DeserializeOwned, U: BixverseNumeric + Serialize + DeserializeOwned,

pub fn to_bytes(&self) -> Result<Vec<u8>, SparseErrors>

Serialise the matrix to bytes.

Returns

A blob that Self::from_bytes reads back.

pub fn from_bytes(bytes: &[u8]) -> Result<Self, SparseErrors>

Read a matrix written by Self::to_bytes.

The decoded structure is validated, since the bytes may come from disk.

Params

• bytes - The blob

Returns

The matrix, or a header, decode or validation error.

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), ) -> Self

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), ) -> Self

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), ) -> Self

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) -> Self

Transform from CSC to CSR or vice versa

Returns

The transformed/transposed version

pub fn transform_single_layer( &self, use_second_layer: bool, ) -> Result<Self, SparseErrors>

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) -> Self

Transpose and convert

Returns

The transformed/transposed version

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

where T: BixverseNumeric + Float,

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<Self, SparseErrors>

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<Self, SparseErrors>

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<Self, SparseErrors>

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 from_entry_fn<G>( nrows: usize, ncols: usize, format: CompressedSparseFormat, get: G, ) -> Self

where T: BixverseNumeric + Float, G: Fn(usize, usize) -> T,

Build a matrix by scanning every (row, col) entry of a virtual dense matrix and storing the non-zeros.

Params

• nrows - Number of rows
• ncols - Number of columns
• format - Format to generate; the scan runs along its major axis
• get - Value at (row, col)

Returns

The sparse matrix, with no second layer.

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

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: SparseErrors::SparseIndptrInvalid for an indptr that disagrees with shape or with the number of stored values, SparseErrors::DimensionMisMatchSparse for a populated layer whose length does not match indices, and SparseErrors::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 + Clone, U: Clone + Clone,

fn clone(&self) -> Self

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: Clone + Debug, U: Clone + Debug,

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

Formats the value using the given formatter.

impl<'de, T, U> Deserialize<'de> for CompressedSparseData2<T, U>

where T: Clone + Deserialize<'de>, U: Clone + Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

where T: Clone + Serialize, U: Clone + Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.