Trait rand_distr::Distribution

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

    pub fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>
    where
        R: Rng,
    { ... }
}

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

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

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

Loading content...

Provided methods

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

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 rng = thread_rng();

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

// String:
let s: String = Alphanumeric.sample_iter(rng).take(7).collect();

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

Loading content...

Implementations on Foreign Types

impl Distribution<f64> for Exp1

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

impl Distribution<f64> for Cauchy

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

impl Distribution<f64> for FisherF

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

impl<'a, T, D> Distribution<T> for &'a D where
    D: Distribution<T>, 

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

impl Distribution<[f64; 3]> for UnitSphereSurface

pub fn sample<R>(&self, rng: &mut R) -> [f64; 3] where
    R: Rng + ?Sized, 

impl Distribution<f64> for Normal

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

impl Distribution<f64> for Triangular

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

impl Distribution<f64> for StandardNormal

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

impl Distribution<f64> for Gamma

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

impl Distribution<u64> for Poisson

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

impl Distribution<f64> for Weibull

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

impl Distribution<f64> for Pareto

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

impl<W> Distribution<usize> for WeightedIndex<W> where
    W: Weight, 

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

impl Distribution<Vec<f64, Global>> for Dirichlet

pub fn sample<R>(&self, rng: &mut R) -> Vec<f64, Global> where
    R: Rng + ?Sized, 

impl Distribution<f64> for StudentT

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

impl Distribution<[f64; 2]> for UnitCircle

pub fn sample<R>(&self, rng: &mut R) -> [f64; 2] where
    R: Rng + ?Sized, 

impl Distribution<f64> for Beta

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

impl Distribution<u64> for Binomial

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

impl Distribution<f64> for LogNormal

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

impl Distribution<f64> for ChiSquared

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

impl Distribution<f64> for Exp

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

Loading content...

Implementors

impl Distribution<bool> for Bernoulli

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

impl Distribution<bool> for Standard

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

impl Distribution<char> for Alphanumeric

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

impl Distribution<char> for Standard

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

impl Distribution<f32> for rand_distr::Exp1

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

impl Distribution<f32> for Open01

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

impl Distribution<f32> for OpenClosed01

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

impl Distribution<f32> for Standard

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

impl Distribution<f32> for rand_distr::StandardNormal

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

impl Distribution<f64> for rand_distr::Exp1

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

impl Distribution<f64> for Open01

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

impl Distribution<f64> for OpenClosed01

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

impl Distribution<f64> for Standard

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

impl Distribution<f64> for rand_distr::StandardNormal

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

impl Distribution<i8> for Standard

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

impl Distribution<i16> for Standard

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

impl Distribution<i32> for Standard

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

impl Distribution<i64> for Standard

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

impl Distribution<i128> for Standard

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

impl Distribution<isize> for Standard

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

impl Distribution<u8> for Standard

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

impl Distribution<u16> for Standard

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

impl Distribution<u32> for Standard

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

impl Distribution<u64> for rand_distr::Binomial

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

impl Distribution<u64> for Standard

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

impl Distribution<u128> for Standard

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

impl Distribution<()> for Standard

pub fn sample<R>(&self, &mut R) where
    R: Rng + ?Sized, 

impl Distribution<usize> for Standard

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

impl Distribution<NonZeroU8> for Standard

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

impl Distribution<NonZeroU16> for Standard

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

impl Distribution<NonZeroU32> for Standard

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

impl Distribution<NonZeroU64> for Standard

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

impl Distribution<NonZeroU128> for Standard

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

impl Distribution<NonZeroUsize> for Standard

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

impl<A> Distribution<(A,)> for Standard where
    Standard: Distribution<A>, 

pub fn sample<R>(&self, _rng: &mut R) -> (A,) where
    R: Rng + ?Sized, 

impl<A, B> Distribution<(A, B)> for Standard where
    Standard: Distribution<A>,
    Standard: Distribution<B>, 

pub fn sample<R>(&self, _rng: &mut R) -> (A, B) where
    R: Rng + ?Sized, 

impl<A, B, C> Distribution<(A, B, C)> for Standard where
    Standard: Distribution<A>,
    Standard: Distribution<B>,
    Standard: Distribution<C>, 

pub fn sample<R>(&self, _rng: &mut R) -> (A, B, C) where
    R: Rng + ?Sized, 

impl<A, B, C, D> Distribution<(A, B, C, D)> for Standard where
    Standard: Distribution<A>,
    Standard: Distribution<B>,
    Standard: Distribution<C>,
    Standard: Distribution<D>, 

pub fn sample<R>(&self, _rng: &mut R) -> (A, B, C, D) where
    R: Rng + ?Sized, 

impl<A, B, C, D, E> Distribution<(A, B, C, D, E)> for Standard where
    Standard: Distribution<A>,
    Standard: Distribution<B>,
    Standard: Distribution<C>,
    Standard: Distribution<D>,
    Standard: Distribution<E>, 

pub fn sample<R>(&self, _rng: &mut R) -> (A, B, C, D, E) where
    R: Rng + ?Sized, 

impl<A, B, C, D, E, F> Distribution<(A, B, C, D, E, F)> for Standard where
    Standard: Distribution<A>,
    Standard: Distribution<B>,
    Standard: Distribution<C>,
    Standard: Distribution<D>,
    Standard: Distribution<E>,
    Standard: Distribution<F>, 

pub fn sample<R>(&self, _rng: &mut R) -> (A, B, C, D, E, F) where
    R: Rng + ?Sized, 

impl<A, B, C, D, E, F, G> Distribution<(A, B, C, D, E, F, G)> for Standard where
    Standard: Distribution<A>,
    Standard: Distribution<B>,
    Standard: Distribution<C>,
    Standard: Distribution<D>,
    Standard: Distribution<E>,
    Standard: Distribution<F>,
    Standard: Distribution<G>, 

pub fn sample<R>(&self, _rng: &mut R) -> (A, B, C, D, E, F, G) where
    R: Rng + ?Sized, 

impl<A, B, C, D, E, F, G, H> Distribution<(A, B, C, D, E, F, G, H)> for Standard where
    Standard: Distribution<A>,
    Standard: Distribution<B>,
    Standard: Distribution<C>,
    Standard: Distribution<D>,
    Standard: Distribution<E>,
    Standard: Distribution<F>,
    Standard: Distribution<G>,
    Standard: Distribution<H>, 

pub fn sample<R>(&self, _rng: &mut R) -> (A, B, C, D, E, F, G, H) where
    R: Rng + ?Sized, 

impl<A, B, C, D, E, F, G, H, I> Distribution<(A, B, C, D, E, F, G, H, I)> for Standard where
    Standard: Distribution<A>,
    Standard: Distribution<B>,
    Standard: Distribution<C>,
    Standard: Distribution<D>,
    Standard: Distribution<E>,
    Standard: Distribution<F>,
    Standard: Distribution<G>,
    Standard: Distribution<H>,
    Standard: Distribution<I>, 

pub fn sample<R>(&self, _rng: &mut R) -> (A, B, C, D, E, F, G, H, I) where
    R: Rng + ?Sized, 

impl<A, B, C, D, E, F, G, H, I, J> Distribution<(A, B, C, D, E, F, G, H, I, J)> for Standard where
    Standard: Distribution<A>,
    Standard: Distribution<B>,
    Standard: Distribution<C>,
    Standard: Distribution<D>,
    Standard: Distribution<E>,
    Standard: Distribution<F>,
    Standard: Distribution<G>,
    Standard: Distribution<H>,
    Standard: Distribution<I>,
    Standard: Distribution<J>, 

pub fn sample<R>(&self, _rng: &mut R) -> (A, B, C, D, E, F, G, H, I, J) where
    R: Rng + ?Sized, 

impl<A, B, C, D, E, F, G, H, I, J, K> Distribution<(A, B, C, D, E, F, G, H, I, J, K)> for Standard where
    Standard: Distribution<A>,
    Standard: Distribution<B>,
    Standard: Distribution<C>,
    Standard: Distribution<D>,
    Standard: Distribution<E>,
    Standard: Distribution<F>,
    Standard: Distribution<G>,
    Standard: Distribution<H>,
    Standard: Distribution<I>,
    Standard: Distribution<J>,
    Standard: Distribution<K>, 

pub fn sample<R>(&self, _rng: &mut R) -> (A, B, C, D, E, F, G, H, I, J, K) where
    R: Rng + ?Sized, 

impl<A, B, C, D, E, F, G, H, I, J, K, L> Distribution<(A, B, C, D, E, F, G, H, I, J, K, L)> for Standard where
    Standard: Distribution<A>,
    Standard: Distribution<B>,
    Standard: Distribution<C>,
    Standard: Distribution<D>,
    Standard: Distribution<E>,
    Standard: Distribution<F>,
    Standard: Distribution<G>,
    Standard: Distribution<H>,
    Standard: Distribution<I>,
    Standard: Distribution<J>,
    Standard: Distribution<K>,
    Standard: Distribution<L>, 

pub fn sample<R>(&self, _rng: &mut R) -> (A, B, C, D, E, F, G, H, I, J, K, L) where
    R: Rng + ?Sized, 

impl<F> Distribution<Vec<F, Global>> for rand_distr::Dirichlet<F> where
    F: Float,
    StandardNormal: Distribution<F>,
    Exp1: Distribution<F>,
    Open01: Distribution<F>, 

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

impl<F> Distribution<F> for rand_distr::Beta<F> where
    F: Float,
    StandardNormal: Distribution<F>,
    Exp1: Distribution<F>,
    Open01: Distribution<F>, 

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

impl<F> Distribution<F> for rand_distr::Cauchy<F> where
    F: Float + FloatConst,
    Standard: Distribution<F>, 

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

impl<F> Distribution<F> for rand_distr::ChiSquared<F> where
    F: Float,
    StandardNormal: Distribution<F>,
    Exp1: Distribution<F>,
    Open01: Distribution<F>, 

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

impl<F> Distribution<F> for rand_distr::Exp<F> where
    F: Float,
    Exp1: Distribution<F>, 

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

impl<F> Distribution<F> for rand_distr::FisherF<F> where
    F: Float,
    StandardNormal: Distribution<F>,
    Exp1: Distribution<F>,
    Open01: Distribution<F>, 

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

impl<F> Distribution<F> for rand_distr::Gamma<F> where
    F: Float,
    StandardNormal: Distribution<F>,
    Exp1: Distribution<F>,
    Open01: Distribution<F>, 

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

impl<F> Distribution<F> for InverseGaussian<F> where
    F: Float,
    StandardNormal: Distribution<F>,
    Standard: Distribution<F>, 

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

impl<F> Distribution<F> for rand_distr::LogNormal<F> where
    F: Float,
    StandardNormal: Distribution<F>, 

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

impl<F> Distribution<F> for rand_distr::Normal<F> where
    F: Float,
    StandardNormal: Distribution<F>, 

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

impl<F> Distribution<F> for NormalInverseGaussian<F> where
    F: Float,
    StandardNormal: Distribution<F>,
    Standard: Distribution<F>, 

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

impl<F> Distribution<F> for rand_distr::Pareto<F> where
    F: Float,
    OpenClosed01: Distribution<F>, 

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

impl<F> Distribution<F> for Pert<F> where
    F: Float,
    StandardNormal: Distribution<F>,
    Exp1: Distribution<F>,
    Open01: Distribution<F>, 

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

impl<F> Distribution<F> for rand_distr::Poisson<F> where
    F: Float + FloatConst,
    Standard: Distribution<F>, 

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

impl<F> Distribution<F> for rand_distr::StudentT<F> where
    F: Float,
    StandardNormal: Distribution<F>,
    Exp1: Distribution<F>,
    Open01: Distribution<F>, 

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

impl<F> Distribution<F> for rand_distr::Triangular<F> where
    F: Float,
    Standard: Distribution<F>, 

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

impl<F> Distribution<F> for rand_distr::Weibull<F> where
    F: Float,
    OpenClosed01: Distribution<F>, 

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

impl<F: Float + SampleUniform> Distribution<[F; 2]> for rand_distr::UnitCircle

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> [F; 2]

impl<F: Float + SampleUniform> Distribution<[F; 2]> for UnitDisc

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> [F; 2]

impl<F: Float + SampleUniform> Distribution<[F; 3]> for UnitBall

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> [F; 3]

impl<F: Float + SampleUniform> Distribution<[F; 3]> for UnitSphere

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> [F; 3]

impl<T> Distribution<Option<T>> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, rng: &mut R) -> Option<T> where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 0]> for Standard

pub fn sample<R>(&self, _rng: &mut R) -> [T; 0] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 1]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 1] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 2]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 2] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 3]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 3] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 4]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 4] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 5]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 5] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 6]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 6] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 7]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 7] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 8]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 8] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 9]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 9] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 10]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 10] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 11]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 11] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 12]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 12] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 13]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 13] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 14]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 14] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 15]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 15] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 16]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 16] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 17]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 17] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 18]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 18] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 19]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 19] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 20]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 20] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 21]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 21] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 22]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 22] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 23]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 23] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 24]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 24] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 25]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 25] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 26]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 26] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 27]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 27] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 28]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 28] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 29]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 29] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 30]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 30] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 31]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 31] where
    R: Rng + ?Sized, 

impl<T> Distribution<[T; 32]> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, _rng: &mut R) -> [T; 32] where
    R: Rng + ?Sized, 

impl<T> Distribution<Wrapping<T>> for Standard where
    Standard: Distribution<T>, 

pub fn sample<R>(&self, rng: &mut R) -> Wrapping<T> where
    R: Rng + ?Sized, 

impl<W: AliasableWeight> Distribution<usize> for WeightedAliasIndex<W>

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

impl<X> Distribution<usize> for rand_distr::WeightedIndex<X> where
    X: SampleUniform + PartialOrd<X>, 

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

impl<X> Distribution<X> for Uniform<X> where
    X: SampleUniform, 

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

Loading content...