Trait consalign::Distribution

source ·

pub trait Distribution<T> {
    // Required method
    fn sample<R>(&self, rng: &mut R) -> T
       where R: Rng + ?Sized;

    // Provided methods
    fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>
       where R: Rng,
             Self: Sized { ... }
    fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>
       where F: Fn(T) -> S,
             Self: Sized { ... }
}

Expand description

Types (distributions) that can be used to create a random instance of T.

It is possible to sample from a distribution through both the Distribution and Rng traits, via distr.sample(&mut rng) and rng.sample(distr). They also both offer the sample_iter method, which produces an iterator that samples from the distribution.

All implementations are expected to be immutable; this has the significant advantage of not needing to consider thread safety, and for most distributions efficient state-less sampling algorithms are available.

Implementations are typically expected to be portable with reproducible results when used with a PRNG with fixed seed; see the portability chapter of The Rust Rand Book. In some cases this does not apply, e.g. the usize type requires different sampling on 32-bit and 64-bit machines.

Required Methods§

source

fn sample<R>(&self, rng: &mut R) -> Twhere R: Rng + ?Sized,

Generate a random value of T, using rng as the source of randomness.

Provided Methods§

source

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

Note that this function takes self by value. This works since Distribution<T> is impl’d for &D where D: Distribution<T>, however borrowing is not automatic hence distr.sample_iter(...) may need to be replaced with (&distr).sample_iter(...) to borrow or (&*distr).sample_iter(...) to reborrow an existing reference.

Example

use rand::thread_rng;
use rand::distributions::{Distribution, Alphanumeric, Uniform, Standard};

let mut rng = thread_rng();

// Vec of 16 x f32:
let v: Vec<f32> = Standard.sample_iter(&mut rng).take(16).collect();

// String:
let s: String = Alphanumeric
    .sample_iter(&mut rng)
    .take(7)
    .map(char::from)
    .collect();

// Dice-rolling:
let die_range = Uniform::new_inclusive(1, 6);
let mut roll_die = die_range.sample_iter(&mut rng);
while roll_die.next().unwrap() != 6 {
    println!("Not a 6; rolling again!");
}

source

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

Example

use rand::thread_rng;
use rand::distributions::{Distribution, Uniform};

let mut rng = thread_rng();

let die = Uniform::new_inclusive(1, 6);
let even_number = die.map(|num| num % 2 == 0);
while !even_number.sample(&mut rng) {
    println!("Still odd; rolling again!");
}

Implementations on Foreign Types§

§

impl Distribution<Matrix<f64, Dynamic, Const<1>, VecStorage<f64, Dynamic, Const<1>>>> for Dirichlet

§

fn sample<R>( &self, rng: &mut R ) -> Matrix<f64, Dynamic, Const<1>, VecStorage<f64, Dynamic, Const<1>>>where R: Rng + ?Sized,

§

impl Distribution<f64> for Poisson

§

fn sample<R>(&self, rng: &mut R) -> f64where R: Rng + ?Sized,

Generates one sample from the Poisson distribution either by Knuth’s method if lambda < 30.0 or Rejection method PA by A. C. Atkinson from the Journal of the Royal Statistical Society Series C (Applied Statistics) Vol. 28 No. 1. (1979) pp. 29 - 35 otherwise

§

impl Distribution<f64> for Erlang

§

fn sample<R>(&self, rng: &mut R) -> f64where R: Rng + ?Sized,

§

impl Distribution<f64> for Categorical

§

fn sample<R>(&self, rng: &mut R) -> f64where R: Rng + ?Sized,

§

impl Distribution<f64> for Gamma

§

fn sample<R>(&self, rng: &mut R) -> f64where R: Rng + ?Sized,

§

impl Distribution<f64> for Dirac

§

fn sample<R>(&self, _: &mut R) -> f64where R: Rng + ?Sized,

§

impl Distribution<Matrix<f64, Dynamic, Const<1>, VecStorage<f64, Dynamic, Const<1>>>> for MultivariateNormal

§

fn sample<R>( &self, rng: &mut R ) -> Matrix<f64, Dynamic, Const<1>, VecStorage<f64, Dynamic, Const<1>>>where R: Rng + ?Sized,

Samples from the multivariate normal distribution

Formula

L * Z + μ

where L is the Cholesky decomposition of the covariance matrix, Z is a vector of normally distributed random variables, and μ is the mean vector

§