Merge changes from #69 (sample_single)

Author: dhardy

benches/distributions.rs

@@ -75,11 +75,13 @@ macro_rules! gen_range_int {
         #[bench]
         fn $fnn(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
+            let high = $high;
 
             b.iter(|| {
                 for _ in 0..::RAND_BENCH_N {
-                    let x: $ty = Range::new($low, $high).sample(&mut rng);
+                    let x: $ty = Range::sample_single($low, high, &mut rng);
                     black_box(x);
+                    black_box(high);
                 }
             });
             b.bytes = size_of::<$ty>() as u64 * ::RAND_BENCH_N;

src/distributions/range.rs

@@ -65,6 +65,13 @@ impl Range<RangeInt<i32>> {
         assert!(low < high, "Range::new called with `low >= high`");
         Range { inner: RangeImpl::new_inclusive(low, high) }
     }
+
+    /// Sample a single value uniformly from `[low, high)`.
+    /// Panics if `low >= high`.
+    pub fn sample_single<X: SampleRange, R: Rng+?Sized>(low: X, high: X, rng: &mut R) -> X {
+        assert!(low < high, "Range::sample_single called with low >= high");
+        X::T::sample_single(low, high, rng)
+    }
 }
 
 impl<T: RangeImpl> Distribution<T::X> for Range<T> {
@@ -118,8 +125,8 @@ pub trait SampleRange: PartialOrd+Sized {
 /// let range = Range::new(low, high);
 /// let x = range.sample(&mut thread_rng());
 /// ```
-pub trait RangeImpl {
-    /// The type sampled by this implementation (output type).
+pub trait RangeImpl: Sized {
+    /// The type sampled by this implementation.
     type X: PartialOrd;
 
     /// Construct self, with inclusive lower bound and exclusive upper bound
@@ -137,6 +144,16 @@ pub trait RangeImpl {
 
     /// Sample a value.
     fn sample<R: Rng+?Sized>(&self, rng: &mut R) -> Self::X;
+
+    /// Sample a single value uniformly from a range with inclusive lower bound
+    /// and exclusive upper bound `[low, high)`.
+    /// Panics if `low >= high`.
+    fn sample_single<R: Rng+?Sized>(low: Self::X, high: Self::X, rng: &mut R)
+        -> Self::X
+    {
+        let range: Self = RangeImpl::new(low, high);
+        range.sample(rng)
+    }
 }
 
 /// Implementation of `RangeImpl` for integer types.
@@ -246,9 +263,9 @@ macro_rules! range_int_impl {
                     loop {
                         let v: $u_large = Uniform.sample(rng);
                         if $use_mult {
-                            let (high, low) = v.wmul(range);
-                            if low <= zone {
-                                return self.low.wrapping_add(high as $ty);
+                            let (hi, lo) = v.wmul(range);
+                            if lo <= zone {
+                                return self.low.wrapping_add(hi as $ty);
                             }
                         } else {
                             if v <= zone {
@@ -261,6 +278,37 @@ macro_rules! range_int_impl {
                     Uniform.sample(rng)
                 }
             }
+
+            fn sample_single<R: Rng+?Sized>(low: Self::X, high: Self::X, rng: &mut R) -> Self::X {
+                let range = (high as $u_large)
+                            .wrapping_sub(low as $u_large);
+                let zone =
+                    if ::core::$unsigned::MAX <= ::core::u16::MAX as $unsigned {
+                        // Using a modulus is faster than the approximation for
+                        // i8 and i16. I suppose we trade the cost of one
+                        // modulus for near-perfect branch prediction.
+                        let unsigned_max: $u_large = ::core::$u_large::MAX;
+                        let ints_to_reject = (unsigned_max - range + 1) % range;
+                        unsigned_max - ints_to_reject
+                    } else {
+                        // conservative but fast approximation
+                       range << range.leading_zeros()
+                    };
+
+                loop {
+                    let v: $u_large = Uniform.sample(rng);
+                    if $use_mult {
+                        let (hi, lo) = v.wmul(range);
+                        if lo <= zone {
+                            return low.wrapping_add(hi as $ty);
+                        }
+                    } else {
+                        if v <= zone {
+                            return low.wrapping_add((v % range) as $ty);
+                        }
+                    }
+                }
+            }
         }
     }
 }

src/distributions/uniform.rs

@@ -218,12 +218,17 @@ impl Distribution<char> for Codepoint {
 
 impl Distribution<char> for AsciiWordChar {
     fn sample<R: Rng+?Sized>(&self, rng: &mut R) -> char {
-        use sequences::Choose;
+        const RANGE: u32 = 26 + 26 + 10;
         const GEN_ASCII_STR_CHARSET: &'static [u8] =
             b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
                 abcdefghijklmnopqrstuvwxyz\
                 0123456789";
-        *GEN_ASCII_STR_CHARSET.choose(rng).unwrap() as char
+        loop {
+            let var = rng.next_u32() & 0x3F;
+            if var < RANGE {
+                return GEN_ASCII_STR_CHARSET[var as usize] as char
+            }
+        }
     }
 }
 

src/lib.rs

@@ -426,8 +426,7 @@ pub trait Sample: Rng {
     /// }
     /// ```
     fn gen_range<T: SampleRange>(&mut self, low: T, high: T) -> T {
-        assert!(low < high, "Sample::gen_range called with low >= high");
-        Range::new(low, high).sample(self)
+        Range::sample_single(low, high, self)
     }
 
     /// Construct an iterator on an `Rng`.