Optimized path of sample_efraimidis_spirakis is stable

This no longer requires nightly

Author: dhardy

Cargo.toml

@@ -28,7 +28,7 @@ features = ["small_rng", "serde1"]
 [features]
 # Meta-features:
 default = ["std", "std_rng"]
-nightly = [] # enables performance optimizations requiring nightly rust
+nightly = [] # some additions requiring nightly Rust
 serde1 = ["serde", "rand_core/serde1"]
 
 # Option (enabled by default): without "std" rand uses libcore; this option
@@ -41,7 +41,7 @@ alloc = ["rand_core/alloc"]
 # Option: use getrandom package for seeding
 getrandom = ["rand_core/getrandom"]
 
-# Option (requires nightly): experimental SIMD support
+# Option (requires nightly rust): experimental SIMD support
 simd_support = ["packed_simd"]
 
 # Option (enabled by default): enable StdRng

README.md

@@ -125,7 +125,7 @@ Optionally, the following dependencies can be enabled:
 Additionally, these features configure Rand:
 
 -   `small_rng` enables inclusion of the `SmallRng` PRNG
--   `nightly` enables some optimizations requiring nightly Rust
+-   `nightly` includes some additions requiring nightly Rust
 -   `simd_support` (experimental) enables sampling of SIMD values
     (uniformly random SIMD integers and floats), requiring nightly Rust
 

src/seq/index.rs

@@ -267,9 +267,7 @@ where R: Rng + ?Sized {
 /// sometimes be useful to have the indices themselves so this is provided as
 /// an alternative.
 ///
-/// This implementation uses `O(length + amount)` space and `O(length)` time
-/// if the "nightly" feature is enabled, or `O(length)` space and
-/// `O(length + amount * log length)` time otherwise.
+/// This implementation uses `O(length + amount)` space and `O(length)` time.
 ///
 /// Panics if `amount > length`.
 #[cfg(feature = "std")]
@@ -300,9 +298,7 @@ where
 ///
 /// This implementation uses the algorithm described by Efraimidis and Spirakis
 /// in this paper: https://doi.org/10.1016/j.ipl.2005.11.003
-/// It uses `O(length + amount)` space and `O(length)` time if the
-/// "nightly" feature is enabled, or `O(length)` space and `O(length
-/// + amount * log length)` time otherwise.
+/// It uses `O(length + amount)` space and `O(length)` time.
 ///
 /// Panics if `amount > length`.
 #[cfg(feature = "std")]
@@ -347,63 +343,33 @@ where
     }
     impl<N> Eq for Element<N> {}
 
-    #[cfg(feature = "nightly")]
-    {
-        let mut candidates = Vec::with_capacity(length.as_usize());
-        let mut index = N::zero();
-        while index < length {
-            let weight = weight(index.as_usize()).into();
-            if !(weight >= 0.) {
-                return Err(WeightedError::InvalidWeight);
-            }
-
-            let key = rng.gen::<f64>().powf(1.0 / weight);
-            candidates.push(Element { index, key });
-
-            index += N::one();
+    let mut candidates = Vec::with_capacity(length.as_usize());
+    let mut index = N::zero();
+    while index < length {
+        let weight = weight(index.as_usize()).into();
+        if !(weight >= 0.) {
+            return Err(WeightedError::InvalidWeight);
         }
 
-        // Partially sort the array to find the `amount` elements with the greatest
-        // keys. Do this by using `select_nth_unstable` to put the elements with
-        // the *smallest* keys at the beginning of the list in `O(n)` time, which
-        // provides equivalent information about the elements with the *greatest* keys.
-        let (_, mid, greater)
-            = candidates.select_nth_unstable(length.as_usize() - amount.as_usize());
-
-        let mut result: Vec<N> = Vec::with_capacity(amount.as_usize());
-        result.push(mid.index);
-        for element in greater {
-            result.push(element.index);
-        }
-        Ok(IndexVec::from(result))
-    }
-
-    #[cfg(not(feature = "nightly"))]
-    {
-        use alloc::collections::BinaryHeap;
+        let key = rng.gen::<f64>().powf(1.0 / weight);
+        candidates.push(Element { index, key });
 
-        // Partially sort the array such that the `amount` elements with the largest
-        // keys are first using a binary max heap.
-        let mut candidates = BinaryHeap::with_capacity(length.as_usize());
-        let mut index = N::zero();
-        while index < length {
-            let weight = weight(index.as_usize()).into();
-            if !(weight >= 0.) {
-                return Err(WeightedError::InvalidWeight);
-            }
+        index += N::one();
+    }
 
-            let key = rng.gen::<f64>().powf(1.0 / weight);
-            candidates.push(Element { index, key });
+    // Partially sort the array to find the `amount` elements with the greatest
+    // keys. Do this by using `select_nth_unstable` to put the elements with
+    // the *smallest* keys at the beginning of the list in `O(n)` time, which
+    // provides equivalent information about the elements with the *greatest* keys.
+    let (_, mid, greater)
+        = candidates.select_nth_unstable(length.as_usize() - amount.as_usize());
 
-            index += N::one();
-        }
-
-        let mut result: Vec<N> = Vec::with_capacity(amount.as_usize());
-        while result.len() < amount.as_usize() {
-            result.push(candidates.pop().unwrap().index);
-        }
-        Ok(IndexVec::from(result))
+    let mut result: Vec<N> = Vec::with_capacity(amount.as_usize());
+    result.push(mid.index);
+    for element in greater {
+        result.push(element.index);
     }
+    Ok(IndexVec::from(result))
 }
 
 /// Randomly sample exactly `amount` indices from `0..length`, using Floyd's