Add RngCore::bytes_per_round

benches/distributions.rs

@@ -1,5 +1,6 @@
 #![feature(test)]
-#![cfg_attr(feature = "i128_support", feature(i128_type, i128))]
+#![cfg_attr(all(feature="i128_support", feature="nightly"), allow(stable_features))] // stable since 2018-03-27
+#![cfg_attr(all(feature="i128_support", feature="nightly"), feature(i128_type, i128))]
 
 extern crate test;
 extern crate rand;

benches/generators.rs

@@ -1,4 +1,6 @@
 #![feature(test)]
+#![cfg_attr(all(feature="i128_support", feature="nightly"), allow(stable_features))] // stable since 2018-03-27
+#![cfg_attr(all(feature="i128_support", feature="nightly"), feature(i128_type, i128))]
 
 extern crate test;
 extern crate rand;
@@ -74,6 +76,10 @@ gen_uint!(gen_u64_std, u64, StdRng::new());
 gen_uint!(gen_u64_small, u64, SmallRng::new());
 gen_uint!(gen_u64_os, u64, OsRng::new().unwrap());
 
+#[cfg(feature = "i128_support")] gen_uint!(gen_u128_xorshift, u128, XorShiftRng::new());
+#[cfg(feature = "i128_support")] gen_uint!(gen_u128_hc128, u128, Hc128Rng::new());
+#[cfg(feature = "i128_support")] gen_uint!(gen_u128_os, u128, OsRng::new().unwrap());
+
 // Do not test JitterRng like the others by running it RAND_BENCH_N times per,
 // measurement, because it is way too slow. Only run it once.
 #[bench]

src/distributions/integer.rs

@@ -13,46 +13,52 @@
 use {Rng};
 use distributions::{Distribution, Standard};
 
-impl Distribution<isize> for Standard {
-    #[inline]
-    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> isize {
-        rng.gen::<usize>() as isize
-    }
-}
-
-impl Distribution<i8> for Standard {
+impl Distribution<u8> for Standard {
     #[inline]
-    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i8 {
-        rng.next_u32() as i8
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u8 {
+        rng.next_u32() as u8
     }
 }
 
-impl Distribution<i16> for Standard {
+impl Distribution<u16> for Standard {
     #[inline]
-    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i16 {
-        rng.next_u32() as i16
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u16 {
+        rng.next_u32() as u16
     }
 }
 
-impl Distribution<i32> for Standard {
+impl Distribution<u32> for Standard {
     #[inline]
-    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i32 {
-        rng.next_u32() as i32
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u32 {
+        rng.next_u32()
     }
 }
 
-impl Distribution<i64> for Standard {
+impl Distribution<u64> for Standard {
     #[inline]
-    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i64 {
-        rng.next_u64() as i64
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u64 {
+        rng.next_u64()
     }
 }
 
 #[cfg(feature = "i128_support")]
-impl Distribution<i128> for Standard {
+impl Distribution<u128> for Standard {
     #[inline]
-    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i128 {
-        rng.gen::<u128>() as i128
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u128 {
+        if rng.bytes_per_round() < 128 {
+            // Use LE; we explicitly generate one value before the next.
+            let x = rng.next_u64() as u128;
+            let y = rng.next_u64() as u128;
+            (y << 64) | x
+        } else {
+            let mut val = 0u128;
+            unsafe {
+                let ptr = &mut val;
+                let b_ptr = &mut *(ptr as *mut u128 as *mut [u8; 16]);
+                rng.fill_bytes(b_ptr);
+            }
+            val.to_le()
+        }
     }
 }
 
@@ -70,44 +76,23 @@ impl Distribution<usize> for Standard {
     }
 }
 
-impl Distribution<u8> for Standard {
-    #[inline]
-    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u8 {
-        rng.next_u32() as u8
+macro_rules! impl_int_from_uint {
+    ($ty:ty, $uty:ty) => {
+        impl Distribution<$ty> for Standard {
+            #[inline]
+            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $ty {
+                rng.gen::<$uty>() as $ty
+            }
+        }
     }
 }
 
-impl Distribution<u16> for Standard {
-    #[inline]
-    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u16 {
-        rng.next_u32() as u16
-    }
-}
-
-impl Distribution<u32> for Standard {
-    #[inline]
-    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u32 {
-        rng.next_u32()
-    }
-}
-
-impl Distribution<u64> for Standard {
-    #[inline]
-    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u64 {
-        rng.next_u64()
-    }
-}
-
-#[cfg(feature = "i128_support")]
-impl Distribution<u128> for Standard {
-    #[inline]
-    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u128 {
-        // Use LE; we explicitly generate one value before the next.
-        let x = rng.next_u64() as u128;
-        let y = rng.next_u64() as u128;
-        (y << 64) | x
-    }
-}
+impl_int_from_uint! { i8, u8 }
+impl_int_from_uint! { i16, u16 }
+impl_int_from_uint! { i32, u32 }
+impl_int_from_uint! { i64, u64 }
+#[cfg(feature = "i128_support")] impl_int_from_uint! { i128, u128 }
+impl_int_from_uint! { isize, usize }
 
 
 #[cfg(test)]