Struct Lognormal 

pub struct Lognormal { /* private fields */ }

Lognormal distribution: ln X ~ Normal(meanlog, sdlog^2).

Parameterized as in SciPy (s = sdlog, scale = exp(meanlog)), R (meanlog, sdlog) and actuar.

Example

use prospicio_prob::{Distribution, Lognormal};

let d = Lognormal::from_mean_cv(1000.0, 0.5).unwrap();
assert!((d.mean() - 1000.0).abs() < 1e-9);
assert!((d.std_dev() - 500.0).abs() < 1e-9);

Implementations

impl Lognormal

pub fn new(meanlog: f64, sdlog: f64) -> Result<Self>

Lognormal with the given log-scale mean and standard deviation.

pub fn from_mean_cv(mean: f64, cv: f64) -> Result<Self>

Lognormal with the given mean and coefficient of variation, the way severity assumptions are usually stated.

pub fn meanlog(&self) -> f64

Log-scale mean.

pub fn sdlog(&self) -> f64

Log-scale standard deviation.

Trait Implementations

impl Clone for Lognormal

fn clone(&self) -> Lognormal

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Lognormal

impl Debug for Lognormal

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

Formats the value using the given formatter.

impl Distribution for Lognormal

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 quantile(&self, p: f64) -> Result<f64>

Smallest x with cdf(x) >= p.

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

fn from(d: Lognormal) -> Self

Converts to this type from the input type.

impl PartialEq for Lognormal

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

Equality operator ==.

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

Inequality operator !=.

impl Severity for Lognormal

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

E[min(X, d)] = e^(mu + s^2/2) Phi((ln d - mu - s^2) / s) + d (1 - Phi((ln d - mu) / s)).

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

E[(X - d)+] = e^(mu + s^2/2) Phi((mu + s^2 - ln d) / s) - d Phi((mu - ln d) / s), with both terms small in the tail, so it keeps full relative precision where mean() - lev(d) would cancel.

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

With b = a + limit and Y the layer loss, E[Y^2] = E[(X - a)^2; a < X <= b] + limit^2 P(X > b), from the partial moments E[X^k; a < X <= b] = e^(k mu + k^2 s^2 / 2) (Phi(z_b - k s) - Phi(z_a - k s)). Differences of Phi are taken in the upper tail so they keep their precision for high layers.

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 Lognormal