Struct rv::dist::NormalInvChiSquared

pub struct NormalInvChiSquared { /* private fields */ }

Prior for Gaussian

Given x ~ N(μ, σ), the Normal Inverse Chi Squared prior implies that μ ~ N(m, σ/√k) and σ² ~ ScaledInvChiSquared(v, s2).

Implementations

impl NormalInvChiSquared

pub fn new( m: f64, k: f64, v: f64, s2: f64, ) -> Result<Self, NormalInvChiSquaredError>

Create a new Normal Inverse Gamma distribution

Arguments

• m: The prior mean
• k: How strongly we believe the prior mean (in prior pseudo-observations)
• v: How strongly we believe the prior variance (in prior pseudo-observations)
• s2: The prior variance

pub fn new_unchecked(m: f64, k: f64, v: f64, s2: f64) -> Self

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

pub fn params(&self) -> (f64, f64, f64, f64)

Returns (m, k, v, s2)

pub fn m(&self) -> f64

Get the m parameter

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

Set the value of m

Example

use rv::dist::NormalInvChiSquared;

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

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

Will error for invalid values

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

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

Set the value of m without input validation

pub fn k(&self) -> f64

Get the k parameter

pub fn set_k(&mut self, k: f64) -> Result<(), NormalInvChiSquaredError>

Set the value of k

Example

use rv::dist::NormalInvChiSquared;

let mut nix = NormalInvChiSquared::new(0.0, 1.2, 2.3, 3.4).unwrap();
assert_eq!(nix.k(), 1.2);

nix.set_k(4.3).unwrap();
assert_eq!(nix.k(), 4.3);

Will error for invalid values

assert!(nix.set_k(2.1).is_ok());

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


assert!(nix.set_k(f64::INFINITY).is_err());
assert!(nix.set_k(f64::NEG_INFINITY).is_err());
assert!(nix.set_k(f64::NAN).is_err());

pub fn set_k_unchecked(&mut self, k: f64)

Set the value of k without input validation

pub fn v(&self) -> f64

Get the v parameter

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

Set the value of v

Example

use rv::dist::NormalInvChiSquared;

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

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

Will error for invalid values

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

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


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

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

Set the value of v without input validation

pub fn s2(&self) -> f64

Get the s2 parameter

pub fn set_s2(&mut self, s2: f64) -> Result<(), NormalInvChiSquaredError>

Set the value of s2

Example

use rv::dist::NormalInvChiSquared;

let mut nix = NormalInvChiSquared::new(0.0, 1.2, 2.3, 3.4).unwrap();
assert_eq!(nix.s2(), 3.4);

nix.set_s2(4.3).unwrap();
assert_eq!(nix.s2(), 4.3);

Will error for invalid values

assert!(nix.set_s2(2.1).is_ok());

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


assert!(nix.set_s2(f64::INFINITY).is_err());
assert!(nix.set_s2(f64::NEG_INFINITY).is_err());
assert!(nix.set_s2(f64::NAN).is_err());

pub fn set_s2_unchecked(&mut self, s2: f64)

Set the value of s2 without input validation

pub fn scaled_inv_x2(&self) -> &ScaledInvChiSquared

pub fn ln_z(&self) -> f64

Trait Implementations

impl Clone for NormalInvChiSquared

fn clone(&self) -> NormalInvChiSquared

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ConjugatePrior<f64, Gaussian> for NormalInvChiSquared

type Posterior = NormalInvChiSquared

Type of the posterior distribution

type MCache = f64

Type of the cache for the marginal likelihood

type PpCache = (GaussianSuffStat, f64)

Type of the cache for the posterior predictive

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

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

Compute the cache for the log marginal likelihood.

fn ln_m_with_cache( &self, cache: &Self::MCache, x: &DataOrSuffStat<'_, f64, Gaussian>, ) -> f64

Log marginal likelihood with supplied cache.

fn ln_pp_cache(&self, x: &DataOrSuffStat<'_, f64, Gaussian>) -> Self::PpCache

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

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

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

fn posterior_from_suffstat(&self, stat: &Fx::Stat) -> Self::Posterior

Computes the posterior distribution from the data

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_with_cache(&self, cache: &Self::PpCache, y: &X) -> f64

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

Posterior Predictive distribution

impl Debug for NormalInvChiSquared

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NormalInvChiSquared

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for NormalInvChiSquared

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

Formats the value using the given formatter.

impl From<&NormalInvChiSquared> for String

fn from(nix: &NormalInvChiSquared) -> String

Converts to this type from the input type.

impl GewekeTestable<Gaussian, f64> for NormalInvChiSquared

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

fn update_params<R: Rng>(&self, data: &[f64], rng: &mut R) -> Gaussian

fn geweke_stats(&self, fx: &Gaussian, xs: &[f64]) -> BTreeMap<String, f64>

impl HasDensity<Gaussian> for NormalInvChiSquared

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

Probability function

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

Probability function

impl Parameterized for NormalInvChiSquared

type Parameters = NormalInvChiSquaredParameters

fn emit_params(&self) -> Self::Parameters

fn from_params(params: Self::Parameters) -> Self

impl PartialEq for NormalInvChiSquared

fn eq(&self, other: &Self) -> 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 Sampleable<Gaussian> for NormalInvChiSquared

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

Single draw from the Rv

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 Serialize for NormalInvChiSquared

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

where __S: Serializer,

Serialize this value into the given Serde serializer.