Struct Normal 

pub struct Normal { /* private fields */ }

The Normal Distribution

Description

Density, distribution function, quantile function and random generation for the normal distribution with mean equal to mean and standard deviation equal to sd.

Arguments

• mean: vector of means.
• sd: vector of standard deviations.

Details

If mean or sd are not specified they assume the default values of 0 and 1, respectively.

The normal distribution has density

$ f(x) = \frac{1}{\sigma \sqrt{2 \pi}} e^{-\frac{(x - \mu)^2}{2 \sigma^2}} $

where $ \mu $ is the mean of the distribution and $ \sigma $ the standard deviation.

Value

dnorm gives the density, pnorm gives the distribution function, qnorm gives the quantile function, and rnorm generates random deviates.

The length of the result is determined by n for rnorm, and is the maximum of the lengths of the numerical arguments for the other functions.

The numerical arguments other than n are recycled to the length of the result. Only the first elements of the logical arguments are used.

For sd = 0 this gives the limit as sd decreases to 0, a point mass at mu. sd < 0 is an error and returns NaN.

Density Plot

let norm = NormalBuilder::new().build();
let x = <[f64]>::sequence(-3.0, 3.0, 1000);
let y = x
    .iter()
    .map(|x| norm.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();

Source

For pnorm, based on

Cody, W. D. (1993) Algorithm 715: SPECFUN – A portable FORTRAN package of special function routines and test drivers. ACM Transactions on Mathematical Software 19, 22–32.

For qnorm, the code is a C translation of

Wichura, M. J. (1988) Algorithm AS 241: The percentage points of the normal distribution. Applied Statistics, 37, 477–484.

which provides precise results up to about 16 digits.

For rnorm, see RNG for how to select the algorithm and for references to the supplie methods.

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 13. Wiley, New York.

See Also

Distributions for other standard distributions, including dlnorm for the Lognormal distribution.

Examples

let norm = NormalBuilder::new().build();
println!("{}", norm.density(0));
println!("{}", 1.0 / (2.0 * f64::PI()).sqrt());

let norm = NormalBuilder::new().build();
println!("{}", norm.density(1));
println!("{}", (-0.5_f64).exp() / (2.0 * f64::PI()).sqrt());
println!("{}", 1.0 / (2.0 * f64::PI() * 1.0_f64.exp()).sqrt());

let norm = NormalBuilder::new().build();

let dx = (-60..50).map(|x| x as f64).collect::<Vec<_>>();
let dy1 = dx
    .iter()
    .map(|x| norm.log_density(x).unwrap())
    .collect::<Vec<_>>();
let dy2 = dx
    .iter()
    .map(|x| norm.density(x).unwrap().ln())
    .collect::<Vec<_>>();

let px = (-50..10).map(|x| x as f64).collect::<Vec<_>>();
let py1 = px
    .iter()
    .map(|x| norm.log_probability(x, true).unwrap())
    .collect::<Vec<_>>();
let py2 = px
    .iter()
    .map(|x| norm.probability(x, true).unwrap().ln())
    .collect::<Vec<_>>();

let root = SVGBackend::new("log_plots.svg", (1024, 768)).into_drawing_area();

Plot::new()
    .with_options(PlotOptions {
        x_axis_label: "x".to_string(),
        y_axis_label: "density".to_string(),
        title: "Log Normal Density".to_string(),
        legend_x: 0.1,
        legend_y: 0.1,
        plot_bottom: 0.5,
        ..Default::default()
    })
    .with_plottable(Line {
        x: dx.clone(),
        y: dy1,
        legend: true,
        label: "log_density()".to_string(),
        color: BLACK,
        ..Default::default()
    })
    .with_plottable(Line {
        x: dx.clone(),
        y: dy2,
        legend: true,
        label: "density().ln()".to_string(),
        color: RED,
        ..Default::default()
    })
    .plot(&root)
    .unwrap();

Plot::new()
    .with_options(PlotOptions {
        x_axis_label: "x".to_string(),
        y_axis_label: "probability".to_string(),
        title: "Log Normal Cumulative".to_string(),
        legend_x: 0.1,
        legend_y: 0.1,
        plot_top: 0.5,
        ..Default::default()
    })
    .with_plottable(Line {
        x: px.clone(),
        y: py1,
        legend: true,
        label: "log_probability()".to_string(),
        color: BLACK,
        ..Default::default()
    })
    .with_plottable(Line {
        x: px.clone(),
        y: py2,
        legend: true,
        label: "probability().ln()".to_string(),
        color: RED,
        ..Default::default()
    })
    .plot(&root)
    .unwrap();

If you want the so-called ‘error function’ (see Abramowitz and Stegun 29.2.29)

fn erf(x: f64) -> f64 {
    let norm = NormalBuilder::new().build();
    2.0 * norm.probability(x * 2.0_f64.sqrt(), true).unwrap() - 1.0
}

and the so-called ‘complementary error function’

fn erfc(x: f64) -> f64 {
    let norm = NormalBuilder::new().build();
    2.0 * norm.probability(x * 2.0_f64.sqrt(), false).unwrap()
}

and the inverses

fn erfinv(x: f64) -> f64 {
    let norm = NormalBuilder::new().build();
    norm.quantile((1.0 + x) / 2.0, true).unwrap() / 2.0_f64.sqrt()
}

fn erfcinv(x: f64) -> f64 {
    let norm = NormalBuilder::new().build();
    norm.quantile(x / 2.0, false).unwrap() / 2.0_f64.sqrt()
}

Trait Implementations

impl Distribution for Normal

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