Struct rand::distributions::Range

pub struct Range<X> { /* fields omitted */ }

Sample values uniformly between two bounds.

This gives a uniform distribution (assuming the RNG used to sample it is itself uniform & the SampleRange implementation for the given type is correct), even for edge cases like low = 0u8, high = 170u8, for which a naive modulo operation would return numbers less than 85 with double the probability to those greater than 85.

Types should attempt to sample in [low, high), i.e., not including high, but this may be very difficult. All the primitive integer types satisfy this property, and the float types normally satisfy it, but rounding may mean high can occur.

Example

use rand::distributions::{IndependentSample, Range};

fn main() {
    let between = Range::new(10, 10000);
    let mut rng = rand::thread_rng();
    let mut sum = 0;
    for _ in 0..1000 {
        sum += between.ind_sample(&mut rng);
    }
    println!("{}", sum);
}

Methods

impl<X> Range<X> where     X: SampleRange + PartialOrd<X>,

pub fn new(low: X, high: X) -> Range<X>

Create a new Range instance that samples uniformly from [low, high). Panics if low >= high.

Trait Implementations

impl<X> Clone for Range<X> where     X: Clone,

fn clone(&self) -> Range<X>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<X> Debug for Range<X> where     X: Debug,

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.

impl<Sup> IndependentSample<Sup> for Range<Sup> where     Sup: SampleRange,

fn ind_sample<R>(&self, rng: &mut R) -> Sup where     R: Rng,

Generate a random value.

impl<X> Copy for Range<X> where     X: Copy,

impl<Sup> Sample<Sup> for Range<Sup> where     Sup: SampleRange,

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

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