chores and performance boost (#9)

OctopusTakopi · web-flow · commit d206eb58f4ed · 2025-07-12T15:18:00.000+02:00
* chores:

* update crates

* fix typos

* make clippy happy

* update info link

perf:

* Static Dispatch: By making Rolling&lt;'a, U, F&gt; generic over U: RollableUnivariate&lt;F&gt;, method calls (update, revert, get) use static dispatch (monomorphized code) instead of dynamic (vtable)

* same Static Dispatch techinic for iter.

* chores: fix typos
diff --git a/Cargo.toml b/Cargo.toml
@@ -10,8 +10,8 @@ keywords = ["statistics", "stream"]
 exclude = [".github", ".pre-commit-config.yaml"]
 readme = "README.md"
 [dependencies]
-num = "0.4.0"
-ordered-float = { version = "3.0", features = ["serde"] }
+num = "0.4"
+ordered-float = { version = "3.9", features = ["serde"] }
 
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
diff --git a/src/iter.rs b/src/iter.rs
@@ -17,17 +17,19 @@ use crate::sum::Sum;
 use crate::variance::Variance;
 
 #[doc(hidden)]
-pub struct IterStat<I>
+pub struct IterStat<U, I>
 where
+    U: Univariate<I::Item>,
     I: Iterator,
     I::Item: Float + FromPrimitive + AddAssign + SubAssign + 'static,
 {
-    stat: Box<dyn Univariate<I::Item>>,
+    stat: U,
     underlying: I,
 }
 
-impl<I> Iterator for IterStat<I>
+impl<U, I> Iterator for IterStat<U, I>
 where
+    U: Univariate<I::Item>,
     I: Iterator,
     I::Item: Float + FromPrimitive + AddAssign + SubAssign,
 {
@@ -55,13 +57,13 @@ pub trait IterStatisticsExtend: Iterator {
     /// }
     ///
     /// ```
-    fn online_sum(self) -> IterStat<Self>
+    fn online_sum(self) -> IterStat<Sum<Self::Item>, Self>
     where
         Self::Item: Float + FromPrimitive + AddAssign + SubAssign,
         Self: Sized,
     {
         IterStat {
-            stat: Box::new(Sum::new()),
+            stat: Sum::new(),
             underlying: self,
         }
     }
@@ -77,13 +79,13 @@ pub trait IterStatisticsExtend: Iterator {
     /// }
     ///
     /// ```
-    fn online_mean(self) -> IterStat<Self>
+    fn online_mean(self) -> IterStat<Mean<Self::Item>, Self>
     where
         Self::Item: Float + FromPrimitive + AddAssign + SubAssign,
         Self: Sized,
     {
         IterStat {
-            stat: Box::new(Mean::new()),
+            stat: Mean::new(),
             underlying: self,
         }
     }
@@ -99,13 +101,13 @@ pub trait IterStatisticsExtend: Iterator {
     /// }
     ///
     /// ```
-    fn online_count(self) -> IterStat<Self>
+    fn online_count(self) -> IterStat<Count<Self::Item>, Self>
     where
         Self::Item: Float + FromPrimitive + AddAssign + SubAssign,
         Self: Sized,
     {
         IterStat {
-            stat: Box::new(Count::new()),
+            stat: Count::new(),
             underlying: self,
         }
     }
@@ -124,13 +126,13 @@ pub trait IterStatisticsExtend: Iterator {
     /// }
     ///
     /// ```
-    fn online_ewmean(self, alpha: Self::Item) -> IterStat<Self>
+    fn online_ewmean(self, alpha: Self::Item) -> IterStat<EWMean<Self::Item>, Self>
     where
         Self::Item: Float + FromPrimitive + AddAssign + SubAssign,
         Self: Sized,
     {
         IterStat {
-            stat: Box::new(EWMean::new(alpha)),
+            stat: EWMean::new(alpha),
             underlying: self,
         }
     }
@@ -148,13 +150,13 @@ pub trait IterStatisticsExtend: Iterator {
     /// }
     ///
     /// ```
-    fn online_ewvar(self, alpha: Self::Item) -> IterStat<Self>
+    fn online_ewvar(self, alpha: Self::Item) -> IterStat<EWVariance<Self::Item>, Self>
     where
         Self::Item: Float + FromPrimitive + AddAssign + SubAssign,
         Self: Sized,
     {
         IterStat {
-            stat: Box::new(EWVariance::new(alpha)),
+            stat: EWVariance::new(alpha),
             underlying: self,
         }
     }
@@ -173,13 +175,13 @@ pub trait IterStatisticsExtend: Iterator {
     /// }
     ///
     /// ```
-    fn online_iqr(self, q_inf: Self::Item, q_sup: Self::Item) -> IterStat<Self>
+    fn online_iqr(self, q_inf: Self::Item, q_sup: Self::Item) -> IterStat<IQR<Self::Item>, Self>
     where
         Self::Item: Float + FromPrimitive + AddAssign + SubAssign,
         Self: Sized,
     {
         IterStat {
-            stat: Box::new(IQR::new(q_inf, q_sup).expect("q_inf must be strictly less than q_sup")),
+            stat: IQR::new(q_inf, q_sup).expect("q_inf must be strictly less than q_sup"),
             underlying: self,
         }
     }
@@ -197,13 +199,13 @@ pub trait IterStatisticsExtend: Iterator {
     /// }
     ///
     /// ```
-    fn online_kurtosis(self, bias: bool) -> IterStat<Self>
+    fn online_kurtosis(self, bias: bool) -> IterStat<Kurtosis<Self::Item>, Self>
     where
         Self::Item: Float + FromPrimitive + AddAssign + SubAssign,
         Self: Sized,
     {
         IterStat {
-            stat: Box::new(Kurtosis::new(bias)),
+            stat: Kurtosis::new(bias),
             underlying: self,
         }
     }
@@ -219,13 +221,13 @@ pub trait IterStatisticsExtend: Iterator {
     /// }
     ///
     /// ```
-    fn online_max(self) -> IterStat<Self>
+    fn online_max(self) -> IterStat<Max<Self::Item>, Self>
     where
         Self::Item: Float + FromPrimitive + AddAssign + SubAssign,
         Self: Sized,
     {
         IterStat {
-            stat: Box::new(Max::new()),
+            stat: Max::new(),
             underlying: self,
         }
     }
@@ -241,13 +243,13 @@ pub trait IterStatisticsExtend: Iterator {
     /// }
     ///
     /// ```
-    fn online_abs_max(self) -> IterStat<Self>
+    fn online_abs_max(self) -> IterStat<AbsMax<Self::Item>, Self>
     where
         Self::Item: Float + FromPrimitive + AddAssign + SubAssign,
         Self: Sized,
     {
         IterStat {
-            stat: Box::new(AbsMax::new()),
+            stat: AbsMax::new(),
             underlying: self,
         }
     }
@@ -263,13 +265,13 @@ pub trait IterStatisticsExtend: Iterator {
     /// }
     ///
     /// ```
-    fn online_min(self) -> IterStat<Self>
+    fn online_min(self) -> IterStat<Min<Self::Item>, Self>
     where
         Self::Item: Float + FromPrimitive + AddAssign + SubAssign,
         Self: Sized,
     {
         IterStat {
-            stat: Box::new(Min::new()),
+            stat: Min::new(),
             underlying: self,
         }
     }
@@ -285,13 +287,13 @@ pub trait IterStatisticsExtend: Iterator {
     /// }
     ///
     /// ```
-    fn online_ptp(self) -> IterStat<Self>
+    fn online_ptp(self) -> IterStat<PeakToPeak<Self::Item>, Self>
     where
         Self::Item: Float + FromPrimitive + AddAssign + SubAssign,
         Self: Sized,
     {
         IterStat {
-            stat: Box::new(PeakToPeak::new()),
+            stat: PeakToPeak::new(),
             underlying: self,
         }
     }
@@ -312,13 +314,13 @@ pub trait IterStatisticsExtend: Iterator {
     ///     assert_eq!(d, t);
     /// }
     /// ```
-    fn online_quantile(self, q: Self::Item) -> IterStat<Self>
+    fn online_quantile(self, q: Self::Item) -> IterStat<Quantile<Self::Item>, Self>
     where
         Self::Item: Float + FromPrimitive + AddAssign + SubAssign,
         Self: Sized,
     {
         IterStat {
-            stat: Box::new(Quantile::new(q).expect("q should be betweek 0 and 1")),
+            stat: Quantile::new(q).expect("q should be between 0 and 1"),
             underlying: self,
         }
     }
@@ -336,13 +338,13 @@ pub trait IterStatisticsExtend: Iterator {
     /// }
     ///
     /// ```
-    fn online_skew(self, bias: bool) -> IterStat<Self>
+    fn online_skew(self, bias: bool) -> IterStat<Skew<Self::Item>, Self>
     where
         Self::Item: Float + FromPrimitive + AddAssign + SubAssign,
         Self: Sized,
     {
         IterStat {
-            stat: Box::new(Skew::new(bias)),
+            stat: Skew::new(bias),
             underlying: self,
         }
     }
@@ -360,15 +362,15 @@ pub trait IterStatisticsExtend: Iterator {
     /// }
     ///
     /// ```
-    fn online_var(self, ddof: u32) -> IterStat<Self>
+    fn online_var(self, ddof: u32) -> IterStat<Variance<Self::Item>, Self>
     where
         Self::Item: Float + FromPrimitive + AddAssign + SubAssign,
         Self: Sized,
     {
         IterStat {
-            stat: Box::new(Variance::new(ddof)),
+            stat: Variance::new(ddof),
             underlying: self,
         }
     }
 }
-impl<I: Iterator> IterStatisticsExtend for I {}
+impl<I: Iterator> IterStatisticsExtend for I {}
diff --git a/src/mean.rs b/src/mean.rs
@@ -59,10 +59,7 @@ impl<F: Float + FromPrimitive + AddAssign + SubAssign> Univariate<F> for Mean<F>
 
 impl<F: Float + FromPrimitive + AddAssign + SubAssign> Revertable<F> for Mean<F> {
     fn revert(&mut self, x: F) -> Result<(), &'static str> {
-        match self.n.revert(x) {
-            Ok(it) => it,
-            Err(err) => return Err(err),
-        };
+        self.n.revert(x)?;
 
         let count = self.n.get();
         if count == F::from_f64(0.).unwrap() {
diff --git a/src/quantile.rs b/src/quantile.rs
@@ -21,9 +21,9 @@ use serde::{Deserialize, Serialize};
 /// assert_eq!(running_quantile.get(), 5.0);
 /// ```
 /// # References
-/// [^1]: [The P² Algorithm for Dynamic Univariateal Computing Calculation of Quantiles and Editor Histograms Without Storing Observations](https://www.cse.wustl.edu/~jain/papers/ftp/psqr.pdf)
+/// [^1]: [The P² Algorithm for Dynamic Calculation of Quantiles and Histograms Without Storing Observations](https://www.cse.wustl.edu/~jain/papers/ftp/psqr.pdf)
 ///
-/// [^2]: [P² quantile estimator: estimating the median without storing values](https://aakinshin.net/posts/p2-quantile-estimator/)
+/// [^2]: [P² quantile estimator: estimating the median without storing values](https://aakinshin.net/posts/p2-quantile-estimator-intro/)
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct Quantile<F: Float + FromPrimitive + AddAssign + SubAssign> {
     q: F,
diff --git a/src/rolling.rs b/src/rolling.rs
@@ -22,43 +22,52 @@ use std::{
 /// let data = vec![9.,7.,3.,2.,6.,1., 8., 5., 4.];
 /// let mut running_sum: Sum<f64> = Sum::new();
 /// // We wrap `running_sum` inside the `Rolling` struct.
-/// let mut rolling_sum: Rolling<f64> = Rolling::new(& mut running_sum, 2).unwrap();
+/// let mut rolling_sum: Rolling<_, f64> = Rolling::new(&mut running_sum, 2).unwrap();
 /// for x in data.iter(){
 ///     rolling_sum.update(*x as f64);
 /// }
 /// assert_eq!(rolling_sum.get(), 9.0);
 /// ```
-
-pub struct Rolling<'a, F: Float + FromPrimitive + AddAssign + SubAssign> {
-    to_roll: &'a mut dyn RollableUnivariate<F>,
+pub struct Rolling<'a, U, F>
+where
+    U: RollableUnivariate<F>,  // Optimization: Generic over U (the concrete type) instead of dyn for static dispatch
+    F: Float + FromPrimitive + AddAssign + SubAssign,
+{
+    to_roll: &'a mut U,  // Optimization: &mut U instead of &mut dyn
     window_size: usize,
     window: VecDeque<F>,
 }
 
-impl<'a, F: Float + FromPrimitive + AddAssign + SubAssign> Rolling<'a, F> {
-    pub fn new(
-        to_roll: &'a mut dyn RollableUnivariate<F>,
-        window_size: usize,
-    ) -> Result<Self, &str> {
+impl<'a, U, F> Rolling<'a, U, F>
+where
+    U: RollableUnivariate<F>,
+    F: Float + FromPrimitive + AddAssign + SubAssign,
+{
+    pub fn new(to_roll: &'a mut U, window_size: usize) -> Result<Self, &'static str> {  // Optimization: &'static str for error (clearer, no lifetime tie)
         if window_size == 0 {
-            return Err("Window size should not equals to 0");
+            return Err("Window size should not equal to 0");
         }
         Ok(Self {
             to_roll,
             window_size,
-            window: VecDeque::new(),
+            window: VecDeque::with_capacity(window_size),  // Optimization: Preallocate to avoid reallocs during growth
         })
     }
 }
 
-impl<'a, F: Float + FromPrimitive + AddAssign + SubAssign> Univariate<F> for Rolling<'_, F> {
+impl<'a, U, F> Univariate<F> for Rolling<'a, U, F>
+where
+    U: RollableUnivariate<F>,
+    F: Float + FromPrimitive + AddAssign + SubAssign,
+{
     fn update(&mut self, x: F) {
         if self.window.len() == self.window_size {
             // To handle the error, the program panics because returning the error type would change
             // the interface of the get method. This problem is unlikely to happen because we
             // control the size of the sliding window in the constructor.
-            match self.to_roll.revert(*self.window.front().unwrap()) {
-                Ok(it) => it,
+            let oldest = self.window.front().copied().expect("Window should not be empty");  // Optimization: copied() for clarity/safety (F is Copy-like for floats); expect for debug assert
+            match self.to_roll.revert(oldest) {
+                Ok(()) => (),  // Assume revert returns Result<(), _>; adjust if different
                 Err(err) => panic!("{}", err),
             };
             self.window.pop_front();
@@ -73,6 +82,7 @@ impl<'a, F: Float + FromPrimitive + AddAssign + SubAssign> Univariate<F> for Rol
         self.to_roll.get()
     }
 }
+
 mod tests {
     #[test]
     fn it_works() {
@@ -82,10 +92,10 @@ mod tests {
         let data = vec![9., 7., 3., 2., 6., 1., 8., 5., 4.];
         let mut running_var: Variance<f64> = Variance::default();
         // We wrap `running_var` inside the `Rolling` struct.
-        let mut rolling_var: Rolling<f64> = Rolling::new(&mut running_var, 2).unwrap();
+        let mut rolling_var: Rolling<_, f64> = Rolling::new(&mut running_var, 2).unwrap();  // Note: _ for type inference
         for x in data.iter() {
             rolling_var.update(*x as f64);
         }
         assert_eq!(rolling_var.get(), 0.5);
     }
-}
+}

Original file line number	Diff line number	Diff line change
`@@ -17,17 +17,19 @@ use crate::sum::Sum;`
`17`	`17`	`use crate::variance::Variance;`
`18`	`18`
`19`	`19`	`#[doc(hidden)]`
`20`		`-pub struct IterStat<I>`
	`20`	`+pub struct IterStat<U, I>`
`21`	`21`	`where`
	`22`	`+ U: Univariate<I::Item>,`
`22`	`23`	`I: Iterator,`
`23`	`24`	`I::Item: Float + FromPrimitive + AddAssign + SubAssign + 'static,`
`24`	`25`	`{`
`25`		`- stat: Box<dyn Univariate<I::Item>>,`
	`26`	`+ stat: U,`
`26`	`27`	`underlying: I,`
`27`	`28`	`}`
`28`	`29`
`29`		`-impl<I> Iterator for IterStat<I>`
	`30`	`+impl<U, I> Iterator for IterStat<U, I>`
`30`	`31`	`where`
	`32`	`+ U: Univariate<I::Item>,`
`31`	`33`	`I: Iterator,`
`32`	`34`	`I::Item: Float + FromPrimitive + AddAssign + SubAssign,`
`33`	`35`	`{`
`@@ -55,13 +57,13 @@ pub trait IterStatisticsExtend: Iterator {`
`55`	`57`	`/// }`
`56`	`58`	`///`
`57`	`59`	/// ```
`58`		`- fn online_sum(self) -> IterStat<Self>`
	`60`	`+ fn online_sum(self) -> IterStat<Sum<Self::Item>, Self>`
`59`	`61`	`where`
`60`	`62`	`Self::Item: Float + FromPrimitive + AddAssign + SubAssign,`
`61`	`63`	`Self: Sized,`
`62`	`64`	`{`
`63`	`65`	`IterStat {`
`64`		`- stat: Box::new(Sum::new()),`
	`66`	`+ stat: Sum::new(),`
`65`	`67`	`underlying: self,`
`66`	`68`	`}`
`67`	`69`	`}`
`@@ -77,13 +79,13 @@ pub trait IterStatisticsExtend: Iterator {`
`77`	`79`	`/// }`
`78`	`80`	`///`
`79`	`81`	/// ```
`80`		`- fn online_mean(self) -> IterStat<Self>`
	`82`	`+ fn online_mean(self) -> IterStat<Mean<Self::Item>, Self>`
`81`	`83`	`where`
`82`	`84`	`Self::Item: Float + FromPrimitive + AddAssign + SubAssign,`
`83`	`85`	`Self: Sized,`
`84`	`86`	`{`
`85`	`87`	`IterStat {`
`86`		`- stat: Box::new(Mean::new()),`
	`88`	`+ stat: Mean::new(),`
`87`	`89`	`underlying: self,`
`88`	`90`	`}`
`89`	`91`	`}`
`@@ -99,13 +101,13 @@ pub trait IterStatisticsExtend: Iterator {`
`99`	`101`	`/// }`
`100`	`102`	`///`
`101`	`103`	/// ```
`102`		`- fn online_count(self) -> IterStat<Self>`
	`104`	`+ fn online_count(self) -> IterStat<Count<Self::Item>, Self>`
`103`	`105`	`where`
`104`	`106`	`Self::Item: Float + FromPrimitive + AddAssign + SubAssign,`
`105`	`107`	`Self: Sized,`
`106`	`108`	`{`
`107`	`109`	`IterStat {`
`108`		`- stat: Box::new(Count::new()),`
	`110`	`+ stat: Count::new(),`
`109`	`111`	`underlying: self,`
`110`	`112`	`}`
`111`	`113`	`}`
`@@ -124,13 +126,13 @@ pub trait IterStatisticsExtend: Iterator {`
`124`	`126`	`/// }`
`125`	`127`	`///`
`126`	`128`	/// ```
`127`		`- fn online_ewmean(self, alpha: Self::Item) -> IterStat<Self>`
	`129`	`+ fn online_ewmean(self, alpha: Self::Item) -> IterStat<EWMean<Self::Item>, Self>`
`128`	`130`	`where`
`129`	`131`	`Self::Item: Float + FromPrimitive + AddAssign + SubAssign,`
`130`	`132`	`Self: Sized,`
`131`	`133`	`{`
`132`	`134`	`IterStat {`
`133`		`- stat: Box::new(EWMean::new(alpha)),`
	`135`	`+ stat: EWMean::new(alpha),`
`134`	`136`	`underlying: self,`
`135`	`137`	`}`
`136`	`138`	`}`
`@@ -148,13 +150,13 @@ pub trait IterStatisticsExtend: Iterator {`
`148`	`150`	`/// }`
`149`	`151`	`///`
`150`	`152`	/// ```
`151`		`- fn online_ewvar(self, alpha: Self::Item) -> IterStat<Self>`
	`153`	`+ fn online_ewvar(self, alpha: Self::Item) -> IterStat<EWVariance<Self::Item>, Self>`
`152`	`154`	`where`
`153`	`155`	`Self::Item: Float + FromPrimitive + AddAssign + SubAssign,`
`154`	`156`	`Self: Sized,`
`155`	`157`	`{`
`156`	`158`	`IterStat {`
`157`		`- stat: Box::new(EWVariance::new(alpha)),`
	`159`	`+ stat: EWVariance::new(alpha),`
`158`	`160`	`underlying: self,`
`159`	`161`	`}`
`160`	`162`	`}`
`@@ -173,13 +175,13 @@ pub trait IterStatisticsExtend: Iterator {`
`173`	`175`	`/// }`
`174`	`176`	`///`
`175`	`177`	/// ```
`176`		`- fn online_iqr(self, q_inf: Self::Item, q_sup: Self::Item) -> IterStat<Self>`
	`178`	`+ fn online_iqr(self, q_inf: Self::Item, q_sup: Self::Item) -> IterStat<IQR<Self::Item>, Self>`
`177`	`179`	`where`
`178`	`180`	`Self::Item: Float + FromPrimitive + AddAssign + SubAssign,`
`179`	`181`	`Self: Sized,`
`180`	`182`	`{`
`181`	`183`	`IterStat {`
`182`		`- stat: Box::new(IQR::new(q_inf, q_sup).expect("q_inf must be strictly less than q_sup")),`
	`184`	`+ stat: IQR::new(q_inf, q_sup).expect("q_inf must be strictly less than q_sup"),`
`183`	`185`	`underlying: self,`
`184`	`186`	`}`
`185`	`187`	`}`
`@@ -197,13 +199,13 @@ pub trait IterStatisticsExtend: Iterator {`
`197`	`199`	`/// }`
`198`	`200`	`///`
`199`	`201`	/// ```
`200`		`- fn online_kurtosis(self, bias: bool) -> IterStat<Self>`
	`202`	`+ fn online_kurtosis(self, bias: bool) -> IterStat<Kurtosis<Self::Item>, Self>`
`201`	`203`	`where`
`202`	`204`	`Self::Item: Float + FromPrimitive + AddAssign + SubAssign,`
`203`	`205`	`Self: Sized,`
`204`	`206`	`{`
`205`	`207`	`IterStat {`
`206`		`- stat: Box::new(Kurtosis::new(bias)),`
	`208`	`+ stat: Kurtosis::new(bias),`
`207`	`209`	`underlying: self,`
`208`	`210`	`}`
`209`	`211`	`}`
`@@ -219,13 +221,13 @@ pub trait IterStatisticsExtend: Iterator {`
`219`	`221`	`/// }`
`220`	`222`	`///`
`221`	`223`	/// ```
`222`		`- fn online_max(self) -> IterStat<Self>`
	`224`	`+ fn online_max(self) -> IterStat<Max<Self::Item>, Self>`
`223`	`225`	`where`
`224`	`226`	`Self::Item: Float + FromPrimitive + AddAssign + SubAssign,`
`225`	`227`	`Self: Sized,`
`226`	`228`	`{`
`227`	`229`	`IterStat {`
`228`		`- stat: Box::new(Max::new()),`
	`230`	`+ stat: Max::new(),`
`229`	`231`	`underlying: self,`
`230`	`232`	`}`
`231`	`233`	`}`
`@@ -241,13 +243,13 @@ pub trait IterStatisticsExtend: Iterator {`
`241`	`243`	`/// }`
`242`	`244`	`///`
`243`	`245`	/// ```
`244`		`- fn online_abs_max(self) -> IterStat<Self>`
	`246`	`+ fn online_abs_max(self) -> IterStat<AbsMax<Self::Item>, Self>`
`245`	`247`	`where`
`246`	`248`	`Self::Item: Float + FromPrimitive + AddAssign + SubAssign,`
`247`	`249`	`Self: Sized,`
`248`	`250`	`{`
`249`	`251`	`IterStat {`
`250`		`- stat: Box::new(AbsMax::new()),`
	`252`	`+ stat: AbsMax::new(),`
`251`	`253`	`underlying: self,`
`252`	`254`	`}`
`253`	`255`	`}`
`@@ -263,13 +265,13 @@ pub trait IterStatisticsExtend: Iterator {`
`263`	`265`	`/// }`
`264`	`266`	`///`
`265`	`267`	/// ```
`266`		`- fn online_min(self) -> IterStat<Self>`
	`268`	`+ fn online_min(self) -> IterStat<Min<Self::Item>, Self>`
`267`	`269`	`where`
`268`	`270`	`Self::Item: Float + FromPrimitive + AddAssign + SubAssign,`
`269`	`271`	`Self: Sized,`
`270`	`272`	`{`
`271`	`273`	`IterStat {`
`272`		`- stat: Box::new(Min::new()),`
	`274`	`+ stat: Min::new(),`
`273`	`275`	`underlying: self,`
`274`	`276`	`}`
`275`	`277`	`}`
`@@ -285,13 +287,13 @@ pub trait IterStatisticsExtend: Iterator {`
`285`	`287`	`/// }`
`286`	`288`	`///`
`287`	`289`	/// ```
`288`		`- fn online_ptp(self) -> IterStat<Self>`
	`290`	`+ fn online_ptp(self) -> IterStat<PeakToPeak<Self::Item>, Self>`
`289`	`291`	`where`
`290`	`292`	`Self::Item: Float + FromPrimitive + AddAssign + SubAssign,`
`291`	`293`	`Self: Sized,`
`292`	`294`	`{`
`293`	`295`	`IterStat {`
`294`		`- stat: Box::new(PeakToPeak::new()),`
	`296`	`+ stat: PeakToPeak::new(),`
`295`	`297`	`underlying: self,`
`296`	`298`	`}`
`297`	`299`	`}`
`@@ -312,13 +314,13 @@ pub trait IterStatisticsExtend: Iterator {`
`312`	`314`	`/// assert_eq!(d, t);`
`313`	`315`	`/// }`
`314`	`316`	/// ```
`315`		`- fn online_quantile(self, q: Self::Item) -> IterStat<Self>`
	`317`	`+ fn online_quantile(self, q: Self::Item) -> IterStat<Quantile<Self::Item>, Self>`
`316`	`318`	`where`
`317`	`319`	`Self::Item: Float + FromPrimitive + AddAssign + SubAssign,`
`318`	`320`	`Self: Sized,`
`319`	`321`	`{`
`320`	`322`	`IterStat {`
`321`		`- stat: Box::new(Quantile::new(q).expect("q should be betweek 0 and 1")),`
	`323`	`+ stat: Quantile::new(q).expect("q should be between 0 and 1"),`
`322`	`324`	`underlying: self,`
`323`	`325`	`}`
`324`	`326`	`}`
`@@ -336,13 +338,13 @@ pub trait IterStatisticsExtend: Iterator {`
`336`	`338`	`/// }`
`337`	`339`	`///`
`338`	`340`	/// ```
`339`		`- fn online_skew(self, bias: bool) -> IterStat<Self>`
	`341`	`+ fn online_skew(self, bias: bool) -> IterStat<Skew<Self::Item>, Self>`
`340`	`342`	`where`
`341`	`343`	`Self::Item: Float + FromPrimitive + AddAssign + SubAssign,`
`342`	`344`	`Self: Sized,`
`343`	`345`	`{`
`344`	`346`	`IterStat {`
`345`		`- stat: Box::new(Skew::new(bias)),`
	`347`	`+ stat: Skew::new(bias),`
`346`	`348`	`underlying: self,`
`347`	`349`	`}`
`348`	`350`	`}`
`@@ -360,15 +362,15 @@ pub trait IterStatisticsExtend: Iterator {`
`360`	`362`	`/// }`
`361`	`363`	`///`
`362`	`364`	/// ```
`363`		`- fn online_var(self, ddof: u32) -> IterStat<Self>`
	`365`	`+ fn online_var(self, ddof: u32) -> IterStat<Variance<Self::Item>, Self>`
`364`	`366`	`where`
`365`	`367`	`Self::Item: Float + FromPrimitive + AddAssign + SubAssign,`
`366`	`368`	`Self: Sized,`
`367`	`369`	`{`
`368`	`370`	`IterStat {`
`369`		`- stat: Box::new(Variance::new(ddof)),`
	`371`	`+ stat: Variance::new(ddof),`
`370`	`372`	`underlying: self,`
`371`	`373`	`}`
`372`	`374`	`}`
`373`	`375`	`}`
`374`		`-impl<I: Iterator> IterStatisticsExtend for I {}`
	`376`	`+impl<I: Iterator> IterStatisticsExtend for I {}`