Alternative performance metrics in the terminal (#986)

src/quantity/mod.rs

@@ -11,80 +11,7 @@ pub use si::ratio::ratio;
 pub use si::time::{hour, microsecond, millisecond, minute, nanosecond, second};
 pub use uom::num_traits::Zero;
 
-pub use units::{InformationUnit, IsUnit, TimeUnit};
-
 pub mod statistics;
-mod units;
-
-pub trait QuantityInUnit<U> {
-    fn value_in_unit(self) -> f64;
-}
-
-impl<U: uom::si::time::Unit + uom::Conversion<f64, T = f64>> QuantityInUnit<U> for Time {
-    fn value_in_unit(self) -> f64 {
-        self.get::<U>()
-    }
-}
-
-impl<U: uom::si::information::Unit + uom::Conversion<f64, T = f64>> QuantityInUnit<U>
-    for Information
-{
-    fn value_in_unit(self) -> f64 {
-        self.get::<U>()
-    }
-}
-
-impl<U: uom::si::ratio::Unit + uom::Conversion<f64, T = f64>> QuantityInUnit<U> for Ratio {
-    fn value_in_unit(self) -> f64 {
-        self.get::<U>()
-    }
-}
-
-pub trait FormatQuantity {
-    type Unit;
-
-    fn suitable_unit(&self) -> Self::Unit;
-
-    fn format_with_precision(&self, unit: Self::Unit, precision: usize) -> String;
-    fn format(&self, unit: Self::Unit) -> String;
-    fn format_auto(&self) -> String;
-    fn format_value(&self, unit: Self::Unit) -> String;
-}
-
-impl FormatQuantity for Time {
-    type Unit = TimeUnit;
-
-    fn suitable_unit(&self) -> TimeUnit {
-        if *self < Time::new::<millisecond>(1.0) {
-            TimeUnit::MicroSecond
-        } else if *self < Time::new::<second>(1.0) {
-            TimeUnit::MilliSecond
-        } else {
-            TimeUnit::Second
-        }
-    }
-
-    /// Format the time duration in the given unit with the given precision.
-    fn format_with_precision(&self, u: TimeUnit, precision: usize) -> String {
-        u.format(*self, precision)
-    }
-
-    /// Format the time duration in the given unit.
-    fn format(&self, unit: TimeUnit) -> String {
-        let value = self.format_with_precision(unit, unit.preferred_precision());
-        format!("{} {}", value, unit.short_name())
-    }
-
-    /// Format the given time duration. The unit will be determined automatically.
-    fn format_auto(&self) -> String {
-        self.format(self.suitable_unit())
-    }
-
-    /// Like `format`, but without displaying the unit.
-    fn format_value(&self, unit: TimeUnit) -> String {
-        self.format_with_precision(unit, unit.preferred_precision())
-    }
-}
 
 pub const fn const_time_from_seconds(value: f64) -> Time {
     // Quantity::new in uom is not yet const: https://docs.rs/uom/0.36.0/uom/si/struct.Quantity.html
@@ -95,43 +22,6 @@ pub const fn const_time_from_seconds(value: f64) -> Time {
     }
 }
 
-impl FormatQuantity for Information {
-    type Unit = InformationUnit;
-
-    fn suitable_unit(&self) -> InformationUnit {
-        if *self < Information::new::<kibibyte>(1.0) {
-            InformationUnit::Byte
-        } else if *self < Information::new::<mebibyte>(1.0) {
-            InformationUnit::KibiByte
-        } else if *self < Information::new::<gibibyte>(1.0) {
-            InformationUnit::MebiByte
-        } else {
-            InformationUnit::GibiByte
-        }
-    }
-
-    /// Format the information in the given unit with the given precision.
-    fn format_with_precision(&self, u: InformationUnit, precision: usize) -> String {
-        u.format(*self, precision)
-    }
-
-    /// Format the information in the given unit.
-    fn format(&self, unit: InformationUnit) -> String {
-        let value = self.format_with_precision(unit, unit.preferred_precision());
-        format!("{} {}", value, unit.short_name())
-    }
-
-    /// Format the given information. The unit will be determined automatically.
-    fn format_auto(&self) -> String {
-        self.format(self.suitable_unit())
-    }
-
-    /// Like `format`, but without displaying the unit.
-    fn format_value(&self, unit: InformationUnit) -> String {
-        self.format_with_precision(unit, unit.preferred_precision())
-    }
-}
-
 pub fn serialize_time<S>(t: &Time, s: S) -> Result<S::Ok, S::Error>
 where
     S: Serializer,
@@ -177,74 +67,3 @@ fn test_information() {
     let largest_exactly_representable = Information::new::<byte>(9_007_199_254_740_992.);
     assert_eq!(largest_exactly_representable.get::<pebibyte>(), 8.);
 }
-
-#[test]
-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!(
-        Time::new::<second>(0.999).suitable_unit(),
-        TimeUnit::MilliSecond
-    );
-    assert_eq!(
-        Time::new::<second>(0.0005).suitable_unit(),
-        TimeUnit::MicroSecond
-    );
-    assert_eq!(
-        Time::new::<second>(0.).suitable_unit(),
-        TimeUnit::MicroSecond
-    );
-    assert_eq!(
-        Time::new::<second>(1000.0).suitable_unit(),
-        TimeUnit::Second
-    );
-}
-
-#[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_auto(), "123.4 ms");
-    assert_eq!(time.format(TimeUnit::MicroSecond), "123400.0 µs");
-
-    let memory_peak_resident = Information::new::<kibibyte>(8.);
-    assert_eq!(memory_peak_resident.format_auto(), "8.0 KiB");
-    assert_eq!(memory_peak_resident.format(InformationUnit::Byte), "8192 B");
-    assert_eq!(
-        memory_peak_resident.format(InformationUnit::KibiByte),
-        "8.0 KiB"
-    );
-}
-
-#[test]
-fn test_format_duration_unit_with_unit() {
-    let out = Time::new::<second>(1.3).format(TimeUnit::Second);
-    assert_eq!("1.300 s", out);
-
-    let out = Time::new::<second>(1.3).format(TimeUnit::MilliSecond);
-    assert_eq!("1300.0 ms", out);
-
-    let out = Time::new::<second>(1.3).format(TimeUnit::MicroSecond);
-    assert_eq!("1300000.0 µs", out);
-}

src/quantity/statistics.rs

@@ -146,11 +146,6 @@ pub fn modified_zscores_f64(xs: &[f64]) -> Vec<f64> {
     xs.iter().map(|&x| (x - x_median) / mad).collect()
 }
 
-pub fn modified_zscores<Q: UnsafeRawValue>(values: &[Q]) -> Vec<f64> {
-    let values: Vec<_> = values.iter().map(|q| q.unsafe_raw_value()).collect();
-    modified_zscores_f64(&values)
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/quantity/units.rs

@@ -1,166 +0,0 @@
-//! This module contains common units for time and information quantities.
-
-use std::marker::PhantomData;
-
-use crate::quantity::{
-    byte, gibibyte, hour, kibibyte, mebibyte, microsecond, millisecond, minute, second, tebibyte,
-    Information, Time,
-};
-
-pub trait IsUnit {
-    type Quantity;
-
-    fn dispatch(&self) -> Box<dyn UnitImpl<Quantity = Self::Quantity>>;
-
-    fn preferred_precision(&self) -> usize;
-
-    fn short_name(&self) -> &'static str {
-        self.dispatch().short_name()
-    }
-
-    fn format(&self, value: Self::Quantity, precision: usize) -> String {
-        self.dispatch().format_value(value, precision)
-    }
-}
-
-/// Supported time units
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum TimeUnit {
-    MicroSecond,
-    MilliSecond,
-    Second,
-    Minute,
-    Hour,
-}
-
-impl IsUnit for TimeUnit {
-    type Quantity = Time;
-
-    fn dispatch(&self) -> Box<dyn UnitImpl<Quantity = Time>> {
-        match self {
-            TimeUnit::MicroSecond => Box::new(TimeUnitDispatcher::<microsecond>::new()),
-            TimeUnit::MilliSecond => Box::new(TimeUnitDispatcher::<millisecond>::new()),
-            TimeUnit::Second => Box::new(TimeUnitDispatcher::<second>::new()),
-            TimeUnit::Minute => Box::new(TimeUnitDispatcher::<minute>::new()),
-            TimeUnit::Hour => Box::new(TimeUnitDispatcher::<hour>::new()),
-        }
-    }
-
-    fn preferred_precision(&self) -> usize {
-        match self {
-            TimeUnit::Second => 3,
-            _ => 1,
-        }
-    }
-}
-
-/// Supported information units
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-
-pub enum InformationUnit {
-    Byte,
-    KibiByte,
-    MebiByte,
-    GibiByte,
-    TebiByte,
-}
-
-impl IsUnit for InformationUnit {
-    type Quantity = Information;
-
-    fn dispatch(&self) -> Box<dyn UnitImpl<Quantity = Information>> {
-        match self {
-            InformationUnit::Byte => Box::new(InformationUnitDispatcher::<byte>::new()),
-            InformationUnit::KibiByte => Box::new(InformationUnitDispatcher::<kibibyte>::new()),
-            InformationUnit::MebiByte => Box::new(InformationUnitDispatcher::<mebibyte>::new()),
-            InformationUnit::GibiByte => Box::new(InformationUnitDispatcher::<gibibyte>::new()),
-            InformationUnit::TebiByte => Box::new(InformationUnitDispatcher::<tebibyte>::new()),
-        }
-    }
-
-    fn preferred_precision(&self) -> usize {
-        match self {
-            InformationUnit::Byte => 0,
-            _ => 1,
-        }
-    }
-}
-
-pub trait UnitImpl {
-    type Quantity;
-
-    fn short_name(&self) -> &'static str;
-    fn format_value(&self, value: Self::Quantity, precision: usize) -> String;
-}
-
-struct TimeUnitDispatcher<U: uom::si::time::Unit + uom::Conversion<f64, T = f64>> {
-    u: PhantomData<U>,
-}
-
-impl<U: uom::si::time::Unit + uom::Conversion<f64, T = f64>> TimeUnitDispatcher<U> {
-    fn new() -> Self {
-        TimeUnitDispatcher { u: PhantomData }
-    }
-}
-
-impl<U: uom::si::time::Unit + uom::Conversion<f64, T = f64>> UnitImpl for TimeUnitDispatcher<U> {
-    type Quantity = Time;
-
-    fn short_name(&self) -> &'static str {
-        U::abbreviation()
-    }
-
-    fn format_value(&self, value: Time, precision: usize) -> String {
-        format!("{value:.precision$}", value = value.get::<U>())
-    }
-}
-
-struct InformationUnitDispatcher<U: uom::si::information::Unit + uom::Conversion<f64, T = f64>> {
-    u: PhantomData<U>,
-}
-
-impl<U: uom::si::information::Unit + uom::Conversion<f64, T = f64>> InformationUnitDispatcher<U> {
-    fn new() -> Self {
-        InformationUnitDispatcher { u: PhantomData }
-    }
-}
-
-impl<U: uom::si::information::Unit + uom::Conversion<f64, T = f64>> UnitImpl
-    for InformationUnitDispatcher<U>
-{
-    type Quantity = Information;
-
-    fn short_name(&self) -> &'static str {
-        U::abbreviation()
-    }
-
-    fn format_value(&self, value: Information, precision: usize) -> String {
-        format!("{value:.precision$}", value = value.get::<U>())
-    }
-}
-
-#[test]
-fn test_time_unit_short_name() {
-    assert_eq!("s", TimeUnit::Second.short_name());
-    assert_eq!("ms", TimeUnit::MilliSecond.short_name());
-    assert_eq!("µs", TimeUnit::MicroSecond.short_name());
-    assert_eq!("min", TimeUnit::Minute.short_name());
-    assert_eq!("h", TimeUnit::Hour.short_name());
-}
-
-// Note - the values are rounded when formatted.
-#[test]
-fn test_unit_format() {
-    use crate::quantity::FormatQuantity;
-
-    let value = Time::new::<second>(123.456789);
-    assert_eq!("123.457", value.format_value(TimeUnit::Second));
-    assert_eq!("123456.8", value.format_value(TimeUnit::MilliSecond));
-
-    assert_eq!(
-        "1234.6",
-        Time::new::<second>(0.00123456).format_value(TimeUnit::MicroSecond)
-    );
-    assert_eq!("2.1", value.format_value(TimeUnit::Minute));
-    assert_eq!("0.0", value.format_value(TimeUnit::Hour));
-}