Struct Mixture 

pub struct Mixture { /* private fields */ }

A severity drawn from component i with probability w_i: attritional and large losses in one model, or a book of mixed risks.

Every quantity that is linear in the distribution (distribution function, survival, limited expected values, layer moments) is the weighted sum of the components’; the variance follows the law of total variance; quantiles bisect the distribution function.

use prospicio_prob::{Distribution, Lognormal, Mixture, Pareto, Severity};

let m = Mixture::new(vec![
    (0.9, Box::new(Lognormal::from_mean_cv(1e4, 1.0).unwrap()) as Box<dyn Severity + Send + Sync>),
    (0.1, Box::new(Pareto::new(1e5, 2.0).unwrap())),
])
.unwrap();
assert!((m.mean() - (0.9 * 1e4 + 0.1 * 2e5)).abs() < 1e-6);
// Above 1e5 only the large losses reach: 0.1 × 2e5.
assert!(m.layer(f64::INFINITY, 1e5) > 0.1 * 1e5);

Implementations

impl Mixture

pub fn new(parts: Vec<(f64, Box<dyn Severity + Send + Sync>)>) -> Result<Self>

A mixture of (weight, component) pairs. Weights must be positive and sum to 1 within 1e-12.

pub fn from_dists(parts: Vec<(f64, SeverityDist)>) -> Result<Self>

A mixture of (weight, component) pairs of native severities. It behaves as Mixture::new, and also keeps the components as SeverityDists, so it can be saved (crate::Dist::to_json).

pub fn dists(&self) -> Option<&[SeverityDist]>

The components as SeverityDists, when built by Mixture::from_dists.

pub fn weights(&self) -> &[f64]

Component weights.

Trait Implementations

impl Debug for Mixture

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

Formats the value using the given formatter.

impl Distribution for Mixture

fn variance(&self) -> f64

Σ w (σ² + μ²) - (Σ w μ)².

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

The smallest x with F(x) >= p, bracketed by the components’ quantiles and bisected (on the survival function above the median).

fn mean(&self) -> f64

Expected value.

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 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.

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).

impl From<Mixture> for Dist

fn from(d: Mixture) -> Self

Converts to this type from the input type.

impl Severity for Mixture

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.