Added temperature. Reworked length tests. Bumped to v0.2.0 because of breaking change with length constants handling.

Author: James O'Cull

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "measurements"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["James O'Cull <[email protected]>"]
 documentation = "https://jocull.github.io/rust-measurements/"
 repository = "https://github.com/jocull/rust-measurements"
-description = "Handle metric and imperial measurements with ease!"
+description = "Handle metric, imperial, and other measurements with ease! Types: Length, Temperature"
 license = "MIT"

src/length/consts.rs

@@ -1,6 +1,20 @@
-pub mod consts;
 mod traits;
-use self::consts::*;
+
+// Constants, metric
+const METER_NANOMETER_FACTOR: f64 = 1000000000.0;
+const METER_MICROMETER_FACTOR: f64 = 1000000.0;
+const METER_MILLIMETER_FACTOR: f64 = 1000.0;
+const METER_CENTIMETER_FACTOR: f64 = 100.0;
+const METER_DECAMETER_FACTOR: f64 = 0.1;
+const METER_HECTOMETER_FACTOR: f64 = 0.01;
+const METER_KILOMETER_FACTOR: f64 = 0.001;
+
+// Constants, imperial
+const METER_INCH_FACTOR: f64 = 39.3700787402;
+const METER_FEET_FACTOR: f64 = 3.28083989501;
+const METER_YARD_FACTOR: f64 = 1.09361329834;
+const METER_FURLONG_FACTOR: f64 = 0.0049709695379;
+const METER_MILE_FACTOR: f64 = 0.000621371192237;
 
 /// The `Length` struct can be used to deal with lengths in a common way.
 /// Common metric and imperial units are supported.

src/length/mod.rs

@@ -16,3 +16,18 @@ mod tests;
 
 #[allow(dead_code)]
 pub mod length;
+
+/// The `Temperature` struct can be used to deal with temperatures in a common way.
+/// 
+/// # Example
+/// 
+/// ```
+/// use measurements::temperature::Temperature;
+/// 
+/// let boiling_water = Temperature::from_celsius(100.0);
+/// let fahrenheit = boiling_water.as_fahrenheit();
+/// println!("Boiling water measures at {} degrees fahrenheit.", fahrenheit);
+/// ```
+
+#[allow(dead_code)]
+pub mod temperature;

src/lib.rs

@@ -0,0 +1,41 @@
+mod traits;
+
+/// The `Temperature` struct can be used to deal with temperatures in a common way.
+#[derive(Copy, Clone, Debug)]
+pub struct Temperature {
+    kelvin: f64
+}
+
+impl Temperature {
+    pub fn from_kelvin(kelvin: f64) -> Temperature {
+        Temperature { kelvin: kelvin }
+    }
+    
+    pub fn from_celsius(celsius: f64) -> Temperature {
+        Self::from_kelvin(celsius + 273.15)
+    }
+    
+    pub fn from_fahrenheit(fahrenheit: f64) -> Temperature {
+        Self::from_kelvin((fahrenheit - 32.0) / 1.8 + 273.15)
+    }
+    
+    pub fn from_rankine(rankine: f64) -> Temperature {
+        Self::from_kelvin((rankine - 491.67) / 1.8 + 273.15)
+    }
+    
+    pub fn as_kelvin(&self) -> f64 {
+        self.kelvin
+    }
+    
+    pub fn as_celsius(&self) -> f64 {
+        self.kelvin - 273.15
+    }
+    
+    pub fn as_fahrenheit(&self) -> f64 {
+        (self.kelvin - 273.15) * 1.8 + 32.0
+    }
+    
+    pub fn as_rankine(&self) -> f64 {
+        (self.kelvin - 273.15) * 1.8 + 491.67
+    }
+}

src/temperature/mod.rs

@@ -0,0 +1,49 @@
+use std::ops::{Add,Sub,Div,Mul};
+use std::cmp::{Eq, PartialEq};
+use std::cmp::{PartialOrd, Ordering};
+use super::Temperature;
+
+impl Add for Temperature {
+    type Output = Temperature;
+    
+    fn add(self, rhs: Temperature) -> Temperature {
+        Temperature::from_kelvin(self.kelvin + rhs.kelvin)
+    }
+}
+
+impl Sub for Temperature {
+    type Output = Temperature;
+    
+    fn sub(self, rhs: Temperature) -> Temperature {
+        Temperature::from_kelvin(self.kelvin - rhs.kelvin)
+    }
+}
+
+impl Div for Temperature {
+    type Output = Temperature;
+    
+    fn div(self, rhs: Temperature) -> Temperature {
+        Temperature::from_kelvin(self.kelvin / rhs.kelvin)
+    }
+}
+
+impl Mul for Temperature {
+    type Output = Temperature;
+    
+    fn mul(self, rhs: Temperature) -> Temperature {
+        Temperature::from_kelvin(self.kelvin * rhs.kelvin)
+    }
+}
+
+impl Eq for Temperature { }
+impl PartialEq for Temperature {
+    fn eq(&self, other: &Temperature) -> bool {
+        self.kelvin == other.kelvin
+    }
+}
+
+impl PartialOrd for Temperature {
+    fn partial_cmp(&self, other: &Temperature) -> Option<Ordering> {
+        self.kelvin.partial_cmp(&other.kelvin)
+    }
+}

src/temperature/traits.rs

@@ -1,84 +1,150 @@
 use length::*;
-use length::consts::*;
 use super::{assert_almost_eq};
 
 // Metric
 #[test]
 fn nanometers() {
-    // Basic tests
-    assert_almost_eq(Length::from_meters(1.0).as_nanometers(), METER_NANOMETER_FACTOR);
-    assert_almost_eq(Length::from_nanometers(METER_NANOMETER_FACTOR).as_meters(), 1.0);
+    let i1 = Length::from_meters(100.0);
+    let r1 = i1.as_nanometers();
 
-    // Floating-point precision tests
-    assert_almost_eq(Length::from_nanometers(1.0).as_nanometers(), Length::from_nanometers(1.0).as_nanometers());
-    assert_almost_eq(Length::from_nanometers(0.00025).as_nanometers(), Length::from_nanometers(0.00025).as_nanometers());
+    let i2 = Length::from_nanometers(100.0);
+    let r2 = i2.as_meters();
+    
+    assert_almost_eq(r1, 100000000000.0);
+    assert_almost_eq(r2, 1.0E-7);
 }
 
 #[test]
 fn micrometers() {
-    assert_almost_eq(Length::from_meters(1.0).as_micrometers(), METER_MICROMETER_FACTOR);
-    assert_almost_eq(Length::from_micrometers(METER_MICROMETER_FACTOR).as_meters(), 1.0);
+    let i1 = Length::from_meters(100.0);
+    let r1 = i1.as_micrometers();
+    
+    let i2 = Length::from_micrometers(100.0);
+    let r2 = i2.as_meters();
+    
+    assert_almost_eq(r1, 100000000.0);
+    assert_almost_eq(r2, 0.0001);
 }
 
 #[test]
 fn millimeters() {
-    assert_almost_eq(Length::from_meters(1.0).as_millimeters(), METER_MILLIMETER_FACTOR);
-    assert_almost_eq(Length::from_millimeters(METER_MILLIMETER_FACTOR).as_meters(), 1.0);
+    let i1 = Length::from_meters(100.0);
+    let r1 = i1.as_millimeters();
+    
+    let i2 = Length::from_millimeters(100.0);
+    let r2 = i2.as_meters();
+    
+    assert_almost_eq(r1, 100000.0);
+    assert_almost_eq(r2, 0.1);
 }
 
 #[test]
 fn centimeters() {
-    assert_almost_eq(Length::from_meters(1.0).as_centimeters(), METER_CENTIMETER_FACTOR);
-    assert_almost_eq(Length::from_centimeters(METER_CENTIMETER_FACTOR).as_meters(), 1.0);
+    let i1 = Length::from_meters(100.0);
+    let r1 = i1.as_centimeters();
+    
+    let i2 = Length::from_centimeters(100.0);
+    let r2 = i2.as_meters();
+    
+    assert_almost_eq(r1, 10000.0);
+    assert_almost_eq(r2, 1.0);
 }
 
 #[test]
 fn decameter() {
-    assert_almost_eq(Length::from_meters(1.0).as_decameters(), METER_DECAMETER_FACTOR);
-    assert_almost_eq(Length::from_decameters(METER_DECAMETER_FACTOR).as_meters(), 1.0);
+    let i1 = Length::from_meters(100.0);
+    let r1 = i1.as_decameters();
+    
+    let i2 = Length::from_decameters(100.0);
+    let r2 = i2.as_meters();
+    
+    assert_almost_eq(r1, 10.0);
+    assert_almost_eq(r2, 1000.0);
 }
 
 #[test]
 fn hectometer() {
-    assert_almost_eq(Length::from_meters(1.0).as_hectometer(), METER_HECTOMETER_FACTOR);
-    assert_almost_eq(Length::from_hectometers(METER_HECTOMETER_FACTOR).as_meters(), 1.0);
+    let i1 = Length::from_meters(100.0);
+    let r1 = i1.as_hectometer();
+    
+    let i2 = Length::from_hectometers(100.0);
+    let r2 = i2.as_meters();
+    
+    assert_almost_eq(r1, 1.0);
+    assert_almost_eq(r2, 10000.0);
 }
 
 #[test]
 fn kilometer() {
-    assert_almost_eq(Length::from_meters(1.0).as_kilometers(), METER_KILOMETER_FACTOR);
-    assert_almost_eq(Length::from_kilometers(METER_KILOMETER_FACTOR).as_meters(), 1.0);
+    let i1 = Length::from_meters(100.0);
+    let r1 = i1.as_kilometers();
+    
+    let i2 = Length::from_kilometers(100.0);
+    let r2 = i2.as_meters();
+    
+    assert_almost_eq(r1, 0.1);
+    assert_almost_eq(r2, 100000.0);
 }
 
 // Imperial
 #[test]
 fn inches() {
-    assert_almost_eq(Length::from_meters(1.0).as_inches(), METER_INCH_FACTOR);
-    assert_almost_eq(Length::from_inches(METER_INCH_FACTOR).as_meters(), 1.0);
+    let i1 = Length::from_meters(100.0);
+    let r1 = i1.as_inches();
+    
+    let i2 = Length::from_inches(100.0);
+    let r2 = i2.as_meters();
+    
+    assert_almost_eq(r1, 3937.00787402);
+    assert_almost_eq(r2, 2.54);
 }
 
 #[test]
 fn feet() {
-    assert_almost_eq(Length::from_meters(1.0).as_feet(), METER_FEET_FACTOR);
-    assert_almost_eq(Length::from_feet(METER_FEET_FACTOR).as_meters(), 1.0);
+    let i1 = Length::from_meters(100.0);
+    let r1 = i1.as_feet();
+    
+    let i2 = Length::from_feet(100.0);
+    let r2 = i2.as_meters();
+    
+    assert_almost_eq(r1, 328.083989501);
+    assert_almost_eq(r2, 30.48);
 }
 
 #[test]
 fn yards() {
-    assert_almost_eq(Length::from_meters(1.0).as_yards(), METER_YARD_FACTOR);
-    assert_almost_eq(Length::from_yards(METER_YARD_FACTOR).as_meters(), 1.0);
+    let i1 = Length::from_meters(100.0);
+    let r1 = i1.as_yards();
+    
+    let i2 = Length::from_yards(100.0);
+    let r2 = i2.as_meters();
+    
+    assert_almost_eq(r1, 109.361329834);
+    assert_almost_eq(r2, 91.44);
 }
 
 #[test]
 fn furlongs() {
-    assert_almost_eq(Length::from_meters(1.0).as_furlongs(), METER_FURLONG_FACTOR);
-    assert_almost_eq(Length::from_furlongs(METER_FURLONG_FACTOR).as_meters(), 1.0);
+    let i1 = Length::from_meters(100.0);
+    let r1 = i1.as_furlongs();
+    
+    let i2 = Length::from_furlongs(100.0);
+    let r2 = i2.as_meters();
+    
+    assert_almost_eq(r1, 0.49709695379);
+    assert_almost_eq(r2, 20116.8);
 }
 
 #[test]
 fn miles() {
-    assert_almost_eq(Length::from_meters(1.0).as_miles(), METER_MILE_FACTOR);
-    assert_almost_eq(Length::from_miles(METER_MILE_FACTOR).as_meters(), 1.0);
+    let i1 = Length::from_meters(100.0);
+    let r1 = i1.as_miles();
+    
+    let i2 = Length::from_miles(100.0);
+    let r2 = i2.as_meters();
+    
+    assert_almost_eq(r1, 0.0621371192237);
+    assert_almost_eq(r2, 160934.4);
 }
 
 // Traits

src/tests/length_tests.rs

@@ -1,4 +1,5 @@
 mod length_tests;
+mod temperature_tests;
 
 const DEFAULT_DELTA: f64 = 0.000001;