Struct LogAffinePareto 

pub struct LogAffinePareto { /* private fields */ }

Log-affine local Pareto: above the threshold t the local Pareto alpha is α(x) = α₀ (1 + γ ln(x/t)), so with L = ln(x/t)

P(X > x) = exp(−α₀ L − ½ α₀ γ L²),   x ≥ t,

and 1 below t. The tail thins out with size (lognormal-like) at a rate set by two readable numbers: the alpha α₀ at the threshold and δ = α₀ γ ln 2, the rise in alpha each time the amount doubles. γ = 0 is the Pareto. Matches pLALocPareto(x, t, alpha_0, gamma) in the R package LocalPareto.

In L the survival function is a Gaussian, so every layer moment reduces to normal tail probabilities, evaluated through the Mills ratio so that layers far in the tail keep full relative precision.

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

// Alpha 1.5 at 1m, rising by 0.5 per doubling.
let d = LogAffinePareto::from_delta(1e6, 1.5, 0.5).unwrap();
assert!((d.local_alpha(2e6) - 2.0).abs() < 1e-14);
assert!(d.layer(4e6, 1e6) > 0.0 && d.mean().is_finite());

Implementations

impl LogAffinePareto

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

Threshold t > 0, alpha α₀ > 0 at the threshold and γ ≥ 0 (a falling alpha would turn negative far out).

pub fn from_delta(t: f64, alpha0: f64, delta: f64) -> Result<Self>

The same distribution from δ = α₀ γ ln 2 ≥ 0, the increase in the local alpha when the amount doubles.

pub fn t(&self) -> f64

pub fn alpha0(&self) -> f64

Local alpha at the threshold.

pub fn gamma(&self) -> f64

pub fn delta(&self) -> f64

δ = α₀ γ ln 2.

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

The local Pareto alpha −x S'(x) / S(x) at x ≥ t (0 below).

Trait Implementations

impl Clone for LogAffinePareto

fn clone(&self) -> LogAffinePareto

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for LogAffinePareto

impl Debug for LogAffinePareto

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

Formats the value using the given formatter.

impl Distribution for LogAffinePareto

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

Solves ½ α₀ γ L² + α₀ L + ln s = 0 for L ≥ 0 in the form L = −2 ln s / (α₀ + √(α₀² − 2 α₀ γ ln s)), which has no cancellation and covers γ = 0.

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

fn from(d: LogAffinePareto) -> Self

Converts to this type from the input type.

impl PartialEq for LogAffinePareto

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

Equality operator ==.

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

Inequality operator !=.

impl Severity for LogAffinePareto

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 LogAffinePareto