Struct rv::dist::Beta

pub struct Beta { /* fields omitted */ }

Beta distribution, Beta(α, β) over x in (0, 1).

Examples

Beta as a conjugate prior for Bernoulli

use rv::prelude::*;

// A prior that encodes our strong belief that coins are fair:
let beta = Beta::new(5.0, 5.0).unwrap();

// The posterior predictive probability that a coin will come up heads given
// no new observations.
let p_prior_heads = beta.pp(&true, &DataOrSuffStat::None); // 0.5
assert!((p_prior_heads - 0.5).abs() < 1E-12);

// Five Bernoulli trials. We flipped a coin five times and it came up head
// four times.
let flips = vec![true, true, false, true, true];

// The posterior predictive probability that a coin will come up heads given
// the five flips we just saw.
let p_pred_heads = beta.pp(&true, &DataOrSuffStat::Data(&flips)); // 9/15
assert!((p_pred_heads - 3.0/5.0).abs() < 1E-12);

Implementations

impl Beta

pub fn new(alpha: f64, beta: f64) -> Result<Self, BetaError>

Create a Beta distribution with even density over (0, 1).

Example

// Uniform
let beta_unif = Beta::new(1.0, 1.0);
assert!(beta_unif.is_ok());

// Jefferey's prior
let beta_jeff  = Beta::new(0.5, 0.5);
assert!(beta_jeff.is_ok());

// Invalid negative parameter
let beta_nope  = Beta::new(-5.0, 1.0);
assert!(beta_nope.is_err());

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

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

pub fn uniform() -> Self

Create a Beta distribution with even density over (0, 1).

Example

let beta = Beta::uniform();
assert_eq!(beta, Beta::new(1.0, 1.0).unwrap());

pub fn jeffreys() -> Self

Create a Beta distribution with the Jeffrey’s parameterization, Beta(0.5, 0.5).

Example

let beta = Beta::jeffreys();
assert_eq!(beta, Beta::new(0.5, 0.5).unwrap());

pub fn alpha(&self) -> f64

Get the alpha parameter

Example

let beta = Beta::new(1.0, 5.0).unwrap();
assert_eq!(beta.alpha(), 1.0);

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

Set the alpha parameter

Example

let mut beta = Beta::new(1.0, 5.0).unwrap();

beta.set_alpha(2.0).unwrap();
assert_eq!(beta.alpha(), 2.0);

Will error for invalid values

assert!(beta.set_alpha(0.1).is_ok());
assert!(beta.set_alpha(0.0).is_err());
assert!(beta.set_alpha(-1.0).is_err());
assert!(beta.set_alpha(std::f64::INFINITY).is_err());
assert!(beta.set_alpha(std::f64::NAN).is_err());

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

Set alpha without input validation

pub fn beta(&self) -> f64

Get the beta parameter

Example

let beta = Beta::new(1.0, 5.0).unwrap();
assert_eq!(beta.beta(), 5.0);

pub fn set_beta(&mut self, beta: f64) -> Result<(), BetaError>

Set the beta parameter

Example

let mut beta = Beta::new(1.0, 5.0).unwrap();

beta.set_beta(2.0).unwrap();
assert_eq!(beta.beta(), 2.0);

Will error for invalid values

assert!(beta.set_beta(0.1).is_ok());
assert!(beta.set_beta(0.0).is_err());
assert!(beta.set_beta(-1.0).is_err());
assert!(beta.set_beta(std::f64::INFINITY).is_err());
assert!(beta.set_beta(std::f64::NAN).is_err());

pub fn set_beta_unchecked(&mut self, beta: f64)

Set beta without input validation

Trait Implementations

impl Cdf<f32> for Beta

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

The value of the Cumulative Density Function at x

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

Survival function, 1 - CDF(x)

impl Cdf<f64> for Beta

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

The value of the Cumulative Density Function at x

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

Survival function, 1 - CDF(x)

impl Clone for Beta

fn clone(&self) -> Self

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 ContinuousDistr<f32> 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 ContinuousDistr<f64> 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 Beta

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

Formats the value using the given formatter.

impl Default for Beta

fn default() -> Self

Returns the “default value” for a type.

impl Display for Beta

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

Formats the value using the given formatter.

impl Entropy for Beta

fn entropy(&self) -> f64

The entropy, H(X)

impl Kurtosis for Beta

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

impl Mean<f32> for Beta

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

Returns None if the mean is undefined

impl Mean<f64> for Beta

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

Returns None if the mean is undefined

impl Mode<f32> for Beta

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

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

impl Mode<f64> for Beta

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

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

impl PartialEq<Beta> for Beta

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

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

#[must_use]

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

This method tests for !=.

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 Rv<f32> for Beta

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

Probability function

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

Single draw from the Rv

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

Multiple draws of the Rv

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

Probability function

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 Rv<f64> for Beta

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

Probability function

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

Single draw from the Rv

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

Multiple draws of the Rv

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

Probability function

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 Beta

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

impl Support<Bernoulli> for Beta

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

Returns true if x is in the support of the Rv

impl Support<f32> for Beta

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

Returns true if x is in the support of the Rv

impl Support<f64> for Beta

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

Returns true if x is in the support of the Rv

impl Variance<f64> for Beta

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

Returns None if the variance is undefined