Update rand to 0.5

cuviper · cuviper · commit 23e7d9baf209 · 2018-07-11T13:19:16.000-07:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -29,6 +29,6 @@ default-features = false
 [dev-dependencies]
 docopt = "1"
 lazy_static = "1"
-rand = "0.4"
+rand = "0.5"
 serde = "1"
 serde_derive = "1"
diff --git a/rayon-core/Cargo.toml b/rayon-core/Cargo.toml
@@ -24,7 +24,7 @@ lazy_static = "1"
 version = "0.2.0"
 
 [dev-dependencies]
-rand = "0.4"
+rand = "0.5"
 
 [[test]]
 name = "stack_overflow_crash"
diff --git a/rayon-core/src/join/test.rs b/rayon-core/src/join/test.rs
@@ -3,6 +3,7 @@
 use ThreadPoolBuilder;
 use join::*;
 use rand::{Rng, SeedableRng, XorShiftRng};
+use rand::distributions::Standard;
 use unwind;
 
 fn quick_sort<T: PartialOrd + Send>(v: &mut [T]) {
@@ -28,10 +29,16 @@ fn partition<T: PartialOrd + Send>(v: &mut [T]) -> usize {
     i
 }
 
+fn seeded_rng() -> XorShiftRng {
+    let mut seed = <XorShiftRng as SeedableRng>::Seed::default();
+    (0..).zip(seed.as_mut()).for_each(|(i, x)| *x = i);
+    XorShiftRng::from_seed(seed)
+}
+
 #[test]
 fn sort() {
-    let mut rng = XorShiftRng::from_seed([0, 1, 2, 3]);
-    let mut data: Vec<_> = (0..6 * 1024).map(|_| rng.next_u32()).collect();
+    let mut rng = seeded_rng();
+    let mut data: Vec<u32> = rng.sample_iter(&Standard).take(6 * 1024).collect();
     let mut sorted_data = data.clone();
     sorted_data.sort();
     quick_sort(&mut data);
@@ -40,8 +47,8 @@ fn sort() {
 
 #[test]
 fn sort_in_pool() {
-    let mut rng = XorShiftRng::from_seed([0, 1, 2, 3]);
-    let mut data: Vec<_> = (0..12 * 1024).map(|_| rng.next_u32()).collect();
+    let mut rng = seeded_rng();
+    let mut data: Vec<u32> = rng.sample_iter(&Standard).take(12 * 1024).collect();
 
     let pool = ThreadPoolBuilder::new().build().unwrap();
     let mut sorted_data = data.clone();
diff --git a/rayon-core/src/scope/test.rs b/rayon-core/src/scope/test.rs
@@ -105,21 +105,23 @@ impl<T: Send> Tree<T> {
 
 fn random_tree(depth: usize) -> Tree<u32> {
     assert!(depth > 0);
-    let mut rng = XorShiftRng::from_seed([0, 1, 2, 3]);
+    let mut seed = <XorShiftRng as SeedableRng>::Seed::default();
+    (0..).zip(seed.as_mut()).for_each(|(i, x)| *x = i);
+    let mut rng = XorShiftRng::from_seed(seed);
     random_tree1(depth, &mut rng)
 }
 
 fn random_tree1(depth: usize, rng: &mut XorShiftRng) -> Tree<u32> {
     let children = if depth == 0 {
         vec![]
     } else {
-        (0..(rng.next_u32() % 3)) // somewhere between 0 and 3 children at each level
+        (0..rng.gen_range(0, 4)) // somewhere between 0 and 3 children at each level
             .map(|_| random_tree1(depth - 1, rng))
             .collect()
     };
 
     Tree {
-        value: rng.next_u32() % 1_000_000,
+        value: rng.gen_range(0, 1_000_000),
         children: children,
     }
 }
diff --git a/rayon-demo/Cargo.toml b/rayon-demo/Cargo.toml
@@ -12,7 +12,7 @@ fixedbitset = "0.1.5"
 glium = "0.20"
 lazy_static = "1"
 odds = "0.3"
-rand = "0.4"
+rand = "0.5"
 regex = "0.2"
 serde = "1"
 serde_derive = "1"
diff --git a/rayon-demo/src/find/mod.rs b/rayon-demo/src/find/mod.rs
@@ -5,16 +5,17 @@ macro_rules! make_tests {
         mod $m {
             use rayon::prelude::*;
             use test::Bencher;
-            use rand::{Rng, SeedableRng, XorShiftRng};
+            use rand::Rng;
+            use rand::distributions::Standard;
 
             lazy_static! {
                 static ref HAYSTACK: Vec<[u32; $n]> = {
-                    let mut rng = XorShiftRng::from_seed([0, 1, 2, 3]);
-                    (0..10_000_000).map(|_| {
+                    let mut rng = ::seeded_rng();
+                    rng.sample_iter(&Standard).map(|x| {
                         let mut result: [u32; $n] = [0; $n];
-                        result[0] = rng.next_u32();
+                        result[0] = x;
                         result
-                    }).collect()
+                    }).take(10_000_000).collect()
                 };
             }
 
diff --git a/rayon-demo/src/life/mod.rs b/rayon-demo/src/life/mod.rs
@@ -13,6 +13,7 @@ Options:
 
 
 use rand::{thread_rng, Rng};
+use rand::distributions::Standard;
 use std::iter::repeat;
 use std::num::Wrapping;
 use std::sync::Arc;
@@ -74,7 +75,7 @@ impl Board {
     }
 
     pub fn random(&self) -> Board {
-        let new_brd = thread_rng().gen_iter().take(self.len()).collect();
+        let new_brd = thread_rng().sample_iter(&Standard).take(self.len()).collect();
 
         self.next_board(new_brd)
     }
diff --git a/rayon-demo/src/main.rs b/rayon-demo/src/main.rs
@@ -95,3 +95,10 @@ fn main() {
         _ => usage()
     }
 }
+
+fn seeded_rng() -> rand::XorShiftRng {
+    use rand::{SeedableRng, XorShiftRng};
+    let mut seed = <XorShiftRng as SeedableRng>::Seed::default();
+    (0..).zip(seed.as_mut()).for_each(|(i, x)| *x = i);
+    XorShiftRng::from_seed(seed)
+}
diff --git a/rayon-demo/src/mergesort/mod.rs b/rayon-demo/src/mergesort/mod.rs
@@ -1,4 +1,5 @@
-use rand::{Rng, SeedableRng, XorShiftRng};
+use rand::Rng;
+use rand::distributions::Standard;
 
 const USAGE: &'static str = "
 Usage: mergesort bench [--size N]
@@ -220,8 +221,8 @@ pub fn is_sorted<T: Send + Ord>(v: &mut [T]) -> bool {
 }
 
 fn default_vec(n: usize) -> Vec<u32> {
-    let mut rng = XorShiftRng::from_seed([0, 1, 2, 3]);
-    (0..n).map(|_| rng.next_u32()).collect()
+    let mut rng = ::seeded_rng();
+    rng.sample_iter(&Standard).take(n).collect()
 }
 
 fn timed_sort<F: FnOnce(&mut [u32])>(n: usize, f: F, name: &str) -> u64 {
diff --git a/rayon-demo/src/nbody/bench.rs b/rayon-demo/src/nbody/bench.rs
@@ -1,4 +1,3 @@
-use rand::{SeedableRng, XorShiftRng};
 use test;
 
 use super::nbody::NBodyBenchmark;
@@ -11,7 +10,7 @@ const BENCH_TICKS: usize = 10;
 fn nbody_bench<TICK>(b: &mut test::Bencher, mut tick: TICK)
     where TICK: FnMut(&mut NBodyBenchmark)
 {
-    let mut rng = XorShiftRng::from_seed([0, 1, 2, 3]);
+    let mut rng = ::seeded_rng();
     let mut benchmark = NBodyBenchmark::new(BENCH_BODIES, &mut rng);
     b.iter(|| {
         for _ in 0 .. BENCH_TICKS {
diff --git a/rayon-demo/src/nbody/mod.rs b/rayon-demo/src/nbody/mod.rs
@@ -1,5 +1,4 @@
 use docopt::Docopt;
-use rand::{SeedableRng, XorShiftRng};
 use time;
 
 #[cfg(test)]
@@ -81,7 +80,7 @@ fn run_benchmarks(mode: Option<ExecutionMode>, bodies: usize, ticks: usize) {
     let run_seq = mode.map(|m| m == ExecutionMode::Seq).unwrap_or(true);
 
     let par_time = if run_par {
-        let mut rng = XorShiftRng::from_seed([0, 1, 2, 3]);
+        let mut rng = ::seeded_rng();
         let mut benchmark = NBodyBenchmark::new(bodies, &mut rng);
         let par_start = time::precise_time_ns();
 
@@ -98,7 +97,7 @@ fn run_benchmarks(mode: Option<ExecutionMode>, bodies: usize, ticks: usize) {
     };
 
     let par_reduce_time = if run_par_reduce {
-        let mut rng = XorShiftRng::from_seed([0, 1, 2, 3]);
+        let mut rng = ::seeded_rng();
         let mut benchmark = NBodyBenchmark::new(bodies, &mut rng);
         let par_start = time::precise_time_ns();
 
@@ -115,7 +114,7 @@ fn run_benchmarks(mode: Option<ExecutionMode>, bodies: usize, ticks: usize) {
     };
 
     let seq_time = if run_seq {
-        let mut rng = XorShiftRng::from_seed([0, 1, 2, 3]);
+        let mut rng = ::seeded_rng();
         let mut benchmark = NBodyBenchmark::new(bodies, &mut rng);
         let seq_start = time::precise_time_ns();
 
diff --git a/rayon-demo/src/nbody/nbody.rs b/rayon-demo/src/nbody/nbody.rs
@@ -30,7 +30,7 @@
 // [1]: https://github.com/IntelLabs/RiverTrail/blob/master/examples/nbody-webgl/NBody.js
 
 use cgmath::{InnerSpace, Point3, Vector3, Zero};
-use rand::{Rand, Rng};
+use rand::Rng;
 use rayon::prelude::*;
 #[cfg(test)]
 use rayon::iter::ParallelBridge;
@@ -54,22 +54,25 @@ impl NBodyBenchmark {
     pub fn new<R: Rng>(num_bodies: usize, rng: &mut R) -> NBodyBenchmark {
         let bodies0: Vec<_> = (0..num_bodies)
             .map(|_| {
+                let r = rng.gen_range(0.0, 10_000.0);
+                let theta = rng.gen_range(0.0, PI);
+                let phi = rng.gen_range(0.0, 2.0 * PI);
                 let position = Point3 {
-                    x: f64::rand(rng).floor() * 40_000.0,
-                    y: f64::rand(rng).floor() * 20_000.0,
-                    z: (f64::rand(rng).floor() - 0.25) * 50_000.0,
+                    x: r * theta.sin() * phi.cos(),
+                    y: r * theta.sin() * phi.sin(),
+                    z: r * theta.cos(),
                 };
 
                 let velocity = Vector3 {
-                    x: (f64::rand(rng) - 0.5) * INITIAL_VELOCITY,
-                    y: (f64::rand(rng) - 0.5) * INITIAL_VELOCITY,
-                    z: f64::rand(rng) * INITIAL_VELOCITY + 10.0,
+                    x: rng.gen_range(-0.5, 0.5) * INITIAL_VELOCITY,
+                    y: rng.gen_range(-0.5, 0.5) * INITIAL_VELOCITY,
+                    z: rng.gen::<f64>() * INITIAL_VELOCITY + 10.0,
                 };
 
                 let velocity2 = Vector3 {
-                    x: (f64::rand(rng) - 0.5) * INITIAL_VELOCITY,
-                    y: (f64::rand(rng) - 0.5) * INITIAL_VELOCITY,
-                    z: f64::rand(rng) * INITIAL_VELOCITY,
+                    x: rng.gen_range(-0.5, 0.5) * INITIAL_VELOCITY,
+                    y: rng.gen_range(-0.5, 0.5) * INITIAL_VELOCITY,
+                    z: rng.gen::<f64>() * INITIAL_VELOCITY,
                 };
 
                 Body {
diff --git a/rayon-demo/src/nbody/visualize.rs b/rayon-demo/src/nbody/visualize.rs
@@ -6,7 +6,7 @@ use glium::glutin::{EventsLoop, WindowBuilder, ContextBuilder};
 use glium::glutin::{ElementState, Event, WindowEvent};
 use glium::glutin::VirtualKeyCode as Key;
 use glium::index::PrimitiveType;
-use rand::{self, Rng, SeedableRng, XorShiftRng};
+use rand::{self, Rng};
 
 use nbody::nbody::NBodyBenchmark;
 use nbody::ExecutionMode;
@@ -115,7 +115,7 @@ pub fn visualize_benchmarks(num_bodies: usize, mut mode: ExecutionMode) {
     let vertex_buffer = VertexBuffer::new(&display, &vertices).unwrap();
     let index_buffer = IndexBuffer::new(&display, PrimitiveType::TrianglesList, &indices).unwrap();
 
-    let mut rng = XorShiftRng::from_seed([0, 1, 2, 3]);
+    let mut rng = ::seeded_rng();
     let instances: Vec<_> =
         (0..num_bodies)
             .map(|_| {
diff --git a/rayon-demo/src/quicksort/mod.rs b/rayon-demo/src/quicksort/mod.rs
@@ -23,7 +23,8 @@ pub struct Args {
 }
 
 use docopt::Docopt;
-use rand::{Rng, SeedableRng, XorShiftRng};
+use rand::Rng;
+use rand::distributions::Standard;
 use rayon;
 use std::time::Instant;
 
@@ -99,8 +100,8 @@ pub fn is_sorted<T: Send + Ord>(v: &[T]) -> bool {
 }
 
 fn default_vec(n: usize) -> Vec<u32> {
-    let mut rng = XorShiftRng::from_seed([0, 1, 2, 3]);
-    (0..n).map(|_| rng.next_u32()).collect()
+    let mut rng = ::seeded_rng();
+    rng.sample_iter(&Standard).take(n).collect()
 }
 
 fn timed_sort<F: FnOnce(&mut [u32])>(n: usize, f: F, name: &str) -> u64 {
diff --git a/rayon-demo/src/sort.rs b/rayon-demo/src/sort.rs
@@ -1,4 +1,5 @@
-use rand::{Rng, SeedableRng, XorShiftRng};
+use rand::Rng;
+use rand::distributions::{Alphanumeric, Standard, Uniform};
 use rayon::prelude::*;
 use std::mem;
 use std::sync::atomic::AtomicUsize;
@@ -14,45 +15,48 @@ fn gen_descending(len: usize) -> Vec<u64> {
 }
 
 fn gen_random(len: usize) -> Vec<u64> {
-    let mut rng = XorShiftRng::from_seed([0, 1, 2, 3]);
-    rng.gen_iter::<u64>().take(len).collect()
+    let mut rng = ::seeded_rng();
+    rng.sample_iter(&Standard).take(len).collect()
 }
 
 fn gen_mostly_ascending(len: usize) -> Vec<u64> {
-    let mut rng = XorShiftRng::from_seed([0, 1, 2, 3]);
+    let mut rng = ::seeded_rng();
+    let len_dist = Uniform::new(0, len);
     let mut v = gen_ascending(len);
     for _ in (0usize..).take_while(|x| x * x <= len) {
-        let x = rng.gen::<usize>() % len;
-        let y = rng.gen::<usize>() % len;
+        let x = rng.sample(&len_dist);
+        let y = rng.sample(&len_dist);
         v.swap(x, y);
     }
     v
 }
 
 fn gen_mostly_descending(len: usize) -> Vec<u64> {
-    let mut rng = XorShiftRng::from_seed([0, 1, 2, 3]);
+    let mut rng = ::seeded_rng();
+    let len_dist = Uniform::new(0, len);
     let mut v = gen_descending(len);
     for _ in (0usize..).take_while(|x| x * x <= len) {
-        let x = rng.gen::<usize>() % len;
-        let y = rng.gen::<usize>() % len;
+        let x = rng.sample(&len_dist);
+        let y = rng.sample(&len_dist);
         v.swap(x, y);
     }
     v
 }
 
 fn gen_strings(len: usize) -> Vec<String> {
-    let mut rng = XorShiftRng::from_seed([0, 1, 2, 3]);
+    let mut rng = ::seeded_rng();
+    let len_dist = Uniform::new(1, 21);
     let mut v = vec![];
     for _ in 0..len {
-        let n = rng.gen::<usize>() % 20 + 1;
-        v.push(rng.gen_ascii_chars().take(n).collect());
+        let n = rng.sample(&len_dist);
+        v.push(rng.sample_iter(&Alphanumeric).take(n).collect());
     }
     v
 }
 
 fn gen_big_random(len: usize) -> Vec<[u64; 16]> {
-    let mut rng = XorShiftRng::from_seed([0, 1, 2, 3]);
-    rng.gen_iter().map(|x| [x; 16]).take(len).collect()
+    let mut rng = ::seeded_rng();
+    rng.sample_iter(&Standard).map(|x| [x; 16]).take(len).collect()
 }
 
 macro_rules! sort {
diff --git a/rayon-demo/src/str_split.rs b/rayon-demo/src/str_split.rs
@@ -1,12 +1,12 @@
 //! Some microbenchmarks for splitting strings
 
 use rayon::prelude::*;
-use rand::{Rng, SeedableRng, XorShiftRng};
+use rand::Rng;
 use test::Bencher;
 
 lazy_static! {
     static ref HAYSTACK: String = {
-        let mut rng = XorShiftRng::from_seed([0, 1, 2, 3]);
+        let mut rng = ::seeded_rng();
         let mut bytes: Vec<u8> = "abcdefg ".bytes().cycle().take(1_000_000).collect();
         rng.shuffle(&mut bytes);
         String::from_utf8(bytes).unwrap()
diff --git a/src/iter/test.rs b/src/iter/test.rs
diff --git a/src/slice/mergesort.rs b/src/slice/mergesort.rs
diff --git a/src/slice/quicksort.rs b/src/slice/quicksort.rs
diff --git a/src/slice/test.rs b/src/slice/test.rs
diff --git a/tests/sort-panic-safe.rs b/tests/sort-panic-safe.rs
diff --git a/tests/str.rs b/tests/str.rs

Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ Options:`
`13`	`13`
`14`	`14`
`15`	`15`	`use rand::{thread_rng, Rng};`
	`16`	`+use rand::distributions::Standard;`
`16`	`17`	`use std::iter::repeat;`
`17`	`18`	`use std::num::Wrapping;`
`18`	`19`	`use std::sync::Arc;`
`@@ -74,7 +75,7 @@ impl Board {`
`74`	`75`	`}`
`75`	`76`
`76`	`77`	`pub fn random(&self) -> Board {`
`77`		`- let new_brd = thread_rng().gen_iter().take(self.len()).collect();`
	`78`	`+ let new_brd = thread_rng().sample_iter(&Standard).take(self.len()).collect();`
`78`	`79`
`79`	`80`	`self.next_board(new_brd)`
`80`	`81`	`}`
Original file line number	Diff line number	Diff line change
`@@ -95,3 +95,10 @@ fn main() {`
`95`	`95`	`_ => usage()`
`96`	`96`	`}`
`97`	`97`	`}`
	`98`	`+`
	`99`	`+fn seeded_rng() -> rand::XorShiftRng {`
	`100`	`+ use rand::{SeedableRng, XorShiftRng};`
	`101`	`+ let mut seed = <XorShiftRng as SeedableRng>::Seed::default();`
	`102`	`+ (0..).zip(seed.as_mut()).for_each(\|(i, x)\| *x = i);`
	`103`	`+ XorShiftRng::from_seed(seed)`
	`104`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`		`-use rand::{Rng, SeedableRng, XorShiftRng};`
	`1`	`+use rand::Rng;`
	`2`	`+use rand::distributions::Standard;`
`2`	`3`
`3`	`4`	`const USAGE: &'static str = "`
`4`	`5`	`Usage: mergesort bench [--size N]`
`@@ -220,8 +221,8 @@ pub fn is_sorted<T: Send + Ord>(v: &mut [T]) -> bool {`
`220`	`221`	`}`
`221`	`222`
`222`	`223`	`fn default_vec(n: usize) -> Vec<u32> {`
`223`		`- let mut rng = XorShiftRng::from_seed([0, 1, 2, 3]);`
`224`		`- (0..n).map(\|_\| rng.next_u32()).collect()`
	`224`	`+ let mut rng = ::seeded_rng();`
	`225`	`+ rng.sample_iter(&Standard).take(n).collect()`
`225`	`226`	`}`
`226`	`227`
`227`	`228`	`fn timed_sort<F: FnOnce(&mut [u32])>(n: usize, f: F, name: &str) -> u64 {`