---

yaml
---
r: 83804
b: refs/heads/try
c: 38732c4
h: refs/heads/master
v: v3

Author: huonw

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0e4d1fc8cae42e15e00f71d9f439b01bb25a86ae
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
-refs/heads/try: a836f13dc0c2c636fd00b77d05f50a00cc3a7c55
+refs/heads/try: 38732c4b5cf778cb1b441bfc4290b3e3524b80c2
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libstd/rand/rand_impls.rs

@@ -95,23 +95,28 @@ impl Rand for u64 {
 }
 
 impl Rand for f32 {
-    /// A random `f32` in the range `[0, 1)`.
+    /// A random `f32` in the range `[0, 1)`, using 24 bits of
+    /// precision.
     #[inline]
     fn rand<R: Rng>(rng: &mut R) -> f32 {
-        // weird, but this is the easiest way to get 2**32
-        static SCALE: f32 = 2.0 * (1u32 << 31) as f32;
-        rng.next_u32() as f32 / SCALE
+        // using any more than 24 bits will cause (e.g.) 0xffff_ffff
+        // to correspond to 1 exactly, so we need to drop 8 to
+        // guarantee the open end.
+
+        static SCALE: f32 = (1u32 << 24) as f32;
+        (rng.next_u32() >> 8) as f32 / SCALE
     }
 }
 
 impl Rand for f64 {
-    /// A random `f64` in the range `[0, 1)`.
+    /// A random `f64` in the range `[0, 1)`, using 53 bits of
+    /// precision.
     #[inline]
     fn rand<R: Rng>(rng: &mut R) -> f64 {
-        // weird, but this is the easiest way to get 2**64
-        static SCALE: f64 = 2.0 * (1u64 << 63) as f64;
+        // as for f32, but using more bits.
 
-        rng.next_u64() as f64 / SCALE
+        static SCALE: f64 = (1u64 << 53) as f64;
+        (rng.next_u64() >> 11) as f64 / SCALE
     }
 }
 
@@ -198,3 +203,19 @@ impl<T: Rand + 'static> Rand for @T {
     #[inline]
     fn rand<R: Rng>(rng: &mut R) -> @T { @rng.gen() }
 }
+
+#[cfg(test)]
+mod tests {
+    use rand::Rng;
+    struct ConstantRng(u64);
+    impl Rng for ConstantRng {
+        fn next_u64(&mut self) -> u64 {
+            **self
+        }
+    }
+    fn floating_point_edge_cases() {
+        // the test for exact equality is correct here.
+        assert!(ConstantRng(0xffff_ffff).gen::<f32>() != 1.0)
+        assert!(ConstantRng(0xffff_ffff_ffff_ffff).gen::<f64>() != 1.0)
+    }
+}