Struct rv::dist::Bernoulli

pub struct Bernoulli { /* fields omitted */ }

Bernoulli distribution with success probability p

Example

let b = Bernoulli::new(0.75).unwrap();
assert::close(b.pmf(&true), 0.75, 1E-12);

The following example panics because 2 is out of outside the Bernoulli support

let b = Bernoulli::new(0.75).unwrap();
assert!(!b.supports(&2_u8));

b.pmf(&2_u8); // panics

Implementations

impl Bernoulli

pub fn new(p: f64) -> Result<Self, BernoulliError>

Create a new Bernoulli distribution.

Examples

let b = Bernoulli::new(0.5).unwrap();

let coin_flips: Vec<bool> = b.sample(5, &mut rng);

assert_eq!(coin_flips.len(), 5);

Bernoulli::new will return an Error type if given an invalid paramter.

assert!(Bernoulli::new(-1.0).is_err());
assert!(Bernoulli::new(1.1).is_err());

pub fn new_unchecked(p: f64) -> Self

Creates a new Bernoulli without checking whether parameter value is valid.

pub fn uniform() -> Self

A Bernoulli distribution with a 50% chance of success

Example

let b = Bernoulli::uniform();

assert_eq!(b.p(), 0.5);
assert_eq!(b.q(), 0.5);

pub fn p(&self) -> f64

Get p, the probability of success.

Example

let b = Bernoulli::new(0.2).unwrap();

assert_eq!(b.p(), 0.2);

pub fn set_p(&mut self, p: f64) -> Result<(), BernoulliError>

Set p, the probability of success.

Example

let mut b = Bernoulli::new(0.2).unwrap();
b.set_p(0.5).unwrap();

assert_eq!(b.p(), 0.5);

Will error for invalid values

assert!(b.set_p(0.0).is_ok());
assert!(b.set_p(1.0).is_ok());
assert!(b.set_p(-1.0).is_err());
assert!(b.set_p(1.1).is_err());
assert!(b.set_p(std::f64::INFINITY).is_err());
assert!(b.set_p(std::f64::NEG_INFINITY).is_err());
assert!(b.set_p(std::f64::NAN).is_err());

pub fn set_p_unchecked(&mut self, p: f64)

Set p without input validation

pub fn q(&self) -> f64

The complement of p, i.e. (1 - p).

Example

let b = Bernoulli::new(0.2).unwrap();

assert_eq!(b.q(), 0.8);

Trait Implementations

impl<X: Booleable> Cdf<X> for Bernoulli

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

The value of the Cumulative Density Function at x

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

Survival function, 1 - CDF(x)

impl Clone for Bernoulli

fn clone(&self) -> Bernoulli

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<X: Booleable> ConjugatePrior<X, Bernoulli> for Beta

type Posterior = Self

Type of the posterior distribution

type LnMCache = f64

Type of the ln_m cache

type LnPpCache = (f64, f64)

Type of the ln_pp cache

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

Computes the posterior distribution from the data

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

Compute the cache for the log marginal likelihood.

fn ln_m_with_cache(
    &self,
    cache: &Self::LnMCache,
    x: &DataOrSuffStat<'_, X, Bernoulli>
) -> f64

Log marginal likelihood with supplied cache.

fn ln_pp_cache(&self, x: &DataOrSuffStat<'_, X, Bernoulli>) -> Self::LnPpCache

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

fn ln_pp_with_cache(&self, cache: &Self::LnPpCache, y: &X) -> 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<Bernoulli> for Beta

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 Bernoulli

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

Formats the value using the given formatter.

impl Default for Bernoulli

fn default() -> Self

Returns the “default value” for a type.

impl<X: Booleable> DiscreteDistr<X> for Bernoulli

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 Bernoulli

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

Formats the value using the given formatter.

impl Entropy for Bernoulli

fn entropy(&self) -> f64

The entropy, H(X)

impl<X: Booleable> HasSuffStat<X> for Bernoulli

type Stat = BernoulliSuffStat

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

impl KlDivergence for Bernoulli

fn kl(&self, other: &Self) -> 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 Bernoulli

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

impl Mean<f64> for Bernoulli

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

Returns None if the mean is undefined

impl Median<f64> for Bernoulli

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

Returns None if the median is undefined

impl<X: Booleable> Mode<X> for Bernoulli

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

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

impl PartialEq<Bernoulli> for Bernoulli

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

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

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

This method tests for !=.

impl PartialOrd<Bernoulli> for Bernoulli

fn partial_cmp(&self, other: &Bernoulli) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]

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

This method tests less than (for self and other) and is used by the < operator.

#[must_use]

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]

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

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Rv<Bernoulli> for Beta

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

Probability function

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

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<X: Booleable> Rv<X> for Bernoulli

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

Probability function

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

Probability function

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

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 Skewness for Bernoulli

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

impl StructuralPartialEq for Bernoulli

impl Support<Bernoulli> for Beta

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

Returns true if x is in the support of the Rv

impl<X: Booleable> Support<X> for Bernoulli

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

Returns true if x is in the support of the Rv

impl Variance<f64> for Bernoulli

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

Returns None if the variance is undefined