[−][src]Struct rv::dist::Gaussian

pub struct Gaussian { /* fields omitted */ }

Gaussian / Normal distribution, N(μ, σ) over real values.

Examples

Compute the KL Divergence between two Gaussians.

use rv::prelude::*;

let gauss_1 = Gaussian::new(0.1, 2.3).unwrap();
let gauss_2 = Gaussian::standard();

// KL is not symmetric
let kl_12 = gauss_1.kl(&gauss_2);
let kl_21 = gauss_2.kl(&gauss_1);

// ... but kl_sym is because it's the sum of KL(P|Q) and KL(Q|P)
let kl_sym = gauss_1.kl_sym(&gauss_2);
assert!((kl_sym - (kl_12 + kl_21)).abs() < 1E-12);

Implementations

`impl Gaussian`[src]

`pub fn new(mu: f64, sigma: f64) -> Result<Self, GaussianError>`[src]

Create a new Gaussian distribution

Aruments

mu: mean
sigma: standard deviation

`pub fn new_unchecked(mu: f64, sigma: f64) -> Self`[src]

Creates a new Gaussian without checking whether the parameters are valid.

`pub fn standard() -> Self`[src]

Standard normal

Example

let gauss = Gaussian::standard();

assert_eq!(gauss, Gaussian::new(0.0, 1.0).unwrap());

`pub fn mu(&self) -> f64`[src]

Get mu parameter

Example

let gauss = Gaussian::new(2.0, 1.5).unwrap();

assert_eq!(gauss.mu(), 2.0);

`pub fn set_mu(&mut self, mu: f64) -> Result<(), GaussianError>`[src]

Set the value of mu

Example

let mut gauss = Gaussian::new(2.0, 1.5).unwrap();
assert_eq!(gauss.mu(), 2.0);

gauss.set_mu(1.3).unwrap();
assert_eq!(gauss.mu(), 1.3);

Will error for invalid values

assert!(gauss.set_mu(1.3).is_ok());
assert!(gauss.set_mu(std::f64::NEG_INFINITY).is_err());
assert!(gauss.set_mu(std::f64::INFINITY).is_err());
assert!(gauss.set_mu(std::f64::NAN).is_err());

`pub fn set_mu_unchecked(&mut self, mu: f64)`[src]

Set the value of mu without input validation

`pub fn sigma(&self) -> f64`[src]

Get sigma parameter

Example

let gauss = Gaussian::new(2.0, 1.5).unwrap();

assert_eq!(gauss.sigma(), 1.5);

`pub fn set_sigma(&mut self, sigma: f64) -> Result<(), GaussianError>`[src]

Set the value of sigma

Example

let mut gauss = Gaussian::standard();
assert_eq!(gauss.sigma(), 1.0);

gauss.set_sigma(2.3).unwrap();
assert_eq!(gauss.sigma(), 2.3);

Will error for invalid values

assert!(gauss.set_sigma(2.3).is_ok());
assert!(gauss.set_sigma(0.0).is_err());
assert!(gauss.set_sigma(-1.0).is_err());
assert!(gauss.set_sigma(std::f64::INFINITY).is_err());
assert!(gauss.set_sigma(std::f64::NEG_INFINITY).is_err());
assert!(gauss.set_sigma(std::f64::NAN).is_err());

`pub fn set_sigma_unchecked(&mut self, sigma: f64)`[src]

Set the value of sigma

Trait Implementations

`impl Cdf<f32> for Gaussian`[src]

`fn cdf(&self, x: &f32) -> f64`[src]

`fn sf(&self, x: &X) -> f64`[src]

`impl Cdf<f64> for Gaussian`[src]

`fn cdf(&self, x: &f64) -> f64`[src]

`fn sf(&self, x: &X) -> f64`[src]

`impl Clone for Gaussian`[src]

`fn clone(&self) -> Self`[src]

`fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl ConjugatePrior<f64, Gaussian> for NormalGamma`[src]

`type Posterior = Self`

`fn posterior(&self, x: &DataOrSuffStat<f64, Gaussian>) -> Self`[src]

`fn ln_m(&self, x: &DataOrSuffStat<f64, Gaussian>) -> f64`[src]

`fn ln_pp(&self, y: &f64, x: &DataOrSuffStat<f64, Gaussian>) -> f64`[src]

`fn m(&self, x: &DataOrSuffStat<X, Fx>) -> f64`[src]

`fn pp(&self, y: &X, x: &DataOrSuffStat<X, Fx>) -> f64`[src]

`impl ContinuousDistr<Gaussian> for NormalGamma`[src]

`fn pdf(&self, x: &X) -> f64`[src]

`fn ln_pdf(&self, x: &X) -> f64`[src]

`impl ContinuousDistr<f32> for Gaussian`[src]

`fn pdf(&self, x: &X) -> f64`[src]

`fn ln_pdf(&self, x: &X) -> f64`[src]

`impl ContinuousDistr<f64> for Gaussian`[src]

`fn pdf(&self, x: &X) -> f64`[src]

`fn ln_pdf(&self, x: &X) -> f64`[src]

`impl Debug for Gaussian`[src]

`fn fmt(&self, f: &mut Formatter) -> Result`[src]

`impl Default for Gaussian`[src]

`fn default() -> Self`[src]

`impl Display for Gaussian`[src]

`fn fmt(&self, f: &mut Formatter) -> Result`[src]

`impl Entropy for Gaussian`[src]

`fn entropy(&self) -> f64`[src]

`impl<'_> From<&'_ Gaussian> for String`[src]

`fn from(gauss: &Gaussian) -> String`[src]

`impl HasSuffStat<f32> for Gaussian`[src]

`type Stat = GaussianSuffStat`

`fn empty_suffstat(&self) -> Self::Stat`[src]

`impl HasSuffStat<f64> for Gaussian`[src]

`type Stat = GaussianSuffStat`

`fn empty_suffstat(&self) -> Self::Stat`[src]

`impl InverseCdf<f32> for Gaussian`[src]

`fn invcdf(&self, p: f64) -> f32`[src]

`fn quantile(&self, p: f64) -> X`[src]

`fn interval(&self, p: f64) -> (X, X)`[src]

`impl InverseCdf<f64> for Gaussian`[src]

`fn invcdf(&self, p: f64) -> f64`[src]

`fn quantile(&self, p: f64) -> X`[src]

`fn interval(&self, p: f64) -> (X, X)`[src]

`impl KlDivergence for Gaussian`[src]

`fn kl(&self, other: &Self) -> f64`[src]

`fn kl_sym(&self, other: &Self) -> f64`[src]

`impl Kurtosis for Gaussian`[src]

`fn kurtosis(&self) -> Option<f64>`[src]

`impl Mean<f32> for Gaussian`[src]

`fn mean(&self) -> Option<f32>`[src]

`impl Mean<f64> for Gaussian`[src]

`fn mean(&self) -> Option<f64>`[src]

`impl Median<f32> for Gaussian`[src]

`fn median(&self) -> Option<f32>`[src]

`impl Median<f64> for Gaussian`[src]

`fn median(&self) -> Option<f64>`[src]

`impl Mode<f32> for Gaussian`[src]

`fn mode(&self) -> Option<f32>`[src]

`impl Mode<f64> for Gaussian`[src]

`fn mode(&self) -> Option<f64>`[src]

`impl PartialEq<Gaussian> for Gaussian`[src]

`fn eq(&self, other: &Gaussian) -> bool`[src]

`#[must_use]fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

`impl QuadBounds for Gaussian`[src]

`fn quad_bounds(&self) -> (f64, f64)`[src]

`impl Rv<Gaussian> for NormalGamma`[src]

`fn ln_f(&self, x: &Gaussian) -> f64`[src]

`fn draw<R: Rng>(&self, rng: &mut R) -> Gaussian`[src]

`fn f(&self, x: &X) -> f64`[src]

`fn sample<R: Rng>(&self, n: usize, rng: &mut R) -> Vec<X>`[src]

`fn sample_stream<'r, R: Rng>( &'r self, rng: &'r mut R ) -> Box<dyn Iterator<Item = X> + 'r>`[src]

`impl Rv<f32> for Gaussian`[src]

`fn ln_f(&self, x: &f32) -> f64`[src]

`fn draw<R: Rng>(&self, rng: &mut R) -> f32`[src]

`fn sample<R: Rng>(&self, n: usize, rng: &mut R) -> Vec<f32>`[src]

`fn f(&self, x: &X) -> f64`[src]

`fn sample_stream<'r, R: Rng>( &'r self, rng: &'r mut R ) -> Box<dyn Iterator<Item = X> + 'r>`[src]

`impl Rv<f64> for Gaussian`[src]

`fn ln_f(&self, x: &f64) -> f64`[src]

`fn draw<R: Rng>(&self, rng: &mut R) -> f64`[src]

`fn sample<R: Rng>(&self, n: usize, rng: &mut R) -> Vec<f64>`[src]

`fn f(&self, x: &X) -> f64`[src]

`fn sample_stream<'r, R: Rng>( &'r self, rng: &'r mut R ) -> Box<dyn Iterator<Item = X> + 'r>`[src]

`impl Skewness for Gaussian`[src]

`fn skewness(&self) -> Option<f64>`[src]

`impl Support<Gaussian> for NormalGamma`[src]

`fn supports(&self, x: &Gaussian) -> bool`[src]

`impl Support<f32> for Gaussian`[src]

`fn supports(&self, x: &f32) -> bool`[src]

`impl Support<f64> for Gaussian`[src]

`fn supports(&self, x: &f64) -> bool`[src]

`impl Variance<f64> for Gaussian`[src]

`fn variance(&self) -> Option<f64>`[src]

Auto Trait Implementations

`impl RefUnwindSafe for Gaussian`

`impl Send for Gaussian`

`impl Sync for Gaussian`

`impl Unpin for Gaussian`

`impl UnwindSafe for Gaussian`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<Fx, X> Cdf<X> for Fx where Fx: Deref, <Fx as Deref>::Target: Cdf<X>,` [src]

`fn cdf(&Self, &X) -> f64`[src]

`fn sf(&Self, &X) -> f64`[src]

`impl<Fx, X> ContinuousDistr<X> for Fx where Fx: Deref, <Fx as Deref>::Target: ContinuousDistr<X>,` [src]

`fn pdf(&self, x: &X) -> f64`[src]

`fn ln_pdf(&self, x: &X) -> f64`[src]

`impl<Fx> Entropy for Fx where Fx: Deref, <Fx as Deref>::Target: Entropy,` [src]

`fn entropy(&Self) -> f64`[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<Fx, X> HasSuffStat<X> for Fx where Fx: Deref, <Fx as Deref>::Target: HasSuffStat<X>,` [src]

`type Stat = <<Fx as Deref>::Target as HasSuffStat<X>>::Stat`

`fn empty_suffstat(&Self) -> <Fx as HasSuffStat<X>>::Stat`[src]

`impl<T, U> Into<U> for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<Fx, X> InverseCdf<X> for Fx where Fx: Deref, <Fx as Deref>::Target: InverseCdf<X>,` [src]

`fn invcdf(&Self, f64) -> X`[src]

`fn quantile(&Self, f64) -> X`[src]

`fn interval(&Self, f64) -> (X, X)`[src]

`impl<Fx> KlDivergence for Fx where Fx: Deref, <Fx as Deref>::Target: KlDivergence,` [src]

`fn kl(&Self, &Fx) -> f64`[src]

`fn kl_sym(&Self, &Fx) -> f64`[src]

`impl<Fx> Kurtosis for Fx where Fx: Deref, <Fx as Deref>::Target: Kurtosis,` [src]

`fn kurtosis(&Self) -> Option<f64>`[src]

`impl<Fx, X> Mean<X> for Fx where Fx: Deref, <Fx as Deref>::Target: Mean<X>,` [src]

`fn mean(&Self) -> Option<X>`[src]

`impl<Fx, X> Median<X> for Fx where Fx: Deref, <Fx as Deref>::Target: Median<X>,` [src]

`fn median(&Self) -> Option<X>`[src]

`impl<Fx, X> Mode<X> for Fx where Fx: Deref, <Fx as Deref>::Target: Mode<X>,` [src]

`fn mode(&Self) -> Option<X>`[src]

`impl<Fx, X> Rv<X> for Fx where Fx: Deref, <Fx as Deref>::Target: Rv<X>,` [src]

`fn ln_f(&Self, &X) -> f64`[src]

`fn f(&Self, &X) -> f64`[src]

`fn draw<R>(&Self, &mut R) -> X where R: Rng,` [src]

`fn sample<R>(&Self, usize, &mut R) -> Vec<X> where R: Rng,` [src]

`fn sample_stream<'r, R: Rng>( &'r self, rng: &'r mut R ) -> Box<dyn Iterator<Item = X> + 'r>`[src]

`impl<T> Same<T> for T`

`type Output = T`

Should always be Self

`impl<Fx> Skewness for Fx where Fx: Deref, <Fx as Deref>::Target: Skewness,` [src]

`fn skewness(&Self) -> Option<f64>`[src]

`impl<SS, SP> SupersetOf<SS> for SP where SS: SubsetOf<SP>,`

`fn to_subset(&self) -> Option<SS>`

`fn is_in_subset(&self) -> bool`

`unsafe fn to_subset_unchecked(&self) -> SS`

`fn from_subset(element: &SS) -> SP`

`impl<Fx, X> Support<X> for Fx where Fx: Deref, <Fx as Deref>::Target: Support<X>,` [src]

`fn supports(&Self, &X) -> bool`[src]

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`fn to_owned(&self) -> T`[src]

`fn clone_into(&self, target: &mut T)`[src]

`impl<T> ToString for T where T: Display + ?Sized,` [src]

`default fn to_string(&self) -> String`[src]

`impl<T, U> TryFrom<U> for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

`impl<T, U> TryInto<U> for T where U: TryFrom<T>,` [src]

`type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

`impl<V, T> VZip<V> for T where V: MultiLane<T>,`

`fn vzip(self) -> V`

`impl<Fx, X> Variance<X> for Fx where Fx: Deref, <Fx as Deref>::Target: Variance<X>,` [src]

`fn variance(&Self) -> Option<X>`[src]