Adjust constraints on ddof for var_axis and std_axis

Requiring `ddof` to not be < 0 allows us to ignore weird edge cases.
Allowing `ddof` to be equal to the length of the axis allows
computation of the population variance (`ddof` = 0) for a zero-length
axis and computation of the sample variance (`ddof` = 1) for an axis
of length one. (The result in these cases is an array of NaNs.)

Note that this is a breaking change because of the new constraint that
`ddof` must not be less than zero.

Author: jturner314

src/numeric/impl_numeric.rs

@@ -163,8 +163,8 @@ impl<A, S, D> ArrayBase<S, D>
     ///     n  i=1
     /// ```
     ///
-    /// **Panics** if `ddof` is greater than or equal to the length of the
-    /// axis or if `axis` is out of bounds.
+    /// **Panics** if `ddof` is less than zero or greater than the length of
+    /// the axis or if `axis` is out of bounds.
     ///
     /// # Example
     ///
@@ -193,13 +193,13 @@ impl<A, S, D> ArrayBase<S, D>
                 *sum_sq = (x - *mean).mul_add(delta, *sum_sq);
             });
         }
-        if ddof >= count {
-            panic!("`ddof` needs to be strictly smaller than the length \
-                    of the axis you are computing the variance for!")
-        } else {
-            let dof = count - ddof;
-            sum_sq.mapv_into(|s| s / dof)
-        }
+        assert!(
+            !(ddof < A::zero() || ddof > count),
+            "`ddof` must not be less than zero or greater than the length of \
+             the axis",
+        );
+        let dof = count - ddof;
+        sum_sq.mapv_into(|s| s / dof)
     }
 
     /// Return standard deviation along `axis`.
@@ -227,8 +227,8 @@ impl<A, S, D> ArrayBase<S, D>
     ///     n  i=1
     /// ```
     ///
-    /// **Panics** if `ddof` is greater than or equal to the length of the
-    /// axis or if `axis` is out of bounds.
+    /// **Panics** if `ddof` is less than zero or greater than the length of
+    /// the axis or if `axis` is out of bounds.
     ///
     /// # Example
     ///

tests/array.rs

@@ -810,15 +810,32 @@ fn std_axis() {
 
 #[test]
 #[should_panic]
-fn var_axis_bad_dof() {
+fn var_axis_negative_ddof() {
+    let a = array![1., 2., 3.];
+    a.var_axis(Axis(0), -1.);
+}
+
+#[test]
+#[should_panic]
+fn var_axis_too_large_ddof() {
     let a = array![1., 2., 3.];
     a.var_axis(Axis(0), 4.);
 }
 
+#[test]
+fn var_axis_nan_ddof() {
+    let a = Array2::<f64>::zeros((2, 3));
+    let v = a.var_axis(Axis(1), ::std::f64::NAN);
+    assert_eq!(v.shape(), &[2]);
+    v.mapv(|x| assert!(x.is_nan()));
+}
+
 #[test]
 fn var_axis_empty_axis() {
-    let a = array![[], []];
-    a.var_axis(Axis(1), -1.);
+    let a = Array2::<f64>::zeros((2, 0));
+    let v = a.var_axis(Axis(1), 0.);
+    assert_eq!(v.shape(), &[2]);
+    v.mapv(|x| assert!(x.is_nan()));
 }
 
 #[test]
@@ -830,8 +847,10 @@ fn std_axis_bad_dof() {
 
 #[test]
 fn std_axis_empty_axis() {
-    let a = array![[], []];
-    a.std_axis(Axis(1), -1.);
+    let a = Array2::<f64>::zeros((2, 0));
+    let v = a.std_axis(Axis(1), 0.);
+    assert_eq!(v.shape(), &[2]);
+    v.mapv(|x| assert!(x.is_nan()));
 }
 
 #[test]