Merge pull request #7 from thejpster/linkmauve-data

Implements Data - a measure of data in octets

Author: thejpster

examples/format_test.rs

@@ -8,6 +8,7 @@ use measurements::Speed;
 use measurements::Acceleration;
 use measurements::Energy;
 use measurements::Power;
+use measurements::Data;
 
 fn main() {
     for power in -12..12 {
@@ -22,5 +23,6 @@ fn main() {
         println!("Acceleration of {0:.3}", Acceleration::from_meters_per_second_per_second(val));
         println!("Energy of {0:.3}", Energy::from_joules(val));
         println!("Power of {0:.3}", Power::from_watts(val));
+        println!("Data size is {0:.3}", Data::from_octets(val));
     }
 }

src/data.rs

@@ -0,0 +1,152 @@
+use super::measurement::*;
+
+// Constants
+const OCTET_BIT_FACTOR: f64 = 0.125;
+
+// Constants, legacy
+const OCTET_KILOOCTET_FACTOR: f64 = 1000.;
+const OCTET_MEGAOCTET_FACTOR: f64 = 1000000.;
+const OCTET_GIGAOCTET_FACTOR: f64 = 1000000000.;
+const OCTET_TERAOCTET_FACTOR: f64 = 1000000000000.;
+
+// Constants, SI
+const OCTET_KIBIOCTET_FACTOR: f64 = 1024.;
+const OCTET_MEBIOCTET_FACTOR: f64 = 1048576.;
+const OCTET_GIBIOCTET_FACTOR: f64 = 1073741824.;
+const OCTET_TEBIOCTET_FACTOR: f64 = 1099511627776.;
+
+/// The `Data` struct can be used to deal with computer information in a common way.
+/// Common legacy and SI units are supported.
+///
+/// # Example
+///
+/// ```
+/// use measurements::Data;
+///
+/// let file_size = Data::from_mebioctets(2.5);
+/// let octets = file_size.as_octets();
+/// println!("There are {} octets in that file.", octets);
+/// ```
+#[derive(Copy, Clone, Debug)]
+pub struct Data {
+    octets: f64,
+}
+
+impl Data {
+    // Inputs
+    pub fn from_octets(octets: f64) -> Self {
+        Data { octets: octets }
+    }
+
+    pub fn from_bits(bits: f64) -> Self {
+        Self::from_octets(bits * OCTET_BIT_FACTOR)
+    }
+
+    // Inputs, legacy
+    pub fn from_kilooctets(kilooctets: f64) -> Self {
+        Self::from_octets(kilooctets * OCTET_KILOOCTET_FACTOR)
+    }
+
+    pub fn from_megaoctets(megaoctets: f64) -> Self {
+        Self::from_octets(megaoctets * OCTET_MEGAOCTET_FACTOR)
+    }
+
+    pub fn from_gigaoctets(gigaoctets: f64) -> Self {
+        Self::from_octets(gigaoctets * OCTET_GIGAOCTET_FACTOR)
+    }
+
+    pub fn from_teraoctets(teraoctets: f64) -> Self {
+        Self::from_octets(teraoctets * OCTET_TERAOCTET_FACTOR)
+    }
+
+    // Inputs, SI
+    pub fn from_kibioctets(kibioctets: f64) -> Self {
+        Self::from_octets(kibioctets * OCTET_KIBIOCTET_FACTOR)
+    }
+
+    pub fn from_mebioctets(mebioctets: f64) -> Self {
+        Self::from_octets(mebioctets * OCTET_MEBIOCTET_FACTOR)
+    }
+
+    pub fn from_gibioctets(gibioctets: f64) -> Self {
+        Self::from_octets(gibioctets * OCTET_GIBIOCTET_FACTOR)
+    }
+
+    pub fn from_tebioctets(tebioctets: f64) -> Self {
+        Self::from_octets(tebioctets * OCTET_TEBIOCTET_FACTOR)
+    }
+
+    // Outputs
+    pub fn as_octets(&self) -> f64 {
+        self.octets
+    }
+
+    pub fn as_bits(&self) -> f64 {
+        self.octets / OCTET_BIT_FACTOR
+    }
+
+    // Outputs, legacy
+    pub fn as_kilooctets(&self) -> f64 {
+        self.octets / OCTET_KILOOCTET_FACTOR
+    }
+
+    pub fn as_megaoctets(&self) -> f64 {
+        self.octets / OCTET_MEGAOCTET_FACTOR
+    }
+
+    pub fn as_gigaoctets(&self) -> f64 {
+        self.octets / OCTET_GIGAOCTET_FACTOR
+    }
+
+    pub fn as_teraoctets(&self) -> f64 {
+        self.octets / OCTET_TERAOCTET_FACTOR
+    }
+
+    // Outputs, SI
+    pub fn as_kibioctets(&self) -> f64 {
+        self.octets / OCTET_KIBIOCTET_FACTOR
+    }
+
+    pub fn as_mebioctets(&self) -> f64 {
+        self.octets / OCTET_MEBIOCTET_FACTOR
+    }
+
+    pub fn as_gibioctets(&self) -> f64 {
+        self.octets / OCTET_GIBIOCTET_FACTOR
+    }
+
+    pub fn as_tebioctets(&self) -> f64 {
+        self.octets / OCTET_TEBIOCTET_FACTOR
+    }
+}
+
+impl Measurement for Data {
+    fn get_base_units(&self) -> f64 {
+        self.octets
+    }
+
+    fn from_base_units(units: f64) -> Self {
+        Self::from_octets(units)
+    }
+
+    fn get_base_units_name(&self) -> &'static str {
+        "octets"
+    }
+
+    fn get_appropriate_units(&self) -> (&'static str, f64) {
+        // Smallest to largest
+        let list = [
+            ("octets", 1.0),
+            ("KiB", 1024.0),
+            ("MiB", 1024.0_f64.powi(2)),
+            ("GiB", 1024.0_f64.powi(3)),
+            ("TiB", 1024.0_f64.powi(4)),
+            ("PiB", 1024.0_f64.powi(5)),
+            ("EiB", 1024.0_f64.powi(6)),
+        ];
+        self.pick_appropriate_units(&list)
+    }
+}
+
+implement_measurement! { Data }
+

src/lib.rs

@@ -29,6 +29,9 @@ pub use energy::Energy;
 pub mod power;
 pub use power::Power;
 
+pub mod data;
+pub use data::Data;
+
 // Include when running tests, but don't export them
 #[cfg(test)]
 #[allow(dead_code)]

src/tests/data_tests.rs

@@ -0,0 +1,167 @@
+use data::*;
+use super::assert_almost_eq;
+
+// Metric
+#[test]
+fn bits() {
+    let i1 = Data::from_octets(100.0);
+    let r1 = i1.as_bits();
+
+    let i2 = Data::from_bits(100.0);
+    let r2 = i2.as_octets();
+
+    assert_almost_eq(r1, 800.0);
+    assert_almost_eq(r2, 12.5);
+}
+
+#[test]
+fn kilooctet() {
+    let i1 = Data::from_octets(100.0);
+    let r1 = i1.as_kilooctets();
+
+    let i2 = Data::from_kilooctets(100.0);
+    let r2 = i2.as_octets();
+
+    assert_almost_eq(r1, 0.1);
+    assert_almost_eq(r2, 1e5);
+}
+
+#[test]
+fn megaoctet() {
+    let i1 = Data::from_octets(100.0);
+    let r1 = i1.as_megaoctets();
+
+    let i2 = Data::from_megaoctets(100.0);
+    let r2 = i2.as_octets();
+
+    assert_almost_eq(r1, 0.0001);
+    assert_almost_eq(r2, 1e8);
+}
+
+#[test]
+fn gigaoctet() {
+    let i1 = Data::from_octets(100.0);
+    let r1 = i1.as_gigaoctets();
+
+    let i2 = Data::from_gigaoctets(100.0);
+    let r2 = i2.as_octets();
+
+    assert_almost_eq(r1, 1e-7);
+    assert_almost_eq(r2, 1e11);
+}
+
+#[test]
+fn teraoctet() {
+    let i1 = Data::from_octets(100.0);
+    let r1 = i1.as_teraoctets();
+
+    let i2 = Data::from_teraoctets(100.0);
+    let r2 = i2.as_octets();
+
+    assert_almost_eq(r1, 1e-10);
+    assert_almost_eq(r2, 1e14);
+}
+
+// Imperial
+#[test]
+fn kibioctet() {
+    let i1 = Data::from_octets(100.0);
+    let r1 = i1.as_kibioctets();
+
+    let i2 = Data::from_kibioctets(100.0);
+    let r2 = i2.as_octets();
+
+    assert_almost_eq(r1, 0.09765625);
+    assert_almost_eq(r2, 102400.0);
+}
+
+#[test]
+fn mebioctet() {
+    let i1 = Data::from_octets(100.0);
+    let r1 = i1.as_mebioctets();
+
+    let i2 = Data::from_mebioctets(100.0);
+    let r2 = i2.as_octets();
+
+    assert_almost_eq(r1, 9.536743e-5);
+    assert_almost_eq(r2, 104857600.0);
+}
+
+#[test]
+fn gibioctets() {
+    let i1 = Data::from_octets(100.0);
+    let r1 = i1.as_gibioctets();
+
+    let i2 = Data::from_gibioctets(100.0);
+    let r2 = i2.as_octets();
+
+    assert_almost_eq(r1, 9.313226e-8);
+    assert_almost_eq(r2, 107374182400.0);
+}
+
+#[test]
+fn tebioctets() {
+    let i1 = Data::from_octets(100.0);
+    let r1 = i1.as_tebioctets();
+
+    let i2 = Data::from_tebioctets(100.0);
+    let r2 = i2.as_octets();
+
+    assert_almost_eq(r1, 9.094947e-11);
+    assert_almost_eq(r2, 109951162777600.0);
+}
+
+// Traits
+#[test]
+fn add() {
+    let a = Data::from_octets(2.0);
+    let b = Data::from_octets(4.0);
+    let c = a + b;
+    assert_almost_eq(c.as_octets(), 6.0);
+}
+
+#[test]
+fn sub() {
+    let a = Data::from_octets(2.0);
+    let b = Data::from_octets(4.0);
+    let c = a - b;
+    assert_almost_eq(c.as_octets(), -2.0);
+}
+
+#[test]
+fn mul() {
+    let b = Data::from_octets(4.0);
+    let d = b * 2.0;
+    assert_almost_eq(d.as_octets(), 8.0);
+}
+
+#[test]
+fn div() {
+    let b = Data::from_octets(4.0);
+    let d = b / 2.0;
+    assert_almost_eq(d.as_octets(), 2.0);
+}
+
+#[test]
+fn eq() {
+    let a = Data::from_octets(2.0);
+    let b = Data::from_octets(2.0);
+    assert_eq!(a == b, true);
+}
+
+#[test]
+fn neq() {
+    let a = Data::from_octets(2.0);
+    let b = Data::from_octets(4.0);
+    assert_eq!(a == b, false);
+}
+
+#[test]
+fn cmp() {
+    let a = Data::from_octets(2.0);
+    let b = Data::from_octets(4.0);
+    assert_eq!(a < b, true);
+    assert_eq!(a <= b, true);
+    assert_eq!(a > b, false);
+    assert_eq!(a >= b, false);
+}

src/tests/mod.rs

@@ -6,6 +6,7 @@ mod speed_tests;
 mod acceleration_tests;
 mod energy_tests;
 mod power_tests;
+mod data_tests;
 
 const DEFAULT_DELTA: f64 = 0.00001;