Struct rv::dist::Gamma

pub struct Gamma { /* private fields */ }

Gamma distribution G(α, β) over x in (0, ∞).

NOTE: The gamma distribution is parameterized in terms of shape, α, and rate, β.

            β^α
f(x|α, β) = ----  x^(α-1) e^(-βx)
            Γ(α)

Implementations

impl Gamma

pub fn new(shape: f64, rate: f64) -> Result<Self, GammaError>

Create a new Gamma distribution with shape (α) and rate (β).

pub fn new_unchecked(shape: f64, rate: f64) -> Self

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

pub fn shape(&self) -> f64

Get the shape parameter

Example

let gam = Gamma::new(2.0, 1.0).unwrap();
assert_eq!(gam.shape(), 2.0);

pub fn set_shape(&mut self, shape: f64) -> Result<(), GammaError>

Set the shape parameter

Example

let mut gam = Gamma::new(2.0, 1.0).unwrap();
assert_eq!(gam.shape(), 2.0);

gam.set_shape(1.1).unwrap();
assert_eq!(gam.shape(), 1.1);

Will error for invalid values

assert!(gam.set_shape(1.1).is_ok());
assert!(gam.set_shape(0.0).is_err());
assert!(gam.set_shape(-1.0).is_err());
assert!(gam.set_shape(std::f64::INFINITY).is_err());
assert!(gam.set_shape(std::f64::NEG_INFINITY).is_err());
assert!(gam.set_shape(std::f64::NAN).is_err());

pub fn set_shape_unchecked(&mut self, shape: f64)

Set the shape parameter without input validation

pub fn rate(&self) -> f64

Get the rate parameter

Example

let gam = Gamma::new(2.0, 1.0).unwrap();
assert_eq!(gam.rate(), 1.0);

pub fn set_rate(&mut self, rate: f64) -> Result<(), GammaError>

Set the rate parameter

Example

let mut gam = Gamma::new(2.0, 1.0).unwrap();
assert_eq!(gam.rate(), 1.0);

gam.set_rate(1.1).unwrap();
assert_eq!(gam.rate(), 1.1);

Will error for invalid values

assert!(gam.set_rate(1.1).is_ok());
assert!(gam.set_rate(0.0).is_err());
assert!(gam.set_rate(-1.0).is_err());
assert!(gam.set_rate(std::f64::INFINITY).is_err());
assert!(gam.set_rate(std::f64::NEG_INFINITY).is_err());
assert!(gam.set_rate(std::f64::NAN).is_err());

pub fn set_rate_unchecked(&mut self, rate: f64)

Set the rate parameter without input validation

Trait Implementations

impl Cdf<f32> for Gamma

fn cdf(&self, x: &f32) -> f64

The value of the Cumulative Density Function at x

fn sf(&self, x: &X) -> f64

Survival function, 1 - CDF(x)

impl Cdf<f64> for Gamma

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

The value of the Cumulative Density Function at x

fn sf(&self, x: &X) -> f64

Survival function, 1 - CDF(x)

impl Clone for Gamma

fn clone(&self) -> Gamma

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ConjugatePrior<u16, Poisson> for Gamma

type Posterior = Gamma

Type of the posterior distribution

type LnMCache = f64

Type of the ln_m cache

type LnPpCache = (f64, f64, f64)

Type of the ln_pp cache

fn posterior(&self, x: &DataOrSuffStat<'_, u16, Poisson>) -> Self

Computes the posterior distribution from the data

fn ln_m_cache(&self) -> Self::LnMCache

Compute the cache for the log marginal likelihood.

fn ln_m_with_cache( &self, cache: &Self::LnMCache, x: &DataOrSuffStat<'_, u16, Poisson> ) -> f64

Log marginal likelihood with supplied cache.

fn ln_pp_cache(&self, x: &DataOrSuffStat<'_, u16, Poisson>) -> Self::LnPpCache

Compute the cache for the Log posterior predictive of y given x.

fn ln_pp_with_cache(&self, cache: &Self::LnPpCache, y: &u16) -> f64

Log posterior predictive of y given x with supplied ln(norm)

fn ln_m(&self, x: &DataOrSuffStat<'_, X, Fx>) -> f64

The log marginal likelihood

fn ln_pp(&self, y: &X, x: &DataOrSuffStat<'_, X, Fx>) -> f64

Log posterior predictive of y given x

fn m(&self, x: &DataOrSuffStat<'_, X, Fx>) -> f64

Marginal likelihood of x

fn pp(&self, y: &X, x: &DataOrSuffStat<'_, X, Fx>) -> f64

Posterior Predictive distribution

impl ConjugatePrior<u32, Poisson> for Gamma

type Posterior = Gamma

Type of the posterior distribution

type LnMCache = f64

Type of the ln_m cache

type LnPpCache = (f64, f64, f64)

Type of the ln_pp cache

fn posterior(&self, x: &DataOrSuffStat<'_, u32, Poisson>) -> Self

Computes the posterior distribution from the data

fn ln_m_cache(&self) -> Self::LnMCache

Compute the cache for the log marginal likelihood.

fn ln_m_with_cache( &self, cache: &Self::LnMCache, x: &DataOrSuffStat<'_, u32, Poisson> ) -> f64

Log marginal likelihood with supplied cache.

fn ln_pp_cache(&self, x: &DataOrSuffStat<'_, u32, Poisson>) -> Self::LnPpCache

Compute the cache for the Log posterior predictive of y given x.

fn ln_pp_with_cache(&self, cache: &Self::LnPpCache, y: &u32) -> f64

Log posterior predictive of y given x with supplied ln(norm)

fn ln_m(&self, x: &DataOrSuffStat<'_, X, Fx>) -> f64

The log marginal likelihood

fn ln_pp(&self, y: &X, x: &DataOrSuffStat<'_, X, Fx>) -> f64

Log posterior predictive of y given x

fn m(&self, x: &DataOrSuffStat<'_, X, Fx>) -> f64

Marginal likelihood of x

fn pp(&self, y: &X, x: &DataOrSuffStat<'_, X, Fx>) -> f64

Posterior Predictive distribution

impl ConjugatePrior<u8, Poisson> for Gamma

type Posterior = Gamma

Type of the posterior distribution

type LnMCache = f64

Type of the ln_m cache

type LnPpCache = (f64, f64, f64)

Type of the ln_pp cache

fn posterior(&self, x: &DataOrSuffStat<'_, u8, Poisson>) -> Self

Computes the posterior distribution from the data

fn ln_m_cache(&self) -> Self::LnMCache

Compute the cache for the log marginal likelihood.

fn ln_m_with_cache( &self, cache: &Self::LnMCache, x: &DataOrSuffStat<'_, u8, Poisson> ) -> f64

Log marginal likelihood with supplied cache.

fn ln_pp_cache(&self, x: &DataOrSuffStat<'_, u8, Poisson>) -> Self::LnPpCache

Compute the cache for the Log posterior predictive of y given x.

fn ln_pp_with_cache(&self, cache: &Self::LnPpCache, y: &u8) -> f64

Log posterior predictive of y given x with supplied ln(norm)

fn ln_m(&self, x: &DataOrSuffStat<'_, X, Fx>) -> f64

The log marginal likelihood

fn ln_pp(&self, y: &X, x: &DataOrSuffStat<'_, X, Fx>) -> f64

Log posterior predictive of y given x

fn m(&self, x: &DataOrSuffStat<'_, X, Fx>) -> f64

Marginal likelihood of x

fn pp(&self, y: &X, x: &DataOrSuffStat<'_, X, Fx>) -> f64

Posterior Predictive distribution

impl ContinuousDistr<Poisson> for Gamma

fn pdf(&self, x: &X) -> f64

The value of the Probability Density Function (PDF) at x

fn ln_pdf(&self, x: &X) -> f64

The value of the log Probability Density Function (PDF) at x

impl ContinuousDistr<f32> for Gamma

fn pdf(&self, x: &X) -> f64

The value of the Probability Density Function (PDF) at x

fn ln_pdf(&self, x: &X) -> f64

The value of the log Probability Density Function (PDF) at x

impl ContinuousDistr<f64> for Gamma

fn pdf(&self, x: &X) -> f64

The value of the Probability Density Function (PDF) at x

fn ln_pdf(&self, x: &X) -> f64

The value of the log Probability Density Function (PDF) at x

impl Debug for Gamma

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

Formats the value using the given formatter.

impl Default for Gamma

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Gamma

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Gamma

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

Formats the value using the given formatter.

impl Entropy for Gamma

fn entropy(&self) -> f64

The entropy, H(X)

impl From<&Gamma> for String

fn from(gam: &Gamma) -> String

Converts to this type from the input type.

impl Kurtosis for Gamma

fn kurtosis(&self) -> Option<f64>

impl Mean<f32> for Gamma

fn mean(&self) -> Option<f32>

Returns None if the mean is undefined

impl Mean<f64> for Gamma

fn mean(&self) -> Option<f64>

Returns None if the mean is undefined

impl Mode<f32> for Gamma

fn mode(&self) -> Option<f32>

Returns None if the mode is undefined or is not a single value

impl Mode<f64> for Gamma

fn mode(&self) -> Option<f64>

Returns None if the mode is undefined or is not a single value

impl PartialEq<Gamma> for Gamma

fn eq(&self, other: &Gamma) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Rv<Poisson> for Gamma

fn ln_f(&self, x: &Poisson) -> f64

Probability function

fn draw<R: Rng>(&self, rng: &mut R) -> Poisson

Single draw from the Rv

fn f(&self, x: &X) -> f64

Probability function

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

Multiple draws of the Rv

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

Create a never-ending iterator of samples

impl Rv<f32> for Gamma

fn ln_f(&self, x: &f32) -> f64

Probability function

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

Single draw from the Rv

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

Multiple draws of the Rv

fn f(&self, x: &X) -> f64

Probability function

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

Create a never-ending iterator of samples

impl Rv<f64> for Gamma

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

Probability function

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

Single draw from the Rv

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

Multiple draws of the Rv

fn f(&self, x: &X) -> f64

Probability function

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

Create a never-ending iterator of samples

impl Serialize for Gamma

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Skewness for Gamma

fn skewness(&self) -> Option<f64>

impl Support<Poisson> for Gamma

fn supports(&self, x: &Poisson) -> bool

Returns true if x is in the support of the Rv

impl Support<f32> for Gamma

fn supports(&self, x: &f32) -> bool

Returns true if x is in the support of the Rv

impl Support<f64> for Gamma

fn supports(&self, x: &f64) -> bool

Returns true if x is in the support of the Rv

impl Variance<f64> for Gamma

fn variance(&self) -> Option<f64>

Returns None if the variance is undefined