Add Energy.

Author: Jonathan Pallant

examples/format_test.rs

@@ -6,10 +6,11 @@ use measurements::Volume;
 use measurements::Weight;
 use measurements::Speed;
 use measurements::Acceleration;
+use measurements::Energy;
 
 fn main() {
-    for power in -9..9 {
-        let val: f64 = 123.456 * (10.0f64.powf(power as f64));
+    for power in -12..12 {
+        let val: f64 = 123.456 * (10f64.powf(power as f64));
         println!("10^{}...", power);
         println!("Temp of {0:.3} outside", Temperature::from_kelvin(val));
         println!("Distance of {0:.3}", Length::from_meters(val));
@@ -18,5 +19,8 @@ fn main() {
         println!("Weight of {0:.3}", Weight::from_kilograms(val));
         println!("Speed of {0:.3}", Speed::from_meters_per_second(val));
         println!("Acceleration of {0:.3}", Acceleration::from_meters_per_second_per_second(val));
+        println!("Energy of {0:.3}", Energy::from_joules(val));
     }
+
+    println!("1.0 GeV is {}", Energy::from_e_v(1e9));
 }

src/energy.rs

@@ -0,0 +1,102 @@
+use super::measurement::*;
+
+/// The `Energy` struct can be used to deal with energies in a common way.
+/// Common metric and imperial units are supported.
+///
+/// # Example
+///
+/// ```
+/// use measurements::Energy;
+///
+/// let energy = Energy::from_kcalories(2500.0);
+/// println!("Some say a health adult male should consume {} per day", energy);
+/// ```
+#[derive(Copy, Clone, Debug)]
+pub struct Energy {
+    joules: f64,
+}
+
+impl Energy {
+    pub fn from_joules(joules: f64) -> Energy {
+        Energy { joules: joules }
+    }
+
+    pub fn from_kcalories(kcalories: f64) -> Energy {
+        Self::from_joules(kcalories * 4186.8)
+    }
+
+    pub fn from_btu(btu: f64) -> Energy {
+        Self::from_joules(btu * 1055.056)
+    }
+
+    pub fn from_e_v(e_v: f64) -> Energy {
+        Self::from_joules(e_v / 6.241509479607718e+18)
+    }
+
+    pub fn from_watt_hours(wh: f64) -> Energy {
+        Self::from_joules(wh * 3600.0)
+    }
+
+    pub fn from_kilowatt_hours(kwh: f64) -> Energy {
+        Self::from_joules(kwh * 3600.0 * 1000.0)
+    }
+
+    pub fn as_joules(&self) -> f64 {
+        self.joules
+    }
+
+    pub fn as_kcalories(&self) -> f64 {
+        self.joules / 4186.8
+    }
+
+    pub fn as_btu(&self) -> f64 {
+        self.joules / 1055.056
+    }
+
+    pub fn as_e_v(&self) -> f64 {
+        self.joules * 6.241509479607718e+18
+    }
+
+    pub fn as_watt_hours(&self) -> f64 {
+        self.joules / 3600.0
+    }
+
+    pub fn as_kilowatt_hours(&self) -> f64 {
+        self.joules / (3600.0 * 1000.0)
+    }
+}
+
+impl Measurement for Energy {
+    fn get_base_units(&self) -> f64 {
+        self.joules
+    }
+
+    fn from_base_units(units: f64) -> Self {
+        Self::from_joules(units)
+    }
+
+    fn get_base_units_name(&self) -> &'static str {
+        "J"
+    }
+
+    fn get_appropriate_units(&self) -> (&'static str, f64) {
+        // Smallest to Largest
+        let list = [
+            ("fJ", 1e-15),
+            ("pJ", 1e-12),
+            ("nJ", 1e-9),
+            ("\u{00B5}J", 1e-6),
+            ("mJ", 1e-3),
+            ("J", 1e0),
+            ("kJ", 1e3),
+            ("MJ", 1e6),
+            ("GJ", 1e9),
+            ("TJ", 1e12),
+            ("PJ", 1e15),
+            ("EJ", 1e18),
+        ];
+        self.pick_appropriate_units(&list)
+    }
+}
+
+implement_measurement! { Energy }

src/lib.rs

@@ -23,6 +23,9 @@ pub use speed::Speed;
 pub mod acceleration;
 pub use acceleration::Acceleration;
 
+pub mod energy;
+pub use energy::Energy;
+
 // Include when running tests, but don't export them
 #[cfg(test)]
 #[allow(dead_code)]

src/tests/energy_tests.rs

@@ -0,0 +1,125 @@
+use energy::*;
+use super::assert_almost_eq;
+
+
+#[test]
+pub fn as_kcalories() {
+    let i1 = Energy::from_kcalories(100.0);
+    let r1 = i1.as_joules();
+
+    let i2 = Energy::from_joules(100.0);
+    let r2 = i2.as_kcalories();
+
+    assert_almost_eq(r1, 418680.0);
+    assert_almost_eq(r2, 0.0238845896627496);
+}
+
+#[test]
+pub fn as_btu() {
+    let i1 = Energy::from_btu(100.0);
+    let r1 = i1.as_joules();
+
+    let i2 = Energy::from_joules(100.0);
+    let r2 = i2.as_btu();
+
+    assert_almost_eq(r1, 105505.6);
+    assert_almost_eq(r2, 0.0947816987913438);
+}
+
+#[test]
+pub fn as_e_v() {
+    let i1 = Energy::from_e_v(100.0);
+    let r1 = i1.as_joules();
+
+    let i2 = Energy::from_joules(100.0);
+    let r2 = i2.as_e_v();
+
+    assert_almost_eq(r1, 1.60217653e-17);
+    assert_almost_eq(r2, 6.241509479607718e+20);
+}
+
+#[test]
+pub fn as_watt_hours() {
+    let i1 = Energy::from_watt_hours(100.0);
+    let r1 = i1.as_joules();
+
+    let i2 = Energy::from_joules(100.0);
+    let r2 = i2.as_watt_hours();
+
+    assert_almost_eq(r1, 360000.0);
+    assert_almost_eq(r2, 0.02777777777777777777777777777778);
+}
+
+#[test]
+pub fn as_kilowatt_hours() {
+    let i1 = Energy::from_kilowatt_hours(100.0);
+    let r1 = i1.as_joules();
+
+    let i2 = Energy::from_joules(100.0);
+    let r2 = i2.as_kilowatt_hours();
+
+    assert_almost_eq(r1, 360000000.0);
+    assert_almost_eq(r2, 2.777777777777777777777777777778e-5);
+}
+
+// Traits
+#[test]
+fn add() {
+    let a = Energy::from_joules(2.0);
+    let b = Energy::from_joules(4.0);
+    let c = a + b;
+    let d = b + a;
+    assert_almost_eq(c.as_joules(), 6.0);
+    assert_eq!(c, d);
+}
+
+#[test]
+fn sub() {
+    let a = Energy::from_joules(2.0);
+    let b = Energy::from_joules(4.0);
+    let c = a - b;
+    assert_almost_eq(c.as_joules(), -2.0);
+}
+
+#[test]
+fn mul() {
+    let a = Energy::from_joules(3.0);
+    let b = a * 2.0;
+    let c = 2.0 * a;
+    assert_almost_eq(b.as_joules(), 6.0);
+    assert_eq!(b, c);
+}
+
+#[test]
+fn div() {
+    let a = Energy::from_joules(2.0);
+    let b = Energy::from_joules(4.0);
+    let c = a / b;
+    let d = a / 2.0;
+    assert_almost_eq(c, 0.5);
+    assert_almost_eq(d.as_joules(), 1.0);
+}
+
+#[test]
+fn eq() {
+    let a = Energy::from_joules(2.0);
+    let b = Energy::from_joules(2.0);
+    assert_eq!(a == b, true);
+}
+
+#[test]
+fn neq() {
+    let a = Energy::from_joules(2.0);
+    let b = Energy::from_joules(4.0);
+    assert_eq!(a == b, false);
+}
+
+#[test]
+fn cmp() {
+    let a = Energy::from_joules(2.0);
+    let b = Energy::from_joules(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

@@ -4,6 +4,7 @@ mod weight_tests;
 mod volume_tests;
 mod speed_tests;
 mod acceleration_tests;
+mod energy_tests;
 
 const DEFAULT_DELTA: f64 = 0.00001;