Struct Tweedie 

pub struct Tweedie { /* private fields */ }

Tweedie distribution with mean μ, dispersion φ and power 1 < p < 2: variance φ μ^p, a point mass at 0 and a continuous density above it.

It is the compound Poisson sum Y = X_1 + … + X_N with

N ~ Poisson(λ),        λ = μ^(2-p) / (φ (2 - p))
X ~ Gamma(α, θ),       α = (2 - p) / (p - 1),   θ = φ (p - 1) μ^(p-1)

the GLM family for pure premium (losses per exposure), where claim counts and severities are not modelled separately. Every quantity is a Poisson-weighted sum over the number of claims n, of the matching quantity of Gamma(nα, θ), summed until the remaining terms are negligible:

• P(Y = 0) = e^(-λ);
• the distribution function, survival function and layer moments from the gamma’s, each tail summed directly so both keep their precision;
• the density (Dunn & Smyth’s series), in log space.

Example

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

let y = Tweedie::new(500.0, 40.0, 1.6).unwrap();
assert!((y.mean() - 500.0).abs() < 1e-9);
assert!((y.variance() - 40.0 * 500f64.powf(1.6)).abs() < 1e-6);
// P(Y = 0) = e^(-λ).
assert!((y.cdf(0.0) - (-y.lambda()).exp()).abs() < 1e-15);
assert!((y.lev(800.0) + y.stop_loss(800.0) - 500.0).abs() < 1e-9);

Implementations

impl Tweedie

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

Tweedie with mean μ > 0, dispersion φ > 0 and power p in (1, 2).

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

The Tweedie equal to a Poisson(lambda) number of Gamma(shape, scale) losses: power (α + 2) / (α + 1), mean λαθ.

use prospicio_prob::Tweedie;

let y = Tweedie::from_poisson_gamma(3.0, 2.0, 100.0).unwrap();
assert!((y.power() - 4.0 / 3.0).abs() < 1e-15);
assert!((y.lambda() - 3.0).abs() < 1e-12);

pub fn mean_param(&self) -> f64

Mean μ.

pub fn dispersion(&self) -> f64

Dispersion φ.

pub fn power(&self) -> f64

Power p.

pub fn lambda(&self) -> f64

Poisson mean λ of the number of losses.

pub fn severity(&self) -> Gamma

The gamma distribution of each loss.

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

Log density at y > 0 (the continuous part); at y = 0, the log of the point mass -λ. -inf below 0.

use prospicio_prob::Tweedie;

// λ = 1 with unit exponential losses:
// f(y) = e^(-1-y) Σ_n y^(n-1) / (n! (n-1)!).
let y = Tweedie::from_poisson_gamma(1.0, 1.0, 1.0).unwrap();
let (mut series, mut term) = (0.0, 1.0); // term = 2^(n-1) / (n! (n-1)!)
for n in 1..40 {
    series += term;
    term *= 2.0 / (f64::from(n + 1) * f64::from(n));
}
assert!((y.ln_pdf(2.0) - (-3.0 + f64::ln(series))).abs() < 1e-13);

Trait Implementations

impl Clone for Tweedie

fn clone(&self) -> Tweedie

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Tweedie

impl Debug for Tweedie

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

Formats the value using the given formatter.

impl Distribution for Tweedie

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

0 when p is within the point mass; otherwise by bisection on the distribution or survival function, whichever is the smaller tail.

fn mean(&self) -> f64

Expected value.

fn variance(&self) -> f64

Variance.

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

P(X <= x).

fn survival(&self, y: 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 sample(&self, rng: &mut StreamRng, n: usize) -> Vec<f64>

n draws from stream rng, by inverse transform unless the family overrides it (crate::Gamma draws by Marsaglia and Tsang).

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<Tweedie> for Dist

fn from(d: Tweedie) -> Self

Converts to this type from the input type.

impl PartialEq for Tweedie

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

Equality operator ==.

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

Inequality operator !=.

impl Severity for Tweedie

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

Limited expected value E[min(X, limit)].

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

Expected excess over a retention, E[max(X - retention, 0)].

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

Expected loss to the layer limit xs attachment, E[min(max(X - attachment, 0), limit)].

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

Second moment of the loss to the layer limit xs attachment, E[min(max(X - attachment, 0), limit)^2]. limit = +inf gives the unlimited layer (infinite if the second moment is).

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

Variance of the loss to the layer limit xs attachment.

impl StructuralPartialEq for Tweedie