Add Power.

Author: Jonathan Pallant

examples/format_test.rs

@@ -7,6 +7,7 @@ use measurements::Weight;
 use measurements::Speed;
 use measurements::Acceleration;
 use measurements::Energy;
+use measurements::Power;
 
 fn main() {
     for power in -12..12 {
@@ -20,7 +21,6 @@ fn main() {
         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!("Power of {0:.3}", Power::from_watts(val));
     }
-
-    println!("1.0 GeV is {}", Energy::from_e_v(1e9));
 }

src/energy.rs

@@ -1,4 +1,6 @@
 use super::measurement::*;
+use super::Power;
+use std::time::Duration;
 
 /// The `Energy` struct can be used to deal with energies in a common way.
 /// Common metric and imperial units are supported.
@@ -66,6 +68,28 @@ impl Energy {
     }
 }
 
+/// Energy / Time = Power
+impl ::std::ops::Div<Duration> for Energy {
+    type Output = Power;
+
+    fn div(self, rhs: Duration) -> Power {
+        // It would be useful if Duration had a method that did this...
+        let seconds: f64 = rhs.as_secs() as f64 + ((rhs.subsec_nanos() as f64) * 1e-9);
+        Power::from_watts(self.as_joules() / seconds)
+    }
+}
+
+/// Energy / Power = Time
+impl ::std::ops::Div<Power> for Energy {
+    type Output = Duration;
+
+    fn div(self, rhs: Power) -> Duration {
+        let seconds =  self.as_joules() / rhs.as_watts();
+        let nanosecs = (seconds * 1e9) % 1e9;
+        Duration::new(seconds as u64, nanosecs as u32)
+    }
+}
+
 impl Measurement for Energy {
     fn get_base_units(&self) -> f64 {
         self.joules

src/lib.rs

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

src/power.rs

@@ -0,0 +1,109 @@
+use super::measurement::*;
+use std::time::Duration;
+use super::Energy;
+
+/// The `Power` struct can be used to deal with energies in a common way.
+/// Common metric and imperial units are supported.
+///
+/// # Example
+///
+/// ```
+/// use measurements::Power;
+///
+/// let power = Power::from_horsepower(100.0);
+/// let k_w = power.as_kilowatts();
+/// println!("A 100.0 hp car produces {} kW", k_w);
+/// ```
+#[derive(Copy, Clone, Debug)]
+pub struct Power {
+    watts: f64,
+}
+
+impl Power {
+    pub fn from_watts(watts: f64) -> Power {
+        Power { watts: watts }
+    }
+
+    pub fn from_horsepower(horsepower: f64) -> Power {
+        Self::from_watts(horsepower * 745.6998715822702)
+    }
+
+    pub fn from_btu_per_minute(btu_per_minute: f64) -> Power {
+        Self::from_watts(btu_per_minute * 17.58426666666667)
+    }
+
+    pub fn from_kilowatts(kw: f64) -> Power {
+        Self::from_watts(kw * 1000.0)
+    }
+
+    pub fn as_watts(&self) -> f64 {
+        self.watts
+    }
+
+    pub fn as_horsepower(&self) -> f64 {
+        self.watts / 745.6998715822702
+    }
+
+    pub fn as_btu_per_minute(&self) -> f64 {
+        self.watts / 17.58426666666667
+    }
+
+    pub fn as_kilowatts(&self) -> f64 {
+        self.watts / 1000.0
+    }
+}
+
+/// Power * Time = Energy
+impl ::std::ops::Mul<Duration> for Power {
+    type Output = Energy;
+
+    fn mul(self, rhs: Duration) -> Energy {
+        // It would be useful if Duration had a method that did this...
+        let seconds: f64 = rhs.as_secs() as f64 + ((rhs.subsec_nanos() as f64) * 1e-9);
+        Energy::from_joules(self.as_watts() * seconds)
+    }
+}
+
+/// Time * Power = Energy
+impl ::std::ops::Mul<Power> for Duration {
+    type Output = Energy;
+
+    fn mul(self, rhs: Power) -> Energy {
+        rhs * self
+    }
+}
+
+impl Measurement for Power {
+    fn get_base_units(&self) -> f64 {
+        self.watts
+    }
+
+    fn from_base_units(units: f64) -> Self {
+        Self::from_watts(units)
+    }
+
+    fn get_base_units_name(&self) -> &'static str {
+        "W"
+    }
+
+    fn get_appropriate_units(&self) -> (&'static str, f64) {
+        // Smallest to Largest
+        let list = [
+            ("fW", 1e-15),
+            ("pW", 1e-12),
+            ("nW", 1e-9),
+            ("\u{00B5}W", 1e-6),
+            ("mW", 1e-3),
+            ("W", 1e0),
+            ("kW", 1e3),
+            ("MW", 1e6),
+            ("GW", 1e9),
+            ("TW", 1e12),
+            ("PW", 1e15),
+            ("EW", 1e18),
+        ];
+        self.pick_appropriate_units(&list)
+    }
+}
+
+implement_measurement! { Power }

src/tests/mod.rs

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

src/tests/power_tests.rs

@@ -0,0 +1,100 @@
+use power::*;
+use super::assert_almost_eq;
+
+#[test]
+pub fn as_btu_per_minute() {
+    let i1 = Power::from_btu_per_minute(100.0);
+    let r1 = i1.as_watts();
+
+    let i2 = Power::from_watts(100.0);
+    let r2 = i2.as_btu_per_minute();
+
+    assert_almost_eq(r1, 1758.426666666667);
+    assert_almost_eq(r2, 5.686901927480627);
+}
+
+#[test]
+pub fn as_horsepower() {
+    let i1 = Power::from_horsepower(100.0);
+    let r1 = i1.as_watts();
+
+    let i2 = Power::from_watts(100.0);
+    let r2 = i2.as_horsepower();
+
+    assert_almost_eq(r1, 74569.98715822702);
+    assert_almost_eq(r2, 0.1341022089595028);
+}
+
+#[test]
+pub fn as_kilowatts() {
+    let i1 = Power::from_kilowatts(100.0);
+    let r1 = i1.as_watts();
+
+    let i2 = Power::from_watts(100.0);
+    let r2 = i2.as_kilowatts();
+
+    assert_almost_eq(r1, 100000.0);
+    assert_almost_eq(r2, 0.1);
+}
+
+// Traits
+#[test]
+fn add() {
+    let a = Power::from_watts(2.0);
+    let b = Power::from_watts(4.0);
+    let c = a + b;
+    let d = b + a;
+    assert_almost_eq(c.as_watts(), 6.0);
+    assert_eq!(c, d);
+}
+
+#[test]
+fn sub() {
+    let a = Power::from_watts(2.0);
+    let b = Power::from_watts(4.0);
+    let c = a - b;
+    assert_almost_eq(c.as_watts(), -2.0);
+}
+
+#[test]
+fn mul() {
+    let a = Power::from_watts(3.0);
+    let b = a * 2.0;
+    let c = 2.0 * a;
+    assert_almost_eq(b.as_watts(), 6.0);
+    assert_eq!(b, c);
+}
+
+#[test]
+fn div() {
+    let a = Power::from_watts(2.0);
+    let b = Power::from_watts(4.0);
+    let c = a / b;
+    let d = a / 2.0;
+    assert_almost_eq(c, 0.5);
+    assert_almost_eq(d.as_watts(), 1.0);
+}
+
+#[test]
+fn eq() {
+    let a = Power::from_watts(2.0);
+    let b = Power::from_watts(2.0);
+    assert_eq!(a == b, true);
+}
+
+#[test]
+fn neq() {
+    let a = Power::from_watts(2.0);
+    let b = Power::from_watts(4.0);
+    assert_eq!(a == b, false);
+}
+
+#[test]
+fn cmp() {
+    let a = Power::from_watts(2.0);
+    let b = Power::from_watts(4.0);
+    assert_eq!(a < b, true);
+    assert_eq!(a <= b, true);
+    assert_eq!(a > b, false);
+    assert_eq!(a >= b, false);
+}