Adds Speed.

Author: Jonathan Pallant

examples/format_test.rs

@@ -4,6 +4,7 @@ use measurements::Length;
 use measurements::Pressure;
 use measurements::Volume;
 use measurements::Weight;
+use measurements::Speed;
 fn main() {
     for power in -9..9 {
         let val: f64 = 123.456 * (10.0f64.powf(power as f64));
@@ -13,5 +14,6 @@ fn main() {
         println!("Pressure of {0:.3}", Pressure::from_millibars(val));
         println!("Volume of {0:.3}", Volume::from_litres(val));
         println!("Weight of {0:.3}", Weight::from_kilograms(val));
+        println!("Speed of {0:.3}", Speed::from_meters_per_second(val));
     }
 }

src/lib.rs

@@ -17,6 +17,9 @@ pub use volume::Volume;
 pub mod pressure;
 pub use pressure::Pressure;
 
+pub mod speed;
+pub use speed::Speed;
+
 // Include when running tests, but don't export them
 #[cfg(test)]
 #[allow(dead_code)]

src/speed.rs

@@ -0,0 +1,77 @@
+use super::measurement::*;
+
+/// The `Speed` struct can be used to deal with speeds in a common way.
+/// Common metric and imperial units are supported.
+///
+/// # Example
+///
+/// ```
+/// use measurements::Speed;
+///
+/// let light = Speed::from_meters_per_second(300_000_000.0);
+/// let mph = light.as_miles_per_hour();
+/// println!("The speed of light is {} mph.", mph);
+/// ```
+#[derive(Copy, Clone, Debug)]
+pub struct Speed {
+    meters_per_second: f64,
+}
+
+impl Speed {
+    pub fn from_meters_per_second(meters_per_second: f64) -> Speed {
+        Speed { meters_per_second: meters_per_second }
+    }
+
+    pub fn from_metres_per_second(metres_per_second: f64) -> Speed {
+        Speed::from_meters_per_second(metres_per_second)
+    }
+
+    pub fn from_kilometers_per_hour(kilometers_per_hour: f64) -> Speed {
+        Speed::from_meters_per_second((kilometers_per_hour * 1000.0) / 3600.0)
+    }
+
+    pub fn from_kilometres_per_hour(kilometres_per_hour: f64) -> Speed {
+        Speed::from_kilometers_per_hour(kilometres_per_hour)
+    }
+
+    pub fn from_miles_per_hour(miles_per_hour: f64) -> Speed {
+        Speed::from_meters_per_second((miles_per_hour * 1609.0) / 3600.0)
+    }
+
+    pub fn as_meters_per_second(&self) -> f64 {
+        self.meters_per_second
+    }
+
+    pub fn as_metres_per_second(&self) -> f64 {
+        self.as_meters_per_second()
+    }
+
+    pub fn as_kilometers_per_hour(&self) -> f64 {
+        (self.meters_per_second / 1000.0) * 3600.0
+    }
+
+    pub fn as_kilometres_per_hour(&self) -> f64 {
+        self.as_kilometers_per_hour()
+    }
+
+
+    pub fn as_miles_per_hour(&self) -> f64 {
+        (self.meters_per_second / 1609.0) * 3600.0
+    }
+}
+
+impl Measurement for Speed {
+    fn get_base_units(&self) -> f64 {
+        self.meters_per_second
+    }
+
+    fn from_base_units(units: f64) -> Self {
+        Self::from_meters_per_second(units)
+    }
+
+    fn get_base_units_name(&self) -> &'static str {
+        "m/s"
+    }
+}
+
+implement_measurement! { Speed }

src/tests/mod.rs

@@ -2,6 +2,7 @@ mod length_tests;
 mod temperature_tests;
 mod weight_tests;
 mod volume_tests;
+mod speed_tests;
 
 const DEFAULT_DELTA: f64 = 0.00001;
 

src/tests/speed_tests.rs

@@ -0,0 +1,101 @@
+use speed::*;
+use super::assert_almost_eq;
+
+// Metric
+#[test]
+fn kilometers_per_hour() {
+    let i1 = Speed::from_meters_per_second(100.0);
+    let r1 = i1.as_kilometers_per_hour();
+
+    let i2 = Speed::from_kilometers_per_hour(100.0);
+    let r2 = i2.as_meters_per_second();
+
+    assert_almost_eq(r1, 360.0);
+    assert_almost_eq(r2, 27.7777777777);
+}
+
+fn kilometres_per_hour() {
+    let i1 = Speed::from_metres_per_second(100.0);
+    let r1 = i1.as_kilometres_per_hour();
+
+    let i2 = Speed::from_kilometres_per_hour(100.0);
+    let r2 = i2.as_metres_per_second();
+
+    assert_almost_eq(r1, 360.0);
+    assert_almost_eq(r2, 27.7777777777);
+}
+
+// Imperial
+#[test]
+fn miles_per_hour() {
+    let i1 = Speed::from_meters_per_second(100.0);
+    let r1 = i1.as_miles_per_hour();
+
+    let i2 = Speed::from_miles_per_hour(100.0);
+    let r2 = i2.as_meters_per_second();
+
+    assert_almost_eq(r1, 223.7414543194530764449968924798);
+    assert_almost_eq(r2, 44.694444444444444444444444444444);
+}
+
+// Traits
+#[test]
+fn add() {
+    let a = Speed::from_meters_per_second(2.0);
+    let b = Speed::from_meters_per_second(4.0);
+    let c = a + b;
+    let d = b + a;
+    assert_almost_eq(c.as_meters_per_second(), 6.0);
+    assert_eq!(c, d);
+}
+
+#[test]
+fn sub() {
+    let a = Speed::from_meters_per_second(2.0);
+    let b = Speed::from_meters_per_second(4.0);
+    let c = a - b;
+    assert_almost_eq(c.as_meters_per_second(), -2.0);
+}
+
+#[test]
+fn mul() {
+    let a = Speed::from_meters_per_second(3.0);
+    let b = a * 2.0;
+    let c = 2.0 * a;
+    assert_almost_eq(b.as_meters_per_second(), 6.0);
+    assert_eq!(b, c);
+}
+
+#[test]
+fn div() {
+    let a = Speed::from_meters_per_second(2.0);
+    let b = Speed::from_meters_per_second(4.0);
+    let c = a / b;
+    let d = a / 2.0;
+    assert_almost_eq(c, 0.5);
+    assert_almost_eq(d.as_meters_per_second(), 1.0);
+}
+
+#[test]
+fn eq() {
+    let a = Speed::from_meters_per_second(2.0);
+    let b = Speed::from_meters_per_second(2.0);
+    assert_eq!(a == b, true);
+}
+
+#[test]
+fn neq() {
+    let a = Speed::from_meters_per_second(2.0);
+    let b = Speed::from_meters_per_second(4.0);
+    assert_eq!(a == b, false);
+}
+
+#[test]
+fn cmp() {
+    let a = Speed::from_meters_per_second(2.0);
+    let b = Speed::from_meters_per_second(4.0);
+    assert_eq!(a < b, true);
+    assert_eq!(a <= b, true);
+    assert_eq!(a > b, false);
+    assert_eq!(a >= b, false);
+}