Use just rand_core and rand_xoshiro.

Author: bodil

CHANGELOG.md

@@ -14,6 +14,11 @@ Versioning](http://semver.org/spec/v2.0.0.html).
   compile, specifically version 1.36.0, so does `im`. This is a breaking change,
   but will of course only affect your code if you're using an older `rustc`.
 
+### Fixed
+
+- Fixed a quadratic time worst case scenario in the quicksort implementation for
+  `Vector`. (#101)
+
 ## [13.0.0] - 2019-05-18
 
 The minimum supported Rust version is now 1.34.0.

Cargo.toml

@@ -31,13 +31,15 @@ quickcheck = { version = "0.9", optional = true }
 proptest = { version = "0.9", optional = true }
 serde = { version = "1.0", optional = true }
 rayon = { version = "1.0", optional = true }
-rand = { version = "0.7", features = ["small_rng"] }
+rand_core = "0.5.1"
+rand_xoshiro = "0.4.0"
 
 [dev-dependencies]
 proptest = "0.9"
 serde = "1.0"
 serde_json = "1.0"
 rayon = "1.0"
+rand = { version = "0.7", features = ["small_rng"] }
 pretty_assertions = "0.6"
 metrohash = "1.0.6"
 proptest-derive = "0.1.0"

benches/sort.rs

@@ -8,59 +8,39 @@ use test::Bencher;
 
 // sorted
 #[bench]
-<<<<<<< HEAD
 fn quicksort_sorted_list_0500(bench: &mut Bencher) {
-=======
-fn sorted_list_0500(bench: &mut Bencher) {
->>>>>>> Benchmarks for quicksort.
     bench.iter(|| {
         let mut v1: Vector<_> = (0..500).collect();
         v1.sort()
     });
 }
 
 #[bench]
-<<<<<<< HEAD
 fn quicksort_sorted_list_1000(bench: &mut Bencher) {
-=======
-fn sorted_list_1000(bench: &mut Bencher) {
->>>>>>> Benchmarks for quicksort.
     bench.iter(|| {
         let mut v1: Vector<_> = (0..1000).collect();
         v1.sort()
     });
 }
 
 #[bench]
-<<<<<<< HEAD
 fn quicksort_sorted_list_1500(bench: &mut Bencher) {
-=======
-fn sorted_list_1500(bench: &mut Bencher) {
->>>>>>> Benchmarks for quicksort.
     bench.iter(|| {
         let mut v1: Vector<_> = (0..1500).collect();
         v1.sort()
     });
 }
 
 #[bench]
-<<<<<<< HEAD
 fn quicksort_sorted_list_2000(bench: &mut Bencher) {
-=======
-fn sorted_list_2000(bench: &mut Bencher) {
->>>>>>> Benchmarks for quicksort.
     bench.iter(|| {
         let mut v1: Vector<_> = (0..2000).collect();
         v1.sort()
     });
 }
 
 #[bench]
-<<<<<<< HEAD
 fn quicksort_sorted_list_2500(bench: &mut Bencher) {
-=======
-fn sorted_list_2500(bench: &mut Bencher) {
->>>>>>> Benchmarks for quicksort.
     bench.iter(|| {
         let mut v1: Vector<_> = (0..2500).rev().collect();
         v1.sort()
@@ -69,59 +49,39 @@ fn sorted_list_2500(bench: &mut Bencher) {
 
 // reverse sorted
 #[bench]
-<<<<<<< HEAD
 fn quicksort_reverse_sorted_list_0500(bench: &mut Bencher) {
-=======
-fn reverse_sorted_list_0500(bench: &mut Bencher) {
->>>>>>> Benchmarks for quicksort.
     bench.iter(|| {
         let mut v1: Vector<_> = (0..500).rev().collect();
         v1.sort()
     });
 }
 
 #[bench]
-<<<<<<< HEAD
 fn quicksort_reverse_sorted_list_1000(bench: &mut Bencher) {
-=======
-fn reverse_sorted_list_1000(bench: &mut Bencher) {
->>>>>>> Benchmarks for quicksort.
     bench.iter(|| {
         let mut v1: Vector<_> = (0..1000).rev().collect();
         v1.sort()
     });
 }
 
 #[bench]
-<<<<<<< HEAD
 fn quicksort_reverse_sorted_list_1500(bench: &mut Bencher) {
-=======
-fn reverse_sorted_list_1500(bench: &mut Bencher) {
->>>>>>> Benchmarks for quicksort.
     bench.iter(|| {
         let mut v1: Vector<_> = (0..1500).rev().collect();
         v1.sort()
     });
 }
 
 #[bench]
-<<<<<<< HEAD
 fn quicksort_reverse_sorted_list_2000(bench: &mut Bencher) {
-=======
-fn reverse_sorted_list_2000(bench: &mut Bencher) {
->>>>>>> Benchmarks for quicksort.
     bench.iter(|| {
         let mut v1: Vector<_> = (0..2000).rev().collect();
         v1.sort()
     });
 }
 
 #[bench]
-<<<<<<< HEAD
 fn quicksort_reverse_sorted_list_2500(bench: &mut Bencher) {
-=======
-fn reverse_sorted_list_2500(bench: &mut Bencher) {
->>>>>>> Benchmarks for quicksort.
     bench.iter(|| {
         let mut v1: Vector<_> = (0..2500).rev().collect();
         v1.sort()
@@ -130,11 +90,7 @@ fn reverse_sorted_list_2500(bench: &mut Bencher) {
 
 // shuffled
 #[bench]
-<<<<<<< HEAD
 fn quicksort_shuffled_list_0500(bench: &mut Bencher) {
-=======
-fn shuffled_list_0500(bench: &mut Bencher) {
->>>>>>> Benchmarks for quicksort.
     let mut rng = rand::thread_rng();
     bench.iter(|| {
         let mut v1: Vec<_> = (0..500).collect();
@@ -145,11 +101,7 @@ fn shuffled_list_0500(bench: &mut Bencher) {
 }
 
 #[bench]
-<<<<<<< HEAD
 fn quicksort_shuffled_list_1000(bench: &mut Bencher) {
-=======
-fn shuffled_list_1000(bench: &mut Bencher) {
->>>>>>> Benchmarks for quicksort.
     let mut rng = rand::thread_rng();
     bench.iter(|| {
         let mut v1: Vec<_> = (0..1000).collect();
@@ -160,11 +112,7 @@ fn shuffled_list_1000(bench: &mut Bencher) {
 }
 
 #[bench]
-<<<<<<< HEAD
 fn quicksort_shuffled_list_1500(bench: &mut Bencher) {
-=======
-fn shuffled_list_1500(bench: &mut Bencher) {
->>>>>>> Benchmarks for quicksort.
     let mut rng = rand::thread_rng();
     bench.iter(|| {
         let mut v1: Vec<_> = (0..1500).collect();
@@ -175,11 +123,7 @@ fn shuffled_list_1500(bench: &mut Bencher) {
 }
 
 #[bench]
-<<<<<<< HEAD
 fn quicksort_shuffled_list_2000(bench: &mut Bencher) {
-=======
-fn shuffled_list_2000(bench: &mut Bencher) {
->>>>>>> Benchmarks for quicksort.
     let mut rng = rand::thread_rng();
     bench.iter(|| {
         let mut v1: Vec<_> = (0..2000).collect();
@@ -190,11 +134,7 @@ fn shuffled_list_2000(bench: &mut Bencher) {
 }
 
 #[bench]
-<<<<<<< HEAD
 fn quicksort_shuffled_list_2500(bench: &mut Bencher) {
-=======
-fn shuffled_list_2500(bench: &mut Bencher) {
->>>>>>> Benchmarks for quicksort.
     let mut rng = rand::thread_rng();
     bench.iter(|| {
         let mut v1: Vec<_> = (0..2500).collect();

src/sort.rs

@@ -3,25 +3,35 @@
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 use crate::vector::FocusMut;
+use rand_core::{RngCore, SeedableRng};
 use std::cmp::Ordering;
-use rand::prelude::*;
+
+fn gen_range<R: RngCore>(rng: &mut R, min: usize, max: usize) -> usize {
+    let range = max - min;
+    min + (rng.next_u64() as usize % range)
+}
 
 // Ported from the Java version at:
 //    http://www.cs.princeton.edu/~rs/talks/QuicksortIsOptimal.pdf
 // Should be O(n) to O(n log n)
-pub fn do_quicksort<A, F, R>(vector: &mut FocusMut<A>, left: usize, right: usize, cmp: &F, rng: &mut R)
-where
+pub fn do_quicksort<A, F, R>(
+    vector: &mut FocusMut<A>,
+    left: usize,
+    right: usize,
+    cmp: &F,
+    rng: &mut R,
+) where
     A: Clone,
     F: Fn(&A, &A) -> Ordering,
-    R: Rng
+    R: RngCore,
 {
     if right <= left {
         return;
     }
 
     let l = left as isize;
     let r = right as isize;
-    let p = rng.gen_range(l, r + 1);
+    let p = gen_range(rng, left, right + 1) as isize;
     let mut l1 = l;
     let mut r1 = r;
     let mut l2 = l - 1;
@@ -80,7 +90,7 @@ where
     A: Clone,
     F: Fn(&A, &A) -> Ordering,
 {
-    let mut rng = rand::thread_rng();
+    let mut rng = rand_xoshiro::Xoshiro256Plus::seed_from_u64(0);
     do_quicksort(vector, left, right, cmp, &mut rng);
 }