Struct Custom 

pub struct Custom { /* private fields */ }

A non-negative loss severity defined by a user’s cdf (and optionally quantile) function.

use std::sync::Arc;
use prospicio_prob::{Custom, Distribution, Severity};

// An exponential with mean 100, given only by its cdf.
let cdf = Arc::new(|x: f64| Ok((1.0 - (-x / 100.0).exp()).max(0.0)));
let d = Custom::new("exponential", cdf, None, true).unwrap();
assert!((d.mean() - 100.0).abs() < 1e-6);
// E[min(X, 50)] = 100 (1 - e^-0.5).
assert!((d.lev(50.0) - 100.0 * (1.0 - (-0.5f64).exp())).abs() < 1e-9);
assert!((d.quantile(0.5).unwrap() - 100.0 * 2f64.ln()).abs() < 1e-9);

Implementations

impl Custom

pub fn new( name: impl Into<String>, cdf: Callback, quantile: Option<Callback>, parallel_safe: bool, ) -> Result<Self>

A severity from its cdf and, optionally, its quantile function.

parallel_safe says whether the callbacks may run on several threads at once (true for a pure Rust closure; false for an R function). Construction evaluates the cdf at the panel quantiles and computes the mean and second moment, so a cdf that fails, leaves [0, 1], decreases or never reaches 1 - 1e-12 is reported here.

pub fn name(&self) -> &str

The name given at construction.

pub fn has_quantile(&self) -> bool

Whether a quantile function was supplied (otherwise quantiles invert the cdf by bisection, about a hundred cdf calls each).

pub fn upper(&self) -> f64

The 1 - 1e-12 quantile, where the integrals stop.

pub fn error(&self) -> Option<String>

The first callback failure since construction, if any. A failure inside a calculation makes that value NaN; this says why.

Trait Implementations

impl Clone for Custom

fn clone(&self) -> Custom

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Custom

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

Formats the value using the given formatter.

impl Distribution for Custom

fn mean(&self) -> f64

Expected value.

fn variance(&self) -> f64

Variance.

fn cdf(&self, x: f64) -> f64

P(X <= x).

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

Smallest x with cdf(x) >= p.

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

fn from(d: Custom) -> Self

Converts to this type from the input type.

impl Severity for Custom

fn stop_loss(&self, retention: f64) -> f64

∫_r^∞ S, integrated directly so far retentions keep their precision.

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

∫_a^{a+l} 2 (x - a) S(x) dx.

fn lev(&self, limit: f64) -> f64

Limited expected value E[min(X, limit)].

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.