Trait rv::traits::SuffStat

pub trait SuffStat<X> {
    fn n(&self) -> usize;
    fn observe(&mut self, x: &X);
    fn forget(&mut self, x: &X);

    fn observe_many(&mut self, xs: &[X]) { ... }
    fn forget_many(&mut self, xs: &[X]) { ... }
}

Is a sufficient statistic for a distribution.

Examples

Basic suffstat useage.

use rv::data::BernoulliSuffStat;
use rv::traits::SuffStat;

// Bernoulli sufficient statistics are the number of observations, n, and
// the number of successes, k.
let mut stat = BernoulliSuffStat::new();

assert!(stat.n() == 0 && stat.k() == 0);

stat.observe(&true);  // observe `true`
assert!(stat.n() == 1 && stat.k() == 1);

stat.observe(&false);  // observe `false`
assert!(stat.n() == 2 && stat.k() == 1);

stat.forget_many(&vec![false, true]);  // forget `true` and `false`
assert!(stat.n() == 0 && stat.k() == 0);

Conjugate analysis of coin flips using Bernoulli with a Beta prior on the success probability.

use rv::traits::SuffStat;
use rv::traits::ConjugatePrior;
use rv::data::BernoulliSuffStat;
use rv::dist::{Bernoulli, Beta};

let flips = vec![true, false, false];

// Pack the data into a sufficient statistic that holds the number of
// trials and the number of successes
let mut stat = BernoulliSuffStat::new();
stat.observe_many(&flips);

let prior = Beta::jeffreys();

// If we observe more false than true, the posterior predictive
// probability of true decreases.
let pp_no_obs = prior.pp(&true, &(&BernoulliSuffStat::new()).into());
let pp_obs = prior.pp(&true, &(&flips).into());

assert!(pp_obs < pp_no_obs);

Required methods

fn n(&self) -> usize

Returns the number of observations

fn observe(&mut self, x: &X)

Assimilate the datum x into the statistic

fn forget(&mut self, x: &X)

Remove the datum x from the statistic

Loading content...

Provided methods

fn observe_many(&mut self, xs: &[X])

Assimilate several observations

fn forget_many(&mut self, xs: &[X])

Forget several observations

Loading content...

Implementors

impl SuffStat<bool> for BernoulliSuffStat

fn n(&self) -> usize

fn observe(&mut self, x: &bool)

fn forget(&mut self, x: &bool)

impl SuffStat<f32> for GaussianSuffStat

fn n(&self) -> usize

fn observe(&mut self, x: &f32)

fn forget(&mut self, x: &f32)

impl SuffStat<f64> for GaussianSuffStat

fn n(&self) -> usize

fn observe(&mut self, x: &f64)

fn forget(&mut self, x: &f64)

impl SuffStat<u16> for PoissonSuffStat

fn n(&self) -> usize

fn observe(&mut self, x: &u16)

fn forget(&mut self, x: &u16)

impl SuffStat<u32> for PoissonSuffStat

fn n(&self) -> usize

fn observe(&mut self, x: &u32)

fn forget(&mut self, x: &u32)

impl SuffStat<u8> for PoissonSuffStat

fn n(&self) -> usize

fn observe(&mut self, x: &u8)

fn forget(&mut self, x: &u8)

impl SuffStat<Matrix<f64, Dynamic, U1, VecStorage<f64, Dynamic, U1>>> for MvGaussianSuffStat

fn n(&self) -> usize

fn observe(&mut self, x: &DVector<f64>)

fn forget(&mut self, x: &DVector<f64>)

impl<S, X> SuffStat<X> for S where
    S: DerefMut,
    S::Target: SuffStat<X>, 

fn n(&self) -> usize

fn observe(&mut self, x: &X)

fn forget(&mut self, x: &X)

fn observe_many(&mut self, xs: &[X])

fn forget_many(&mut self, xs: &[X])

impl<X, Fx, Pr> SuffStat<X> for ConjugateModel<X, Fx, Pr> where
    Fx: Rv<X> + HasSuffStat<X>,
    Pr: ConjugatePrior<X, Fx>, 

fn n(&self) -> usize

fn observe(&mut self, x: &X)

fn forget(&mut self, x: &X)

impl<X: Booleable> SuffStat<X> for BernoulliSuffStat

fn n(&self) -> usize

fn observe(&mut self, x: &X)

fn forget(&mut self, x: &X)

impl<X: CategoricalDatum> SuffStat<X> for CategoricalSuffStat

fn n(&self) -> usize

fn observe(&mut self, x: &X)

fn forget(&mut self, x: &X)

Loading content...