Move add and merge to trait

This should make it possible to write more generic code.

Author: vks

src/lib.rs

@@ -19,7 +19,7 @@
 //! ### Example
 //!
 //! ```
-//! use average::MeanWithError;
+//! use average::{MeanWithError, Estimate};
 //!
 //! let mut a: MeanWithError = (1..6).map(Into::into).collect();
 //! a.add(42.);

src/macros.rs

@@ -40,7 +40,7 @@ macro_rules! assert_almost_eq {
 /// # extern crate core;
 /// # #[macro_use] extern crate average;
 /// # fn main() {
-/// use average::{Min, Max};
+/// use average::{Min, Max, Estimate};
 ///
 /// concatenate!(MinMax, [Min, min], [Max, max]);
 ///
@@ -54,7 +54,7 @@ macro_rules! assert_almost_eq {
 /// The generated code looks roughly like this:
 ///
 /// ```
-/// # use average::{Min, Max};
+/// # use average::{Min, Max, Estimate};
 /// #
 /// struct MinMax {
 ///     min: Min,
@@ -88,7 +88,7 @@ macro_rules! assert_almost_eq {
 /// # extern crate core;
 /// # #[macro_use] extern crate average;
 /// # fn main() {
-/// use average::{Variance, Quantile};
+/// use average::{Variance, Quantile, Estimate};
 ///
 /// concatenate!(Estimator,
 ///     [Variance, variance, mean, sample_variance],

src/minmax.rs

@@ -1,6 +1,7 @@
 use core;
 
 use super::reduce::Reduce;
+use super::{Estimate, Merge};
 
 /// Calculate the minimum of `a` and `b`.
 fn min(a: f64, b: f64) -> f64 {
@@ -43,25 +44,41 @@ impl Min {
         Min::from_value(::core::f64::INFINITY)
     }
 
-    /// Add an observation sampled from the population.
+    /// Estimate the minium of the population.
     #[inline]
-    pub fn add(&mut self, x: f64) {
+    pub fn min(&self) -> f64 {
+        self.r.reduction()
+    }
+}
+
+impl core::default::Default for Min {
+    fn default() -> Min {
+        Min::new()
+    }
+}
+
+impl_from_iterator!(Min);
+
+impl Estimate for Min {
+    #[inline]
+    fn add(&mut self, x: f64) {
         self.r.add(x);
     }
 
-    /// Estimate the minium of the population.
     #[inline]
-    pub fn min(&self) -> f64 {
-        self.r.reduction()
+    fn estimate(&self) -> f64 {
+        self.min()
     }
+}
 
+impl Merge for Min {
     /// Merge another sample into this one.
     ///
     ///
     /// ## Example
     ///
     /// ```
-    /// use average::Min;
+    /// use average::{Min, Merge};
     ///
     /// let sequence: &[f64] = &[1., 2., 3., 4., 5., 6., 7., 8., 9.];
     /// let (left, right) = sequence.split_at(3);
@@ -72,19 +89,11 @@ impl Min {
     /// assert_eq!(min_total.min(), min_left.min());
     /// ```
     #[inline]
-    pub fn merge(&mut self, other: &Min) {
+    fn merge(&mut self, other: &Min) {
         self.r.merge(&other.r);
     }
 }
 
-impl core::default::Default for Min {
-    fn default() -> Min {
-        Min::new()
-    }
-}
-
-impl_from_iterator!(Min);
-
 /// Estimate the maximum of a sequence of numbers ("population").
 ///
 ///
@@ -116,25 +125,41 @@ impl Max {
         Max::from_value(::core::f64::NEG_INFINITY)
     }
 
-    /// Add an observation sampled from the population.
+    /// Estimate the maxium of the population.
     #[inline]
-    pub fn add(&mut self, x: f64) {
+    pub fn max(&self) -> f64 {
+        self.r.reduction()
+    }
+}
+
+impl core::default::Default for Max {
+    fn default() -> Max {
+        Max::new()
+    }
+}
+
+impl_from_iterator!(Max);
+
+impl Estimate for Max {
+    #[inline]
+    fn add(&mut self, x: f64) {
         self.r.add(x);
     }
 
-    /// Estimate the maxium of the population.
     #[inline]
-    pub fn max(&self) -> f64 {
-        self.r.reduction()
+    fn estimate(&self) -> f64 {
+        self.max()
     }
+}
 
+impl Merge for Max {
     /// Merge another sample into this one.
     ///
     ///
     /// ## Example
     ///
     /// ```
-    /// use average::Max;
+    /// use average::{Max, Merge};
     ///
     /// let sequence: &[f64] = &[1., 2., 3., 4., 5., 6., 7., 8., 9.];
     /// let (left, right) = sequence.split_at(3);
@@ -145,15 +170,7 @@ impl Max {
     /// assert_eq!(max_total.max(), max_left.max());
     /// ```
     #[inline]
-    pub fn merge(&mut self, other: &Max) {
+    fn merge(&mut self, other: &Max) {
         self.r.merge(&other.r);
     }
 }
-
-impl core::default::Default for Max {
-    fn default() -> Max {
-        Max::new()
-    }
-}
-
-impl_from_iterator!(Max);

src/moments/kurtosis.rs

@@ -20,15 +20,6 @@ impl Kurtosis {
         }
     }
 
-    /// Add an observation sampled from the population.
-    #[inline]
-    pub fn add(&mut self, x: f64) {
-        let delta = x - self.mean();
-        self.increment();
-        let n = f64::approx_from(self.len()).unwrap();
-        self.add_inner(delta, delta/n);
-    }
-
     /// Increment the sample size.
     ///
     /// This does not update anything else.
@@ -114,9 +105,26 @@ impl Kurtosis {
         n * self.sum_4 / (self.avg.avg.sum_2 * self.avg.avg.sum_2) - 3.
     }
 
-    /// Merge another sample into this one.
+}
+
+impl Estimate for Kurtosis {
+    #[inline]
+    fn add(&mut self, x: f64) {
+        let delta = x - self.mean();
+        self.increment();
+        let n = f64::approx_from(self.len()).unwrap();
+        self.add_inner(delta, delta/n);
+    }
+
+    #[inline]
+    fn estimate(&self) -> f64 {
+        self.kurtosis()
+    }
+}
+
+impl Merge for Kurtosis {
     #[inline]
-    pub fn merge(&mut self, other: &Kurtosis) {
+    fn merge(&mut self, other: &Kurtosis) {
         let len_self = f64::approx_from(self.len()).unwrap();
         let len_other = f64::approx_from(other.len()).unwrap();
         let len_total = len_self + len_other;

src/moments/mean.rs

@@ -1,8 +1,3 @@
-use core;
-
-use conv::ApproxFrom;
-
-
 /// Estimate the arithmetic mean of a sequence of numbers ("population").
 ///
 ///
@@ -29,15 +24,6 @@ impl Mean {
         Mean { avg: 0., n: 0 }
     }
 
-    /// Add an observation sampled from the population.
-    #[inline]
-    pub fn add(&mut self, sample: f64) {
-        self.increment();
-        let delta_n = (sample - self.avg)
-            / f64::approx_from(self.n).unwrap();
-        self.add_inner(delta_n);
-    }
-
     /// Increment the sample size.
     ///
     /// This does not update anything else.
@@ -80,13 +66,36 @@ impl Mean {
         self.n
     }
 
+}
+
+impl core::default::Default for Mean {
+    fn default() -> Mean {
+        Mean::new()
+    }
+}
+
+impl Estimate for Mean {
+    #[inline]
+    fn add(&mut self, sample: f64) {
+        self.increment();
+        let delta_n = (sample - self.avg)
+            / f64::approx_from(self.n).unwrap();
+        self.add_inner(delta_n);
+    }
+
+    fn estimate(&self) -> f64 {
+        self.mean()
+    }
+}
+
+impl Merge for Mean {
     /// Merge another sample into this one.
     ///
     ///
     /// ## Example
     ///
     /// ```
-    /// use average::Mean;
+    /// use average::{Mean, Merge};
     ///
     /// let sequence: &[f64] = &[1., 2., 3., 4., 5., 6., 7., 8., 9.];
     /// let (left, right) = sequence.split_at(3);
@@ -97,7 +106,7 @@ impl Mean {
     /// assert_eq!(avg_total.mean(), avg_left.mean());
     /// ```
     #[inline]
-    pub fn merge(&mut self, other: &Mean) {
+    fn merge(&mut self, other: &Mean) {
         // This algorithm was proposed by Chan et al. in 1979.
         //
         // See https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance.
@@ -114,10 +123,4 @@ impl Mean {
     }
 }
 
-impl core::default::Default for Mean {
-    fn default() -> Mean {
-        Mean::new()
-    }
-}
-
 impl_from_iterator!(Mean);

src/moments/mod.rs

@@ -1,3 +1,9 @@
+use core;
+
+use conv::ApproxFrom;
+
+use super::{Estimate, Merge};
+
 include!("mean.rs");
 include!("variance.rs");
 include!("skewness.rs");

src/moments/skewness.rs

@@ -20,15 +20,6 @@ impl Skewness {
         }
     }
 
-    /// Add an observation sampled from the population.
-    #[inline]
-    pub fn add(&mut self, x: f64) {
-        let delta = x - self.mean();
-        self.increment();
-        let n = f64::approx_from(self.len()).unwrap();
-        self.add_inner(delta, delta/n);
-    }
-
     /// Increment the sample size.
     ///
     /// This does not update anything else.
@@ -107,10 +98,32 @@ impl Skewness {
         debug_assert_ne!(sum_2, 0.);
         n.sqrt() * self.sum_3 / (sum_2*sum_2*sum_2).sqrt()
     }
+}
+
+impl Default for Skewness {
+    fn default() -> Skewness {
+        Skewness::new()
+    }
+}
+
+impl Estimate for Skewness {
+    #[inline]
+    fn add(&mut self, x: f64) {
+        let delta = x - self.mean();
+        self.increment();
+        let n = f64::approx_from(self.len()).unwrap();
+        self.add_inner(delta, delta/n);
+    }
+
+    #[inline]
+    fn estimate(&self) -> f64 {
+        self.skewness()
+    }
+}
 
-    /// Merge another sample into this one.
+impl Merge for Skewness {
     #[inline]
-    pub fn merge(&mut self, other: &Skewness) {
+    fn merge(&mut self, other: &Skewness) {
         let len_self = f64::approx_from(self.len()).unwrap();
         let len_other = f64::approx_from(other.len()).unwrap();
         let len_total = len_self + len_other;