Trait rv::traits::Rv

pub trait Rv<X> {
    fn ln_f(&self, x: &X) -> f64;
    fn draw<R: Rng>(&self, rng: &mut R) -> X;

    fn f(&self, x: &X) -> f64 { ... }
    fn sample<R: Rng>(&self, n: usize, rng: &mut R) -> Vec<X> { ... }
}

Random variable

Contains the minimal functionality that a random object must have to be useful: a function defining the un-normalized density/mass at a point, and functions to draw samples from the distribution.

Required methods

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

Probability function

Example

use rv::dist::Gaussian;
use rv::traits::Rv;

let g = Gaussian::standard();
assert!(g.ln_f(&0.0_f64) > g.ln_f(&0.1_f64));
assert!(g.ln_f(&0.0_f64) > g.ln_f(&-0.1_f64));

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

Single draw from the Rv

Example

Flip a coin

extern crate rand;

use rv::dist::Bernoulli;
use rv::traits::Rv;

let b = Bernoulli::uniform();
let mut rng = rand::thread_rng();
let x: bool = b.draw(&mut rng); // could be true, could be false.

Loading content...

Provided methods

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

Probability function

Example

use rv::dist::Gaussian;
use rv::traits::Rv;

let g = Gaussian::standard();
assert!(g.f(&0.0_f64) > g.f(&0.1_f64));
assert!(g.f(&0.0_f64) > g.f(&-0.1_f64));

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

Multiple draws of the Rv

Example

Flip a lot of coins

extern crate rand;

use rv::dist::Bernoulli;
use rv::traits::Rv;

let b = Bernoulli::uniform();
let mut rng = rand::thread_rng();
let xs: Vec<bool> = b.sample(22, &mut rng);

assert_eq!(xs.len(), 22);

Loading content...

Implementors

impl Rv<bool> for Bernoulli

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

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

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

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

impl Rv<f32> for Beta

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

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

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

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

impl Rv<f32> for Cauchy

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

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

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

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

impl Rv<f32> for ChiSquared

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

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

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

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

impl Rv<f32> for Exponential

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

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

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

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

impl Rv<f32> for Gamma

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

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

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

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

impl Rv<f32> for Gaussian

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

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

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

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

impl Rv<f32> for Gev

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

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

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

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

impl Rv<f32> for InvGamma

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

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

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

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

impl Rv<f32> for Laplace

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

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

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

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

impl Rv<f32> for LogNormal

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

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

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

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

impl Rv<f32> for Pareto

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

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

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

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

impl Rv<f32> for StudentsT

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

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

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

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

impl Rv<f32> for Uniform

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

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

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

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

impl Rv<f32> for VonMises

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

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

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

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

impl Rv<f64> for Beta

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

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

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

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

impl Rv<f64> for Cauchy

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

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

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

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

impl Rv<f64> for ChiSquared

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

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

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

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

impl Rv<f64> for Exponential

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

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

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

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

impl Rv<f64> for Gamma

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

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

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

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

impl Rv<f64> for Gaussian

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

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

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

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

impl Rv<f64> for Gev

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

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

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

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

impl Rv<f64> for InvGamma

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

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

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

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

impl Rv<f64> for Laplace

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

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

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

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

impl Rv<f64> for LogNormal

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

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

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

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

impl Rv<f64> for Pareto

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

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

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

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

impl Rv<f64> for StudentsT

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

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

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

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

impl Rv<f64> for Uniform

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

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

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

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

impl Rv<f64> for VonMises

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

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

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

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

impl Rv<i16> for Bernoulli

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

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

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

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

impl Rv<i16> for BetaBinomial

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

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

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

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

impl Rv<i16> for Binomial

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

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

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

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

impl Rv<i32> for Bernoulli

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

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

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

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

impl Rv<i32> for BetaBinomial

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

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

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

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

impl Rv<i32> for Binomial

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

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

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

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

impl Rv<i64> for Bernoulli

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

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

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

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

impl Rv<i64> for BetaBinomial

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

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

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

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

impl Rv<i64> for Binomial

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

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

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

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

impl Rv<i8> for Bernoulli

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

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

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

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

impl Rv<i8> for BetaBinomial

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

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

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

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

impl Rv<i8> for Binomial

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

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

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

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

impl Rv<isize> for Bernoulli

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

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

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

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

impl Rv<u16> for Bernoulli

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

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

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

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

impl Rv<u16> for BetaBinomial

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

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

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

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

impl Rv<u16> for Binomial

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

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

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

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

impl Rv<u16> for Poisson

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

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

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

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

impl Rv<u32> for Bernoulli

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

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

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

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

impl Rv<u32> for BetaBinomial

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

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

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

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

impl Rv<u32> for Binomial

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

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

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

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

impl Rv<u32> for Poisson

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

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

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

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

impl Rv<u64> for Bernoulli

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

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

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

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

impl Rv<u64> for BetaBinomial

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

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

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

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

impl Rv<u64> for Binomial

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

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

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

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

impl Rv<u8> for Bernoulli

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

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

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

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

impl Rv<u8> for BetaBinomial

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

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

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

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

impl Rv<u8> for Binomial

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

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

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

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

impl Rv<u8> for Poisson

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

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

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

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

impl Rv<usize> for Bernoulli

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

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

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

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

impl Rv<usize> for BetaBinomial

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

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

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

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

impl Rv<usize> for Binomial

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

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

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

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

impl Rv<Partition> for Crp

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

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

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

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

impl Rv<Bernoulli> for Beta

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

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

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

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

impl Rv<Categorical> for Dirichlet

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

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

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

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

impl Rv<Categorical> for SymmetricDirichlet

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

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

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

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

impl Rv<Gaussian> for NormalGamma

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

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

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

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

impl Rv<MvGaussian> for NormalInvWishart

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

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

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

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

impl Rv<Vec<f64>> for SymmetricDirichlet

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

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

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

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

impl Rv<Vec<f64>> for Dirichlet

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

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

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

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

impl Rv<Matrix<f64, Dynamic, Dynamic, <DefaultAllocator as Allocator<f64, Dynamic, Dynamic>>::Buffer>> for InvWishart

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

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

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

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

impl Rv<Matrix<f64, Dynamic, U1, VecStorage<f64, Dynamic, U1>>> for MvGaussian

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

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

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

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

impl<X> Rv<X> for Geometric where
    X: Unsigned + Integer + FromPrimitive + ToPrimitive + Saturating + Bounded, 

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

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

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

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

impl<X, Fx> Rv<X> for Mixture<Fx> where
    Fx: Rv<X> + ApiReady, 

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

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

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

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

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

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

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

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

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

impl<X, T> Rv<X> for DiscreteUniform<T> where
    T: Integer + SampleUniform + Copy,
    X: Integer + From<T>, 

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

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

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

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

impl<X: CategoricalDatum> Rv<X> for Categorical

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

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

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

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

Loading content...