Struct rv::dist::SymmetricDirichlet

pub struct SymmetricDirichlet { /* private fields */ }

Symmetric Dirichlet distribution where all alphas are the same.

SymmetricDirichlet { alpha, k } is mathematical equivalent to Dirichlet { alphas: vec![alpha; k] }. This version has some extra optimizations to seep up computing the PDF and drawing random vectors.

Implementations

impl SymmetricDirichlet

pub fn new(alpha: f64, k: usize) -> Result<Self, SymmetricDirichletError>

Create a new symmetric Dirichlet distribution

Arguments

• alpha: The Dirichlet weight.
• k : The number of weights. alpha will be replicated k times.

pub fn new_unchecked(alpha: f64, k: usize) -> Self

Create a new SymmetricDirichlet without checking whether the parameters are valid.

pub fn jeffreys(k: usize) -> Result<Self, SymmetricDirichletError>

The Jeffrey’s Dirichlet prior for Categorical distributions

Example

let symdir = SymmetricDirichlet::jeffreys(4).unwrap();
assert_eq!(symdir, SymmetricDirichlet::new(0.5, 4).unwrap());

pub fn alpha(&self) -> f64

Get the alpha uniform weight parameter

Example

let symdir = SymmetricDirichlet::new(1.2, 5).unwrap();
assert_eq!(symdir.alpha(), 1.2);

pub fn set_alpha(&mut self, alpha: f64) -> Result<(), SymmetricDirichletError>

Set the value of alpha

Example

let mut symdir = SymmetricDirichlet::new(1.1, 5).unwrap();
assert_eq!(symdir.alpha(), 1.1);

symdir.set_alpha(2.3).unwrap();
assert_eq!(symdir.alpha(), 2.3);

Will error for invalid parameters

assert!(symdir.set_alpha(0.5).is_ok());
assert!(symdir.set_alpha(0.0).is_err());
assert!(symdir.set_alpha(-1.0).is_err());
assert!(symdir.set_alpha(f64::INFINITY).is_err());
assert!(symdir.set_alpha(f64::NEG_INFINITY).is_err());
assert!(symdir.set_alpha(f64::NAN).is_err());

pub fn set_alpha_unchecked(&mut self, alpha: f64)

Set the value of alpha without input validation

pub fn k(&self) -> usize

Get the number of weights, k

Example

let symdir = SymmetricDirichlet::new(1.2, 5).unwrap();
assert_eq!(symdir.k(), 5);

Trait Implementations

impl Clone for SymmetricDirichlet

fn clone(&self) -> SymmetricDirichlet

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<X: CategoricalDatum> ConjugatePrior<X, Categorical> for SymmetricDirichlet

type Posterior = Dirichlet

Type of the posterior distribution

type MCache = f64

Type of the cache for the marginal likelihood

type PpCache = (Vec<f64>, f64)

Type of the cache for the posterior predictive

fn posterior(&self, x: &CategoricalData<'_, X>) -> Self::Posterior

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: &CategoricalData<'_, X>, ) -> f64

Log marginal likelihood with supplied cache.

fn ln_pp_cache(&self, x: &CategoricalData<'_, X>) -> Self::PpCache

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

fn ln_pp_with_cache(&self, cache: &Self::PpCache, y: &X) -> 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 ContinuousDistr<Vec<f64>> for SymmetricDirichlet

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 SymmetricDirichlet

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SymmetricDirichlet

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for SymmetricDirichlet

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

Formats the value using the given formatter.

impl From<&SymmetricDirichlet> for Dirichlet

fn from(symdir: &SymmetricDirichlet) -> Self

Converts to this type from the input type.

impl From<&SymmetricDirichlet> for String

fn from(symdir: &SymmetricDirichlet) -> String

Converts to this type from the input type.

impl From<SymmetricDirichlet> for Dirichlet

fn from(symdir: SymmetricDirichlet) -> Self

Converts to this type from the input type.

impl HasDensity<Categorical> for SymmetricDirichlet

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

Probability function

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

Probability function

impl HasDensity<Vec<f64>> for SymmetricDirichlet

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

Probability function

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

Probability function

impl Parameterized for SymmetricDirichlet

type Parameters = SymmetricDirichletParameters

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

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

impl PartialEq for SymmetricDirichlet

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<Categorical> for SymmetricDirichlet

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

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 Sampleable<Vec<f64>> for SymmetricDirichlet

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

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 SymmetricDirichlet

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Support<Vec<f64>> for SymmetricDirichlet

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

Returns true if x is in the support of the Rv