mixle.stats.univariate.discrete.point_mass module

Fixed point-mass distribution and estimator support.

This module implements a sequence-encodable Dirac distribution, including sampling, encoding, enumeration, backend scoring, and the estimator hooks needed for mixture and combinator use.

class PointMassDistribution(value, name=None, keys=None)

Bases: SequenceEncodableProbabilityDistribution

Fixed Dirac/point-mass distribution assigning all mass to one value.

Parameters:

• value (Any)

• name (str | None)

• keys (str | None)

classmethod compute_capabilities()

Declare generic NumPy/Torch scoring support for fixed atoms.

classmethod compute_declaration()

Return the declaration for a fixed non-estimated atom.

density(x)

Return the probability density or mass at a single observation.

Parameters:

x (Any)

Return type:

float

log_density(x)

Return the log-density or log-mass at a single observation.

Parameters:

x (Any)

Return type:

float

seq_log_density(x)

Return vectorized log-density values for sequence-encoded observations.

Parameters:

x (ndarray)

Return type:

ndarray

backend_seq_log_density(x, engine)

Engine-neutral vectorized log-density from encoded equality flags.

Parameters:

• x (ndarray)

• engine (Any)

Return type:

Any

classmethod backend_stacked_params(dists, engine)

Return stacked point-mass parameters for identical fixed atoms.

Parameters:

• dists (Sequence[PointMassDistribution])

• engine (Any)

Return type:

dict[str, Any]

classmethod backend_stacked_log_density(x, params, engine)

Return an (n, k) matrix of point-mass log densities.

Parameters:

• x (ndarray)

• params (dict[str, Any])

• engine (Any)

Return type:

Any

classmethod backend_stacked_sufficient_statistics(x, weights, params, engine)

Return per-component empty statistics for fixed point masses.

Parameters:

• x (ndarray)

• weights (Any)

• params (dict[str, Any])

• engine (Any)

Return type:

tuple[None, …]

support_size()

A single atom.

Return type:

int

sampler(seed=None)

Return a sampler for drawing observations from this distribution.

Parameters:

seed (int | None)

Return type:

PointMassSampler

estimator(pseudo_count=None)

Return an estimator for fitting this distribution from data.

Parameters:

pseudo_count (float | None)

Return type:

PointMassEstimator

dist_to_encoder()

Return the data encoder used by this distribution for vectorized methods.

Return type:

PointMassDataEncoder

enumerator()

Return an enumerator over the distribution support when available.

Return type:

PointMassEnumerator

quantized_index(max_bits, bin_width_bits=1.0)

Return a bounded quantized support index for this observation.

Parameters:

• max_bits (float)

• bin_width_bits (float)

Return type:

QuantizedEnumerationIndex

class PointMassEnumerator(dist)

Bases: DistributionEnumerator

Enumerate the single atom of a PointMassDistribution.

Parameters:

dist (PointMassDistribution)

class PointMassSampler(dist, seed=None)

Bases: DistributionSampler

Sampler returning the fixed atom.

Parameters:

• dist (PointMassDistribution)

• seed (int | None)

sample(size=None)

Return the fixed atom once or repeated size times.

Parameters:

size (int | None)

Return type:

Any | Sequence[Any]

class PointMassAccumulator(value, keys=None)

Bases: SequenceEncodableStatisticAccumulator

Accumulator for a fixed point mass; no parameters are learned.

Parameters:

• value (Any)

• keys (str | None)

update(x, weight, estimate)

Ignore one observation because the atom is fixed.

Parameters:

• x (Any)

• weight (float)

• estimate (PointMassDistribution | None)

Return type:

None

seq_update(x, weights, estimate)

Ignore encoded observations because the atom is fixed.

Parameters:

• x (ndarray)

• weights (ndarray)

• estimate (PointMassDistribution | None)

Return type:

None

seq_update_engine(x, weights, estimate, engine)

Ignore engine-resident observations because the atom is fixed.

Parameters:

• x (ndarray)

• weights (Any)

• estimate (PointMassDistribution | None)

• engine (Any)

Return type:

None

initialize(x, weight, rng)

Ignore initialization observations because the atom is fixed.

Parameters:

• x (Any)

• weight (float)

• rng (RandomState | None)

Return type:

None

seq_initialize(x, weights, rng)

Ignore encoded initialization observations because the atom is fixed.

Parameters:

• x (ndarray)

• weights (ndarray)

• rng (RandomState | None)

Return type:

None

combine(suff_stat)

Return this accumulator because fixed atoms have no sufficient statistics.

Parameters:

suff_stat (Any)

Return type:

PointMassAccumulator

value()

Return None because fixed atoms have no sufficient statistics.

Return type:

None

from_value(x)

Return this accumulator because there is no state to restore.

Parameters:

x (Any)

Return type:

PointMassAccumulator

key_merge(stats_dict)

Register the key with empty statistics when configured.

Parameters:

stats_dict (dict[str, Any])

Return type:

None

key_replace(stats_dict)

Ignore keyed replacements because there is no accumulator state.

Parameters:

stats_dict (dict[str, Any])

Return type:

None

acc_to_encoder()

Return the equality-mask encoder for this atom.

Return type:

PointMassDataEncoder

class PointMassAccumulatorFactory(value, keys=None)

Bases: StatisticAccumulatorFactory

Factory for PointMassAccumulator.

Parameters:

• value (Any)

• keys (str | None)

make()

Create an empty point-mass accumulator.

Return type:

PointMassAccumulator

class PointMassEstimator(value, pseudo_count=None, suff_stat=None, name=None, keys=None)

Bases: ParameterEstimator

Estimator that always returns the configured point mass.

Parameters:

• value (Any)

• pseudo_count (float | None)

• suff_stat (Any | None)

• name (str | None)

• keys (str | None)

accumulator_factory()

Return a factory for point-mass no-op accumulators.

Return type:

PointMassAccumulatorFactory

estimate(nobs, suff_stat=None)

Return the configured point mass unchanged.

Parameters:

• nobs (float | None)

• suff_stat (Any | None)

Return type:

PointMassDistribution

class PointMassDataEncoder(value)

Bases: DataSequenceEncoder

Encode observations as a boolean equality mask against the fixed atom.

Parameters:

value (Any)

seq_encode(x)

Encode observations as booleans indicating equality with the fixed atom.

Parameters:

x (Sequence[Any])

Return type:

ndarray