Crate refactor

Cargo.toml

@@ -20,11 +20,5 @@ nightly = ["i128_support"]
 [dependencies]
 libc = "0.2"
 
-[dev-dependencies]
-log = "0.3.0"
-
-[workspace]
-members = ["rand-derive"]
-
 [target.'cfg(target_os = "fuchsia")'.dependencies]
 magenta = "^0.1.1"

README.md

@@ -25,57 +25,36 @@ extern crate rand;
 
 ## Examples
 
-There is built-in support for a random number generator (RNG) associated with each thread stored in thread-local storage. This RNG can be accessed via thread_rng, or used implicitly via random. This RNG is normally randomly seeded from an operating-system source of randomness, e.g. /dev/urandom on Unix systems, and will automatically reseed itself from this source after generating 32 KiB of random data.
+There is built-in support for a random number generator (RNG) associated with
+each thread stored in thread-local storage. This RNG can be accessed via
+thread_rng.
 
 ```rust
-let tuple = rand::random::<(f64, char)>();
-println!("{:?}", tuple)
+use rand::thread_rng;
+
+let x: u32 = thread_rng().next_u32();
+println!("{}", u32)
 ```
 
 ```rust
+use rand::dist::{uniform};
 use rand::Rng;
 
 let mut rng = rand::thread_rng();
-if rng.gen() { // random bool
-    println!("i32: {}, u32: {}", rng.gen::<i32>(), rng.gen::<u32>())
+if uniform(&mut rng) { // random bool
+    let x: i32 = uniform(&mut rng);
+    let y: u32 = uniform(&mut rng);
+    println!("i32: {}, u32: {}", x, y);
 }
 ```
 
-It is also possible to use other RNG types, which have a similar interface. The following uses the "ChaCha" algorithm instead of the default.
-
-```rust
-use rand::{Rng, ChaChaRng};
-
-let mut rng = rand::ChaChaRng::new_unseeded();
-println!("i32: {}, u32: {}", rng.gen::<i32>(), rng.gen::<u32>())
-```
-
-# `derive(Rand)`
-
-You can derive the `Rand` trait for your custom type via the `#[derive(Rand)]`
-directive. To use this first add this to your Cargo.toml:
-
-```toml
-rand = "0.3"
-rand-derive = "0.3"
-```
-
-Next in your crate:
+It is also possible to use other generators types, which have a similar interface. The following uses the "ChaCha" algorithm instead of the default.
 
 ```rust
-extern crate rand;
-#[macro_use]
-extern crate rand_derive;
-
-#[derive(Rand, Debug)]
-struct MyStruct {
-    a: i32,
-    b: u32,
-}
+use rand::{thread_rng, ChaChaRng, dist};
 
-fn main() {
-    println!("{:?}", rand::random::<MyStruct>());
-}
+let mut rng = ChaChaRng::new_from_rng(&mut thread_rng());
+println!("random between 0-9: {}", dist::range(0, 10, &mut rng));
 ```
 
 

benches/bench.rs

@@ -9,37 +9,39 @@ mod distributions;
 
 use std::mem::size_of;
 use test::{black_box, Bencher};
-use rand::{XorShiftRng, StdRng, IsaacRng, Isaac64Rng, Rng};
-use rand::{OsRng, sample, weak_rng};
+use rand::{Rng, StdRng, OsRng, weak_rng};
+use rand::prng::{XorShiftRng, IsaacRng, Isaac64Rng};
+use rand::{sample, Shuffle};
+use rand::dist::uniform;
 
 #[bench]
 fn rand_xorshift(b: &mut Bencher) {
-    let mut rng: XorShiftRng = OsRng::new().unwrap().gen();
+    let mut rng = XorShiftRng::new_from_rng(&mut OsRng::new().unwrap());
     b.iter(|| {
         for _ in 0..RAND_BENCH_N {
-            black_box(rng.gen::<usize>());
+            black_box(uniform::<usize, _>(&mut rng));
         }
     });
     b.bytes = size_of::<usize>() as u64 * RAND_BENCH_N;
 }
 
 #[bench]
 fn rand_isaac(b: &mut Bencher) {
-    let mut rng: IsaacRng = OsRng::new().unwrap().gen();
+    let mut rng = IsaacRng::new_from_rng(&mut OsRng::new().unwrap());
     b.iter(|| {
         for _ in 0..RAND_BENCH_N {
-            black_box(rng.gen::<usize>());
+            black_box(uniform::<usize, _>(&mut rng));
         }
     });
     b.bytes = size_of::<usize>() as u64 * RAND_BENCH_N;
 }
 
 #[bench]
 fn rand_isaac64(b: &mut Bencher) {
-    let mut rng: Isaac64Rng = OsRng::new().unwrap().gen();
+    let mut rng = Isaac64Rng::new_from_rng(&mut OsRng::new().unwrap());
     b.iter(|| {
         for _ in 0..RAND_BENCH_N {
-            black_box(rng.gen::<usize>());
+            black_box(uniform::<usize, _>(&mut rng));
         }
     });
     b.bytes = size_of::<usize>() as u64 * RAND_BENCH_N;
@@ -50,7 +52,7 @@ fn rand_std(b: &mut Bencher) {
     let mut rng = StdRng::new().unwrap();
     b.iter(|| {
         for _ in 0..RAND_BENCH_N {
-            black_box(rng.gen::<usize>());
+            black_box(uniform::<usize, _>(&mut rng));
         }
     });
     b.bytes = size_of::<usize>() as u64 * RAND_BENCH_N;
@@ -83,7 +85,7 @@ fn rand_shuffle_100(b: &mut Bencher) {
     let mut rng = weak_rng();
     let x : &mut [usize] = &mut [1; 100];
     b.iter(|| {
-        rng.shuffle(x);
+        x.shuffle(&mut rng);
     })
 }
 

benches/distributions/exponential.rs

@@ -1,13 +1,13 @@
 use std::mem::size_of;
 use test::Bencher;
 use rand;
-use rand::distributions::exponential::Exp;
-use rand::distributions::Sample;
+use rand::dist::exponential::Exp;
+use rand::dist::Distribution;
 
 #[bench]
 fn rand_exp(b: &mut Bencher) {
     let mut rng = rand::weak_rng();
-    let mut exp = Exp::new(2.71828 * 3.14159);
+    let exp = Exp::new(2.71828 * 3.14159);
 
     b.iter(|| {
         for _ in 0..::RAND_BENCH_N {

benches/distributions/gamma.rs

@@ -1,8 +1,8 @@
 use std::mem::size_of;
 use test::Bencher;
 use rand;
-use rand::distributions::IndependentSample;
-use rand::distributions::gamma::Gamma;
+use rand::dist::Distribution;
+use rand::dist::gamma::Gamma;
 
 #[bench]
 fn bench_gamma_large_shape(b: &mut Bencher) {
@@ -11,7 +11,7 @@ fn bench_gamma_large_shape(b: &mut Bencher) {
 
     b.iter(|| {
         for _ in 0..::RAND_BENCH_N {
-            gamma.ind_sample(&mut rng);
+            gamma.sample(&mut rng);
         }
     });
     b.bytes = size_of::<f64>() as u64 * ::RAND_BENCH_N;
@@ -24,7 +24,7 @@ fn bench_gamma_small_shape(b: &mut Bencher) {
 
     b.iter(|| {
         for _ in 0..::RAND_BENCH_N {
-            gamma.ind_sample(&mut rng);
+            gamma.sample(&mut rng);
         }
     });
     b.bytes = size_of::<f64>() as u64 * ::RAND_BENCH_N;

benches/distributions/normal.rs

@@ -1,13 +1,13 @@
 use std::mem::size_of;
 use test::Bencher;
 use rand;
-use rand::distributions::Sample;
-use rand::distributions::normal::Normal;
+use rand::dist::Distribution;
+use rand::dist::normal::Normal;
 
 #[bench]
 fn rand_normal(b: &mut Bencher) {
     let mut rng = rand::weak_rng();
-    let mut normal = Normal::new(-2.71828, 3.14159);
+    let normal = Normal::new(-2.71828, 3.14159);
 
     b.iter(|| {
         for _ in 0..::RAND_BENCH_N {