---

yaml
---
r: 145828
b: refs/heads/try2
c: 71addde
h: refs/heads/master
v: v3

Author: huonw

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 5bb5f7678530c32caa11a1bc31e27187ff74bc19
+refs/heads/try2: 71addded64548ff845d9ef3852a2c1d2592ae39f
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libstd/rand/isaac.rs

@@ -10,7 +10,8 @@
 
 //! The ISAAC random number generator.
 
-use rand::{seed, Rng, SeedableRng};
+use cast;
+use rand::{Rng, SeedableRng, OSRng};
 use iter::{Iterator, range, range_step, Repeat};
 use option::{None, Some};
 
@@ -29,23 +30,31 @@ pub struct IsaacRng {
     priv b: u32,
     priv c: u32
 }
+static EMPTY: IsaacRng = IsaacRng {
+    cnt: 0,
+    rsl: [0, .. RAND_SIZE],
+    mem: [0, .. RAND_SIZE],
+    a: 0, b: 0, c: 0
+};
 
 impl IsaacRng {
     /// Create an ISAAC random number generator with a random seed.
     pub fn new() -> IsaacRng {
-        let s = unsafe {seed::<u32>(RAND_SIZE as uint)};
-        SeedableRng::from_seed(s.as_slice())
+        let mut rng = EMPTY;
+
+        {
+            let bytes = unsafe {cast::transmute::<&mut [u32], &mut [u8]>(rng.rsl)};
+            OSRng::new().fill_bytes(bytes);
+        }
+
+        rng.init(true);
+        rng
     }
 
     /// Create an ISAAC random number generator using the default
     /// fixed seed.
     pub fn new_unseeded() -> IsaacRng {
-        let mut rng = IsaacRng {
-            cnt: 0,
-            rsl: [0, .. RAND_SIZE],
-            mem: [0, .. RAND_SIZE],
-            a: 0, b: 0, c: 0
-        };
+        let mut rng = EMPTY;
         rng.init(false);
         rng
     }
@@ -193,15 +202,8 @@ impl<'self> SeedableRng<&'self [u32]> for IsaacRng {
     /// constructed with a given seed will generate the same sequence
     /// of values as all other generators constructed with that seed.
     fn from_seed(seed: &'self [u32]) -> IsaacRng {
-        let mut rng = IsaacRng {
-            cnt: 0,
-            rsl: [0, .. RAND_SIZE],
-            mem: [0, .. RAND_SIZE],
-            a: 0, b: 0, c: 0
-        };
-
+        let mut rng = EMPTY;
         rng.reseed(seed);
-
         rng
     }
 }
@@ -224,23 +226,30 @@ pub struct Isaac64Rng {
     priv c: u64,
 }
 
+static EMPTY_64: Isaac64Rng = Isaac64Rng {
+    cnt: 0,
+    rsl: [0, .. RAND_SIZE_64],
+    mem: [0, .. RAND_SIZE_64],
+    a: 0, b: 0, c: 0,
+};
+
 impl Isaac64Rng {
     /// Create a 64-bit ISAAC random number generator with a random
     /// seed.
     pub fn new() -> Isaac64Rng {
-        let s = unsafe {seed::<u64>(RAND_SIZE_64)};
-        SeedableRng::from_seed(s.as_slice())
+        let mut rng = EMPTY_64;
+        {
+            let bytes = unsafe {cast::transmute::<&mut [u64], &mut [u8]>(rng.rsl)};
+            OSRng::new().fill_bytes(bytes);
+        }
+        rng.init(true);
+        rng
     }
 
     /// Create a 64-bit ISAAC random number generator using the
     /// default fixed seed.
     pub fn new_unseeded() -> Isaac64Rng {
-        let mut rng = Isaac64Rng {
-            cnt: 0,
-            rsl: [0, .. RAND_SIZE_64],
-            mem: [0, .. RAND_SIZE_64],
-            a: 0, b: 0, c: 0,
-        };
+        let mut rng = EMPTY_64;
         rng.init(false);
         rng
     }
@@ -388,12 +397,7 @@ impl<'self> SeedableRng<&'self [u64]> for Isaac64Rng {
     /// constructed with a given seed will generate the same sequence
     /// of values as all other generators constructed with that seed.
     fn from_seed(seed: &'self [u64]) -> Isaac64Rng {
-        let mut rng = Isaac64Rng {
-            cnt: 0,
-            rsl: [0, .. RAND_SIZE_64],
-            mem: [0, .. RAND_SIZE_64],
-            a: 0, b: 0, c: 0,
-        };
+        let mut rng = EMPTY_64;
         rng.reseed(seed);
         rng
     }
@@ -402,21 +406,21 @@ impl<'self> SeedableRng<&'self [u64]> for Isaac64Rng {
 #[cfg(test)]
 mod test {
     use super::*;
-    use rand::{Rng, SeedableRng, seed};
+    use rand::{Rng, SeedableRng, OSRng};
     use option::Some;
     use iter::range;
     use vec;
 
     #[test]
     fn test_rng_32_rand_seeded() {
-        let s = unsafe {seed::<u32>(256)};
+        let s = OSRng::new().gen_vec::<u32>(256);
         let mut ra: IsaacRng = SeedableRng::from_seed(s.as_slice());
         let mut rb: IsaacRng = SeedableRng::from_seed(s.as_slice());
         assert_eq!(ra.gen_ascii_str(100u), rb.gen_ascii_str(100u));
     }
     #[test]
     fn test_rng_64_rand_seeded() {
-        let s = unsafe {seed::<u64>(256)};
+        let s = OSRng::new().gen_vec::<u64>(256);
         let mut ra: Isaac64Rng = SeedableRng::from_seed(s.as_slice());
         let mut rb: Isaac64Rng = SeedableRng::from_seed(s.as_slice());
         assert_eq!(ra.gen_ascii_str(100u), rb.gen_ascii_str(100u));
@@ -439,7 +443,7 @@ mod test {
 
     #[test]
     fn test_rng_32_reseed() {
-        let s = unsafe {seed::<u32>(256)};
+        let s = OSRng::new().gen_vec::<u32>(256);
         let mut r: IsaacRng = SeedableRng::from_seed(s.as_slice());
         let string1 = r.gen_ascii_str(100);
 
@@ -450,7 +454,7 @@ mod test {
     }
     #[test]
     fn test_rng_64_reseed() {
-        let s = unsafe {seed::<u64>(256)};
+        let s = OSRng::new().gen_vec::<u64>(256);
         let mut r: Isaac64Rng = SeedableRng::from_seed(s.as_slice());
         let string1 = r.gen_ascii_str(100);
 

branches/try2/src/libstd/rand/mod.rs

@@ -672,20 +672,6 @@ impl XorShiftRng {
     }
 }
 
-/// Create a new random seed of length `n`. This should only be used
-/// to create types for which *any* bit pattern is valid.
-pub unsafe fn seed<T: Clone>(n: uint) -> ~[T] {
-    use unstable::intrinsics;
-    let mut s = vec::from_elem(n, intrinsics::init());
-    let mut r = OSRng::new();
-
-    {
-        let s_u8 = cast::transmute::<&mut [T], &mut [u8]>(s);
-        r.fill_bytes(s_u8);
-    }
-    s
-}
-
 /// Controls how the task-local RNG is reseeded.
 enum TaskRngReseeder {
     /// Reseed using the StdRng::new() function, i.e. reading new
@@ -994,15 +980,15 @@ mod test {
 
     #[test]
     fn test_std_rng_seeded() {
-        let s = unsafe {seed::<uint>(256)};
+        let s = OSRng::new().gen_vec::<uint>(256);
         let mut ra: StdRng = SeedableRng::from_seed(s.as_slice());
         let mut rb: StdRng = SeedableRng::from_seed(s.as_slice());
         assert_eq!(ra.gen_ascii_str(100u), rb.gen_ascii_str(100u));
     }
 
     #[test]
     fn test_std_rng_reseed() {
-        let s = unsafe {seed::<uint>(256)};
+        let s = OSRng::new().gen_vec::<uint>(256);
         let mut r: StdRng = SeedableRng::from_seed(s.as_slice());
         let string1 = r.gen_ascii_str(100);