Struct probability::prelude::Gaussian

pub struct Gaussian { /* private fields */ }

A Gaussian distribution.

Implementations

impl Gaussian

pub fn new(mu: f64, sigma: f64) -> Self

Create a Gaussian distribution with mean mu and standard deviation sigma.

It should hold that sigma > 0.

Examples found in repository

src/distribution/gaussian.rs (line 48)

    fn default() -> Self {
        Gaussian::new(0.0, 1.0)
    }
}

impl distribution::Continuous for Gaussian {
    fn density(&self, x: f64) -> f64 {
        (-(x - self.mu).powi(2) / (2.0 * self.sigma * self.sigma)).exp() / self.norm
    }
}

impl distribution::Distribution for Gaussian {
    type Value = f64;

    fn distribution(&self, x: f64) -> f64 {
        use core::f64::consts::SQRT_2;
        use special::Error;
        (1.0 + ((x - self.mu) / (self.sigma * SQRT_2)).error()) / 2.0
    }
}

impl distribution::Entropy for Gaussian {
    #[inline]
    fn entropy(&self) -> f64 {
        use core::f64::consts::{E, PI};
        0.5 * (2.0 * PI * E * self.sigma * self.sigma).ln()
    }
}

impl distribution::Inverse for Gaussian {
    /// Compute the inverse of the cumulative distribution function.
    ///
    /// ## References
    ///
    /// 1. M. J. Wichura, “Algorithm as 241: The percentage points of the normal
    ///    distribution,” Journal of the Royal Statistical Society. Series C
    ///    (Applied Statistics), vol. 37, no. 3, pp. pp. 477–484, 1988.
    ///
    /// 2. <http://people.sc.fsu.edu/~jburkardt/c_src/asa241/asa241.html>
    #[inline(always)]
    fn inverse(&self, p: f64) -> f64 {
        self.mu + self.sigma * inverse(p)
    }
}

impl distribution::Kurtosis for Gaussian {
    #[inline]
    fn kurtosis(&self) -> f64 {
        0.0
    }
}

impl distribution::Mean for Gaussian {
    #[inline]
    fn mean(&self) -> f64 {
        self.mu
    }
}

impl distribution::Median for Gaussian {
    #[inline]
    fn median(&self) -> f64 {
        self.mu
    }
}

impl distribution::Modes for Gaussian {
    #[inline]
    fn modes(&self) -> Vec<f64> {
        vec![self.mu]
    }
}

impl distribution::Sample for Gaussian {
    /// Draw a sample.
    ///
    /// ## References
    ///
    /// 1. G. Marsaglia and W. W. Tsang, “The ziggurat method for generating
    ///    random variables,” Journal of Statistical Software, vol. 5, no. 8,
    ///    pp. 1–7, 10 2000.
    ///
    /// 2. D. Eddelbuettel, “Ziggurat Revisited,” 2014.
    #[inline]
    fn sample<S>(&self, source: &mut S) -> f64
    where
        S: Source,
    {
        self.sigma * sample(source) + self.mu
    }
}

impl distribution::Skewness for Gaussian {
    #[inline]
    fn skewness(&self) -> f64 {
        0.0
    }
}

impl distribution::Variance for Gaussian {
    #[inline]
    fn variance(&self) -> f64 {
        self.sigma * self.sigma
    }

    #[inline]
    fn deviation(&self) -> f64 {
        self.sigma
    }
}

impl core::iter::FromIterator<f64> for Gaussian {
    /// Infer the distribution from an iterator.
    fn from_iter<T: IntoIterator<Item = f64>>(iterator: T) -> Self {
        let samples: Vec<f64> = iterator.into_iter().collect();
        let mu = samples.iter().fold(0.0, |a, b| a + b) / samples.len() as f64;
        let sigma = f64::sqrt(
            samples
                .iter()
                .fold(0.0, |a, b| a + f64::powf(b - mu as f64, 2.0))
                / (samples.len() - 1) as f64,
        );
        Gaussian::new(mu, sigma)
    }

src/distribution/lognormal.rs (line 26)

    pub fn new(mu: f64, sigma: f64) -> Self {
        should!(sigma > 0.0);
        Lognormal {
            mu,
            sigma,
            gaussian: Gaussian::new(mu, sigma),
        }
    }

src/distribution/cauchy.rs (line 111)

    fn sample<S>(&self, source: &mut S) -> f64
    where
        S: Source,
    {
        let gaussian = distribution::Gaussian::new(0.0, 1.0);
        let a = gaussian.sample(source);
        let b = gaussian.sample(source);
        self.x_0() + self.gamma() * a / (b.abs() + f64::MIN_POSITIVE)
    }

pub fn mu(&self) -> f64

Return the mean.

pub fn sigma(&self) -> f64

Return the standard deviation.

Trait Implementations

impl Clone for Gaussian

fn clone(&self) -> Gaussian

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Continuous for Gaussian

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

Compute the probability density function.

impl Debug for Gaussian

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

Formats the value using the given formatter.

impl Default for Gaussian

fn default() -> Self

Returns the “default value” for a type.

impl Distribution for Gaussian

type Value = f64

The type of outcomes.

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

Compute the cumulative distribution function.

impl Entropy for Gaussian

fn entropy(&self) -> f64

Compute the differential entropy.

impl FromIterator<f64> for Gaussian

fn from_iter<T: IntoIterator<Item = f64>>(iterator: T) -> Self

Infer the distribution from an iterator.

impl Inverse for Gaussian

fn inverse(&self, p: f64) -> f64

Compute the inverse of the cumulative distribution function.

References

1. M. J. Wichura, “Algorithm as 241: The percentage points of the normal distribution,” Journal of the Royal Statistical Society. Series C (Applied Statistics), vol. 37, no. 3, pp. pp. 477–484, 1988.

2. http://people.sc.fsu.edu/~jburkardt/c_src/asa241/asa241.html

impl Kurtosis for Gaussian

fn kurtosis(&self) -> f64

Compute the excess kurtosis.

impl Mean for Gaussian

fn mean(&self) -> f64

Compute the expected value.

impl Median for Gaussian

fn median(&self) -> f64

Compute the median.

impl Modes for Gaussian

fn modes(&self) -> Vec<f64>

Compute the modes.

impl Sample for Gaussian

fn sample<S>(&self, source: &mut S) -> f64where
    S: Source,

Draw a sample.

References

1. G. Marsaglia and W. W. Tsang, “The ziggurat method for generating random variables,” Journal of Statistical Software, vol. 5, no. 8, pp. 1–7, 10 2000.

2. D. Eddelbuettel, “Ziggurat Revisited,” 2014.

impl Skewness for Gaussian

fn skewness(&self) -> f64

Compute the skewness.

impl Variance for Gaussian

fn variance(&self) -> f64

Compute the variance.

fn deviation(&self) -> f64

Compute the standard deviation.

impl Copy for Gaussian