Trait ndarray_rand::rand::distributions::uniform::UniformSampler[−][src]

pub trait UniformSampler {
    type X;
    pub fn new<B1, B2>(low: B1, high: B2) -> Self
    where
        B1: SampleBorrow<Self::X>,
        B2: SampleBorrow<Self::X>;

    pub fn new_inclusive<B1, B2>(low: B1, high: B2) -> Self
    where
        B1: SampleBorrow<Self::X>,
        B2: SampleBorrow<Self::X>;

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

    pub fn sample_single<R, B1, B2>(low: B1, high: B2, rng: &mut R) -> Self::X
    where
        R: Rng + ?Sized,
        B1: SampleBorrow<Self::X>,
        B2: SampleBorrow<Self::X>,
    { ... }

    pub fn sample_single_inclusive<R, B1, B2>(
        low: B1, 
        high: B2, 
        rng: &mut R
    ) -> Self::X
    where
        R: Rng + ?Sized,
        B1: SampleBorrow<Self::X>,
        B2: SampleBorrow<Self::X>,
    { ... }
}

Helper trait handling actual uniform sampling.

See the module documentation on how to implement Uniform range sampling for a custom type.

Implementation of sample_single is optional, and is only useful when the implementation can be faster than Self::new(low, high).sample(rng).

Associated Types

type X[src]

The type sampled by this implementation.

Loading content...

Required methods

pub fn new<B1, B2>(low: B1, high: B2) -> Self where
    B1: SampleBorrow<Self::X>,
    B2: SampleBorrow<Self::X>, [src]

Construct self, with inclusive lower bound and exclusive upper bound [low, high).

Usually users should not call this directly but instead use Uniform::new, which asserts that low < high before calling this.

pub fn new_inclusive<B1, B2>(low: B1, high: B2) -> Self where
    B1: SampleBorrow<Self::X>,
    B2: SampleBorrow<Self::X>, [src]

Construct self, with inclusive bounds [low, high].

Usually users should not call this directly but instead use Uniform::new_inclusive, which asserts that low <= high before calling this.

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

Sample a value.

Loading content...

Provided methods

pub fn sample_single<R, B1, B2>(low: B1, high: B2, rng: &mut R) -> Self::X where
    R: Rng + ?Sized,
    B1: SampleBorrow<Self::X>,
    B2: SampleBorrow<Self::X>, [src]

Sample a single value uniformly from a range with inclusive lower bound and exclusive upper bound [low, high).

By default this is implemented using UniformSampler::new(low, high).sample(rng). However, for some types more optimal implementations for single usage may be provided via this method (which is the case for integers and floats). Results may not be identical.

Note that to use this method in a generic context, the type needs to be retrieved via SampleUniform::Sampler as follows:

use rand::{thread_rng, distributions::uniform::{SampleUniform, UniformSampler}};
fn sample_from_range<T: SampleUniform>(lb: T, ub: T) -> T {
    let mut rng = thread_rng();
    <T as SampleUniform>::Sampler::sample_single(lb, ub, &mut rng)
}

pub fn sample_single_inclusive<R, B1, B2>(
    low: B1,
    high: B2,
    rng: &mut R
) -> Self::X where
    R: Rng + ?Sized,
    B1: SampleBorrow<Self::X>,
    B2: SampleBorrow<Self::X>, [src]

Sample a single value uniformly from a range with inclusive lower bound and inclusive upper bound [low, high].

By default this is implemented using UniformSampler::new_inclusive(low, high).sample(rng). However, for some types more optimal implementations for single usage may be provided via this method. Results may not be identical.

Loading content...

Implementors

impl UniformSampler for UniformChar[src]

type X = char

impl UniformSampler for UniformDuration[src]

type X = Duration

impl UniformSampler for UniformFloat<f32>[src]

type X = f32

impl UniformSampler for UniformFloat<f64>[src]

type X = f64

impl UniformSampler for UniformInt<i8>[src]

type X = i8

impl UniformSampler for UniformInt<i16>[src]

type X = i16

impl UniformSampler for UniformInt<i32>[src]

type X = i32

impl UniformSampler for UniformInt<i64>[src]

type X = i64

impl UniformSampler for UniformInt<i128>[src]

type X = i128

impl UniformSampler for UniformInt<isize>[src]

type X = isize

impl UniformSampler for UniformInt<u8>[src]

type X = u8

impl UniformSampler for UniformInt<u16>[src]

type X = u16

impl UniformSampler for UniformInt<u32>[src]

type X = u32

impl UniformSampler for UniformInt<u64>[src]

type X = u64

impl UniformSampler for UniformInt<u128>[src]

type X = u128

impl UniformSampler for UniformInt<usize>[src]

type X = usize

Loading content...