Switch var_axis and std_axis to use FromPrimitive

The documentation for the `Zero` and `One` traits says only that they
are the additive and multiplicative identities; it doesn't say
anything about converting an integer to a float by adding `One::one()`
to `Zero::zero()` repeatedly. Additionally, it's nice to panic early
instead of waiting until after the sum has been calculated.

Author: jturner314

src/numeric/impl_numeric.rs

@@ -7,7 +7,7 @@
 // except according to those terms.
 
 use std::ops::{Add, Div, Mul};
-use libnum::{self, One, Zero, Float};
+use libnum::{self, One, Zero, Float, FromPrimitive};
 use itertools::free::enumerate;
 
 use imp_prelude::*;
@@ -163,8 +163,11 @@ impl<A, S, D> ArrayBase<S, D>
     ///     n  i=1
     /// ```
     ///
-    /// **Panics** if `ddof` is less than zero or greater than the length of
-    /// the axis or if `axis` is out of bounds.
+    /// and `n` is the length of the axis.
+    ///
+    /// **Panics** if `ddof` is less than zero or greater than `n`, if `axis`
+    /// is out of bounds, or if `A::from_usize()` fails for any any of the
+    /// numbers in the range `0..=n`.
     ///
     /// # Example
     ///
@@ -179,26 +182,27 @@ impl<A, S, D> ArrayBase<S, D>
     /// ```
     pub fn var_axis(&self, axis: Axis, ddof: A) -> Array<A, D::Smaller>
     where
-        A: Float,
+        A: Float + FromPrimitive,
         D: RemoveAxis,
     {
-        let mut count = A::zero();
+        let zero = A::from_usize(0).expect("Converting 0 to `A` must not fail.");
+        let n = A::from_usize(self.len_of(axis)).expect("Converting length to `A` must not fail.");
+        assert!(
+            !(ddof < zero || ddof > n),
+            "`ddof` must not be less than zero or greater than the length of \
+             the axis",
+        );
+        let dof = n - ddof;
         let mut mean = Array::<A, _>::zeros(self.dim.remove_axis(axis));
         let mut sum_sq = Array::<A, _>::zeros(self.dim.remove_axis(axis));
-        for subview in self.axis_iter(axis) {
-            count = count + A::one();
+        for (i, subview) in self.axis_iter(axis).enumerate() {
+            let count = A::from_usize(i + 1).expect("Converting index to `A` must not fail.");
             azip!(mut mean, mut sum_sq, x (subview) in {
                 let delta = x - *mean;
                 *mean = *mean + delta / count;
                 *sum_sq = (x - *mean).mul_add(delta, *sum_sq);
             });
         }
-        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)
     }
 
@@ -227,8 +231,11 @@ impl<A, S, D> ArrayBase<S, D>
     ///     n  i=1
     /// ```
     ///
-    /// **Panics** if `ddof` is less than zero or greater than the length of
-    /// the axis or if `axis` is out of bounds.
+    /// and `n` is the length of the axis.
+    ///
+    /// **Panics** if `ddof` is less than zero or greater than `n`, if `axis`
+    /// is out of bounds, or if `A::from_usize()` fails for any any of the
+    /// numbers in the range `0..=n`.
     ///
     /// # Example
     ///
@@ -243,7 +250,7 @@ impl<A, S, D> ArrayBase<S, D>
     /// ```
     pub fn std_axis(&self, axis: Axis, ddof: A) -> Array<A, D::Smaller>
     where
-        A: Float,
+        A: Float + FromPrimitive,
         D: RemoveAxis,
     {
         self.var_axis(axis, ddof).mapv_into(|x| x.sqrt())