1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Probability distributions.

use random::Source;

/// A probability distribution.
pub trait Distribution {
    /// The type of outcomes.
    type Value;

    /// Compute the distribution function.
    ///
    /// The function is also known as the cumulative distribution function.
    fn cdf(&self, f64) -> f64;
}

/// A continuous distribution.
pub trait Continuous: Distribution {
    /// Compute the probability density function.
    fn pdf(&self, f64) -> f64;
}

/// A discrete distribution.
pub trait Discrete: Distribution {
    /// Compute the probability mass function.
    fn pmf(&self, Self::Value) -> f64;
}

/// A distribution capable of computing the differential entropy.
pub trait Entropy: Distribution {
    /// Compute the differential entropy.
    ///
    /// The entropy is computed in nats.
    fn entropy(&self) -> f64;
}

/// A distribution capable of inverting the distribution function.
pub trait Inverse: Distribution {
    /// Compute the inverse of the distribution function.
    fn inv_cdf(&self, f64) -> Self::Value;
}

/// A distribution capable of computing the excess kurtosis.
pub trait Kurtosis: Skewness {
    /// Compute the excess kurtosis.
    fn kurtosis(&self) -> f64;
}

/// A distribution capable of computing the expected value.
///
/// The trait is applicable when the expected value exists, that is, finite.
pub trait Mean: Distribution {
    /// Compute the expected value.
    fn mean(&self) -> f64;
}

/// A distribution capable of computing the median.
///
/// The trait is applicable when exactly one median exists.
pub trait Median: Distribution {
    /// Compute the median.
    fn median(&self) -> f64;
}

/// A distribution capable of computing the modes.
///
/// The trait is applicable when the number of modes is finite.
pub trait Modes: Distribution {
    /// Compute the modes.
    fn modes(&self) -> Vec<Self::Value>;
}

/// A distribution capable of sampling.
pub trait Sample: Distribution {
    /// Draw a sample.
    fn sample<S>(&self, &mut S) -> Self::Value where S: Source;
}

/// A distribution capable of computing the skewness.
pub trait Skewness: Variance {
    /// Compute the skewness.
    fn skewness(&self) -> f64;
}

/// A distribution capable of computing the variance.
///
/// The trait is applicable when the variance exists, that is, finite.
pub trait Variance: Mean {
    /// Compute the variance.
    fn variance(&self) -> f64;

    /// Compute the standard deviation.
    #[inline(always)]
    fn deviation(&self) -> f64 {
        self.variance().sqrt()
    }

    /// Compute the variance.
    ///
    /// The function is an alias for `variance`.
    #[inline(always)]
    fn var(&self) -> f64 {
        self.variance()
    }

    /// Compute the standard deviation.
    ///
    /// The function is an alias for `deviation`.
    #[inline(always)]
    fn sd(&self) -> f64 {
        self.deviation()
    }
}

pub use self::bernoulli::Bernoulli;
pub use self::beta::Beta;
pub use self::binomial::Binomial;
pub use self::categorical::Categorical;
pub use self::exponential::Exponential;
pub use self::gamma::Gamma;
pub use self::gaussian::Gaussian;
pub use self::uniform::Uniform;

mod bernoulli;
mod beta;
mod binomial;
mod categorical;
mod exponential;
mod gamma;
mod gaussian;
mod uniform;