Trait rand::distributions::uniform::UniformSampler

pub trait UniformSampler: Sized {
    type X;
    fn new<B1, B2>(low: B1, high: B2) -> Self
    where
        B1: SampleBorrow<Self::X> + Sized,
        B2: SampleBorrow<Self::X> + Sized;
    fn new_inclusive<B1, B2>(low: B1, high: B2) -> Self
    where
        B1: SampleBorrow<Self::X> + Sized,
        B2: SampleBorrow<Self::X> + Sized;
    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Self::X;

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

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

The type sampled by this implementation.

Loading content...

Required methods

fn new<B1, B2>(low: B1, high: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

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.

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

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.

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

Sample a value.

Loading content...

Provided methods

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

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

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

Via this method, implementations can provide a method optimized for sampling only a single value from the specified range. The default implementation simply calls UniformSampler::new then sample on the result.

Loading content...

Implementors

impl UniformSampler for UniformDuration

type X = Duration

fn new<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

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

impl UniformSampler for UniformFloat<f32>

type X = f32

fn new<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

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

fn sample_single<R: Rng + ?Sized, B1, B2>(
    low_b: B1,
    high_b: B2,
    rng: &mut R
) -> Self::X where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

impl UniformSampler for UniformFloat<f64>

type X = f64

fn new<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

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

fn sample_single<R: Rng + ?Sized, B1, B2>(
    low_b: B1,
    high_b: B2,
    rng: &mut R
) -> Self::X where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

impl UniformSampler for UniformInt<i128>

type X = i128

fn new<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

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

fn sample_single<R: Rng + ?Sized, B1, B2>(
    low_b: B1,
    high_b: B2,
    rng: &mut R
) -> Self::X where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

impl UniformSampler for UniformInt<i16>

type X = i16

fn new<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

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

fn sample_single<R: Rng + ?Sized, B1, B2>(
    low_b: B1,
    high_b: B2,
    rng: &mut R
) -> Self::X where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

impl UniformSampler for UniformInt<i32>

type X = i32

fn new<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

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

fn sample_single<R: Rng + ?Sized, B1, B2>(
    low_b: B1,
    high_b: B2,
    rng: &mut R
) -> Self::X where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

impl UniformSampler for UniformInt<i64>

type X = i64

fn new<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

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

fn sample_single<R: Rng + ?Sized, B1, B2>(
    low_b: B1,
    high_b: B2,
    rng: &mut R
) -> Self::X where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

impl UniformSampler for UniformInt<i8>

type X = i8

fn new<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

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

fn sample_single<R: Rng + ?Sized, B1, B2>(
    low_b: B1,
    high_b: B2,
    rng: &mut R
) -> Self::X where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

impl UniformSampler for UniformInt<isize>

type X = isize

fn new<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

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

fn sample_single<R: Rng + ?Sized, B1, B2>(
    low_b: B1,
    high_b: B2,
    rng: &mut R
) -> Self::X where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

impl UniformSampler for UniformInt<u128>

type X = u128

fn new<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

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

fn sample_single<R: Rng + ?Sized, B1, B2>(
    low_b: B1,
    high_b: B2,
    rng: &mut R
) -> Self::X where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

impl UniformSampler for UniformInt<u16>

type X = u16

fn new<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

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

fn sample_single<R: Rng + ?Sized, B1, B2>(
    low_b: B1,
    high_b: B2,
    rng: &mut R
) -> Self::X where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

impl UniformSampler for UniformInt<u32>

type X = u32

fn new<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

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

fn sample_single<R: Rng + ?Sized, B1, B2>(
    low_b: B1,
    high_b: B2,
    rng: &mut R
) -> Self::X where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

impl UniformSampler for UniformInt<u64>

type X = u64

fn new<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

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

fn sample_single<R: Rng + ?Sized, B1, B2>(
    low_b: B1,
    high_b: B2,
    rng: &mut R
) -> Self::X where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

impl UniformSampler for UniformInt<u8>

type X = u8

fn new<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

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

fn sample_single<R: Rng + ?Sized, B1, B2>(
    low_b: B1,
    high_b: B2,
    rng: &mut R
) -> Self::X where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

impl UniformSampler for UniformInt<usize>

type X = usize

fn new<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Self where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

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

fn sample_single<R: Rng + ?Sized, B1, B2>(
    low_b: B1,
    high_b: B2,
    rng: &mut R
) -> Self::X where
    B1: SampleBorrow<Self::X> + Sized,
    B2: SampleBorrow<Self::X> + Sized, 

Loading content...