Bump ndarray-slice.

Reduces time complexity in the length of `indexes`.

Author: n3vu0r

Cargo.toml

@@ -17,13 +17,12 @@ categories = ["data-structures", "science"]
 
 [dependencies]
 ndarray = "0.15.0"
-ndarray-slice = "0.1.1"
+ndarray-slice = "0.2.0"
 noisy_float = "0.2.0"
 num-integer = "0.1"
 num-traits = "0.2"
 rand = "0.8.3"
 itertools = { version = "0.10.0", default-features = false }
-indexmap = "1.6.2"
 
 [dev-dependencies]
 ndarray = { version = "0.15.0", features = ["approx"] }
@@ -45,3 +44,6 @@ harness = false
 [[bench]]
 name = "deviation"
 harness = false
+
+[profile.test]
+opt-level = 2

benches/sort.rs

@@ -42,7 +42,8 @@ fn get_many_from_sorted_mut(c: &mut Criterion) {
             b.iter_batched(
                 || Array1::from(data.clone()),
                 |mut arr| {
-                    black_box(arr.select_many_nth_unstable(&indices));
+                    let mut values = Vec::with_capacity(indices.len());
+                    black_box(arr.select_many_nth_unstable(&indices, &mut values));
                 },
                 BatchSize::SmallInput,
             )

src/quantile/mod.rs

@@ -2,12 +2,11 @@ use self::interpolate::{higher_index, lower_index, Interpolate};
 use crate::errors::QuantileError;
 use crate::errors::{EmptyInput, MinMaxError, MinMaxError::UndefinedOrder};
 use crate::{MaybeNan, MaybeNanExt};
-use indexmap::IndexMap;
 use ndarray::prelude::*;
 use ndarray::{Data, DataMut, RemoveAxis, Zip};
 use ndarray_slice::Slice1Ext;
 use noisy_float::types::N64;
-use std::cmp;
+use std::{cmp, collections::HashMap};
 
 /// Quantile methods for `ArrayBase`.
 pub trait QuantileExt<A, S, D>
@@ -480,20 +479,16 @@ where
             Zip::from(results.lanes_mut(axis))
                 .and(data.lanes_mut(axis))
                 .for_each(|mut results, mut data| {
-                    let (lower_values, _higher) = data.select_many_nth_unstable(&indexes);
-                    let index_map = indexes
-                        .iter()
-                        .copied()
-                        .zip(lower_values.iter().map(|(_lower, value)| (*value).clone()))
-                        .collect::<IndexMap<usize, A>>();
+                    let mut values = HashMap::new();
+                    data.select_many_nth_unstable(&indexes, &mut values);
                     for (result, &q) in results.iter_mut().zip(qs) {
                         let lower = if I::needs_lower(q, axis_len) {
-                            Some(index_map[&lower_index(q, axis_len)].clone())
+                            Some(values[&lower_index(q, axis_len)].clone())
                         } else {
                             None
                         };
                         let higher = if I::needs_higher(q, axis_len) {
-                            Some(index_map[&higher_index(q, axis_len)].clone())
+                            Some(values[&higher_index(q, axis_len)].clone())
                         } else {
                             None
                         };

tests/quantile.rs

@@ -168,6 +168,45 @@ fn test_max_skipnan_all_nan() {
     assert!(a.max_skipnan().is_nan());
 }
 
+#[test]
+fn test_quantile_mut_with_large_array_of_equal_floats() {
+    let mut array: Array1<N64> = Array1::ones(10_000_000);
+    array.quantile_mut(n64(0.5), &Linear).unwrap();
+}
+
+#[test]
+fn test_quantile_mut_with_large_array_of_sorted_floats() {
+    let mut array: Array1<N64> = Array1::range(n64(0.0), n64(1e7), n64(1.0));
+    array.quantile_mut(n64(0.5), &Linear).unwrap();
+}
+
+#[test]
+fn test_quantile_mut_with_large_array_of_rev_sorted_floats() {
+    let mut array: Array1<N64> = Array1::range(n64(1e7), n64(0.0), n64(-1.0));
+    array.quantile_mut(n64(0.5), &Linear).unwrap();
+}
+
+#[test]
+fn test_quantiles_mut_with_large_array_of_equal_floats() {
+    let mut array: Array1<N64> = Array1::ones(10_000_000);
+    let quantiles: Array1<N64> = Array1::range(n64(0.0), n64(1.0), n64(1e-5));
+    array.quantiles_mut(&quantiles, &Linear).unwrap();
+}
+
+#[test]
+fn test_quantiles_mut_with_large_array_of_sorted_floats() {
+    let mut array: Array1<N64> = Array1::range(n64(0.0), n64(1e7), n64(1.0));
+    let quantiles: Array1<N64> = Array1::range(n64(0.0), n64(1.0), n64(1e-5));
+    array.quantiles_mut(&quantiles, &Linear).unwrap();
+}
+
+#[test]
+fn test_quantiles_mut_with_large_array_of_rev_sorted_floats() {
+    let mut array: Array1<N64> = Array1::range(n64(1e7), n64(0.0), n64(-1.0));
+    let quantiles: Array1<N64> = Array1::range(n64(0.0), n64(1.0), n64(1e-5));
+    array.quantiles_mut(&quantiles, &Linear).unwrap();
+}
+
 #[test]
 fn test_quantile_axis_mut_with_odd_axis_length() {
     let mut a = arr2(&[[1, 3, 2, 10], [2, 4, 3, 11], [3, 5, 6, 12]]);

tests/sort.rs

@@ -1,6 +1,7 @@
 use ndarray::prelude::*;
 use ndarray_slice::Slice1Ext;
 use quickcheck_macros::quickcheck;
+use std::collections::HashMap;
 
 #[test]
 fn test_sorted_get_mut() {
@@ -28,18 +29,12 @@ fn test_sorted_get_many_mut(mut xs: Vec<i64>) -> bool {
         indexes.sort_unstable();
         let (indexes, _duplicates) = indexes.partition_dedup();
 
-        let mut sorted_v = Vec::with_capacity(n);
-        for value in v
-            .select_many_nth_unstable(&indexes)
-            .0
-            .into_iter()
-            .map(|(_, value)| *value)
-        {
-            sorted_v.push(value);
-        }
+        let mut map = HashMap::new();
+        v.select_many_nth_unstable(&indexes, &mut map);
+        let sorted_v = indexes.map(|index| *map[index]);
         xs.sort();
         println!("Sorted: {:?}. Truth: {:?}", sorted_v, xs);
-        xs == sorted_v
+        Array::from_vec(xs) == sorted_v
     }
 }