Merge pull request #5 from thejpster/temperature_delta

Temperature delta

Author: James O'Cull

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "measurements"
-version = "0.3.0"
+version = "0.4.0"
 authors = ["James O'Cull <jocull@delmarsd.com>",
           "Jonathan Pallant <github@thejpster.org.uk>",
           "Hannah McLaughlin <h@mcla.ug>"]

src/lib.rs

@@ -6,7 +6,7 @@ pub mod length;
 pub use length::Length;
 
 pub mod temperature;
-pub use temperature::Temperature;
+pub use temperature::{Temperature, TemperatureDelta};
 
 pub mod weight;
 pub use weight::Weight;

src/temperature.rs

@@ -13,57 +13,163 @@ use super::measurement::*;
 /// ```
 #[derive(Copy, Clone, Debug)]
 pub struct Temperature {
-    kelvin: f64,
+    degrees_kelvin: f64,
+}
+
+/// The `TemperatureDelta` struct can be used to deal with differences between
+/// temperatures in a common way.
+///
+/// # Example
+///
+/// ```
+/// use measurements::{Temperature, TemperatureDelta};
+///
+/// let boiling_water = Temperature::from_celsius(100.0);
+/// let frozen_water = Temperature::from_celsius(0.0);
+/// let difference = boiling_water - frozen_water;
+/// println!("Boiling water is {} above freezing.", difference);
+/// ```
+#[derive(Copy, Clone, Debug)]
+pub struct TemperatureDelta {
+    kelvin_degrees: f64,
+}
+
+impl TemperatureDelta {
+    pub fn from_kelvin(kelvin_degrees: f64) -> Self {
+        TemperatureDelta { kelvin_degrees: kelvin_degrees }
+    }
+
+    pub fn from_celsius(celsius_degrees: f64) -> Self {
+        TemperatureDelta::from_kelvin(celsius_degrees)
+    }
+
+    pub fn from_fahrenheit(farenheit_degrees: f64) -> Self {
+        TemperatureDelta { kelvin_degrees: farenheit_degrees / 1.8}
+    }
+
+    pub fn from_rankine(rankine_degrees: f64) -> Self {
+        TemperatureDelta { kelvin_degrees: rankine_degrees / 1.8}
+    }
+
+    pub fn as_kelvin(&self) -> f64 {
+        self.kelvin_degrees
+    }
+
+    pub fn as_celsius(&self) -> f64 {
+        self.kelvin_degrees
+    }
+
+    pub fn as_fahrenheit(&self) -> f64 {
+        self.kelvin_degrees * 1.8
+    }
+
+    pub fn as_rankine(&self) -> f64 {
+        self.kelvin_degrees * 1.8
+    }
 }
 
 impl Temperature {
-    pub fn from_kelvin(kelvin: f64) -> Self {
-        Temperature { kelvin: kelvin }
+    pub fn from_kelvin(degrees_kelvin: f64) -> Self {
+        Temperature { degrees_kelvin: degrees_kelvin }
     }
 
-    pub fn from_celsius(celsius: f64) -> Self {
-        Self::from_kelvin(celsius + 273.15)
+    pub fn from_celsius(degrees_celsius: f64) -> Self {
+        Self::from_kelvin(degrees_celsius + 273.15)
     }
 
-    pub fn from_fahrenheit(fahrenheit: f64) -> Self {
-        Self::from_kelvin((fahrenheit - 32.0) / 1.8 + 273.15)
+    pub fn from_fahrenheit(degrees_fahrenheit: f64) -> Self {
+        Self::from_kelvin((degrees_fahrenheit - 32.0) / 1.8 + 273.15)
     }
 
-    pub fn from_rankine(rankine: f64) -> Self {
-        Self::from_kelvin((rankine - 491.67) / 1.8 + 273.15)
+    pub fn from_rankine(degrees_rankine: f64) -> Self {
+        Self::from_kelvin((degrees_rankine - 491.67) / 1.8 + 273.15)
     }
 
     pub fn as_kelvin(&self) -> f64 {
-        self.kelvin
+        self.degrees_kelvin
     }
 
     pub fn as_celsius(&self) -> f64 {
-        self.kelvin - 273.15
+        self.degrees_kelvin - 273.15
     }
 
     pub fn as_fahrenheit(&self) -> f64 {
-        (self.kelvin - 273.15) * 1.8 + 32.0
+        (self.degrees_kelvin - 273.15) * 1.8 + 32.0
     }
 
     pub fn as_rankine(&self) -> f64 {
-        (self.kelvin - 273.15) * 1.8 + 491.67
+        (self.degrees_kelvin - 273.15) * 1.8 + 491.67
     }
 }
 
 impl Measurement for Temperature {
     fn get_base_units(&self) -> f64 {
-        self.kelvin
+        self.degrees_kelvin
+    }
+
+    fn from_base_units(degrees_kelvin: f64) -> Self {
+        Self::from_kelvin(degrees_kelvin)
     }
+}
+
+impl ::std::ops::Add<TemperatureDelta> for Temperature {
+    type Output = Temperature;
 
-    fn from_base_units(units: f64) -> Self {
-        Self::from_kelvin(units)
+    fn add(self, other: TemperatureDelta) -> Temperature {
+        Temperature::from_kelvin(self.degrees_kelvin + other.kelvin_degrees)
     }
 }
 
-implement_measurement! { Temperature }
+impl ::std::ops::Sub<TemperatureDelta> for Temperature {
+    type Output = Temperature;
+
+    fn sub(self, other: TemperatureDelta) -> Temperature {
+        Temperature::from_kelvin(self.degrees_kelvin - other.kelvin_degrees)
+    }
+}
+
+impl ::std::ops::Sub<Temperature> for Temperature {
+    type Output = TemperatureDelta;
+
+    fn sub(self, other: Temperature) -> TemperatureDelta {
+        TemperatureDelta::from_kelvin(self.degrees_kelvin - other.degrees_kelvin)
+    }
+}
+
+impl ::std::cmp::Eq for Temperature { }
+impl ::std::cmp::PartialEq for Temperature {
+    fn eq(&self, other: &Self) -> bool {
+        self.get_base_units() == other.get_base_units()
+    }
+}
+
+impl ::std::cmp::PartialOrd for Temperature {
+    fn partial_cmp(&self, other: &Self) -> Option<::std::cmp::Ordering> {
+        self.get_base_units().partial_cmp(&other.get_base_units())
+    }
+}
+
+impl ::std::cmp::Eq for TemperatureDelta { }
+impl ::std::cmp::PartialEq for TemperatureDelta {
+    fn eq(&self, other: &Self) -> bool {
+        self.kelvin_degrees == other.kelvin_degrees
+    }
+}
+
+impl ::std::cmp::PartialOrd for TemperatureDelta {
+    fn partial_cmp(&self, other: &Self) -> Option<::std::cmp::Ordering> {
+        self.kelvin_degrees.partial_cmp(&other.kelvin_degrees)
+    }
+}
 
 impl ::std::fmt::Display for Temperature {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
         write!(f, "{:.1} \u{00B0}C", self.as_celsius())
     }
 }
+
+impl ::std::fmt::Display for TemperatureDelta {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "{:.1} C\u{00B0}", self.as_celsius())
+    }
+}

src/tests/mod.rs

@@ -3,7 +3,7 @@ mod temperature_tests;
 mod weight_tests;
 mod volume_tests;
 
-const DEFAULT_DELTA: f64 = 1.000000001;
+const DEFAULT_DELTA: f64 = 0.00001;
 
 fn almost_eq(a: f64, b: f64) -> bool {
     almost_eq_delta(a, b, DEFAULT_DELTA)

src/tests/temperature_tests.rs

@@ -38,37 +38,25 @@ fn rankine() {
 #[test]
 fn add() {
     let a = Temperature::from_kelvin(2.0);
-    let b = Temperature::from_kelvin(4.0);
+    let b = TemperatureDelta::from_kelvin(4.0);
     let c = a + b;
     assert_almost_eq(c.as_kelvin(), 6.0);
 }
 
 #[test]
 fn sub() {
-    let a = Temperature::from_kelvin(2.0);
-    let b = Temperature::from_kelvin(4.0);
+    let a = Temperature::from_kelvin(4.0);
+    let b = TemperatureDelta::from_kelvin(2.0);
     let c = a - b;
-    assert_almost_eq(c.as_kelvin(), -2.0);
+    assert_almost_eq(c.as_kelvin(), 2.0);
 }
 
 #[test]
-fn mul() {
-    let a = Temperature::from_kelvin(2.0);
-    let b = Temperature::from_kelvin(4.0);
-    let c = a * b;
-    let d = a * 2.0;
-    assert_almost_eq(c.as_kelvin(), 8.0);
-    assert_almost_eq(d.as_kelvin(), 4.0);
-}
-
-#[test]
-fn div() {
-    let a = Temperature::from_kelvin(2.0);
-    let b = Temperature::from_kelvin(4.0);
-    let c = a / b;
-    let d = a / 2.0;
-    assert_almost_eq(c, 0.5);
-    assert_almost_eq(d.as_kelvin(), 1.0);
+fn sub2() {
+    let a = Temperature::from_fahrenheit(212.0);
+    let b = Temperature::from_celsius(75.0);
+    let c = a - b;
+    assert_almost_eq(c.as_kelvin(), 25.0);
 }
 
 #[test]