Struct InMemorySparseReader 

pub struct InMemorySparseReader<'a> { /* private fields */ }

Gene-major in-memory store behind the SingleCellReading interface.

Reads are slices of the underlying buffers copied into the chunk types the trait hands back, so a full gene sweep costs one copy of the matrix rather than a decompression per chunk.

Implementations

impl<'a> InMemorySparseReader<'a>

pub fn new( matrix: &'a CompressedSparseData2<u32, f32>, target_size: Option<f32>, ) -> Result<Self, ScDataErrors>

Wrap a sparse matrix as a gene-major store.

Params

• matrix - The counts, CSC with shape (cells, genes). Raw counts in data, normalised counts in data_2.
• target_size - Library size data_2 was normalised against, if the caller knows it.

Returns

The reader, or SparseErrors::SparseMatrixMustBeCsc for a CSR input and SparseErrors::Data2NotAvailable when the normalised layer is missing.

pub fn new_cell_major( matrix: &'a CompressedSparseData2<u32, f32>, target_size: Option<f32>, ) -> Result<Self, ScDataErrors>

Wrap the same matrix as a cell-major store.

Builds and owns a CSR twin, so peak memory is roughly twice the matrix for as long as the reader lives. Use it only where cell chunks are genuinely needed, such as the per-cell totals the analytic Pearson fit sums over each group’s retained genes.

Note this is not CompressedSparseData2::transpose_and_convert, which relabels a CSC as a CSR and swaps the shape, describing the transpose. What is wanted here is the same matrix in the other layout, which is a real scatter.

Params

• matrix - The counts, CSC with shape (cells, genes). Raw counts in data, normalised counts in data_2.
• target_size - Library size data_2 was normalised against, if the caller knows it.

Returns

The reader, or SparseErrors::SparseMatrixMustBeCsc for a CSR input and SparseErrors::Data2NotAvailable when the normalised layer is missing.

Trait Implementations

impl SingleCellReading for InMemorySparseReader<'_>

fn read_cells_parallel( &self, indices: &[usize], ) -> Result<Vec<CsrCellChunk>, ScDataErrors>

Read cells by index in a multi-threaded manner

Only available on a reader built with InMemorySparseReader::new_cell_major; the default gene-major reader has no CSR twin to read from.

Params

• indices - Index positions of the cells to retrieve

Returns

The CsrCellChunks in the order given by indices, or ScDataErrors::ReaderModeMismatch in gene-major mode.

fn read_cells_sparse<T>( &self, indices: &[usize], data_layer: &DataLayerReturn, ) -> Result<CompressedSparseData2<T, f32>, ScDataErrors>

where T: BixverseNumeric + FromPrimitive,

Read a batch of cells straight into CSR

Slices the CSR twin directly, so no chunk is built and the normalised layer stays f32 rather than passing through the chunks’ F16.

Params

• indices - Cell indices, in output row order
• data_layer - Which layer(s) to materialise

Returns

The batch as CSR, or ScDataErrors::ReaderModeMismatch in gene-major mode.

fn read_genes_sparse<T>( &self, indices: &[usize], cells_to_keep: Option<&IndexSet<u32>>, data_layer: &DataLayerReturn, ) -> Result<CompressedSparseData2<T, f32>, ScDataErrors>

where T: BixverseNumeric + FromPrimitive,

Read a batch of genes straight into CSC, optionally filtering cells

Slices the matrix directly, so no chunk is built and the normalised layer stays f32 rather than passing through the chunks’ F16.

Params

• indices - Gene indices, in output column order
• cells_to_keep - Cells to keep, in output row order, or None
• data_layer - Which layer(s) to materialise

Returns

The batch as CSC, or ScDataErrors::ReaderModeMismatch in cell-major mode.

fn read_gene_parallel( &self, indices: &[usize], ) -> Result<Vec<CscGeneChunk>, ScDataErrors>

Read genes by index in a multi-threaded manner

Params

• indices - Index positions of the genes to retrieve

Returns

The CscGeneChunks in the order given by indices, or ScDataErrors::ReaderModeMismatch in cell-major mode.

fn get_header(&self) -> SparseDataHeader

Return the header of the underlying store

Returns

The SparseDataHeader.

fn is_cell_based(&self) -> bool

Is the store laid out for fast cell retrieval?

Returns

true when built with InMemorySparseReader::new_cell_major.

fn target_size(&self) -> Option<f32>

Library size the normalised layer was scaled to.

Returns

Whatever the caller passed to InMemorySparseReader::new.

fn read_cell_library_sizes( &self, indices: &[usize], ) -> Result<Vec<usize>, ScDataErrors>

Total raw counts per cell

Served from the sums taken in InMemorySparseReader::new, which is why a gene-major store can answer a cell-side question at all.

Params

• indices - Cell indices

Returns

The library sizes in the order given by indices, or ScDataErrors::ChunkIndexNotFound for an index past the cell axis.

fn read_gene_parallel_raw( &self, indices: &[usize], ) -> Result<Vec<CscGeneChunk>, ScDataErrors>

Read genes for consumers of the raw counts and indices only.

fn is_gene_based(&self) -> bool

Is the store laid out for fast gene retrieval?

fn read_cell(&self, index: usize) -> Result<CsrCellChunk, ScDataErrors>

Read a single cell by index

fn read_gene(&self, index: usize) -> Result<CscGeneChunk, ScDataErrors>

Read a single gene by index

fn read_cells_range( &self, start: usize, end: usize, ) -> Result<Vec<CsrCellChunk>, ScDataErrors>

Read a contiguous range of cells

fn get_all_cells(&self) -> Result<Vec<CsrCellChunk>, ScDataErrors>

Return all cells in the store

fn get_all_genes(&self) -> Result<Vec<CscGeneChunk>, ScDataErrors>

Return all genes in the store

fn read_gene_parallel_filtered( &self, indices: &[usize], cells_to_keep: &IndexSet<u32>, ) -> Result<Vec<CscGeneChunk>, ScDataErrors>

Read genes by index and filter them to a set of cells

fn read_gene_nnz(&self, indices: &[usize]) -> Result<Vec<usize>, ScDataErrors>

Read the NNZ for the given genes

fn get_all_gene_nnz(&self) -> Result<Vec<usize>, ScDataErrors>

Return NNZ for all genes

fn get_clr_offsets( &self, indices: &[usize], batch_size: Option<usize>, ) -> Result<Vec<f64>, ScDataErrors>

Compute the shifted CLR per-cell offsets freshly from raw counts.