Struct Pareto 

pub struct Pareto { /* private fields */ }

Pareto distribution Pareto(t, α): P(X > x) = (t/x)^α for x ≥ t, and 1 below t. Also known as Pareto type I or single-parameter Pareto; matches the R package Pareto (pPareto(x, t, alpha)).

With a truncation T > t it is the Pareto conditioned on X < T: P(X > x) = ((t/x)^α − (t/T)^α) / (1 − (t/T)^α) for t ≤ x < T.

Layer integrals are in closed form for every α > 0, including the logarithmic cases α = 1 (limited mean) and α = 2 (limited second moment), which need no special handling: integrals of x^{k−α} are evaluated as a^{k+1−α} · L · exprel((k + 1 − α) L) with L = ln(b/a) and exprel(z) = (e^z − 1)/z.

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

let p = Pareto::new(500.0, 2.0).unwrap();
// The R package's vignette example: layer 4000 xs 1000.
assert!((p.layer(4000.0, 1000.0) - 200.0).abs() < 1e-12);
assert!((p.mean() - 1000.0).abs() < 1e-12);

Implementations

impl Pareto

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

Maximum likelihood fit of the alpha of Pareto(t, α), optionally truncated at truncation, to losses at or above t.

Each loss is conditioned on exceeding its reporting threshold raised to t, so t itself matters only through that floor. Untruncated, the estimate is in closed form, α = Σ_uncensored w / Σ w ln(y / r). Truncated, the score is solved by bisection and the estimate clamped to [1e-3, 1e3], as in the R package Pareto (whose upper bound is 10).

impl Pareto

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

Pareto with threshold t > 0 and alpha α > 0.

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

The same Pareto conditioned on X < truncation, with t < truncation < ∞.

pub fn t(&self) -> f64

Threshold t.

pub fn alpha(&self) -> f64

Pareto alpha.

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

Truncation point, if any.

Trait Implementations

impl Clone for Pareto

fn clone(&self) -> Pareto

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Pareto

impl Debug for Pareto

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

Formats the value using the given formatter.

impl Distribution for Pareto

fn mean(&self) -> f64

α t / (α − 1) untruncated; infinite for α ≤ 1.

fn variance(&self) -> f64

α t² / ((α − 1)² (α − 2)) untruncated; infinite for α ≤ 2.

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

t (1 − p)^(−1/α) untruncated; p = 1 gives +∞ (or the truncation point).

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

fn from(d: Pareto) -> Self

Converts to this type from the input type.

impl PartialEq for Pareto

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

Equality operator ==.

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

Inequality operator !=.

impl Severity for Pareto

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 Pareto