Struct Poisson 

pub struct Poisson { /* private fields */ }

Possion distribution over x in {0, 1, … }.

Example

use rv::prelude::*;

// Create Poisson(λ=5.3)
let pois = Poisson::new(5.3).unwrap();

// CDF at 5
assert!((pois.cdf(&5_u16) - 0.56347339228807169).abs() < 1E-12);

// Draw 100 samples
let mut rng = rand::thread_rng();
let xs: Vec<u32> = pois.sample(100, &mut rng);
assert_eq!(xs.len(), 100)

The Poisson can have two modes. The modes are distinct only if the rate is an integer.

{
    let pois = Poisson::new(2.0).unwrap();
    let modes: (u32, u32) = pois.mode().unwrap();

    assert_eq!(modes, (1, 2))
}

{
    let pois = Poisson::new(2.1).unwrap();
    let modes: (u32, u32) = pois.mode().unwrap();

    assert_eq!(modes, (2, 2))
}

If we know that the rate is not an integer, or we only care about one of the modes, we can call mode for an unsigned type, which will return the leftmost (lowest) mode.

let pois = Poisson::new(2.1).unwrap();
let mode: u32 = pois.mode().unwrap();

assert_eq!(mode, 2)

Implementations

impl Poisson

pub fn new(rate: f64) -> Result<Poisson, PoissonError>

Create a new Poisson distribution with given rate

pub fn new_unchecked(rate: f64) -> Poisson

Creates a new Poisson without checking whether the parameter is valid.

pub fn rate(&self) -> f64

Get the rate parameter

Example

let pois = Poisson::new(2.0).unwrap();
assert_eq!(pois.rate(), 2.0);

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

Set the rate parameter

Example

use rv::dist::Poisson;
let mut pois = Poisson::new(1.0).unwrap();
assert_eq!(pois.rate(), 1.0);

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

Will error for invalid values

assert!(pois.set_rate(1.1).is_ok());
assert!(pois.set_rate(0.0).is_err());
assert!(pois.set_rate(-1.0).is_err());
assert!(pois.set_rate(std::f64::INFINITY).is_err());
assert!(pois.set_rate(std::f64::NEG_INFINITY).is_err());
assert!(pois.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<u16> for Poisson

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

The value of the Cumulative Density Function at x

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

Survival function, 1 - CDF(x)

impl Cdf<u32> for Poisson

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

The value of the Cumulative Density Function at x

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

Survival function, 1 - CDF(x)

impl Cdf<u8> for Poisson

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

The value of the Cumulative Density Function at x

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

Survival function, 1 - CDF(x)

impl Cdf<usize> for Poisson

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

The value of the Cumulative Density Function at x

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

Survival function, 1 - CDF(x)

impl Clone for Poisson

fn clone(&self) -> Poisson

Returns a duplicate 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>) -> Gamma

Computes the posterior distribution from the data

fn ln_m_cache(&self) -> <Gamma as ConjugatePrior<u16, Poisson>>::LnMCache

Compute the cache for the log marginal likelihood.

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

Log marginal likelihood with supplied cache.

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

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

fn ln_pp_with_cache( &self, cache: &<Gamma as ConjugatePrior<u16, Poisson>>::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>) -> Gamma

Computes the posterior distribution from the data

fn ln_m_cache(&self) -> <Gamma as ConjugatePrior<u32, Poisson>>::LnMCache

Compute the cache for the log marginal likelihood.

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

Log marginal likelihood with supplied cache.

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

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

fn ln_pp_with_cache( &self, cache: &<Gamma as ConjugatePrior<u32, Poisson>>::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>) -> Gamma

Computes the posterior distribution from the data

fn ln_m_cache(&self) -> <Gamma as ConjugatePrior<u8, Poisson>>::LnMCache

Compute the cache for the log marginal likelihood.

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

Log marginal likelihood with supplied cache.

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

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

fn ln_pp_with_cache( &self, cache: &<Gamma as ConjugatePrior<u8, Poisson>>::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 Debug for Poisson

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

Formats the value using the given formatter.

impl DiscreteDistr<u16> for Poisson

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

Probability mass function (PMF) at x

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

Natural logarithm of the probability mass function (PMF)

impl DiscreteDistr<u32> for Poisson

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

Probability mass function (PMF) at x

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

Natural logarithm of the probability mass function (PMF)

impl DiscreteDistr<u8> for Poisson

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

Probability mass function (PMF) at x

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

Natural logarithm of the probability mass function (PMF)

impl DiscreteDistr<usize> for Poisson

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

Probability mass function (PMF) at x

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

Natural logarithm of the probability mass function (PMF)

impl Display for Poisson

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

Formats the value using the given formatter.

impl Entropy for Poisson

fn entropy(&self) -> f64

The entropy, H(X)

impl HasSuffStat<u16> for Poisson

type Stat = PoissonSuffStat

fn empty_suffstat(&self) -> <Poisson as HasSuffStat<u16>>::Stat

fn ln_f_stat(&self, stat: &<Poisson as HasSuffStat<u16>>::Stat) -> f64

Return the log likelihood for the data represented by the sufficient statistic.

impl HasSuffStat<u32> for Poisson

type Stat = PoissonSuffStat

fn empty_suffstat(&self) -> <Poisson as HasSuffStat<u32>>::Stat

fn ln_f_stat(&self, stat: &<Poisson as HasSuffStat<u32>>::Stat) -> f64

Return the log likelihood for the data represented by the sufficient statistic.

impl HasSuffStat<u8> for Poisson

type Stat = PoissonSuffStat

fn empty_suffstat(&self) -> <Poisson as HasSuffStat<u8>>::Stat

fn ln_f_stat(&self, stat: &<Poisson as HasSuffStat<u8>>::Stat) -> f64

Return the log likelihood for the data represented by the sufficient statistic.

impl HasSuffStat<usize> for Poisson

type Stat = PoissonSuffStat

fn empty_suffstat(&self) -> <Poisson as HasSuffStat<usize>>::Stat

fn ln_f_stat(&self, stat: &<Poisson as HasSuffStat<usize>>::Stat) -> f64

Return the log likelihood for the data represented by the sufficient statistic.

impl KlDivergence for Poisson

fn kl(&self, other: &Poisson) -> f64

The KL divergence, KL(P|Q) between this distribution, P, and another, Q

fn kl_sym(&self, other: &Self) -> f64

Symmetrised divergence, KL(P|Q) + KL(Q|P)

impl Kurtosis for Poisson

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

impl Mean<f64> for Poisson

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

Returns None if the mean is undefined

impl Mode<(u16, u16)> for Poisson

fn mode(&self) -> Option<(u16, u16)>

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

impl Mode<(u32, u32)> for Poisson

fn mode(&self) -> Option<(u32, u32)>

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

impl Mode<(u8, u8)> for Poisson

fn mode(&self) -> Option<(u8, u8)>

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

impl Mode<(usize, usize)> for Poisson

fn mode(&self) -> Option<(usize, usize)>

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

impl Mode<u16> for Poisson

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

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

impl Mode<u32> for Poisson

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

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

impl Mode<u8> for Poisson

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

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

impl Mode<usize> for Poisson

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

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

impl PartialEq for Poisson

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

Tests for self and other values to be equal, and is used by ==.

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

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>(&self, rng: &mut R) -> Poisson

where R: Rng,

Single draw from the Rv

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

Probability function

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

where R: Rng,

Multiple draws of the Rv

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

where R: Rng,

Create a never-ending iterator of samples

impl Rv<u16> for Poisson

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

Probability function

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

where R: Rng,

Single draw from the Rv

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

where R: Rng,

Multiple draws of the Rv

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

Probability function

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

where R: Rng,

Create a never-ending iterator of samples

impl Rv<u32> for Poisson

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

Probability function

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

where R: Rng,

Single draw from the Rv

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

where R: Rng,

Multiple draws of the Rv

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

Probability function

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

where R: Rng,

Create a never-ending iterator of samples

impl Rv<u8> for Poisson

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

Probability function

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

where R: Rng,

Single draw from the Rv

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

where R: Rng,

Multiple draws of the Rv

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

Probability function

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

where R: Rng,

Create a never-ending iterator of samples

impl Rv<usize> for Poisson

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

Probability function

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

where R: Rng,

Single draw from the Rv

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

where R: Rng,

Multiple draws of the Rv

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

Probability function

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

where R: Rng,

Create a never-ending iterator of samples

impl Skewness for Poisson

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<u16> for Poisson

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

Returns true if x is in the support of the Rv

impl Support<u32> for Poisson

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

Returns true if x is in the support of the Rv

impl Support<u8> for Poisson

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

Returns true if x is in the support of the Rv

impl Support<usize> for Poisson

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

Returns true if x is in the support of the Rv

impl Variance<f64> for Poisson

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

Returns None if the variance is undefined