Remove min/max for A: Ord

The problem with the old methods was that they panicked when the array
was empty, which was very problematic. (See rust-ndarray/ndarray#512
for discussion.) The old `min_partialord` and `max_partialord` have
been renamed to `min`/`max`.

Author: jturner314

src/histogram/strategies.rs

@@ -188,8 +188,8 @@ impl<T> BinsBuildingStrategy for Sqrt<T>
     {
         let n_elems = a.len();
         let n_bins = (n_elems as f64).sqrt().round() as usize;
-        let min = a.min().clone();
-        let max = a.max().clone();
+        let min = a.min().unwrap().clone();
+        let max = a.max().unwrap().clone();
         let bin_width = compute_bin_width(min.clone(), max.clone(), n_bins);
         let builder = EquiSpaced::new(bin_width, min, max);
         Self { builder }
@@ -227,8 +227,8 @@ impl<T> BinsBuildingStrategy for Rice<T>
     {
         let n_elems = a.len();
         let n_bins = (2. * (n_elems as f64).powf(1./3.)).round() as usize;
-        let min = a.min().clone();
-        let max = a.max().clone();
+        let min = a.min().unwrap().clone();
+        let max = a.max().unwrap().clone();
         let bin_width = compute_bin_width(min.clone(), max.clone(), n_bins);
         let builder = EquiSpaced::new(bin_width, min, max);
         Self { builder }
@@ -266,8 +266,8 @@ impl<T> BinsBuildingStrategy for Sturges<T>
     {
         let n_elems = a.len();
         let n_bins = (n_elems as f64).log2().round() as usize + 1;
-        let min = a.min().clone();
-        let max = a.max().clone();
+        let min = a.min().unwrap().clone();
+        let max = a.max().unwrap().clone();
         let bin_width = compute_bin_width(min.clone(), max.clone(), n_bins);
         let builder = EquiSpaced::new(bin_width, min, max);
         Self { builder }
@@ -311,8 +311,8 @@ impl<T> BinsBuildingStrategy for FreedmanDiaconis<T>
         let iqr = third_quartile - first_quartile;
 
         let bin_width = FreedmanDiaconis::compute_bin_width(n_points, iqr);
-        let min = a_copy.min().clone();
-        let max = a_copy.max().clone();
+        let min = a_copy.min().unwrap().clone();
+        let max = a_copy.max().unwrap().clone();
         let builder = EquiSpaced::new(bin_width, min, max);
         Self { builder }
     }

src/quantile.rs

@@ -175,21 +175,14 @@ where
     S: Data<Elem = A>,
     D: Dimension,
 {
-    /// Finds the elementwise minimum of the array.
-    ///
-    /// **Panics** if the array is empty.
-    fn min(&self) -> &A
-    where
-        A: Ord;
-
     /// Finds the elementwise minimum of the array.
     ///
     /// Returns `None` if any of the pairwise orderings tested by the function
     /// are undefined. (For example, this occurs if there are any
     /// floating-point NaN values in the array.)
     ///
     /// Additionally, returns `None` if the array is empty.
-    fn min_partialord(&self) -> Option<&A>
+    fn min(&self) -> Option<&A>
     where
         A: PartialOrd;
 
@@ -203,21 +196,14 @@ where
         A: MaybeNan,
         A::NotNan: Ord;
 
-    /// Finds the elementwise maximum of the array.
-    ///
-    /// **Panics** if the array is empty.
-    fn max(&self) -> &A
-    where
-        A: Ord;
-
     /// Finds the elementwise maximum of the array.
     ///
     /// Returns `None` if any of the pairwise orderings tested by the function
     /// are undefined. (For example, this occurs if there are any
     /// floating-point NaN values in the array.)
     ///
     /// Additionally, returns `None` if the array is empty.
-    fn max_partialord(&self) -> Option<&A>
+    fn max(&self) -> Option<&A>
     where
         A: PartialOrd;
 
@@ -285,22 +271,11 @@ where
     S: Data<Elem = A>,
     D: Dimension,
 {
-    fn min(&self) -> &A
-    where
-        A: Ord,
-    {
-        let first = self
-            .iter()
-            .next()
-            .expect("Attempted to find min of empty array.");
-        self.fold(first, |acc, elem| if elem < acc { elem } else { acc })
-    }
-
-    fn min_partialord(&self) -> Option<&A>
+    fn min(&self) -> Option<&A>
     where
         A: PartialOrd,
     {
-        let first = self.iter().next()?;
+        let first = self.first()?;
         self.fold(Some(first), |acc, elem| match elem.partial_cmp(acc?)? {
             cmp::Ordering::Less => Some(elem),
             _ => acc,
@@ -312,7 +287,7 @@ where
         A: MaybeNan,
         A::NotNan: Ord,
     {
-        let first = self.iter().next().and_then(|v| v.try_as_not_nan());
+        let first = self.first().and_then(|v| v.try_as_not_nan());
         A::from_not_nan_ref_opt(self.fold_skipnan(first, |acc, elem| {
             Some(match acc {
                 Some(acc) => acc.min(elem),
@@ -321,22 +296,11 @@ where
         }))
     }
 
-    fn max(&self) -> &A
-    where
-        A: Ord,
-    {
-        let first = self
-            .iter()
-            .next()
-            .expect("Attempted to find max of empty array.");
-        self.fold(first, |acc, elem| if elem > acc { elem } else { acc })
-    }
-
-    fn max_partialord(&self) -> Option<&A>
+    fn max(&self) -> Option<&A>
     where
         A: PartialOrd,
     {
-        let first = self.iter().next()?;
+        let first = self.first()?;
         self.fold(Some(first), |acc, elem| match elem.partial_cmp(acc?)? {
             cmp::Ordering::Greater => Some(elem),
             _ => acc,
@@ -348,7 +312,7 @@ where
         A: MaybeNan,
         A::NotNan: Ord,
     {
-        let first = self.iter().next().and_then(|v| v.try_as_not_nan());
+        let first = self.first().and_then(|v| v.try_as_not_nan());
         A::from_not_nan_ref_opt(self.fold_skipnan(first, |acc, elem| {
             Some(match acc {
                 Some(acc) => acc.max(elem),

tests/quantile.rs

@@ -11,16 +11,13 @@ use ndarray_stats::{
 #[test]
 fn test_min() {
     let a = array![[1, 5, 3], [2, 0, 6]];
-    assert_eq!(a.min(), &0);
-}
+    assert_eq!(a.min(), Some(&0));
 
-#[test]
-fn test_min_partialord() {
     let a = array![[1., 5., 3.], [2., 0., 6.]];
-    assert_eq!(a.min_partialord(), Some(&0.));
+    assert_eq!(a.min(), Some(&0.));
 
     let a = array![[1., 5., 3.], [2., ::std::f64::NAN, 6.]];
-    assert_eq!(a.min_partialord(), None);
+    assert_eq!(a.min(), None);
 }
 
 #[test]
@@ -41,16 +38,13 @@ fn test_min_skipnan_all_nan() {
 #[test]
 fn test_max() {
     let a = array![[1, 5, 7], [2, 0, 6]];
-    assert_eq!(a.max(), &7);
-}
+    assert_eq!(a.max(), Some(&7));
 
-#[test]
-fn test_max_partialord() {
     let a = array![[1., 5., 7.], [2., 0., 6.]];
-    assert_eq!(a.max_partialord(), Some(&7.));
+    assert_eq!(a.max(), Some(&7.));
 
     let a = array![[1., 5., 7.], [2., ::std::f64::NAN, 6.]];
-    assert_eq!(a.max_partialord(), None);
+    assert_eq!(a.max(), None);
 }
 
 #[test]