Struct rv::dist::NormalGamma

pub struct NormalGamma { /* fields omitted */ }

Prior for Gaussian

Given x ~ N(μ, σ), the Normal Gamma prior implies that μ ~ N(m, 1/(rρ)) and ρ ~ Gamma(ν/2, s/2).

Implementations

impl NormalGamma

pub fn new(m: f64, r: f64, s: f64, v: f64) -> Result<Self, NormalGammaError>

Create a new Normal Gamma distribution

Arguments

• m: The prior mean
• r: Relative precision of μ versus data
• s: The mean of rho (the precision) is v/s.
• v: Degrees of freedom of precision of rho

pub fn new_unchecked(m: f64, r: f64, s: f64, v: f64) -> Self

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

pub fn m(&self) -> f64

Get the m parameter

pub fn set_m(&mut self, m: f64) -> Result<(), NormalGammaError>

Set the value of m

Example

use rv::dist::NormalGamma;

let mut ng = NormalGamma::new(0.0, 1.2, 2.3, 3.4).unwrap();
assert_eq!(ng.m(), 0.0);

ng.set_m(-1.1).unwrap();
assert_eq!(ng.m(), -1.1);

Will error for invalid values

assert!(ng.set_m(-1.1).is_ok());
assert!(ng.set_m(std::f64::INFINITY).is_err());
assert!(ng.set_m(std::f64::NEG_INFINITY).is_err());
assert!(ng.set_m(std::f64::NAN).is_err());

pub fn set_m_unchecked(&mut self, m: f64)

Set the value of m without input validation

pub fn r(&self) -> f64

Get the r parameter

pub fn set_r(&mut self, r: f64) -> Result<(), NormalGammaError>

Set the value of r

Example

use rv::dist::NormalGamma;

let mut ng = NormalGamma::new(0.0, 1.2, 2.3, 3.4).unwrap();
assert_eq!(ng.r(), 1.2);

ng.set_r(2.1).unwrap();
assert_eq!(ng.r(), 2.1);

Will error for invalid values

assert!(ng.set_r(2.1).is_ok());

// must be greater than zero
assert!(ng.set_r(0.0).is_err());
assert!(ng.set_r(-1.0).is_err());


assert!(ng.set_r(std::f64::INFINITY).is_err());
assert!(ng.set_r(std::f64::NEG_INFINITY).is_err());
assert!(ng.set_r(std::f64::NAN).is_err());

pub fn set_r_unchecked(&mut self, r: f64)

Set the value of r without input validation

pub fn s(&self) -> f64

Get the s parameter

pub fn set_s(&mut self, s: f64) -> Result<(), NormalGammaError>

Set the value of s

Example

use rv::dist::NormalGamma;

let mut ng = NormalGamma::new(0.0, 1.2, 2.3, 3.4).unwrap();
assert_eq!(ng.s(), 2.3);

ng.set_s(3.2).unwrap();
assert_eq!(ng.s(), 3.2);

Will error for invalid values

assert!(ng.set_s(2.1).is_ok());

// must be greater than zero
assert!(ng.set_s(0.0).is_err());
assert!(ng.set_s(-1.0).is_err());


assert!(ng.set_s(std::f64::INFINITY).is_err());
assert!(ng.set_s(std::f64::NEG_INFINITY).is_err());
assert!(ng.set_s(std::f64::NAN).is_err());

pub fn set_s_unchecked(&mut self, s: f64)

Set the value of s without input validation

pub fn v(&self) -> f64

Get the v parameter

pub fn set_v(&mut self, v: f64) -> Result<(), NormalGammaError>

Set the value of v

Example

use rv::dist::NormalGamma;

let mut ng = NormalGamma::new(0.0, 1.2, 2.3, 3.4).unwrap();
assert_eq!(ng.v(), 3.4);

ng.set_v(4.3).unwrap();
assert_eq!(ng.v(), 4.3);

Will error for invalid values

assert!(ng.set_v(2.1).is_ok());

// must be greater than zero
assert!(ng.set_v(0.0).is_err());
assert!(ng.set_v(-1.0).is_err());


assert!(ng.set_v(std::f64::INFINITY).is_err());
assert!(ng.set_v(std::f64::NEG_INFINITY).is_err());
assert!(ng.set_v(std::f64::NAN).is_err());

pub fn set_v_unchecked(&mut self, v: f64)

Set the value of v without input validation

Trait Implementations

impl Clone for NormalGamma

fn clone(&self) -> NormalGamma

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ConjugatePrior<f64, Gaussian> for NormalGamma

type Posterior = Self

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

Computes the posterior distribution from the data

fn ln_m(&self, x: &DataOrSuffStat<f64, Gaussian>) -> f64

Log marginal likelihood

fn ln_pp(&self, y: &f64, x: &DataOrSuffStat<f64, Gaussian>) -> 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<Gaussian> for NormalGamma

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 NormalGamma

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

Formats the value using the given formatter.

impl Display for NormalGamma

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

Formats the value using the given formatter.

impl<'_> From<&'_ NormalGamma> for String

fn from(ng: &NormalGamma) -> String

Performs the conversion.

impl HasSuffStat<f64> for NormalGamma

type Stat = GaussianSuffStat

fn empty_suffstat(&self) -> Self::Stat

impl PartialEq<NormalGamma> for NormalGamma

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

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

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

This method tests for !=.

impl Rv<Gaussian> for NormalGamma

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

Probability function

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

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 StructuralPartialEq for NormalGamma

impl Support<Gaussian> for NormalGamma

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

Returns true if x is in the support of the Rv