Struct rv::dist::BetaBinomial

pub struct BetaBinomial { /* fields omitted */ }

Beta Binomial distribution over k in {0, …, n}

Example

use std::f64;
use rv::prelude::*;

let a = 3.0;
let b = 2.0;
let n = 20;

let beta = Beta::new(a, b).unwrap();
let beta_binom = BetaBinomial::new(n, a, b).unwrap();

let beta_mean: f64 = beta.mean().unwrap();
let beta_binom_mean: f64 = beta_binom.mean().unwrap();
assert!( (beta_mean * f64::from(n) - beta_binom_mean).abs() < 1E-12 );

Some functions will panic when given data outside the supported range: [0, n]

let beta_binom = BetaBinomial::new(20, 3.0, 2.0).unwrap();
assert!(!beta_binom.supports(&21_u32));

The following will panic because 21 is out of the support

beta_binom.pmf(&21_u32); // panics

Implementations

impl BetaBinomial

pub fn new(n: u32, alpha: f64, beta: f64) -> Result<Self, BetaBinomialError>

Create a beta-binomal distirbution

Arguments

• n: the total number of trials
• alpha: the prior pseudo obersvations of success
• beta: the prior pseudo obersvations of failure

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

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

pub fn n(&self) -> u32

Get n, the number of trials.

Example

use rv::dist::BetaBinomial;
let bb = BetaBinomial::new(10, 1.0, 2.0).unwrap();
assert_eq!(bb.n(), 10);

pub fn alpha(&self) -> f64

Get the alpha parameter

Example

use rv::dist::BetaBinomial;
let bb = BetaBinomial::new(10, 1.0, 2.0).unwrap();
assert_eq!(bb.alpha(), 1.0);

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

Set the alpha parameter

Example

use rv::dist::BetaBinomial;

let mut bb = BetaBinomial::new(10, 1.0, 5.0).unwrap();

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

Will error for invalid values

assert!(bb.set_alpha(0.1).is_ok());
assert!(bb.set_alpha(0.0).is_err());
assert!(bb.set_alpha(-1.0).is_err());
assert!(bb.set_alpha(std::f64::INFINITY).is_err());
assert!(bb.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

use rv::dist::BetaBinomial;
let bb = BetaBinomial::new(10, 1.0, 2.0).unwrap();
assert_eq!(bb.beta(), 2.0);

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

Set the beta parameter

Example

let mut bb = BetaBinomial::new(10, 1.0, 5.0).unwrap();

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

Will error for invalid values

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

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

Set beta without input validation

pub fn set_n(&mut self, n: u32) -> Result<(), BetaBinomialError>

Set the value of the n parameter

Example

use rv::dist::BetaBinomial;

let mut bb = BetaBinomial::new(10, 0.5, 0.5).unwrap();

bb.set_n(11).unwrap();

assert_eq!(bb.n(), 11);

Will error for invalid values

assert!(bb.set_n(11).is_ok());
assert!(bb.set_n(1).is_ok());
assert!(bb.set_n(0).is_err());

pub fn set_n_unchecked(&mut self, n: u32)

Set the value of n without input validation

Trait Implementations

impl Cdf<i16> for BetaBinomial

fn cdf(&self, k: &i16) -> f64

The value of the Cumulative Density Function at x

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

Survival function, 1 - CDF(x)

impl Cdf<i32> for BetaBinomial

fn cdf(&self, k: &i32) -> f64

The value of the Cumulative Density Function at x

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

Survival function, 1 - CDF(x)

impl Cdf<i64> for BetaBinomial

fn cdf(&self, k: &i64) -> f64

The value of the Cumulative Density Function at x

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

Survival function, 1 - CDF(x)

impl Cdf<i8> for BetaBinomial

fn cdf(&self, k: &i8) -> f64

The value of the Cumulative Density Function at x

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

Survival function, 1 - CDF(x)

impl Cdf<u16> for BetaBinomial

fn cdf(&self, k: &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 BetaBinomial

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

The value of the Cumulative Density Function at x

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

Survival function, 1 - CDF(x)

impl Cdf<u64> for BetaBinomial

fn cdf(&self, k: &u64) -> 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 BetaBinomial

fn cdf(&self, k: &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 BetaBinomial

fn cdf(&self, k: &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 BetaBinomial

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BetaBinomial

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

Formats the value using the given formatter.

impl DiscreteDistr<i16> for BetaBinomial

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<i32> for BetaBinomial

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<i64> for BetaBinomial

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<i8> for BetaBinomial

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

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 BetaBinomial

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<u64> for BetaBinomial

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 BetaBinomial

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 BetaBinomial

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 BetaBinomial

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

Formats the value using the given formatter.

impl Mean<f64> for BetaBinomial

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

Returns None if the mean is undefined

impl PartialEq<BetaBinomial> for BetaBinomial

fn eq(&self, other: &BetaBinomial) -> 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<i16> for BetaBinomial

fn ln_f(&self, k: &i16) -> f64

Probability function

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

Single draw from the Rv

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

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<i32> for BetaBinomial

fn ln_f(&self, k: &i32) -> f64

Probability function

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

Single draw from the Rv

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

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<i64> for BetaBinomial

fn ln_f(&self, k: &i64) -> f64

Probability function

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

Single draw from the Rv

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

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<i8> for BetaBinomial

fn ln_f(&self, k: &i8) -> f64

Probability function

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

Single draw from the Rv

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

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

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

Probability function

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

Single draw from the Rv

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

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<u32> for BetaBinomial

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

Probability function

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

Single draw from the Rv

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

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<u64> for BetaBinomial

fn ln_f(&self, k: &u64) -> f64

Probability function

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

Single draw from the Rv

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

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<u8> for BetaBinomial

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

Probability function

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

Single draw from the Rv

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

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<usize> for BetaBinomial

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

Probability function

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

Single draw from the Rv

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

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 Support<i16> for BetaBinomial

fn supports(&self, k: &i16) -> bool

Returns true if x is in the support of the Rv

impl Support<i32> for BetaBinomial

fn supports(&self, k: &i32) -> bool

Returns true if x is in the support of the Rv

impl Support<i64> for BetaBinomial

fn supports(&self, k: &i64) -> bool

Returns true if x is in the support of the Rv

impl Support<i8> for BetaBinomial

fn supports(&self, k: &i8) -> bool

Returns true if x is in the support of the Rv

impl Support<u16> for BetaBinomial

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

Returns true if x is in the support of the Rv

impl Support<u32> for BetaBinomial

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

Returns true if x is in the support of the Rv

impl Support<u64> for BetaBinomial

fn supports(&self, k: &u64) -> bool

Returns true if x is in the support of the Rv

impl Support<u8> for BetaBinomial

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

Returns true if x is in the support of the Rv

impl Support<usize> for BetaBinomial

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

Returns true if x is in the support of the Rv

impl Variance<f64> for BetaBinomial

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

Returns None if the variance is undefined