[−][src]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
[src]

type X = Duration

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, 
[src]

impl UniformSampler for UniformFloat<f32>
[src]

type X = f32

impl UniformSampler for UniformFloat<f64>
[src]

type X = f64

impl UniformSampler for UniformFloat<f32x4>
[src]

type X = f32x4

impl UniformSampler for UniformFloat<f64x2>
[src]

type X = f64x2

impl UniformSampler for UniformFloat<f32x8>
[src]

type X = f32x8

impl UniformSampler for UniformFloat<f64x4>
[src]

type X = f64x4

impl UniformSampler for UniformFloat<f32x16>
[src]

type X = f32x16

impl UniformSampler for UniformFloat<f64x8>
[src]

type X = f64x8

impl UniformSampler for UniformFloat<f32x2>
[src]

type X = f32x2

impl UniformSampler for UniformInt<i128>
[src]

type X = i128

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<i8>
[src]

type X = i8

impl UniformSampler for UniformInt<isize>
[src]

type X = isize

impl UniformSampler for UniformInt<u128>
[src]

type X = u128

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<u8>
[src]

type X = u8

impl UniformSampler for UniformInt<usize>
[src]

type X = usize

impl UniformSampler for UniformInt<i16x8>
[src]

type X = i16x8

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, 
[src]

impl UniformSampler for UniformInt<i32x4>
[src]

type X = i32x4

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, 
[src]

impl UniformSampler for UniformInt<i64x2>
[src]

type X = i64x2

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, 
[src]

impl UniformSampler for UniformInt<i8x16>
[src]

type X = i8x16

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, 
[src]

impl UniformSampler for UniformInt<u16x8>
[src]

type X = u16x8

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, 
[src]

impl UniformSampler for UniformInt<u32x4>
[src]

type X = u32x4

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, 
[src]

impl UniformSampler for UniformInt<u64x2>
[src]

type X = u64x2

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, 
[src]

impl UniformSampler for UniformInt<u8x16>
[src]

type X = u8x16

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, 
[src]

impl UniformSampler for UniformInt<i8x2>
[src]

type X = i8x2

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, 
[src]

impl UniformSampler for UniformInt<u8x2>
[src]

type X = u8x2

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, 
[src]

impl UniformSampler for UniformInt<i16x16>
[src]

type X = i16x16

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, 
[src]

impl UniformSampler for UniformInt<i32x8>
[src]

type X = i32x8

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, 
[src]

impl UniformSampler for UniformInt<i64x4>
[src]

type X = i64x4

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, 
[src]

impl UniformSampler for UniformInt<i8x32>
[src]

type X = i8x32

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, 
[src]

impl UniformSampler for UniformInt<u16x16>
[src]

type X = u16x16

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, 
[src]

impl UniformSampler for UniformInt<u32x8>
[src]

type X = u32x8

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, 
[src]

impl UniformSampler for UniformInt<u64x4>
[src]

type X = u64x4

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, 
[src]

impl UniformSampler for UniformInt<u8x32>
[src]

type X = u8x32

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, 
[src]

impl UniformSampler for UniformInt<i16x2>
[src]

type X = i16x2

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, 
[src]

impl UniformSampler for UniformInt<i8x4>
[src]

type X = i8x4

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, 
[src]

impl UniformSampler for UniformInt<u16x2>
[src]

type X = u16x2

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, 
[src]

impl UniformSampler for UniformInt<u8x4>
[src]

type X = u8x4

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, 
[src]

impl UniformSampler for UniformInt<i16x32>
[src]

type X = i16x32

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, 
[src]

impl UniformSampler for UniformInt<i32x16>
[src]

type X = i32x16

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, 
[src]

impl UniformSampler for UniformInt<i64x8>
[src]

type X = i64x8

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, 
[src]

impl UniformSampler for UniformInt<i8x64>
[src]

type X = i8x64

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, 
[src]

impl UniformSampler for UniformInt<u16x32>
[src]

type X = u16x32

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, 
[src]

impl UniformSampler for UniformInt<u32x16>
[src]

type X = u32x16

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, 
[src]

impl UniformSampler for UniformInt<u64x8>
[src]

type X = u64x8

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, 
[src]

impl UniformSampler for UniformInt<u8x64>
[src]

type X = u8x64

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, 
[src]

impl UniformSampler for UniformInt<i16x4>
[src]

type X = i16x4

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, 
[src]

impl UniformSampler for UniformInt<i32x2>
[src]

type X = i32x2

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, 
[src]

impl UniformSampler for UniformInt<i8x8>
[src]

type X = i8x8

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, 
[src]

impl UniformSampler for UniformInt<u16x4>
[src]

type X = u16x4

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, 
[src]

impl UniformSampler for UniformInt<u32x2>
[src]

type X = u32x2

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, 
[src]

impl UniformSampler for UniformInt<u8x8>
[src]

type X = u8x8

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, 
[src]

Loading content...