mixle.stats.univariate.continuous.skew_normal module

Skew-normal distribution – a Gaussian with an asymmetry (shape) parameter.

The skew-normal extends the normal with a shape alpha that tilts the density without bounding it:

f(x) = (2 / omega) phi((x - xi) / omega) Phi(alpha (x - xi) / omega),

with location xi, scale omega > 0 and shape alpha (alpha = 0 recovers the normal, the sign of alpha sets the direction of skew). It samples exactly from two standard normals, and is fit by method of moments: the sample skewness fixes alpha through the monotone skewness-vs-shape relation, then the variance fixes omega and the mean fixes xi.

Reference: Azzalini, ‘A class of distributions which includes the normal ones’, Scand. J. Statist. (1985).

class SkewNormalDistribution(loc, scale, shape, name=None, keys=None)

Bases: SequenceEncodableProbabilityDistribution

Skew-normal distribution with location loc, scale > 0 and shape alpha.

Parameters:

• loc (float)

• scale (float)

• shape (float)

• name (str | None)

• keys (str | None)

density(x)

Return the probability density at a single observation.

Parameters:

x (float)

Return type:

float

log_density(x)

Return the log-density at a single observation.

Parameters:

x (float)

Return type:

float

seq_log_density(x)

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

Parameters:

x (ndarray)

Return type:

ndarray

classmethod compute_capabilities()

Describe backend support for generated skew-normal scoring kernels.

backend_seq_log_density(x, engine)

Engine-neutral vectorized skew-normal log-density for encoded data.

Parameters:

• x (Any)

• engine (Any)

Return type:

Any

cdf(x)

Cumulative distribution function P(X <= x) (exact).

Parameters:

x (float)

Return type:

float

quantile(q)

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

Parameters:

q (float)

Return type:

float

mean()

Mean E[X] = loc + scale * delta * sqrt(2/pi), delta = shape / sqrt(1 + shape^2).

Return type:

float

variance()

Variance Var[X] = scale^2 (1 - 2 delta^2 / pi), delta = shape / sqrt(1 + shape^2).

Return type:

float

entropy()

Differential entropy log(scale) + 0.5 log(2 pi e) - log(2) - E[log Phi(alpha Y)].

Y is the standard skew-normal(alpha); E[Y^2] = 1 for every alpha (a property of the two-Gaussian stochastic representation) collapses the Gaussian part of the log-density to a closed form, leaving E[log Phi(alpha Y)]. That term has no closed form for general alpha (Arellano-Valle, Contreras-Reyes & Genton, ‘Shannon entropy and mutual information for multivariate skew-elliptical distributions’, Scand. J. Statist. 40 (2013)), so it is evaluated by adaptive quadrature against the standard skew-normal density itself.

Return type:

float

sampler(seed=None)

Return a sampler for drawing observations from this distribution.

Parameters:

seed (int | None)

Return type:

SkewNormalSampler

estimator(pseudo_count=None)

Return a method-of-moments estimator for loc, scale and shape.

Parameters:

pseudo_count (float | None)

Return type:

SkewNormalEstimator

dist_to_encoder()

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

Return type:

SkewNormalDataEncoder

class SkewNormalSampler(dist, seed=None)

Bases: DistributionSampler

Draw observations as xi + omega (delta * abs(Z0) + sqrt(1-delta^2) Z1) with Z0, Z1 standard normal.

Parameters:

• dist (SkewNormalDistribution)

• seed (int | None)

sample(size=None, *, batched=True)

Draw one sample or an array of iid samples.

Parameters:

• size (int | None)

• batched (bool)

Return type:

float | ndarray

class SkewNormalAccumulator(name=None, keys=None)

Bases: SequenceEncodableStatisticAccumulator

Accumulate weighted central moments for skew-normal estimation.

The sufficient statistic is stored as (count, mean, M2, M3) where M2 = sum_i w_i (x_i - mean)^2 and M3 = sum_i w_i (x_i - mean)^3 are the weighted central moments. This is mathematically equivalent to the raw power sums (sum x, sum x^2, sum x^3) but avoids the catastrophic E[x^2] - E[x]^2 cancellation when abs(mean) is large relative to the spread: each batch is centered on its own mean before squaring/cubing, and batches merge through the Pébay/West parallel-moment formulas (exact for real weights). SkewNormal is a host-only leaf (no exponential-family / engine-resident path), so changing the accumulator representation has no engine-swap parity implications.

Parameters:

• name (str | None)

• keys (str | None)

update(x, weight, estimate)

Accumulate a single weighted observation into central moments.

Parameters:

• x (float)

• weight (float)

• estimate (SkewNormalDistribution | 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 central moments from encoded observations.

Centering the batch on its own mean removes the E[x^2]-E[x]^2 cancellation, but a SINGLE centering pass does not remove all of it: the computed mean carries the rounding of a large-magnitude sum, and that residue enters the third moment linearly, which left the fitted shape 1.1e-3 off at offset 1e12 and 5e-7 off at the Unix-epoch offset. The second pass in centered_batch_moments() computes the residue at spread scale, where it is exact, and makes the fit shift-equivariant.

Parameters:

• x (ndarray)

• weights (ndarray)

• estimate (SkewNormalDistribution | None)

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 central-moment statistic tuple.

Parameters:

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

Return type:

SkewNormalAccumulator

value()

Return count, mean, second central moment sum, and third central moment sum.

Return type:

tuple[float, float, float, float]

from_value(x)

Replace accumulator contents from a central-moment statistic tuple.

Parameters:

x (tuple[float, float, float, float])

Return type:

SkewNormalAccumulator

scale(c)

Scale weight-linear statistics while preserving the weighted mean.

Parameters:

c (float)

Return type:

SkewNormalAccumulator

acc_to_encoder()

Return the encoder used by this accumulator.

Return type:

SkewNormalDataEncoder

class SkewNormalAccumulatorFactory(name=None, keys=None)

Bases: StatisticAccumulatorFactory

Factory for SkewNormalAccumulator.

Parameters:

• name (str | None)

• keys (str | None)

make()

Create a fresh skew-normal accumulator.

Return type:

SkewNormalAccumulator

class SkewNormalEstimator(pseudo_count=None, suff_stat=None, min_scale=1.0e-12, name=None, keys=None)

Bases: ParameterEstimator

Method-of-moments estimator for skew-normal location, scale and shape.

The fit is SHIFT-EQUIVARIANT: estimating on x + c returns loc + c with scale and shape unchanged, for any constant c the data can carry – epoch seconds (~1.7e9), 2**31 and 1e12 included. The moments come from SkewNormalAccumulator, which centers each batch twice for exactly this reason; a single centering pass left the fitted shape 1.1e-3 off at 1e12, silently.

Parameters:

• pseudo_count (float | None)

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

• min_scale (float)

• name (str | None)

• keys (str | None)

accumulator_factory()

Return an accumulator factory for skew-normal moment statistics.

Return type:

SkewNormalAccumulatorFactory

estimate(nobs, suff_stat)

Estimate location, scale, and shape from weighted central moments.

Parameters:

• nobs (float | None)

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

Return type:

SkewNormalDistribution

class SkewNormalDataEncoder

Bases: DataSequenceEncoder

Encode skew-normal observations as a float array.

seq_encode(x)

Encode observations as a floating-point array.

Parameters:

x (Sequence[float])

Return type:

ndarray