Merge pull request #76 from cassiersg/ndarray-0.15

Ndarray 0.15

Author: xd009642

.travis.yml

@@ -7,7 +7,7 @@ addons:
       - libssl-dev
 cache: cargo
 rust:
-  - 1.42.0
+  - 1.49.0
   - stable
   - beta
   - nightly

Cargo.toml

@@ -16,22 +16,22 @@ keywords = ["array", "multidimensional", "statistics", "matrix", "ndarray"]
 categories = ["data-structures", "science"]
 
 [dependencies]
-ndarray = "0.14"
-noisy_float = "0.1.8"
+ndarray = "0.15.0"
+noisy_float = "0.2.0"
 num-integer = "0.1"
 num-traits = "0.2"
-rand = "0.7"
-itertools = { version = "0.9.0", default-features = false }
-indexmap = "1.0"
+rand = "0.8.3"
+itertools = { version = "0.10.0", default-features = false }
+indexmap = "1.6.2"
 
 [dev-dependencies]
-ndarray = { version = "0.14", features = ["approx"] }
+ndarray = { version = "0.15.0", features = ["approx"] }
 criterion = "0.3"
 quickcheck = { version = "0.9.2", default-features = false }
-ndarray-rand = "0.12"
+ndarray-rand = "0.14.0"
 approx = "0.4"
-quickcheck_macros = "0.9"
-num-bigint = "0.3.1"
+quickcheck_macros = "1.0.0"
+num-bigint = "0.4.0"
 
 [[bench]]
 name = "sort"

benches/deviation.rs

@@ -1,26 +1,24 @@
 use criterion::{
-    black_box, criterion_group, criterion_main, AxisScale, Criterion, ParameterizedBenchmark,
-    PlotConfiguration,
+    black_box, criterion_group, criterion_main, AxisScale, Criterion, PlotConfiguration,
 };
 use ndarray::prelude::*;
+use ndarray_rand::rand_distr::Uniform;
 use ndarray_rand::RandomExt;
 use ndarray_stats::DeviationExt;
-use rand::distributions::Uniform;
 
 fn sq_l2_dist(c: &mut Criterion) {
     let lens = vec![10, 100, 1000, 10000];
-    let benchmark = ParameterizedBenchmark::new(
-        "sq_l2_dist",
-        |bencher, &len| {
+    let mut group = c.benchmark_group("sq_l2_dist");
+    group.plot_config(PlotConfiguration::default().summary_scale(AxisScale::Logarithmic));
+    for len in &lens {
+        group.bench_with_input(format!("{}", len), len, |b, &len| {
             let data = Array::random(len, Uniform::new(0.0, 1.0));
             let data2 = Array::random(len, Uniform::new(0.0, 1.0));
 
-            bencher.iter(|| black_box(data.sq_l2_dist(&data2).unwrap()))
-        },
-        lens,
-    )
-    .plot_config(PlotConfiguration::default().summary_scale(AxisScale::Logarithmic));
-    c.bench("sq_l2_dist", benchmark);
+            b.iter(|| black_box(data.sq_l2_dist(&data2).unwrap()))
+        });
+    }
+    group.finish();
 }
 
 criterion_group! {

benches/sort.rs

@@ -1,21 +1,21 @@
 use criterion::{
-    black_box, criterion_group, criterion_main, AxisScale, BatchSize, Criterion,
-    ParameterizedBenchmark, PlotConfiguration,
+    black_box, criterion_group, criterion_main, AxisScale, BatchSize, Criterion, PlotConfiguration,
 };
 use ndarray::prelude::*;
 use ndarray_stats::Sort1dExt;
 use rand::prelude::*;
 
 fn get_from_sorted_mut(c: &mut Criterion) {
     let lens = vec![10, 100, 1000, 10000];
-    let benchmark = ParameterizedBenchmark::new(
-        "get_from_sorted_mut",
-        |bencher, &len| {
+    let mut group = c.benchmark_group("get_from_sorted_mut");
+    group.plot_config(PlotConfiguration::default().summary_scale(AxisScale::Logarithmic));
+    for len in &lens {
+        group.bench_with_input(format!("{}", len), len, |b, &len| {
             let mut rng = StdRng::seed_from_u64(42);
             let mut data: Vec<_> = (0..len).collect();
             data.shuffle(&mut rng);
             let indices: Vec<_> = (0..len).step_by(len / 10).collect();
-            bencher.iter_batched(
+            b.iter_batched(
                 || Array1::from(data.clone()),
                 |mut arr| {
                     for &i in &indices {
@@ -24,34 +24,31 @@ fn get_from_sorted_mut(c: &mut Criterion) {
                 },
                 BatchSize::SmallInput,
             )
-        },
-        lens,
-    )
-    .plot_config(PlotConfiguration::default().summary_scale(AxisScale::Logarithmic));
-    c.bench("get_from_sorted_mut", benchmark);
+        });
+    }
+    group.finish();
 }
 
 fn get_many_from_sorted_mut(c: &mut Criterion) {
     let lens = vec![10, 100, 1000, 10000];
-    let benchmark = ParameterizedBenchmark::new(
-        "get_many_from_sorted_mut",
-        |bencher, &len| {
+    let mut group = c.benchmark_group("get_many_from_sorted_mut");
+    group.plot_config(PlotConfiguration::default().summary_scale(AxisScale::Logarithmic));
+    for len in &lens {
+        group.bench_with_input(format!("{}", len), len, |b, &len| {
             let mut rng = StdRng::seed_from_u64(42);
             let mut data: Vec<_> = (0..len).collect();
             data.shuffle(&mut rng);
             let indices: Array1<_> = (0..len).step_by(len / 10).collect();
-            bencher.iter_batched(
+            b.iter_batched(
                 || Array1::from(data.clone()),
                 |mut arr| {
                     black_box(arr.get_many_from_sorted_mut(&indices));
                 },
                 BatchSize::SmallInput,
             )
-        },
-        lens,
-    )
-    .plot_config(PlotConfiguration::default().summary_scale(AxisScale::Logarithmic));
-    c.bench("get_many_from_sorted_mut", benchmark);
+        });
+    }
+    group.finish();
 }
 
 criterion_group! {

benches/summary_statistics.rs

@@ -1,32 +1,30 @@
 use criterion::{
-    black_box, criterion_group, criterion_main, AxisScale, BatchSize, Criterion,
-    ParameterizedBenchmark, PlotConfiguration,
+    black_box, criterion_group, criterion_main, AxisScale, BatchSize, Criterion, PlotConfiguration,
 };
 use ndarray::prelude::*;
+use ndarray_rand::rand_distr::Uniform;
 use ndarray_rand::RandomExt;
 use ndarray_stats::SummaryStatisticsExt;
-use rand::distributions::Uniform;
 
 fn weighted_std(c: &mut Criterion) {
     let lens = vec![10, 100, 1000, 10000];
-    let benchmark = ParameterizedBenchmark::new(
-        "weighted_std",
-        |bencher, &len| {
+    let mut group = c.benchmark_group("weighted_std");
+    group.plot_config(PlotConfiguration::default().summary_scale(AxisScale::Logarithmic));
+    for len in &lens {
+        group.bench_with_input(format!("{}", len), len, |b, &len| {
             let data = Array::random(len, Uniform::new(0.0, 1.0));
             let mut weights = Array::random(len, Uniform::new(0.0, 1.0));
             weights /= weights.sum();
-            bencher.iter_batched(
+            b.iter_batched(
                 || data.clone(),
                 |arr| {
                     black_box(arr.weighted_std(&weights, 0.0).unwrap());
                 },
                 BatchSize::SmallInput,
             )
-        },
-        lens,
-    )
-    .plot_config(PlotConfiguration::default().summary_scale(AxisScale::Logarithmic));
-    c.bench("weighted_std", benchmark);
+        });
+    }
+    group.finish();
 }
 
 criterion_group! {

src/correlation.rs

@@ -185,10 +185,10 @@ where
 mod cov_tests {
     use super::*;
     use ndarray::array;
+    use ndarray_rand::rand;
+    use ndarray_rand::rand_distr::Uniform;
     use ndarray_rand::RandomExt;
     use quickcheck_macros::quickcheck;
-    use rand;
-    use rand::distributions::Uniform;
 
     #[quickcheck]
     fn constant_random_variables_have_zero_covariance_matrix(value: f64) -> bool {
@@ -288,9 +288,10 @@ mod cov_tests {
 mod pearson_correlation_tests {
     use super::*;
     use ndarray::array;
+    use ndarray::Array;
+    use ndarray_rand::rand_distr::Uniform;
     use ndarray_rand::RandomExt;
     use quickcheck_macros::quickcheck;
-    use rand::distributions::Uniform;
 
     #[quickcheck]
     fn output_matrix_is_symmetric(bound: f64) -> bool {

src/deviation.rs

@@ -232,7 +232,7 @@ where
 
         let mut count = 0;
 
-        Zip::from(self).and(other).apply(|a, b| {
+        Zip::from(self).and(other).for_each(|a, b| {
             if a == b {
                 count += 1;
             }
@@ -259,7 +259,7 @@ where
 
         let mut result = A::zero();
 
-        Zip::from(self).and(other).apply(|self_i, other_i| {
+        Zip::from(self).and(other).for_each(|self_i, other_i| {
             let (a, b) = (self_i.clone(), other_i.clone());
             let diff = a - b;
             result += diff.clone() * diff;
@@ -291,7 +291,7 @@ where
 
         let mut result = A::zero();
 
-        Zip::from(self).and(other).apply(|self_i, other_i| {
+        Zip::from(self).and(other).for_each(|self_i, other_i| {
             let (a, b) = (self_i.clone(), other_i.clone());
             result += (a - b).abs();
         });
@@ -309,7 +309,7 @@ where
 
         let mut max = A::zero();
 
-        Zip::from(self).and(other).apply(|self_i, other_i| {
+        Zip::from(self).and(other).for_each(|self_i, other_i| {
             let (a, b) = (self_i.clone(), other_i.clone());
             let diff = (a - b).abs();
             if diff > max {

src/entropy.rs

@@ -169,7 +169,7 @@ where
         Zip::from(&mut temp)
             .and(self)
             .and(q)
-            .apply(|result, &p, &q| {
+            .for_each(|result, &p, &q| {
                 *result = {
                     if p == A::zero() {
                         A::zero()
@@ -202,7 +202,7 @@ where
         Zip::from(&mut temp)
             .and(self)
             .and(q)
-            .apply(|result, &p, &q| {
+            .for_each(|result, &p, &q| {
                 *result = {
                     if p == A::zero() {
                         A::zero()

src/maybe_nan/mod.rs

@@ -332,7 +332,7 @@ where
         A: 'a,
         F: FnMut(&'a A::NotNan),
     {
-        self.visit(|elem| {
+        self.for_each(|elem| {
             if let Some(not_nan) = elem.try_as_not_nan() {
                 f(not_nan)
             }

src/quantile/mod.rs

@@ -477,7 +477,7 @@ where
             let mut results = Array::from_elem(results_shape, data.first().unwrap().clone());
             Zip::from(results.lanes_mut(axis))
                 .and(data.lanes_mut(axis))
-                .apply(|mut results, mut data| {
+                .for_each(|mut results, mut data| {
                     let index_map =
                         get_many_from_sorted_mut_unchecked(&mut data, &searched_indexes);
                     for (result, &q) in results.iter_mut().zip(qs) {

src/sort.rs

@@ -116,7 +116,7 @@ where
             self[0].clone()
         } else {
             let mut rng = thread_rng();
-            let pivot_index = rng.gen_range(0, n);
+            let pivot_index = rng.gen_range(0..n);
             let partition_index = self.partition_mut(pivot_index);
             if i < partition_index {
                 self.slice_axis_mut(Axis(0), Slice::from(..partition_index))
@@ -251,7 +251,7 @@ fn _get_many_from_sorted_mut_unchecked<A>(
 
     // We pick a random pivot index: the corresponding element is the pivot value
     let mut rng = thread_rng();
-    let pivot_index = rng.gen_range(0, n);
+    let pivot_index = rng.gen_range(0..n);
 
     // We partition the array with respect to the pivot value.
     // The pivot value moves to `array_partition_index`.

tests/summary_statistics.rs

@@ -1,13 +1,13 @@
 use approx::{abs_diff_eq, assert_abs_diff_eq};
 use ndarray::{arr0, array, Array, Array1, Array2, Axis};
+use ndarray_rand::rand_distr::Uniform;
 use ndarray_rand::RandomExt;
 use ndarray_stats::{
     errors::{EmptyInput, MultiInputError, ShapeMismatch},
     SummaryStatisticsExt,
 };
 use noisy_float::types::N64;
 use quickcheck::{quickcheck, TestResult};
-use rand::distributions::Uniform;
 use std::f64;
 
 #[test]