Enum Distortion 

pub enum Distortion {
    Tvar(f64),
    Wang(f64),
    ProportionalHazard(f64),
    DualPower(f64),
    Exponential(f64),
}

A distortion of the survival function. Every variant is concave, so every measure here is coherent.

Variant	g(s)	Parameter
Tvar(p)	min(s / (1 - p), 1)	p in [0, 1]
Wang(λ)	Φ(Φ⁻¹(s) + λ)	λ >= 0
ProportionalHazard(ρ)	s^ρ	ρ in (0, 1]
DualPower(β)	1 - (1 - s)^β	β >= 1
Exponential(k)	(1 - e^(-k s)) / (1 - e^(-k))	k > 0

Each has a parameter value that gives the mean (Tvar(0), Wang(0), ProportionalHazard(1), DualPower(1), and Exponential(k) as k → 0).

A concave distortion is a spectral risk measure, ρ = ∫₀¹ φ(u) VaR_u du with the non-decreasing risk-aversion spectrum φ(u) = g'(1 - u). Exponential(k) is the spectral measure with exponential risk aversion, φ(u) = k e^(-k(1-u)) / (1 - e^(-k)) (Acerbi, 2002; Dowd, Cotter and Sorwar, 2008); Tvar(p) is the one whose spectrum is flat above p.

use prospicio_prob::Distortion;

let x = [1.0, 2.0, 3.0, 4.0];
// TVaR at 50%: the mean of the top half.
assert_eq!(Distortion::tvar(0.5).unwrap().apply_sorted(&x), 3.5);
// Wang with λ = 0 is the mean.
assert!((Distortion::wang(0.0).unwrap().apply_sorted(&x) - 2.5).abs() < 1e-15);

Variants

Tvar(f64)

Wang(f64)

ProportionalHazard(f64)

DualPower(f64)

Exponential(f64)

Implementations

impl Distortion

pub fn tvar(p: f64) -> Result<Self>

Tail value at risk at level p.

pub fn wang(lambda: f64) -> Result<Self>

Wang transform with market price of risk lambda >= 0.

pub fn proportional_hazard(rho: f64) -> Result<Self>

Proportional hazard transform with rho in (0, 1].

pub fn dual_power(beta: f64) -> Result<Self>

Dual power transform with beta >= 1.

pub fn exponential(k: f64) -> Result<Self>

The spectral measure with exponential risk aversion k > 0: the larger k, the more weight on the worst outcomes.

pub fn g(&self, s: f64) -> f64

The distortion g(s) of a survival probability s in [0, 1].

pub fn weights(&self, n: usize) -> Vec<f64>

Weights for n equally likely values sorted ascending: value i (0-based) gets g((n - i) / n) - g((n - i - 1) / n). They are non-negative and sum to 1.

use prospicio_prob::Distortion;

// TVaR at 50% on four values: the top two, equally.
assert_eq!(Distortion::tvar(0.5).unwrap().weights(4), [0.0, 0.0, 0.5, 0.5]);

pub fn apply_sorted(&self, sorted: &[f64]) -> f64

The risk measure of equally likely draws sorted ascending.

For Tvar(p) this agrees with tvar_sorted up to rounding, including the fractional weight at the VaR. sorted must be non-empty and sorted ascending; this is checked only in debug builds.

pub fn apply_discrete(&self, values: &[f64], probs: &[f64]) -> f64

The risk measure of a discrete distribution with ascending values and their probs (which should sum to 1).

Survival probabilities are summed from the top, so small tail probabilities keep their precision.

use prospicio_prob::Distortion;

let ph = Distortion::proportional_hazard(0.5).unwrap();
// P(X = 0) = 0.75, P(X = 1) = 0.25: ρ = g(0.25) = 0.5.
assert_eq!(ph.apply_discrete(&[0.0, 1.0], &[0.75, 0.25]), 0.5);

Trait Implementations

impl Clone for Distortion

fn clone(&self) -> Distortion

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Distortion

impl Debug for Distortion

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

Formats the value using the given formatter.

impl PartialEq for Distortion

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Distortion