Add StdRng serde

We get this for free after implementing Isaac via derive.

Author: UserAB1236872

benches/bench.rs.bk

@@ -0,0 +1,97 @@
+#![feature(test)]
+
+extern crate test;
+extern crate rand;
+
+const RAND_BENCH_N: u64 = 1000;
+
+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};
+
+#[bench]
+fn rand_xorshift(b: &mut Bencher) {
+    let mut rng: XorShiftRng = OsRng::new().unwrap().gen();
+    b.iter(|| {
+        for _ in 0..RAND_BENCH_N {
+            black_box(rng.gen::<usize>());
+        }
+    });
+    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();
+    b.iter(|| {
+        for _ in 0..RAND_BENCH_N {
+            black_box(rng.gen::<usize>());
+        }
+    });
+    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();
+    b.iter(|| {
+        for _ in 0..RAND_BENCH_N {
+            black_box(rng.gen::<usize>());
+        }
+    });
+    b.bytes = size_of::<usize>() as u64 * RAND_BENCH_N;
+}
+
+#[bench]
+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>());
+        }
+    });
+    b.bytes = size_of::<usize>() as u64 * RAND_BENCH_N;
+}
+
+#[bench]
+fn rand_f32(b: &mut Bencher) {
+    let mut rng = StdRng::new().unwrap();
+    b.iter(|| {
+        for _ in 0..RAND_BENCH_N {
+            black_box(rng.next_f32());
+        }
+    });
+    b.bytes = size_of::<f32>() as u64 * RAND_BENCH_N;
+}
+
+#[bench]
+fn rand_f64(b: &mut Bencher) {
+    let mut rng = StdRng::new().unwrap();
+    b.iter(|| {
+        for _ in 0..RAND_BENCH_N {
+            black_box(rng.next_f64());
+        }
+    });
+    b.bytes = size_of::<f64>() as u64 * RAND_BENCH_N;
+}
+
+#[bench]
+fn rand_shuffle_100(b: &mut Bencher) {
+    let mut rng = weak_rng();
+    let x : &mut [usize] = &mut [1; 100];
+    b.iter(|| {
+        rng.shuffle(x);
+    })
+}
+
+#[bench]
+fn rand_sample_10_of_100(b: &mut Bencher) {
+    let mut rng = weak_rng();
+    let x : &[usize] = &[1; 100];
+    b.iter(|| {
+        sample(&mut rng, x, 10);
+    })
+}

benches/distributions/exponential.rs.bk

@@ -0,0 +1,18 @@
+use std::mem::size_of;
+use test::Bencher;
+use rand;
+use rand::distributions::exponential::Exp;
+use rand::distributions::Sample;
+
+#[bench]
+fn rand_exp(b: &mut Bencher) {
+    let mut rng = rand::weak_rng();
+    let mut exp = Exp::new(2.71828 * 3.14159);
+
+    b.iter(|| {
+        for _ in 0..::RAND_BENCH_N {
+            exp.sample(&mut rng);
+        }
+    });
+    b.bytes = size_of::<f64>() as u64 * ::RAND_BENCH_N;
+}

benches/distributions/gamma.rs.bk

@@ -0,0 +1,31 @@
+use std::mem::size_of;
+use test::Bencher;
+use rand;
+use rand::distributions::IndependentSample;
+use rand::distributions::gamma::Gamma;
+
+#[bench]
+fn bench_gamma_large_shape(b: &mut Bencher) {
+    let gamma = Gamma::new(10., 1.0);
+    let mut rng = rand::weak_rng();
+
+    b.iter(|| {
+        for _ in 0..::RAND_BENCH_N {
+            gamma.ind_sample(&mut rng);
+        }
+    });
+    b.bytes = size_of::<f64>() as u64 * ::RAND_BENCH_N;
+}
+
+#[bench]
+fn bench_gamma_small_shape(b: &mut Bencher) {
+    let gamma = Gamma::new(0.1, 1.0);
+    let mut rng = rand::weak_rng();
+
+    b.iter(|| {
+        for _ in 0..::RAND_BENCH_N {
+            gamma.ind_sample(&mut rng);
+        }
+    });
+    b.bytes = size_of::<f64>() as u64 * ::RAND_BENCH_N;
+}

benches/distributions/mod.rs.bk

@@ -0,0 +1,3 @@
+mod exponential;
+mod normal;
+mod gamma;

benches/distributions/normal.rs.bk

@@ -0,0 +1,18 @@
+use std::mem::size_of;
+use test::Bencher;
+use rand;
+use rand::distributions::Sample;
+use rand::distributions::normal::Normal;
+
+#[bench]
+fn rand_normal(b: &mut Bencher) {
+    let mut rng = rand::weak_rng();
+    let mut normal = Normal::new(-2.71828, 3.14159);
+
+    b.iter(|| {
+        for _ in 0..::RAND_BENCH_N {
+            normal.sample(&mut rng);
+        }
+    });
+    b.bytes = size_of::<f64>() as u64 * ::RAND_BENCH_N;
+}