Add uniformity test for unit sphere and circle

Cargo.toml

@@ -58,6 +58,8 @@ wasm-bindgen = { version = "0.2.12", optional = true }
 # This is for testing serde, unfortunately we can't specify feature-gated dev
 # deps yet, see: https://github.com/rust-lang/cargo/issues/1596
 bincode = "1.0"
+# This has a histogram implementation used for testing uniformity.
+average = "0.9.1"
 
 [package.metadata.docs.rs]
 all-features = true

tests/uniformity.rs

@@ -0,0 +1,57 @@
+#[macro_use]
+extern crate average;
+extern crate rand;
+
+use std as core;
+use rand::FromEntropy;
+use rand::distributions::Distribution;
+use average::Histogram;
+
+const N_BINS: usize = 100;
+const N_SAMPLES: u32 = 1_000_000;
+const TOL: f64 = 1e-3;
+define_histogram!(hist, 100);
+use hist::Histogram as Histogram100;
+
+#[test]
+fn unit_sphere() {
+    const N_DIM: usize = 3;
+    let h = Histogram100::with_const_width(-1., 1.);
+    let mut histograms = [h.clone(), h.clone(), h];
+    let dist = rand::distributions::UnitSphereSurface::new();
+    let mut rng = rand::rngs::SmallRng::from_entropy();
+    for _ in 0..N_SAMPLES {
+        let v = dist.sample(&mut rng);
+        for i in 0..N_DIM {
+            histograms[i].add(v[i]).map_err(
+                |e| { println!("v: {}", v[i]); e }
+            ).unwrap();
+        }
+    }
+    for h in &histograms {
+        let sum: u64 = h.bins().iter().sum();
+        println!("{:?}", h);
+        for &b in h.bins() {
+            let p = (b as f64) / (sum as f64);
+            assert!((p - 1.0 / (N_BINS as f64)).abs() < TOL, "{}", p);
+        }
+    }
+}
+
+#[test]
+fn unit_circle() {
+    use ::std::f64::consts::PI;
+    let mut h = Histogram100::with_const_width(-PI, PI);
+    let dist = rand::distributions::UnitCircle::new();
+    let mut rng = rand::rngs::SmallRng::from_entropy();
+    for _ in 0..N_SAMPLES {
+        let v = dist.sample(&mut rng);
+        h.add(v[0].atan2(v[1])).unwrap();
+    }
+    let sum: u64 = h.bins().iter().sum();
+    println!("{:?}", h);
+    for &b in h.bins() {
+        let p = (b as f64) / (sum as f64);
+        assert!((p - 1.0 / (N_BINS as f64)).abs() < TOL, "{}", p);
+    }
+}