Struct Exponential 

pub struct Exponential { /* private fields */ }

The Exponential Distribution

Description:

Density, distribution function, quantile function and random generation for the exponential distribution with rate ‘rate’ (i.e., mean ‘1/rate’).

Arguments:

• rate.
• scale: 1 / rate

Details:

If ‘rate’ is not specified, it assumes the default value of ‘1’.

The exponential distribution with rate lambda has density

$ f(x) = lambda {e}^{- lambda x} $

for $x >= 0$.

Density Plot

let exp = ExponentialBuilder::new().build();
let x = <[f64]>::sequence(-0.5, 4.0, 1000);
let y = x
    .iter()
    .map(|x| exp.density(x).unwrap())
    .collect::<Vec<_>>();

let root = SVGBackend::new("density.svg", (1024, 768)).into_drawing_area();
Plot::new()
    .with_options(PlotOptions {
        x_axis_label: "x".to_string(),
        y_axis_label: "density".to_string(),
        ..Default::default()
    })
    .with_plottable(Line {
        x,
        y,
        color: BLACK,
        ..Default::default()
    })
    .plot(&root)
    .unwrap();

Note:

The cumulative hazard $H(t) = - \text{log}(1 - F(t))$ is ‘-pexp(t, r, lower = FALSE, log = TRUE)’.

Source:

‘dexp’, ‘pexp’ and ‘qexp’ are all calculated from numerically stable versions of the definitions.

‘rexp’ uses

Ahrens, J. H. and Dieter, U. (1972). Computer methods for sampling from the exponential and normal distributions. Communications of the ACM, 15, 873-882.

References:

Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) The New S Language. Wadsworth & Brooks/Cole.

Johnson, N. L., Kotz, S. and Balakrishnan, N. (1995) Continuous Univariate Distributions, volume 1, chapter 19. Wiley, New York.

See Also:

‘exp’ for the exponential function.

Distributions for other standard distributions, including ‘dgamma’ for the gamma distribution and ‘dweibull’ for the Weibull distribution, both of which generalize the exponential.

Examples:

println!("{}", (-1.0_f64).exp());
println!("{}", exp.density(1));

A fast way to generate sorted U[0,1] random numbers

let rsunif = |n| {
    let mut rng = MersenneTwister::new();
    rng.set_seed(1);
    let exp = ExponentialBuilder::new().build();
    let ce = (0..n)
        .map(|_| exp.random_sample(&mut rng).unwrap())
        .collect::<Vec<_>>()
        .cumsum();
    let ce_max = ce[n - 1];
    ce.into_iter().map(|ce| ce / ce_max).collect::<Vec<_>>()
};

let x = (0..1000).map(|x| x as f64).collect::<Vec<_>>();
let y = rsunif(1000);

let root = SVGBackend::new("rsunif.svg", (1024, 768)).into_drawing_area();
Plot::new()
    .with_options(PlotOptions {
        x_axis_label: "index".to_string(),
        y_axis_label: "rsunif".to_string(),
        ..Default::default()
    })
    .with_plottable(Line {
        x: vec![0.0, 1000.0],
        y: vec![0.0, 1.0],
        color: GREY_500,
        ..Default::default()
    })
    .with_plottable(Points {
        x,
        y,
        color: BLACK,
        ..Default::default()
    })
    .plot(&root)
    .unwrap();

Trait Implementations

impl Distribution for Exponential

fn density<R: Into<Real64>>(&self, x: R) -> Real64

The density of the values at a given point

fn log_density<R: Into<Real64>>(&self, x: R) -> Real64

The logarithmic density of the values at a given point

fn probability<R: Into<Real64>>(&self, q: R, lower_tail: bool) -> Probability64

PDF; The probability that a value is found in a distribution (inverse of quantile)

fn log_probability<R: Into<Real64>>( &self, q: R, lower_tail: bool, ) -> LogProbability64

log(PDF); The logarithmic probability that a value is found in a distribution (inverse of quantile)

fn quantile<P: Into<Probability64>>(&self, p: P, lower_tail: bool) -> Real64

The value in the distribution that is associated with a probability (inverse of probability)

fn log_quantile<LP: Into<LogProbability64>>( &self, p: LP, lower_tail: bool, ) -> Real64

The logarithmic value in the distribution that is associated with a probability (inverse of probability)

fn random_sample<R: RNG>(&self, rng: &mut R) -> Real64

Generates a random sample from the distribution