mixle.stats.univariate.continuous.nakagami module

Nakagami distribution – the amplitude/envelope law of Nakagami-m fading.

A positive-support family for signal envelopes (wireless/radar/sonar fading, also reliability and hydrology). With shape m >= 1/2 and spread omega = E[X^2] > 0,

f(x; m, omega) = 2 m^m / (Gamma(m) omega^m) * x^(2m-1) * exp(-m x^2 / omega), x > 0,

so X^2 ~ Gamma(m, omega/m); m = 1/2 is the half-normal and m = 1 the Rayleigh. The CDF is the regularized lower incomplete gamma, it samples exactly via a Gamma draw, and it has a clean closed-form method-of-moments fit: omega = E[X^2] and m = E[X^2]^2 / Var[X^2].

Reference: Nakagami, “The m-distribution – a general formula of intensity distribution of rapid fading”, in Statistical Methods in Radio Wave Propagation (1960).

class NakagamiDistribution(m, omega, name=None, keys=None)

Bases: SequenceEncodableProbabilityDistribution

Nakagami distribution with shape m >= 1/2 and spread omega = E[X^2] > 0.

Parameters:

• m (float)

• omega (float)

• name (str | None)

• keys (str | None)

density(x)

Return the probability density at x.

Parameters:

x (float)

Return type:

float

log_density(x)

Return the log-density at x (-inf for x <= 0).

Parameters:

x (float)

Return type:

float

seq_log_density(x)

Return vectorized log-density for a sequence-encoded array of observations.

Parameters:

x (ndarray)

Return type:

ndarray

classmethod compute_capabilities()

Describe backend support for generated Nakagami kernels.

classmethod compute_declaration()

Return the structured compute declaration for Nakagami distributions.

static backend_legacy_sufficient_statistics(x, params, engine)

Per-row Nakagami power sums in accumulator order (count, sum x^2, sum x^4).

Parameters:

• x (Any)

• params (dict[str, Any])

• engine (Any)

Return type:

tuple[Any, …]

static backend_log_density_from_params(x, m, omega, engine)

Engine-neutral Nakagami log-density from explicit parameters (-inf for x <= 0).

Parameters:

• x (Any)

• m (Any)

• omega (Any)

• engine (Any)

Return type:

Any

backend_seq_log_density(x, engine)

Engine-neutral vectorized log-density for encoded data.

Parameters:

• x (Any)

• engine (Any)

Return type:

Any

classmethod backend_stacked_params(dists, engine)

Stacked Nakagami parameters for a homogeneous mixture kernel.

Parameters:

• dists (Sequence[NakagamiDistribution])

• engine (Any)

Return type:

dict[str, Any]

classmethod backend_stacked_log_density(x, params, engine)

Return an (n, k) matrix of Nakagami log densities.

Parameters:

• x (ndarray)

• params (dict[str, Any])

• engine (Any)

Return type:

Any

classmethod backend_stacked_sufficient_statistics(x, weights, params, engine)

Stacked Nakagami power sums (count, sum x^2, sum x^4) using engine-resident arrays.

Parameters:

• x (ndarray)

• weights (Any)

• params (dict[str, Any])

• engine (Any)

Return type:

tuple[Any, Any, Any]

cdf(x)

Cumulative distribution function P(X <= x) = P(m, m x^2 / omega) (0 for x <= 0).

Parameters:

x (float)

Return type:

float

quantile(q)

Inverse CDF F^{-1}(q).

Parameters:

q (float)

Return type:

float

mean()

Mean (Gamma(m+1/2)/Gamma(m)) sqrt(omega/m).

Return type:

float

variance()

Variance omega - mean^2 (since E[X^2] = omega).

Return type:

float

sampler(seed=None)

Return a sampler (X = sqrt(Gamma(m, omega/m))).

Parameters:

seed (int | None)

Return type:

NakagamiSampler

estimator(pseudo_count=None)

Return a closed-form method-of-moments estimator.

Parameters:

pseudo_count (float | None)

Return type:

NakagamiEstimator

dist_to_encoder()

Return the data encoder used by this distribution (the raw value).

Return type:

NakagamiDataEncoder

class NakagamiSampler(dist, seed=None)

Bases: DistributionSampler

Draw X = sqrt(G) with G ~ Gamma(shape=m, scale=omega/m) (so X^2 ~ Gamma(m, omega/m)).

Parameters:

• dist (NakagamiDistribution)

• seed (int | None)

sample(size=None)

Draw one sample or an array of iid samples.

Parameters:

size (int | None)

Return type:

float | ndarray

class NakagamiAccumulator(name=None, keys=None)

Bases: SequenceEncodableStatisticAccumulator

Accumulate the weighted power sums (count, sum x^2, sum x^4) for the moment fit.

Parameters:

• name (str | None)

• keys (str | None)

update(x, weight, estimate)

Accumulate weighted second and fourth power sums for one observation.

Parameters:

• x (float)

• weight (float)

• estimate (NakagamiDistribution | None)

Return type:

None

initialize(x, weight, rng)

Initialize statistics from one observation.

Parameters:

• x (float)

• weight (float)

• rng (RandomState | None)

Return type:

None

seq_update(x, weights, estimate)

Accumulate weighted second and fourth power sums from encoded data.

Parameters:

• x (ndarray)

• weights (ndarray)

• estimate (Any)

Return type:

None

seq_initialize(x, weights, rng)

Initialize statistics from encoded observations.

Parameters:

• x (ndarray)

• weights (ndarray)

• rng (RandomState | None)

Return type:

None

combine(suff_stat)

Merge another Nakagami sufficient-statistic tuple.

Parameters:

suff_stat (tuple[float, float, float])

Return type:

NakagamiAccumulator

value()

Return count, second power sum, and fourth power sum.

Return type:

tuple[float, float, float]

from_value(x)

Replace accumulator contents from a sufficient-statistic tuple.

Parameters:

x (tuple[float, float, float])

Return type:

NakagamiAccumulator

key_merge(stats_dict)

Merge keyed statistics into stats_dict when keys are configured.

Parameters:

stats_dict (dict[str, Any])

Return type:

None

key_replace(stats_dict)

Replace this accumulator from keyed statistics when available.

Parameters:

stats_dict (dict[str, Any])

Return type:

None

acc_to_encoder()

Return the encoder used by this accumulator.

Return type:

NakagamiDataEncoder

class NakagamiAccumulatorFactory(name=None, keys=None)

Bases: StatisticAccumulatorFactory

Factory for NakagamiAccumulator.

Parameters:

• name (str | None)

• keys (str | None)

make()

Create a fresh Nakagami accumulator.

Return type:

NakagamiAccumulator

class NakagamiEstimator(m_min=0.5, name=None, keys=None)

Bases: ParameterEstimator

Method-of-moments estimator: omega = E[X^2], m = E[X^2]^2 / Var[X^2] (clamped m >= 1/2).

Parameters:

• m_min (float)

• name (str | None)

• keys (str | None)

accumulator_factory()

Return an accumulator factory for Nakagami power-sum statistics.

Return type:

NakagamiAccumulatorFactory

estimate(nobs, suff_stat)

Estimate shape and spread from weighted second and fourth moments.

Parameters:

• nobs (float | None)

• suff_stat (tuple[float, float, float])

Return type:

NakagamiDistribution

class NakagamiDataEncoder

Bases: DataSequenceEncoder

Encode observations as a float array.

seq_encode(x)

Encode observations as a floating-point array.

Parameters:

x (Sequence[float])

Return type:

ndarray