Struct FragmentLengthDistribution 

pub struct FragmentLengthDistribution { /* private fields */ }

Tracks the observed distribution of fragment lengths.

Implementations

impl FragmentLengthDistribution

pub fn new( alpha: f64, max_val: usize, prior_mu: f64, prior_sigma: f64, kernel_n: usize, kernel_p: f64, bin_size: usize, ) -> Self

Construct a distribution.

• alpha – total pseudo-count mass (linear space).
• max_val – maximum representable length.
• prior_mu – Gaussian prior mean; if <= 0, a uniform prior is used.
• prior_sigma – Gaussian prior standard deviation.
• kernel_n – binomial kernel trials; must be even (after binning).
• kernel_p – binomial kernel success probability.
• bin_size – internal length binning (use 1 for no binning).

pub fn default_for_paired() -> Self

salmon’s default fragment-length distribution: pseudo-count 1.0, max length 1000, no Gaussian prior (uniform), kernel n=4, p=0.5.

pub fn max_val(&self) -> usize

pub fn min_val(&self) -> usize

pub fn add_val(&self, len: usize, mass: f64)

Add mass (log space) for an observed fragment of length len, spreading it over the smoothing kernel. Lock-free; safe to call from multiple threads. (Must not race with cache.)

pub fn pmf(&self, len: usize) -> f64

Logged probability of observing a fragment of length len.

pub fn cmf(&self, len: usize) -> f64

Logged cumulative mass up to and including len.

pub fn tot_mass(&self) -> f64

Total observed mass (log space).

pub fn mean(&self) -> f64

Mean observed length.

pub fn sd(&self) -> f64

Standard deviation of the observed length distribution, computed from the cached normalized PMF (call after cache).

pub fn cache(&mut self)

Freeze the distribution and precompute normalized PMF/CMF for fast, allocation-free lookup. Call once after updates have stopped.

pub fn log_pmf(&self) -> &[f64]

The cached, normalized log-PMF over [0, max_val]. Requires cache.

pub fn conditional_means(&self) -> Vec<f64>

Cumulative conditional means E[L | L ≤ i] over [0, max_val], i.e. salmon’s correctionFactorsFromMass (DistributionUtils.cpp): cm[i] = (Σ_{l≤i} l·pmf[l]) / (Σ_{l≤i} pmf[l]).

These are the per-length correction factors computeSmoothedEffectiveLengths subtracts from the reference length to get the base effective length. The ratio is invariant to the PMF normalization, so the cached (normalized) PMF gives the same values as salmon’s 100·exp(logPMF) mass. Requires cache.

Trait Implementations

impl Debug for FragmentLengthDistribution

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

Formats the value using the given formatter.