Enum Distribution 

#[non_exhaustive]
pub enum Distribution {
    Uniform {
        lo: f64,
        hi: f64,
    },
    Normal {
        mu: f64,
        sigma: f64,
    },
    LogNormal {
        mu_log: f64,
        sigma_log: f64,
    },
    Triangular {
        lo: f64,
        mode: f64,
        hi: f64,
    },
    Beta {
        alpha: f64,
        beta: f64,
        lo: f64,
        hi: f64,
    },
    Gamma {
        shape: f64,
        scale: f64,
    },
    Weibull {
        shape: f64,
        scale: f64,
    },
    Exponential {
        lambda: f64,
    },
    Bernoulli {
        p: f64,
    },
    DiscreteUniform {
        lo: i64,
        hi: i64,
    },
}

Factor distributions saltelli supports. Closed enum, #[non_exhaustive]. Future variants (Truncated, Empirical, Categorical, …) land non-breaking via follow-on ADRs.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Uniform

Uniform on [lo, hi]. Closed-form quantile.

Fields

lo: f64

hi: f64

Normal

Normal N(mu, sigma²). statrs::Normal::inverse_cdf.

Fields

mu: f64

sigma: f64

LogNormal

Log-normal — exp(N(mu_log, sigma_log²)). statrs::LogNormal::inverse_cdf.

Fields

mu_log: f64

sigma_log: f64

Triangular

Triangular on [lo, hi] with mode mode. Closed-form quantile (piecewise sqrt).

Fields

lo: f64

mode: f64

hi: f64

Beta

Beta on [lo, hi] with shape parameters alpha, beta. statrs::Beta::inverse_cdf then affine-mapped to [lo, hi].

Fields

alpha: f64

beta: f64

lo: f64

hi: f64

Gamma

Gamma with shape shape and scale scale (so mean = shape × scale). statrs::Gamma parameterizes by rate, so we pass 1/scale. Closed-form for shape = 1 collapses to Exponential { lambda: 1/scale }.

Fields

shape: f64

scale: f64

Weibull

Weibull with shape shape, scale scale. Closed-form quantile: scale * (-ln(1 - u))^(1/shape).

Fields

shape: f64

scale: f64

Exponential

Exponential with rate lambda. Closed-form quantile: -ln(1 - u) / lambda.

Fields

lambda: f64

Bernoulli

Bernoulli with success probability p. Quantile: 0 if u < 1 - p, else 1.

Fields

p: f64

DiscreteUniform

Discrete uniform on the inclusive integer range [lo, hi].

Fields

lo: i64

hi: i64

Implementations

impl Distribution

pub fn quantile(&self, u: f64) -> f64

Inverse CDF. u ∈ [0, 1] (saturated; out-of-range inputs clamp to the support boundary). Pure function of (parameters, u).

Panics

On invalid distribution parameters (sigma ≤ 0, alpha ≤ 0, Beta with lo ≥ hi, etc.). Problem construction validates parameters at build time so this never fires for a Problem produced by ProblemBuilder::build.

pub fn support(&self) -> (f64, f64)

Support of the distribution as (lower, upper). For distributions with infinite support, returns ±f64::INFINITY. quantile(0.0) returns the lower support and quantile(1.0) the upper support.

Trait Implementations

impl Clone for Distribution

fn clone(&self) -> Distribution

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Distribution

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Distribution

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Distribution

fn eq(&self, other: &Distribution) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Distribution

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Distribution