scirs2_series::gpu_acceleration::ndarray::compat::distributions

Trait Distribution

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) -> T
where 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!");
}

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Trait Distribution Copy item path

Required Methods§

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

Provided Methods§

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

§Example

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

§Example

Dyn Compatibility§

Implementations on Foreign Types§

impl Distribution<bool> for Bernoulli

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

impl Distribution<f64> for Bernoulli

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

impl Distribution<f64> for Beta

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

impl Distribution<f64> for Binomial

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 Cauchy

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

impl Distribution<f64> for Chi

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

impl Distribution<f64> for ChiSquared

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

impl Distribution<f64> for Dirac

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

impl Distribution<f64> for DiscreteUniform

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

impl Distribution<f64> for Empirical

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

impl Distribution<f64> for Erlang

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

impl Distribution<f64> for Exp

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

impl Distribution<f64> for FisherSnedecor

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 Geometric

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

impl Distribution<f64> for Gumbel

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

impl Distribution<f64> for Hypergeometric

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

impl Distribution<f64> for InverseGamma

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

impl Distribution<f64> for Laplace

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

impl Distribution<f64> for LogNormal

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

impl Distribution<f64> for Normal

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

impl Distribution<f64> for Pareto

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

impl Distribution<f64> for Poisson

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

impl Distribution<f64> for StudentsT

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

impl Distribution<f64> for Triangular

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

impl Distribution<f64> for Uniform

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

impl Distribution<f64> for Weibull

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

impl Distribution<i64> for DiscreteUniform

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

impl Distribution<u64> for Binomial

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

impl Distribution<u64> for Categorical

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

impl Distribution<u64> for Geometric

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

impl Distribution<u64> for Hypergeometric

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

impl Distribution<u64> for NegativeBinomial

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

impl Distribution<u64> for Poisson

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

Trait Distribution

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

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,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<D> Distribution<f64> for Data<D>
where D: AsRef<[f64]>,

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

impl<D> Distribution<Matrix<f64, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<f64>>> for Dirichlet<D>
where D: Dim, DefaultAllocator: Allocator<D>,

fn sample<R>( &self, rng: &mut R, ) -> Matrix<f64, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<f64>>
where R: Rng + ?Sized,

impl<D> Distribution<Matrix<f64, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<f64>>> for Multinomial<D>
where D: Dim, DefaultAllocator: Allocator<D>,

fn sample<R>( &self, rng: &mut R, ) -> Matrix<f64, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<f64>>
where R: Rng + ?Sized,

impl<D> Distribution<Matrix<f64, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<f64>>> for MultivariateNormal<D>
where D: Dim, DefaultAllocator: Allocator<D> + Allocator<D, D>,

fn sample<R>( &self, rng: &mut R, ) -> Matrix<f64, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<f64>>
where R: Rng + ?Sized,

impl<D> Distribution<Matrix<f64, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<f64>>> for MultivariateStudent<D>
where D: Dim, DefaultAllocator: Allocator<D> + Allocator<D, D>,

fn sample<R>( &self, rng: &mut R, ) -> Matrix<f64, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<f64>>
where R: Rng + ?Sized,

impl<D> Distribution<Matrix<u64, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<u64>>> for Multinomial<D>
where D: Dim, DefaultAllocator: Allocator<D>,

fn sample<R>( &self, rng: &mut R, ) -> Matrix<u64, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<u64>>
where R: Rng + ?Sized,

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

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

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

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