Crate refactor

Cargo.toml

@@ -14,17 +14,13 @@ keywords = ["random", "rng"]
 categories = ["algorithms"]
 
 [features]
-i128_support = []
+default = ["std"]
 nightly = ["i128_support"]
+std = []
+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!("{}", x)
 ```
 
 ```rust
+use rand::distributions::{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, distributions};
 
-fn main() {
-    println!("{:?}", rand::random::<MyStruct>());
-}
+let mut rng = ChaChaRng::new_from_rng(&mut thread_rng());
+println!("random between 0-9: {}", distributions::range(0, 10, &mut rng));
 ```
 
 

benches/distributions.rs

@@ -0,0 +1,96 @@
+#![feature(test)]
+
+extern crate test;
+extern crate rand;
+
+const RAND_BENCH_N: u64 = 1000;
+
+use std::mem::size_of;
+use test::Bencher;
+
+use rand::{XorShiftRng, Default, Rand};
+use rand::distributions::Distribution;
+use rand::distributions::exponential::Exp;
+use rand::distributions::normal::{Normal, LogNormal};
+use rand::distributions::gamma::Gamma;
+
+
+#[bench]
+fn distr_baseline(b: &mut Bencher) {
+    let mut rng = XorShiftRng::new();
+
+    b.iter(|| {
+        for _ in 0..::RAND_BENCH_N {
+            f64::rand(&mut rng, Default);
+        }
+    });
+    b.bytes = size_of::<f64>() as u64 * ::RAND_BENCH_N;
+}
+
+
+#[bench]
+fn distr_exp(b: &mut Bencher) {
+    let mut rng = XorShiftRng::new();
+    let distr = Exp::new(2.71828 * 3.14159);
+
+    b.iter(|| {
+        for _ in 0..::RAND_BENCH_N {
+            distr.sample(&mut rng);
+        }
+    });
+    b.bytes = size_of::<f64>() as u64 * ::RAND_BENCH_N;
+}
+
+
+#[bench]
+fn distr_normal(b: &mut Bencher) {
+    let mut rng = XorShiftRng::new();
+    let distr = Normal::new(-2.71828, 3.14159);
+
+    b.iter(|| {
+        for _ in 0..::RAND_BENCH_N {
+            distr.sample(&mut rng);
+        }
+    });
+    b.bytes = size_of::<f64>() as u64 * ::RAND_BENCH_N;
+}
+
+#[bench]
+fn distr_log_normal(b: &mut Bencher) {
+    let mut rng = XorShiftRng::new();
+    let distr = LogNormal::new(-2.71828, 3.14159);
+
+    b.iter(|| {
+        for _ in 0..::RAND_BENCH_N {
+            distr.sample(&mut rng);
+        }
+    });
+    b.bytes = size_of::<f64>() as u64 * ::RAND_BENCH_N;
+}
+
+
+#[bench]
+fn distr_gamma_large_shape(b: &mut Bencher) {
+    let mut rng = XorShiftRng::new();
+    let distr = Gamma::new(10., 1.0);
+
+    b.iter(|| {
+        for _ in 0..::RAND_BENCH_N {
+            distr.sample(&mut rng);
+        }
+    });
+    b.bytes = size_of::<f64>() as u64 * ::RAND_BENCH_N;
+}
+
+#[bench]
+fn distr_gamma_small_shape(b: &mut Bencher) {
+    let mut rng = XorShiftRng::new();
+    let distr = Gamma::new(0.1, 1.0);
+
+    b.iter(|| {
+        for _ in 0..::RAND_BENCH_N {
+            distr.sample(&mut rng);
+        }
+    });
+    b.bytes = size_of::<f64>() as u64 * ::RAND_BENCH_N;
+}