Struct Gamma 

pub struct Gamma { /* private fields */ }

Gamma distribution with shape α and scale θ: density x^(α-1) e^(-x/θ) / (Γ(α) θ^α), mean αθ, variance αθ².

Parameterized as in SciPy (a = shape, scale) and R (shape, scale = 1/rate). The gamma GLM family is this distribution with shape 1/φ and mean μ; see Gamma::from_mean_dispersion.

Example

use prospicio_prob::{Distribution, Gamma, Severity};

let d = Gamma::from_mean_cv(1000.0, 0.5).unwrap();
assert!((d.shape() - 4.0).abs() < 1e-12);
assert!((d.std_dev() - 500.0).abs() < 1e-9);
// LEV + stop-loss = mean.
assert!((d.lev(1500.0) + d.stop_loss(1500.0) - 1000.0).abs() < 1e-9);

Implementations

impl Gamma

pub fn new(shape: f64, scale: f64) -> Result<Self>

Gamma with shape α > 0 and scale θ > 0.

pub fn from_mean_cv(mean: f64, cv: f64) -> Result<Self>

Gamma with the given mean and coefficient of variation: shape 1/cv², scale mean cv².

pub fn from_mean_dispersion(mean: f64, dispersion: f64) -> Result<Self>

Gamma with mean μ and GLM dispersion φ (variance φμ²): shape 1/φ, scale φμ.

pub fn shape(&self) -> f64

Shape α.

pub fn scale(&self) -> f64

Scale θ.

pub fn ln_pdf(&self, x: f64) -> f64

Log density at x; -inf outside the support (and at 0 for shape above 1).

use prospicio_prob::Gamma;

// Shape 1 is the exponential: f(x) = e^(-x/θ) / θ.
let d = Gamma::new(1.0, 2.0).unwrap();
assert!((d.ln_pdf(3.0) - (-1.5 - 2f64.ln())).abs() < 1e-15);

Trait Implementations

impl Clone for Gamma

fn clone(&self) -> Gamma

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Gamma

impl Debug for Gamma

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

Formats the value using the given formatter.

impl Distribution for Gamma

fn quantile(&self, p: f64) -> Result<f64>

By bisection to full precision, on the distribution function below the median and on the survival function above it, so both tails keep their relative precision.

fn sample(&self, rng: &mut StreamRng, n: usize) -> Vec<f64>

n draws by Marsaglia and Tsang (2000), not inverse transform: each is θ times a Gamma(α, 1) draw from rng (for α < 1, a draw at α + 1 times U^(1/α)), so draws stay a pure function of (seed, stream) but are not monotone in one uniform. The quantile function costs a bisection on the incomplete gamma function, whose series grows with the shape, where this costs about one normal and one uniform at any shape.

fn mean(&self) -> f64

Expected value.

fn variance(&self) -> f64

Variance.

fn cdf(&self, x: f64) -> f64

P(X <= x).

fn survival(&self, x: f64) -> f64

P(X > x). Representations with a direct form override the default 1 - cdf(x), which loses all precision far in the tail.

fn std_dev(&self) -> f64

Standard deviation.

fn is_parallel_safe(&self) -> bool

Whether the distribution may be evaluated on several threads at once. True for every native family; false for a crate::Custom whose callbacks must stay on the calling thread (an R function), so the parallel simulations run single-threaded when they meet one.

impl From<Gamma> for Dist

fn from(d: Gamma) -> Self

Converts to this type from the input type.

impl PartialEq for Gamma

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

Equality operator ==.

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

Inequality operator !=.

impl Severity for Gamma

fn lev(&self, limit: f64) -> f64

E[min(X, u)] = αθ P(α + 1, u/θ) + u Q(α, u/θ).

fn stop_loss(&self, retention: f64) -> f64

E[(X - d)+] = αθ Q(α + 1, d/θ) - d Q(α, d/θ), from the tail, so it does not cancel against the mean.

fn layer(&self, limit: f64, attachment: f64) -> f64

LEV(a + limit) - LEV(a) for a layer attaching below the mean, where both are small, and stop_loss(a) - stop_loss(a + limit) above it, where those are: neither difference cancels.

fn layer_second_moment(&self, limit: f64, attachment: f64) -> f64

With b = a + limit and t_k(u) = E[X^k; X > u] - u^k S(u), E[Y²] = t_2(a) - t_2(b) - 2a (t_1(a) - t_1(b)), every term taken from the tail.

fn layer_variance(&self, limit: f64, attachment: f64) -> f64

Variance of the loss to the layer limit xs attachment.

impl StructuralPartialEq for Gamma