Bulk quantiles

src/errors.rs

@@ -1,4 +1,5 @@
 //! Custom errors returned from our methods and functions.
+use noisy_float::types::N64;
 use std::error::Error;
 use std::fmt;
 
@@ -112,3 +113,31 @@ impl From<ShapeMismatch> for MultiInputError {
         MultiInputError::ShapeMismatch(err)
     }
 }
+
+/// An error computing a quantile.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum QuantileError {
+    /// The input was empty.
+    EmptyInput,
+    /// The `q` was not between `0.` and `1.` (inclusive).
+    InvalidQuantile(N64),
+}
+
+impl fmt::Display for QuantileError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            QuantileError::EmptyInput => write!(f, "Empty input."),
+            QuantileError::InvalidQuantile(q) => {
+                write!(f, "{:} is not between 0. and 1. (inclusive).", q)
+            }
+        }
+    }
+}
+
+impl Error for QuantileError {}
+
+impl From<EmptyInput> for QuantileError {
+    fn from(_: EmptyInput) -> QuantileError {
+        QuantileError::EmptyInput
+    }
+}

src/lib.rs

@@ -34,7 +34,6 @@ extern crate rand;
 
 #[cfg(test)]
 extern crate approx;
-extern crate core;
 #[cfg(test)]
 extern crate ndarray_rand;
 #[cfg(test)]

src/quantile/mod.rs

@@ -1,6 +1,7 @@
 use self::interpolate::{higher_index, lower_index, Interpolate};
 use super::sort::get_many_from_sorted_mut_unchecked;
 use crate::errors::{EmptyInput, MinMaxError, MinMaxError::UndefinedOrder};
+use errors::QuantileError;
 use ndarray::prelude::*;
 use ndarray::{Data, DataMut, RemoveAxis, Zip};
 use noisy_float::types::N64;
@@ -213,14 +214,15 @@ where
     ///
     /// Returns `Err(EmptyInput)` when the specified axis has length 0.
     ///
-    /// **Panics** if `axis` is out of bounds or if
-    /// `q` is not between `0.` and `1.` (inclusive).
+    /// Returns `Err(InvalidQuantile(q))` if `q` is not between `0.` and `1.` (inclusive).
+    ///
+    /// **Panics** if `axis` is out of bounds.
     fn quantile_axis_mut<I>(
         &mut self,
         axis: Axis,
         q: N64,
         interpolate: &I,
-    ) -> Result<Array<A, D::Smaller>, EmptyInput>
+    ) -> Result<Array<A, D::Smaller>, QuantileError>
     where
         D: RemoveAxis,
         A: Ord + Clone,
@@ -238,8 +240,9 @@ where
     ///
     /// Returns `Err(EmptyInput)` when the specified axis has length 0.
     ///
-    /// **Panics** if `axis` is out of bounds or if
-    /// any `q` in `qs` is not between `0.` and `1.` (inclusive).
+    /// Returns `Err(InvalidQuantile(q))` if any `q` in `qs` is not between `0.` and `1.` (inclusive).
+    ///
+    /// **Panics** if `axis` is out of bounds.
     ///
     /// [`quantile_axis_mut`]: #tymethod.quantile_axis_mut
     ///
@@ -269,7 +272,7 @@ where
         axis: Axis,
         qs: &ArrayBase<S2, Ix1>,
         interpolate: &I,
-    ) -> Result<Array<A, D>, EmptyInput>
+    ) -> Result<Array<A, D>, QuantileError>
     where
         D: RemoveAxis,
         A: Ord + Clone,
@@ -285,7 +288,7 @@ where
         axis: Axis,
         q: N64,
         interpolate: &I,
-    ) -> Result<Array<A, D::Smaller>, EmptyInput>
+    ) -> Result<Array<A, D::Smaller>, QuantileError>
     where
         D: RemoveAxis,
         A: MaybeNan,
@@ -438,7 +441,7 @@ where
         axis: Axis,
         qs: &ArrayBase<S2, Ix1>,
         interpolate: &I,
-    ) -> Result<Array<A, D>, EmptyInput>
+    ) -> Result<Array<A, D>, QuantileError>
     where
         D: RemoveAxis,
         A: Ord + Clone,
@@ -452,17 +455,21 @@ where
             axis: Axis,
             qs: ArrayView1<N64>,
             _interpolate: &I,
-        ) -> Result<Array<A, D>, EmptyInput>
+        ) -> Result<Array<A, D>, QuantileError>
         where
             D: RemoveAxis,
             A: Ord + Clone,
             I: Interpolate<A>,
         {
-            assert!(qs.iter().all(|x| (*x >= 0.) && (*x <= 1.)));
+            for &q in qs {
+                if !((q >= 0.) && (q <= 1.)) {
+                    return Err(QuantileError::InvalidQuantile(q));
+                }
+            }
 
             let axis_len = data.len_of(axis);
             if axis_len == 0 {
-                return Err(EmptyInput);
+                return Err(QuantileError::EmptyInput);
             }
 
             let mut results_shape = data.raw_dim();
@@ -514,7 +521,7 @@ where
         axis: Axis,
         q: N64,
         interpolate: &I,
-    ) -> Result<Array<A, D::Smaller>, EmptyInput>
+    ) -> Result<Array<A, D::Smaller>, QuantileError>
     where
         D: RemoveAxis,
         A: Ord + Clone,
@@ -530,17 +537,22 @@ where
         axis: Axis,
         q: N64,
         interpolate: &I,
-    ) -> Result<Array<A, D::Smaller>, EmptyInput>
+    ) -> Result<Array<A, D::Smaller>, QuantileError>
     where
         D: RemoveAxis,
         A: MaybeNan,
         A::NotNan: Clone + Ord,
         S: DataMut,
         I: Interpolate<A::NotNan>,
     {
+        if !((q >= 0.) && (q <= 1.)) {
+            return Err(QuantileError::InvalidQuantile(q));
+        }
+
         if self.len_of(axis) == 0 {
-            return Err(EmptyInput);
+            return Err(QuantileError::EmptyInput);
         }
+
         let quantile = self.map_axis_mut(axis, |lane| {
             let mut not_nan = A::remove_nan_mut(lane);
             A::from_not_nan_opt(if not_nan.is_empty() {
@@ -591,8 +603,8 @@ where
     ///
     /// Returns `Err(EmptyInput)` if the array is empty.
     ///
-    /// **Panics** if `q` is not between `0.` and `1.` (inclusive).
-    fn quantile_mut<I>(&mut self, q: N64, interpolate: &I) -> Result<A, EmptyInput>
+    /// Returns `Err(InvalidQuantile(q))` if `q` is not between `0.` and `1.` (inclusive).
+    fn quantile_mut<I>(&mut self, q: N64, interpolate: &I) -> Result<A, QuantileError>
     where
         A: Ord + Clone,
         S: DataMut,
@@ -606,17 +618,18 @@ where
     ///
     /// Returns `Err(EmptyInput)` if the array is empty.
     ///
+    /// Returns `Err(InvalidQuantile(q))` if any `q` in
+    /// `qs` is not between `0.` and `1.` (inclusive).
+    ///
     /// See [`quantile_mut`] for additional details on quantiles and the algorithm
     /// used to retrieve them.
     ///
-    /// **Panics** if any `q` in `qs` is not between `0.` and `1.` (inclusive).
-    ///
     /// [`quantile_mut`]: #tymethod.quantile_mut
     fn quantiles_mut<S2, I>(
         &mut self,
         qs: &ArrayBase<S2, Ix1>,
         interpolate: &I,
-    ) -> Result<Array1<A>, EmptyInput>
+    ) -> Result<Array1<A>, QuantileError>
     where
         A: Ord + Clone,
         S: DataMut,
@@ -628,18 +641,17 @@ impl<A, S> Quantile1dExt<A, S> for ArrayBase<S, Ix1>
 where
     S: Data<Elem = A>,
 {
-    fn quantile_mut<I>(&mut self, q: N64, interpolate: &I) -> Result<A, EmptyInput>
+    fn quantile_mut<I>(&mut self, q: N64, interpolate: &I) -> Result<A, QuantileError>
     where
         A: Ord + Clone,
         S: DataMut,
         I: Interpolate<A>,
     {
         if self.is_empty() {
-            Err(EmptyInput)
+            Err(QuantileError::EmptyInput)
         } else {
             Ok(self
-                .quantile_axis_mut(Axis(0), q, interpolate)
-                .unwrap()
+                .quantile_axis_mut(Axis(0), q, interpolate)?
                 .into_scalar())
         }
     }
@@ -648,7 +660,7 @@ where
         &mut self,
         qs: &ArrayBase<S2, Ix1>,
         interpolate: &I,
-    ) -> Result<Array1<A>, EmptyInput>
+    ) -> Result<Array1<A>, QuantileError>
     where
         A: Ord + Clone,
         S: DataMut,

tests/quantile.rs

@@ -10,7 +10,7 @@ use itertools::izip;
 use ndarray::array;
 use ndarray::prelude::*;
 use ndarray_stats::{
-    errors::{EmptyInput, MinMaxError},
+    errors::{MinMaxError, QuantileError},
     interpolate::{Higher, Interpolate, Linear, Lower, Midpoint, Nearest},
     Quantile1dExt, QuantileExt,
 };
@@ -192,7 +192,7 @@ fn test_quantile_axis_mut_with_zero_axis_length() {
     let mut a = Array2::<i32>::zeros((5, 0));
     assert_eq!(
         a.quantile_axis_mut(Axis(1), n64(0.5), &Lower),
-        Err(EmptyInput)
+        Err(QuantileError::EmptyInput)
     );
 }