Make the entire crate compatible with the array reference type

Author: akern40

Cargo.toml

@@ -16,7 +16,7 @@ keywords = ["array", "multidimensional", "statistics", "matrix", "ndarray"]
 categories = ["data-structures", "science"]
 
 [dependencies]
-ndarray = "0.16.0"
+ndarray = "0.17.1"
 noisy_float = "0.2.0"
 num-integer = "0.1"
 num-traits = "0.2"
@@ -25,10 +25,10 @@ itertools = { version = "0.13", default-features = false }
 indexmap = "2.4"
 
 [dev-dependencies]
-ndarray = { version = "0.16.1", features = ["approx"] }
+ndarray = { version = "0.17.1", features = ["approx"] }
 criterion = "0.3"
 quickcheck = { version = "0.9.2", default-features = false }
-ndarray-rand = "0.15.0"
+ndarray-rand = "0.16.0"
 approx = "0.5"
 quickcheck_macros = "1.0.0"
 num-bigint = "0.4.0"

benches/deviation.rs

@@ -12,8 +12,8 @@ fn sq_l2_dist(c: &mut Criterion) {
     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));
+            let data = Array::random(len, Uniform::new(0.0, 1.0).unwrap());
+            let data2 = Array::random(len, Uniform::new(0.0, 1.0).unwrap());
 
             b.iter(|| black_box(data.sq_l2_dist(&data2).unwrap()))
         });

benches/summary_statistics.rs

@@ -12,8 +12,8 @@ fn weighted_std(c: &mut Criterion) {
     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));
+            let data = Array::random(len, Uniform::new(0.0, 1.0).unwrap());
+            let mut weights = Array::random(len, Uniform::new(0.0, 1.0).unwrap());
             weights /= weights.sum();
             b.iter_batched(
                 || data.clone(),

src/correlation.rs

@@ -1,14 +1,10 @@
 use crate::errors::EmptyInput;
 use ndarray::prelude::*;
-use ndarray::Data;
 use num_traits::{Float, FromPrimitive};
 
-/// Extension trait for `ArrayBase` providing functions
+/// Extension trait for `ndarray` providing functions
 /// to compute different correlation measures.
-pub trait CorrelationExt<A, S>
-where
-    S: Data<Elem = A>,
-{
+pub trait CorrelationExt<A> {
     /// Return the covariance matrix `C` for a 2-dimensional
     /// array of observations `M`.
     ///
@@ -125,10 +121,7 @@ where
     private_decl! {}
 }
 
-impl<A: 'static, S> CorrelationExt<A, S> for ArrayBase<S, Ix2>
-where
-    S: Data<Elem = A>,
-{
+impl<A: 'static> CorrelationExt<A> for ArrayRef2<A> {
     fn cov(&self, ddof: A) -> Result<Array2<A>, EmptyInput>
     where
         A: Float + FromPrimitive,
@@ -147,7 +140,7 @@ where
         let mean = self.mean_axis(observation_axis);
         match mean {
             Some(mean) => {
-                let denoised = self - &mean.insert_axis(observation_axis);
+                let denoised = self - mean.insert_axis(observation_axis);
                 let covariance = denoised.dot(&denoised.t());
                 Ok(covariance.mapv_into(|x| x / dof))
             }
@@ -208,7 +201,7 @@ mod cov_tests {
         let n_observations = 4;
         let a = Array::random(
             (n_random_variables, n_observations),
-            Uniform::new(-bound.abs(), bound.abs()),
+            Uniform::new(-bound.abs(), bound.abs()).unwrap(),
         );
         let covariance = a.cov(1.).unwrap();
         abs_diff_eq!(covariance, &covariance.t(), epsilon = 1e-8)
@@ -219,7 +212,10 @@ mod cov_tests {
     fn test_invalid_ddof() {
         let n_random_variables = 3;
         let n_observations = 4;
-        let a = Array::random((n_random_variables, n_observations), Uniform::new(0., 10.));
+        let a = Array::random(
+            (n_random_variables, n_observations),
+            Uniform::new(0., 10.).unwrap(),
+        );
         let invalid_ddof = (n_observations as f64) + rand::random::<f64>().abs();
         let _ = a.cov(invalid_ddof);
     }
@@ -299,7 +295,7 @@ mod pearson_correlation_tests {
         let n_observations = 4;
         let a = Array::random(
             (n_random_variables, n_observations),
-            Uniform::new(-bound.abs(), bound.abs()),
+            Uniform::new(-bound.abs(), bound.abs()).unwrap(),
         );
         let pearson_correlation = a.pearson_correlation().unwrap();
         abs_diff_eq!(

src/deviation.rs

@@ -1,15 +1,14 @@
-use ndarray::{ArrayBase, Data, Dimension, Zip};
+use ndarray::{ArrayRef, Dimension, Zip};
 use num_traits::{Signed, ToPrimitive};
 use std::convert::Into;
 use std::ops::AddAssign;
 
 use crate::errors::MultiInputError;
 
-/// An extension trait for `ArrayBase` providing functions
+/// An extension trait for `ndarray` providing functions
 /// to compute different deviation measures.
-pub trait DeviationExt<A, S, D>
+pub trait DeviationExt<A, D>
 where
-    S: Data<Elem = A>,
     D: Dimension,
 {
     /// Counts the number of indices at which the elements of the arrays `self`
@@ -19,10 +18,9 @@ where
     ///
     /// * `MultiInputError::EmptyInput` if `self` is empty
     /// * `MultiInputError::ShapeMismatch` if `self` and `other` don't have the same shape
-    fn count_eq<T>(&self, other: &ArrayBase<T, D>) -> Result<usize, MultiInputError>
+    fn count_eq(&self, other: &ArrayRef<A, D>) -> Result<usize, MultiInputError>
     where
-        A: PartialEq,
-        T: Data<Elem = A>;
+        A: PartialEq;
 
     /// Counts the number of indices at which the elements of the arrays `self`
     /// and `other` are not equal.
@@ -31,10 +29,9 @@ where
     ///
     /// * `MultiInputError::EmptyInput` if `self` is empty
     /// * `MultiInputError::ShapeMismatch` if `self` and `other` don't have the same shape
-    fn count_neq<T>(&self, other: &ArrayBase<T, D>) -> Result<usize, MultiInputError>
+    fn count_neq(&self, other: &ArrayRef<A, D>) -> Result<usize, MultiInputError>
     where
-        A: PartialEq,
-        T: Data<Elem = A>;
+        A: PartialEq;
 
     /// Computes the [squared L2 distance] between `self` and `other`.
     ///
@@ -52,10 +49,9 @@ where
     /// * `MultiInputError::ShapeMismatch` if `self` and `other` don't have the same shape
     ///
     /// [squared L2 distance]: https://en.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
-    fn sq_l2_dist<T>(&self, other: &ArrayBase<T, D>) -> Result<A, MultiInputError>
+    fn sq_l2_dist(&self, other: &ArrayRef<A, D>) -> Result<A, MultiInputError>
     where
-        A: AddAssign + Clone + Signed,
-        T: Data<Elem = A>;
+        A: AddAssign + Clone + Signed;
 
     /// Computes the [L2 distance] between `self` and `other`.
     ///
@@ -75,10 +71,9 @@ where
     /// **Panics** if the type cast from `A` to `f64` fails.
     ///
     /// [L2 distance]: https://en.wikipedia.org/wiki/Euclidean_distance
-    fn l2_dist<T>(&self, other: &ArrayBase<T, D>) -> Result<f64, MultiInputError>
+    fn l2_dist(&self, other: &ArrayRef<A, D>) -> Result<f64, MultiInputError>
     where
-        A: AddAssign + Clone + Signed + ToPrimitive,
-        T: Data<Elem = A>;
+        A: AddAssign + Clone + Signed + ToPrimitive;
 
     /// Computes the [L1 distance] between `self` and `other`.
     ///
@@ -96,10 +91,9 @@ where
     /// * `MultiInputError::ShapeMismatch` if `self` and `other` don't have the same shape
     ///
     /// [L1 distance]: https://en.wikipedia.org/wiki/Taxicab_geometry
-    fn l1_dist<T>(&self, other: &ArrayBase<T, D>) -> Result<A, MultiInputError>
+    fn l1_dist(&self, other: &ArrayRef<A, D>) -> Result<A, MultiInputError>
     where
-        A: AddAssign + Clone + Signed,
-        T: Data<Elem = A>;
+        A: AddAssign + Clone + Signed;
 
     /// Computes the [L∞ distance] between `self` and `other`.
     ///
@@ -116,10 +110,9 @@ where
     /// * `MultiInputError::ShapeMismatch` if `self` and `other` don't have the same shape
     ///
     /// [L∞ distance]: https://en.wikipedia.org/wiki/Chebyshev_distance
-    fn linf_dist<T>(&self, other: &ArrayBase<T, D>) -> Result<A, MultiInputError>
+    fn linf_dist(&self, other: &ArrayRef<A, D>) -> Result<A, MultiInputError>
     where
-        A: Clone + PartialOrd + Signed,
-        T: Data<Elem = A>;
+        A: Clone + PartialOrd + Signed;
 
     /// Computes the [mean absolute error] between `self` and `other`.
     ///
@@ -139,10 +132,9 @@ where
     /// **Panics** if the type cast from `A` to `f64` fails.
     ///
     /// [mean absolute error]: https://en.wikipedia.org/wiki/Mean_absolute_error
-    fn mean_abs_err<T>(&self, other: &ArrayBase<T, D>) -> Result<f64, MultiInputError>
+    fn mean_abs_err(&self, other: &ArrayRef<A, D>) -> Result<f64, MultiInputError>
     where
-        A: AddAssign + Clone + Signed + ToPrimitive,
-        T: Data<Elem = A>;
+        A: AddAssign + Clone + Signed + ToPrimitive;
 
     /// Computes the [mean squared error] between `self` and `other`.
     ///
@@ -162,10 +154,9 @@ where
     /// **Panics** if the type cast from `A` to `f64` fails.
     ///
     /// [mean squared error]: https://en.wikipedia.org/wiki/Mean_squared_error
-    fn mean_sq_err<T>(&self, other: &ArrayBase<T, D>) -> Result<f64, MultiInputError>
+    fn mean_sq_err(&self, other: &ArrayRef<A, D>) -> Result<f64, MultiInputError>
     where
-        A: AddAssign + Clone + Signed + ToPrimitive,
-        T: Data<Elem = A>;
+        A: AddAssign + Clone + Signed + ToPrimitive;
 
     /// Computes the unnormalized [root-mean-square error] between `self` and `other`.
     ///
@@ -183,10 +174,9 @@ where
     /// **Panics** if the type cast from `A` to `f64` fails.
     ///
     /// [root-mean-square error]: https://en.wikipedia.org/wiki/Root-mean-square_deviation
-    fn root_mean_sq_err<T>(&self, other: &ArrayBase<T, D>) -> Result<f64, MultiInputError>
+    fn root_mean_sq_err(&self, other: &ArrayRef<A, D>) -> Result<f64, MultiInputError>
     where
-        A: AddAssign + Clone + Signed + ToPrimitive,
-        T: Data<Elem = A>;
+        A: AddAssign + Clone + Signed + ToPrimitive;
 
     /// Computes the [peak signal-to-noise ratio] between `self` and `other`.
     ///
@@ -205,27 +195,24 @@ where
     /// **Panics** if the type cast from `A` to `f64` fails.
     ///
     /// [peak signal-to-noise ratio]: https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio
-    fn peak_signal_to_noise_ratio<T>(
+    fn peak_signal_to_noise_ratio(
         &self,
-        other: &ArrayBase<T, D>,
+        other: &ArrayRef<A, D>,
         maxv: A,
     ) -> Result<f64, MultiInputError>
     where
-        A: AddAssign + Clone + Signed + ToPrimitive,
-        T: Data<Elem = A>;
+        A: AddAssign + Clone + Signed + ToPrimitive;
 
     private_decl! {}
 }
 
-impl<A, S, D> DeviationExt<A, S, D> for ArrayBase<S, D>
+impl<A, D> DeviationExt<A, D> for ArrayRef<A, D>
 where
-    S: Data<Elem = A>,
     D: Dimension,
 {
-    fn count_eq<T>(&self, other: &ArrayBase<T, D>) -> Result<usize, MultiInputError>
+    fn count_eq(&self, other: &ArrayRef<A, D>) -> Result<usize, MultiInputError>
     where
         A: PartialEq,
-        T: Data<Elem = A>,
     {
         return_err_if_empty!(self);
         return_err_unless_same_shape!(self, other);
@@ -241,18 +228,16 @@ where
         Ok(count)
     }
 
-    fn count_neq<T>(&self, other: &ArrayBase<T, D>) -> Result<usize, MultiInputError>
+    fn count_neq(&self, other: &ArrayRef<A, D>) -> Result<usize, MultiInputError>
     where
         A: PartialEq,
-        T: Data<Elem = A>,
     {
         self.count_eq(other).map(|n_eq| self.len() - n_eq)
     }
 
-    fn sq_l2_dist<T>(&self, other: &ArrayBase<T, D>) -> Result<A, MultiInputError>
+    fn sq_l2_dist(&self, other: &ArrayRef<A, D>) -> Result<A, MultiInputError>
     where
         A: AddAssign + Clone + Signed,
-        T: Data<Elem = A>,
     {
         return_err_if_empty!(self);
         return_err_unless_same_shape!(self, other);
@@ -268,10 +253,9 @@ where
         Ok(result)
     }
 
-    fn l2_dist<T>(&self, other: &ArrayBase<T, D>) -> Result<f64, MultiInputError>
+    fn l2_dist(&self, other: &ArrayRef<A, D>) -> Result<f64, MultiInputError>
     where
         A: AddAssign + Clone + Signed + ToPrimitive,
-        T: Data<Elem = A>,
     {
         let sq_l2_dist = self
             .sq_l2_dist(other)?
@@ -281,10 +265,9 @@ where
         Ok(sq_l2_dist.sqrt())
     }
 
-    fn l1_dist<T>(&self, other: &ArrayBase<T, D>) -> Result<A, MultiInputError>
+    fn l1_dist(&self, other: &ArrayRef<A, D>) -> Result<A, MultiInputError>
     where
         A: AddAssign + Clone + Signed,
-        T: Data<Elem = A>,
     {
         return_err_if_empty!(self);
         return_err_unless_same_shape!(self, other);
@@ -299,10 +282,9 @@ where
         Ok(result)
     }
 
-    fn linf_dist<T>(&self, other: &ArrayBase<T, D>) -> Result<A, MultiInputError>
+    fn linf_dist(&self, other: &ArrayRef<A, D>) -> Result<A, MultiInputError>
     where
         A: Clone + PartialOrd + Signed,
-        T: Data<Elem = A>,
     {
         return_err_if_empty!(self);
         return_err_unless_same_shape!(self, other);
@@ -320,10 +302,9 @@ where
         Ok(max)
     }
 
-    fn mean_abs_err<T>(&self, other: &ArrayBase<T, D>) -> Result<f64, MultiInputError>
+    fn mean_abs_err(&self, other: &ArrayRef<A, D>) -> Result<f64, MultiInputError>
     where
         A: AddAssign + Clone + Signed + ToPrimitive,
-        T: Data<Elem = A>,
     {
         let l1_dist = self
             .l1_dist(other)?
@@ -334,10 +315,9 @@ where
         Ok(l1_dist / n)
     }
 
-    fn mean_sq_err<T>(&self, other: &ArrayBase<T, D>) -> Result<f64, MultiInputError>
+    fn mean_sq_err(&self, other: &ArrayRef<A, D>) -> Result<f64, MultiInputError>
     where
         A: AddAssign + Clone + Signed + ToPrimitive,
-        T: Data<Elem = A>,
     {
         let sq_l2_dist = self
             .sq_l2_dist(other)?
@@ -348,23 +328,21 @@ where
         Ok(sq_l2_dist / n)
     }
 
-    fn root_mean_sq_err<T>(&self, other: &ArrayBase<T, D>) -> Result<f64, MultiInputError>
+    fn root_mean_sq_err(&self, other: &ArrayRef<A, D>) -> Result<f64, MultiInputError>
     where
         A: AddAssign + Clone + Signed + ToPrimitive,
-        T: Data<Elem = A>,
     {
         let msd = self.mean_sq_err(other)?;
         Ok(msd.sqrt())
     }
 
-    fn peak_signal_to_noise_ratio<T>(
+    fn peak_signal_to_noise_ratio(
         &self,
-        other: &ArrayBase<T, D>,
+        other: &ArrayRef<A, D>,
         maxv: A,
     ) -> Result<f64, MultiInputError>
     where
         A: AddAssign + Clone + Signed + ToPrimitive,
-        T: Data<Elem = A>,
     {
         let maxv_f = maxv.to_f64().expect("failed cast from type A to f64");
         let msd = self.mean_sq_err(&other)?;