Struct Weibull

pub struct Weibull { /* private fields */ }

The Weibull Distribution

Description

Density, distribution function, quantile function and random generation for the Weibull distribution with parameters shape and scale.

Arguments

• shape, scale: shape and scale parameters, the latter defaulting to 1.

Details

The Weibull distribution with shape parameter a and scale parameter b has density given by

$ f(x) = (a/b) (x/b)^{a-1} exp(- (x/b)^a) $

for x > 0. The cumulative distribution function is $F(x) = 1 - exp(- (x/b)^a)$ on x > 0, the mean is $E(X) = b \Gamma(1 + 1/a)$, and the $Var(X) = b^2 * (\Gamma(1 + 2/a) - (\Gamma(1 + 1/a))^2)$.

Density Plot

let weibull = WeibullBuilder::new().build();
let x = <[f64]>::sequence(-1.0, 5.0, 1000);
let y = x
    .iter()
    .map(|x| weibull.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) = - log(1 - F(t))$ is

-pweibull(t, a, b, lower = FALSE, log = TRUE) which is just $H(t) = (t/b)^a$.

Source

[dpq]weibull are calculated directly from the definitions. rweibull uses inversion.

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

See Also

Distributions for other standard distributions, including the Exponential which is a special case of the Weibull distribution.

Examples

Using this x for everything below

let mut rng = MersenneTwister::new();
rng.set_seed(1);

let lnorm = LogNormalBuilder::new().build();

let mut x = (0..50)
    .map(|_| lnorm.random_sample(&mut rng).unwrap())
    .collect::<Vec<_>>();
x.insert(0, 0.0);

let weibull = WeibullBuilder::new().with_shape(1).build();
let r1 = x
    .iter()
    .map(|x| weibull.density(x).unwrap())
    .collect::<Vec<_>>();

let exp = ExponentialBuilder::new().build();
let r2 = x
    .iter()
    .map(|x| exp.density(x).unwrap())
    .collect::<Vec<_>>();

println!("{r1:?}");
println!("{r2:?}");

let weibull = WeibullBuilder::new()
    .with_shape(1)
    .with_scale(f64::PI())
    .build();
let r1 = x
    .iter()
    .map(|x| weibull.probability(x, true).unwrap())
    .collect::<Vec<_>>();

let exp = ExponentialBuilder::new().with_rate(1.0 / f64::PI()).build();
let r2 = x
    .iter()
    .map(|x| exp.probability(x, true).unwrap())
    .collect::<Vec<_>>();

println!("{r1:?}");
println!("{r2:?}");

Cumulative hazard H()

let weibull = WeibullBuilder::new()
    .with_shape(2.5)
    .with_scale(f64::PI())
    .build();
let r1 = x
    .iter()
    .map(|x| weibull.log_probability(x, false).unwrap())
    .collect::<Vec<_>>();

let r2 = x
    .iter()
    .map(|x| -(x / f64::PI()).powf(2.5))
    .collect::<Vec<_>>();

println!("{r1:?}");
println!("{r2:?}");

let weibull = WeibullBuilder::new()
    .with_shape(1)
    .with_scale(f64::PI())
    .build();
let r1 = x
    .iter()
    .map(|x| weibull.quantile(x / 11.0, true).unwrap())
    .collect::<Vec<_>>();

let exp = ExponentialBuilder::new().with_rate(1.0 / f64::PI()).build();
let r2 = x
    .iter()
    .map(|x| exp.quantile(x / 11.0, true).unwrap())
    .collect::<Vec<_>>();

println!("{r1:?}");
println!("{r2:?}");

Trait Implementations

impl Distribution for Weibull

fn density<R>(&self, x: R) -> NonNan<f64>

where R: Into<NonNan<f64>>,

The density of the values at a given point

fn log_density<R>(&self, x: R) -> NonNan<f64>

where R: Into<NonNan<f64>>,

The logarithmic density of the values at a given point

fn probability<R>( &self, q: R, lower_tail: bool, ) -> GreaterThanEqualZero<LessThanEqualOne<NonNan<f64>>>

where R: Into<NonNan<f64>>,

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

fn log_probability<R>( &self, q: R, lower_tail: bool, ) -> LessThanEqualZero<NonNan<f64>>

where R: Into<NonNan<f64>>,

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

fn quantile<P>(&self, p: P, lower_tail: bool) -> NonNan<f64>

where P: Into<GreaterThanEqualZero<LessThanEqualOne<NonNan<f64>>>>,

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

fn log_quantile<LP>(&self, p: LP, lower_tail: bool) -> NonNan<f64>

where LP: Into<LessThanEqualZero<NonNan<f64>>>,

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

fn random_sample<R>(&self, rng: &mut R) -> NonNan<f64>

where R: RNG,

Generates a random sample from the distribution