remove the use of gen_range from seq

Author: vitiral

src/seq.rs

@@ -45,7 +45,7 @@ pub fn sample_iter<T, I, R>(rng: &mut R, iterable: I, amount: usize) -> Vec<T>
     // If the iterator stops once, then so do we.
     if reservoir.len() == amount {
         for (i, elem) in iter.enumerate() {
-            let k = rng.gen_range(0, i + 1 + amount);
+            let k = (rng.next_f64() * (i + 1 + amount) as f64) as usize;
             if let Some(spot) = reservoir.get_mut(k) {
                 *spot = elem;
             }
@@ -161,10 +161,10 @@ fn sample_indices_inplace<R>(rng: &mut R, length: usize, amount: usize) -> Vec<u
     let mut indices: Vec<usize> = Vec::with_capacity(length);
     indices.extend(0..length);
     for i in 0..amount {
-        let j: usize = rng.gen_range(i, length);
+        let k = (rng.next_f64() * (length - i) as f64) as usize + i;
         let tmp = indices[i];
-        indices[i] = indices[j];
-        indices[j] = tmp;
+        indices[i] = indices[k];
+        indices[k] = tmp;
     }
     indices.truncate(amount);
     debug_assert_eq!(indices.len(), amount);
@@ -188,22 +188,22 @@ fn sample_indices_cache<R>(
     let mut cache = HashMap::with_capacity(amount);
     let mut out = Vec::with_capacity(amount);
     for i in 0..amount {
-        let j: usize = rng.gen_range(i, length);
+        let k = (rng.next_f64() * (length - i) as f64) as usize + i;
 
         // equiv: let tmp = slice[i];
         let tmp = match cache.get(&i) {
             Some(e) => *e,
             None => i,
         };
 
-        // equiv: slice[i] = slice[j];
-        let x = match cache.get(&j) {
+        // equiv: slice[i] = slice[k];
+        let x = match cache.get(&k) {
             Some(x) => *x,
-            None => j,
+            None => k,
         };
 
-        // equiv: slice[j] = tmp;
-        cache.insert(j, tmp);
+        // equiv: slice[k] = tmp;
+        cache.insert(k, tmp);
 
         // note that in the inplace version, slice[i] is automatically "returned" value
         out.push(x);
@@ -261,6 +261,21 @@ mod test {
         assert_eq!(sample_indices_cache(&mut r, 1, 0), vec![]);
         assert_eq!(sample_indices_cache(&mut r, 1, 1), vec![0]);
 
+        // Make sure lucky 777's aren't lucky
+        let slice = &[42, 777];
+        let mut num_42 = 0;
+        let total = 1000;
+        for _ in 0..total {
+            let v = sample_slice(&mut r, slice, 1);
+            assert_eq!(v.len(), 1);
+            let v = v[0];
+            assert!(v == 42 || v == 777);
+            if v == 42 {
+                num_42 += 1;
+            }
+        }
+        let ratio_42 = num_42 as f64 / 1000 as f64;
+        assert!(0.4 <= ratio_42 || ratio_42 <= 0.6, "{}", ratio_42);
     }
 
     #[test]