Struct GammaMatrix 

pub struct GammaMatrix { /* private fields */ }

Implementations

impl GammaMatrix

pub fn release_stats(&mut self)

Drop the sufficient-stat planes (a_stat / b_stat) after calibration, keeping only the posterior estimates. Use when the consumer reads posterior means / log-means but never posterior_sample (which is the only reader of a_stat/b_stat). Halves the resident footprint of a calibrated parameter.

pub fn sparsify_mean_to_support(&mut self, numerator: &DMatrix<f32>)

Zero every estimated_mean entry whose corresponding numerator is zero, collapsing the per-column Gamma prior baseline (a0/denom, present at every unobserved cell) to exact zero. This lets a downstream triplet-ization of the mean be sparse — only the observed support survives. It’s the lossy-but-correct choice for count-based consumers (the baseline is a regularization floor, not signal). numerator must match the mean’s shape; only meaningful after a mean calibration.

pub fn has_data_support(&self, row: usize, col: usize) -> bool

Whether the posterior at (row, col) carries any data beyond the prior: a_stat > a0. The read-only counterpart of Self::sparsify_mean_to_support, for consumers that serialize the mean without owning the numerator — an unsupported entry’s mean is the prior floor a0 / (b0 + denom), which is regularization, not signal. Writing those floors out turns a sparse posterior dense: a carried pseudobulk reference measured 100.0% dense (34M of 34M entries) before its writer checked this.

pub fn evidence_mean(&self, row: usize, col: usize) -> f32

The unregularized rate at (row, col): (a_stat − a0) / (b_stat − b0) — data sum over data denominator, no prior in either. Zero when the entry has no data support.

This is what a serialized posterior should usually store: paired with its denominator, it is a bijection of the sufficient statistics, so a consumer reconstructs a_stat/b_stat exactly. The posterior mean (a0 + sum)/(b0 + n) is the right estimate but the wrong carrier — its prior shrinkage (1.85× at sum = 1, n = 12) gets re-ingested as if it were data, and a second posterior forms around an already-shrunk value.

pub fn with_row_prior( dims: (usize, usize), a0: &DVector<f32>, b0: &DVector<f32>, ) -> Self

A matrix whose row d has prior Gamma(a0[d], b0[d]). The statistics start at the prior, as with TwoStatParam::new.

pub fn set_row_prior(&mut self, a0: &DVector<f32>, b0: &DVector<f32>)

Replace the per-row prior. Accumulated statistics are left as they are; the new prior applies at the next reset_stat / update_stat.

pub fn row_prior(&self) -> Option<(&DVector<f32>, &DVector<f32>)>

The per-row prior, if one is set.

pub fn vconcat(blocks: Vec<GammaMatrix>, stack_stats: bool) -> Self

Row-stack per-feature-block parameters (from a gene-blocked fit) into one [Σrowsᵢ × K] parameter. All blocks must share the column count and either share the scalar hyper-params or all carry a row prior, in which case the row priors are concatenated. Calibrated planes present in the first block are stacked; lazily-empty planes stay empty. stack_stats controls whether a_stat/b_stat are carried through — pass false when the output only needs posterior estimates, so the heavy sufficient-stat planes are never assembled at full width.

Trait Implementations

impl Clone for GammaMatrix

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GammaMatrix

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

Formats the value using the given formatter.

impl Inference for GammaMatrix

type Mat = Matrix<f32, Dyn, Dyn, VecStorage<f32, Dyn, Dyn>>

type Scalar = f32

fn posterior_mean(&self) -> &Self::Mat

fn posterior_sd(&self) -> &Self::Mat

fn posterior_log_mean(&self) -> &Self::Mat

fn posterior_log_sd(&self) -> &Self::Mat

fn posterior_sample(&self) -> Result<Self::Mat>

fn posterior_log_sample(&self, seed: u64) -> Result<Self::Mat>

Draw a fresh sample of log λ per element. Delta-method approximation: log λ ≈ Normal(posterior_log_mean, posterior_log_sd²). Caller must have called calibrate_with(CalibrateTarget::All) first so log_mean / log_sd are populated.

fn nrows(&self) -> usize

fn ncols(&self) -> usize

impl ParamIo for GammaMatrix

type Mat = Matrix<f32, Dyn, Dyn, VecStorage<f32, Dyn, Dyn>>

fn to_tsv(&self, header: &str) -> Result<()>

fn to_melted_parquet( &self, file_path: &str, row_names: (Option<&[Box<str>]>, Option<&str>), column_names: (Option<&[Box<str>]>, Option<&str>), ) -> Result<()>

fn to_parquet(&self, file_path: &str) -> Result<()>

Write to parquet with default names

impl TwoStatParam for GammaMatrix

type Mat = Matrix<f32, Dyn, Dyn, VecStorage<f32, Dyn, Dyn>>

type Scalar = f32

fn new(dims: (usize, usize), a: Self::Scalar, b: Self::Scalar) -> Self

fn add_stat(&mut self, add_a: &Self::Mat, add_b: &Self::Mat)

fn update_stat(&mut self, update_a: &Self::Mat, update_b: &Self::Mat)

fn reset_stat(&mut self)

fn update_stat_col( &mut self, update_a: &Self::Mat, update_b: &Self::Mat, k: usize, )

fn map_calibrate_mean(&mut self)

fn map_calibrate_sd(&mut self)

fn map_calibrate_log_mean(&mut self)

fn map_calibrate_log_sd(&mut self)

fn calibrate(&mut self)

Calibrate all posterior quantities (mean, sd, log_mean, log_sd)

fn calibrate_with(&mut self, target: CalibrateTarget)

Calibrate only the posterior quantities specified by target.