Split out statistics module

src/quantity/mod.rs

@@ -1,13 +1,9 @@
 use core::f64;
 use std::marker::PhantomData;
-use std::ops::Add;
-use std::ops::AddAssign;
-use std::ops::Div;
 
 use serde::ser::SerializeStruct;
 use serde::Serializer;
 
-use uom::num_traits;
 use uom::si;
 
 pub use si::f64::{Information, Ratio, Time};
@@ -18,6 +14,7 @@ pub use uom::num_traits::Zero;
 
 pub use units::{InformationUnit, IsUnit, TimeUnit};
 
+pub mod statistics;
 mod units;
 
 pub trait FormatQuantity {
@@ -83,8 +80,12 @@ impl FormatQuantity for Information {
     fn suitable_unit(&self) -> InformationUnit {
         if *self < Information::new::<kibibyte>(1.0) {
             InformationUnit::Byte
-        } else {
+        } else if *self < Information::new::<mebibyte>(1.0) {
             InformationUnit::KibiByte
+        } else if *self < Information::new::<gibibyte>(1.0) {
+            InformationUnit::MebiByte
+        } else {
+            InformationUnit::GibiByte
         }
     }
 
@@ -132,113 +133,6 @@ where
     state.end()
 }
 
-pub trait UnsafeRawValue {
-    fn unsafe_raw_value(&self) -> f64;
-    fn unsafe_from_raw_value(value: f64) -> Self;
-}
-
-impl UnsafeRawValue for Time {
-    fn unsafe_raw_value(&self) -> f64 {
-        self.get::<second>()
-    }
-
-    fn unsafe_from_raw_value(value: f64) -> Self {
-        Time::new::<second>(value)
-    }
-}
-
-impl UnsafeRawValue for Information {
-    fn unsafe_raw_value(&self) -> f64 {
-        self.get::<byte>()
-    }
-
-    fn unsafe_from_raw_value(value: f64) -> Self {
-        Information::new::<byte>(value)
-    }
-}
-
-macro_rules! quantity_fn {
-    ($name:ident, $unwrapped_values:ident, $body:expr) => {
-        pub fn $name<Q: UnsafeRawValue>(values: &[Q]) -> Q {
-            let $unwrapped_values: Vec<_> = values.iter().map(|q| q.unsafe_raw_value()).collect();
-            let result_value = $body;
-
-            Q::unsafe_from_raw_value(result_value)
-        }
-    };
-}
-
-/// A max function that assumes no NaNs and at least one element
-pub fn max<V: PartialOrd>(values: impl IntoIterator<Item = V>) -> V {
-    values
-        .into_iter()
-        .max_by(|a, b| a.partial_cmp(b).expect("No NaN values"))
-        .expect("'max' requires at least one element")
-}
-
-/// A min function that assumes no NaNs and at least one element
-pub fn min<V: PartialOrd>(values: impl IntoIterator<Item = V>) -> V {
-    values
-        .into_iter()
-        .min_by(|a, b| a.partial_cmp(b).expect("No NaN values"))
-        .expect("'min' requires at least one element")
-}
-
-/// A mean function that assumes at least one element
-pub fn mean<Q, P>(values: impl IntoIterator<Item = Q>) -> Q
-where
-    Q: AddAssign + num_traits::Zero + Div<Ratio, Output = P>,
-    P: Into<Q>,
-{
-    let mut sum = Q::zero();
-    let mut count = 0;
-    for value in values {
-        sum += value;
-        count += 1;
-    }
-
-    let count = Ratio::new::<ratio>(count as f64);
-    (sum / count).into()
-}
-
-pub fn median<Q, P>(values: impl IntoIterator<Item = Q>) -> Q
-where
-    Q: Copy + PartialOrd + Add<Output = Q> + Div<Ratio, Output = P>,
-    P: Into<Q>,
-{
-    let mut values = values.into_iter().collect::<Vec<_>>();
-    values.sort_by(|a, b| a.partial_cmp(b).expect("No NaN values"));
-
-    let len = values.len();
-    if len % 2 == 0 {
-        let mid = len / 2;
-        let a = &values[mid - 1];
-        let b = &values[mid];
-        ((*a + *b) / Ratio::new::<ratio>(2.)).into()
-    } else {
-        values[len / 2]
-    }
-}
-
-quantity_fn!(standard_deviation, values, {
-    let mean_value = statistical::mean(&values);
-    statistical::standard_deviation(&values, Some(mean_value))
-});
-
-pub fn modified_zscores<Q: UnsafeRawValue>(values: &[Q]) -> Vec<f64> {
-    let values: Vec<_> = values.iter().map(|q| q.unsafe_raw_value()).collect();
-    crate::outlier_detection::modified_zscores(&values)
-}
-
-#[test]
-fn test_max() {
-    assert_eq!(1.0, max([1.0]));
-    assert_eq!(-1.0, max([-1.0]));
-    assert_eq!(-1.0, max([-2.0, -1.0]));
-    assert_eq!(1.0, max([-1.0, 1.0]));
-    assert_eq!(1.0, max([-1.0, 1.0, 0.0]));
-}
-
 #[test]
 fn test_time() {
     let time = Time::new::<millisecond>(123.4);
@@ -266,32 +160,7 @@ fn test_information() {
 }
 
 #[test]
-fn test_format() {
-    let time = Time::new::<millisecond>(123.4);
-    assert_eq!(time.format(TimeUnit::Second), "0.123 s");
-    assert_eq!(time.format(TimeUnit::MilliSecond), "123.4 ms");
-    assert_eq!(time.format(TimeUnit::MicroSecond), "123400.0 µs");
-
-    let peak_memory_usage = Information::new::<kibibyte>(8.);
-    assert_eq!(peak_memory_usage.format(InformationUnit::Byte), "8192 B");
-    assert_eq!(
-        peak_memory_usage.format(InformationUnit::KibiByte),
-        "8.0 KiB"
-    );
-}
-
-#[test]
-fn test_mean() {
-    let values = vec![
-        Time::new::<millisecond>(123.4),
-        Time::new::<millisecond>(234.5),
-    ];
-    let result = mean(values.into_iter());
-    assert_eq!(result.format(TimeUnit::MilliSecond), "178.9 ms");
-}
-
-#[test]
-fn test_suiteable_unit() {
+fn test_suiteable_unit_time() {
     assert_eq!(Time::new::<second>(1.3).suitable_unit(), TimeUnit::Second);
     assert_eq!(Time::new::<second>(1.0).suitable_unit(), TimeUnit::Second);
     assert_eq!(
@@ -312,6 +181,41 @@ fn test_suiteable_unit() {
     );
 }
 
+#[test]
+fn test_suitable_unit_information() {
+    assert_eq!(
+        Information::new::<byte>(512.0).suitable_unit(),
+        InformationUnit::Byte
+    );
+    assert_eq!(
+        Information::new::<byte>(2048.0).suitable_unit(),
+        InformationUnit::KibiByte
+    );
+    assert_eq!(
+        Information::new::<byte>(2_097_152.0).suitable_unit(),
+        InformationUnit::MebiByte
+    );
+    assert_eq!(
+        Information::new::<byte>(2_147_483_648.0).suitable_unit(),
+        InformationUnit::GibiByte
+    );
+}
+
+#[test]
+fn test_format() {
+    let time = Time::new::<millisecond>(123.4);
+    assert_eq!(time.format(TimeUnit::Second), "0.123 s");
+    assert_eq!(time.format(TimeUnit::MilliSecond), "123.4 ms");
+    assert_eq!(time.format(TimeUnit::MicroSecond), "123400.0 µs");
+
+    let peak_memory_usage = Information::new::<kibibyte>(8.);
+    assert_eq!(peak_memory_usage.format(InformationUnit::Byte), "8192 B");
+    assert_eq!(
+        peak_memory_usage.format(InformationUnit::KibiByte),
+        "8.0 KiB"
+    );
+}
+
 #[test]
 fn test_format_duration_unit_with_unit() {
     let out = Time::new::<second>(1.3).format(TimeUnit::Second);
@@ -323,34 +227,3 @@ fn test_format_duration_unit_with_unit() {
     let out = Time::new::<second>(1.3).format(TimeUnit::MicroSecond);
     assert_eq!("1300000.0 µs", out);
 }
-
-#[test]
-fn statistics() {
-    let values = vec![
-        Time::new::<second>(1.0),
-        Time::new::<second>(2.0),
-        Time::new::<second>(3.0),
-    ];
-
-    assert_eq!(
-        mean(values.iter().copied()).format(TimeUnit::Second),
-        "2.000 s"
-    );
-    assert_eq!(
-        median(values.iter().copied()).format(TimeUnit::Second),
-        "2.000 s"
-    );
-    assert_eq!(min(&values).format(TimeUnit::Second), "1.000 s");
-    assert_eq!(max(&values).format(TimeUnit::Second), "3.000 s");
-    assert_eq!(
-        standard_deviation(&values).format(TimeUnit::Second),
-        "1.000 s"
-    );
-
-    let values = vec![
-        Information::new::<byte>(1.0),
-        Information::new::<byte>(2.0),
-        Information::new::<byte>(3.0),
-    ];
-    mean(values.iter().copied()).format(InformationUnit::Byte);
-}