Struct PiecewisePareto 

pub struct PiecewisePareto { /* private fields */ }

Piecewise Pareto distribution with thresholds t_1 < … < t_n and alphas α_1, …, α_n: P(X > x) = 1 below t_1, and on [t_k, t_{k+1})

P(X > x) = P(X > t_k) (t_k / x)^α_k,

so α_k is the local Pareto alpha on the k-th piece. Interior alphas may be 0 (no losses end in that piece); the last must be positive. Matches pPiecewisePareto(x, t, alpha) in the R package Pareto.

Survival at the thresholds is kept as a logarithm, so steep pieces far in the tail do not underflow. Every layer moment is a sum of single-piece Pareto integrals, in closed form.

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

let pp = PiecewisePareto::new(vec![1000.0, 2000.0], vec![1.0, 2.0]).unwrap();
// P(X > 2000) = 1/2, then Pareto(2000, 2) above.
assert!((pp.survival(4000.0) - 0.125).abs() < 1e-15);
// E[X − 2000]+ = P(X > 2000) · 2000 / (2 − 1).
assert!((pp.stop_loss(2000.0) - 1000.0).abs() < 1e-12);

Implementations

impl PiecewisePareto

pub fn fit( t: Vec<f64>, data: &LargeLosses, truncation: Option<(f64, Truncation)>, ) -> Result<Self>

Maximum likelihood fit of the alphas of a piecewise Pareto with thresholds t to losses at or above t[0], optionally with the last piece truncated at truncation.

The likelihood separates by piece: alpha k is the uncensored weight ending in piece k over the weighted log-exposure Σ w ln(min(y, t_{k+1}) / max(r, t_k))⁺ inside it, and a truncated last piece is the truncated Pareto fit of the losses reaching it. Every piece needs some exposure; a piece where no uncensored loss ends gets alpha 0 (the last piece must have one).

Truncation of the whole distribution at T couples the alphas, since each loss’s likelihood is conditioned through S(r) − S(T). The fit then maximizes the likelihood by coordinate ascent from the untruncated estimates, each alpha by bisection on its analytic partial derivative and clamped to [1e-3, 1e3] (as the R package clamps to its bounds). S(a) − S(T) is computed as S(a) (1 − e^D) with D summed piece by piece over [a, T], so losses just below T keep their precision.

use prospicio_prob::{LargeLosses, PiecewisePareto};

let data = LargeLosses::new(vec![1200.0, 1500.0, 2500.0, 6000.0]).unwrap();
let fit = PiecewisePareto::fit(vec![1000.0, 2000.0], &data, None).unwrap();
// Piece 1: 2 losses end in it; exposure ln 1.2 + ln 1.5 + 2 ln 2.
let want = 2.0 / (1.2f64.ln() + 1.5f64.ln() + 2.0 * 2f64.ln());
assert!((fit.alphas()[0] - want).abs() < 1e-14);

impl PiecewisePareto

pub fn new(t: Vec<f64>, alpha: Vec<f64>) -> Result<Self>

Piecewise Pareto from strictly increasing positive thresholds t and alphas alpha of the same length: interior alphas ≥ 0, the last > 0.

pub fn truncated(self, truncation: f64, kind: Truncation) -> Result<Self>

The same distribution truncated at truncation, which must be finite and above the last threshold (as in the R package).

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

Thresholds t_1 < … < t_n.

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

Alphas α_1, …, α_n.

pub fn truncation(&self) -> Option<(f64, Truncation)>

Truncation point and kind, if any.

Trait Implementations

impl Clone for PiecewisePareto

fn clone(&self) -> PiecewisePareto

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PiecewisePareto

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

Formats the value using the given formatter.

impl Distribution for PiecewisePareto

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

p = 1 gives +∞, or the truncation point.

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

fn from(d: PiecewisePareto) -> Self

Converts to this type from the input type.

impl PartialEq for PiecewisePareto

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

Equality operator ==.

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

Inequality operator !=.

impl Severity for PiecewisePareto

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

2 ∫_a^b (x − a) S(x) dx with b = a + limit.

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_variance(&self, limit: f64, attachment: f64) -> f64

Variance of the loss to the layer limit xs attachment.

impl StructuralPartialEq for PiecewisePareto