Remove rand::seq::gen_index

Author: dhardy

src/seq/iterator.rs

@@ -9,7 +9,6 @@
 //! `IteratorRandom`
 
 use super::coin_flipper::CoinFlipper;
-use super::gen_index;
 #[allow(unused)]
 use super::IndexedRandom;
 use crate::Rng;
@@ -71,7 +70,7 @@ pub trait IteratorRandom: Iterator + Sized {
             return match lower {
                 0 => None,
                 1 => self.next(),
-                _ => self.nth(gen_index(rng, lower)),
+                _ => self.nth(rng.gen_range(0..lower)),
             };
         }
 
@@ -81,7 +80,7 @@ pub trait IteratorRandom: Iterator + Sized {
         // Continue until the iterator is exhausted
         loop {
             if lower > 1 {
-                let ix = gen_index(coin_flipper.rng, lower + consumed);
+                let ix = coin_flipper.rng.gen_range(0..lower + consumed);
                 let skip = if ix < lower {
                     result = self.nth(ix);
                     lower - (ix + 1)
@@ -204,7 +203,7 @@ pub trait IteratorRandom: Iterator + Sized {
 
         // Continue, since the iterator was not exhausted
         for (i, elem) in self.enumerate() {
-            let k = gen_index(rng, i + 1 + amount);
+            let k = rng.gen_range(0..i + 1 + amount);
             if let Some(slot) = buf.get_mut(k) {
                 *slot = elem;
             }
@@ -240,7 +239,7 @@ pub trait IteratorRandom: Iterator + Sized {
         // If the iterator stops once, then so do we.
         if reservoir.len() == amount {
             for (i, elem) in self.enumerate() {
-                let k = gen_index(rng, i + 1 + amount);
+                let k = rng.gen_range(0..i + 1 + amount);
                 if let Some(slot) = reservoir.get_mut(k) {
                     *slot = elem;
                 }

src/seq/mod.rs

@@ -43,27 +43,8 @@ pub use iterator::IteratorRandom;
 pub use slice::SliceChooseIter;
 pub use slice::{IndexedMutRandom, IndexedRandom, SliceRandom};
 
-use crate::Rng;
-
-// Sample a number uniformly between 0 and `ubound`. Uses 32-bit sampling where
-// possible, primarily in order to produce the same output on 32-bit and 64-bit
-// platforms.
-#[inline]
-fn gen_index<R: Rng + ?Sized>(rng: &mut R, ubound: usize) -> usize {
-    if ubound <= (u32::MAX as usize) {
-        rng.gen_range(0..ubound as u32) as usize
-    } else {
-        #[cfg(target_pointer_width = "32")]
-        unreachable!();
-
-        #[cfg(target_pointer_width = "64")]
-        return rng.gen_range(0..ubound as u64) as usize;
-    }
-}
-
 /// Low-level API for sampling indices
 pub mod index {
-    use super::gen_index;
     use crate::Rng;
 
     #[cfg(feature = "alloc")]
@@ -88,7 +69,7 @@ pub mod index {
         // Floyd's algorithm
         let mut indices = [0; N];
         for (i, j) in (len - N..len).enumerate() {
-            let t = gen_index(rng, j + 1);
+            let t = rng.gen_range(0..j + 1);
             if let Some(pos) = indices[0..i].iter().position(|&x| x == t) {
                 indices[pos] = j;
             }

src/seq/slice.rs

@@ -9,7 +9,7 @@
 //! `IndexedRandom`, `IndexedMutRandom`, `SliceRandom`
 
 use super::increasing_uniform::IncreasingUniform;
-use super::{gen_index, index};
+use super::index;
 #[cfg(feature = "alloc")]
 use crate::distr::uniform::{SampleBorrow, SampleUniform};
 #[cfg(feature = "alloc")]
@@ -57,7 +57,7 @@ pub trait IndexedRandom: Index<usize> {
         if self.is_empty() {
             None
         } else {
-            Some(&self[gen_index(rng, self.len())])
+            Some(&self[rng.gen_range(0..self.len())])
         }
     }
 
@@ -253,7 +253,7 @@ pub trait IndexedMutRandom: IndexedRandom + IndexMut<usize> {
             None
         } else {
             let len = self.len();
-            Some(&mut self[gen_index(rng, len)])
+            Some(&mut self[rng.gen_range(0..len)])
         }
     }
 
@@ -393,7 +393,7 @@ impl<T> SliceRandom for [T] {
         // It ensures that the last `amount` elements of the slice
         // are randomly selected from the whole slice.
 
-        // `IncreasingUniform::next_index()` is faster than `gen_index`
+        // `IncreasingUniform::next_index()` is faster than `Rng::gen_range`
         // but only works for 32 bit integers
         // So we must use the slow method if the slice is longer than that.
         if self.len() < (u32::MAX as usize) {
@@ -404,7 +404,7 @@ impl<T> SliceRandom for [T] {
             }
         } else {
             for i in m..self.len() {
-                let index = gen_index(rng, i + 1);
+                let index = rng.gen_range(0..i + 1);
                 self.swap(i, index);
             }
         }