Added acceleration.

Author: Jonathan Pallant

examples/format_test.rs

@@ -5,6 +5,8 @@ use measurements::Pressure;
 use measurements::Volume;
 use measurements::Weight;
 use measurements::Speed;
+use measurements::Acceleration;
+
 fn main() {
     for power in -9..9 {
         let val: f64 = 123.456 * (10.0f64.powf(power as f64));
@@ -15,5 +17,6 @@ fn main() {
         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));
+        println!("Acceleration of {0:.3}", Acceleration::from_meters_per_second_per_second(val));
     }
 }

src/acceleration.rs

@@ -0,0 +1,78 @@
+use super::measurement::*;
+use super::Speed;
+use std::time::Duration;
+
+/// The `Acceleration` struct can be used to deal with Accelerations in a common way.
+/// Common metric and imperial units are supported.
+///
+/// # Example
+///
+/// ```
+/// use measurements::{Acceleration, Length, Speed};
+/// use std::time::Duration;
+///
+/// // Standing quarter mile in 10.0 dead, at 120.0 mph
+/// let track = Length::from_miles(0.25);
+/// let finish = Speed::from_miles_per_hour(120.0);
+/// let time = Duration::new(10, 0);
+/// let accel = finish / time;
+/// println!("You accelerated over {} at an average of {}", track, accel);
+/// ```
+#[derive(Copy, Clone, Debug)]
+pub struct Acceleration {
+    meters_per_second_per_second: f64,
+}
+
+impl Acceleration {
+    pub fn from_meters_per_second_per_second(meters_per_second_per_second: f64) -> Acceleration {
+        Acceleration { meters_per_second_per_second: meters_per_second_per_second }
+    }
+
+    pub fn from_metres_per_second_per_second(metres_per_second_per_second: f64) -> Acceleration {
+        Acceleration::from_meters_per_second_per_second(metres_per_second_per_second)
+    }
+
+    pub fn as_meters_per_second_per_second(&self) -> f64 {
+        self.meters_per_second_per_second
+    }
+
+    pub fn as_metres_per_second_per_second(&self) -> f64 {
+        self.as_meters_per_second_per_second()
+    }
+}
+
+/// Acceleration * Time = Speed
+impl ::std::ops::Mul<Duration> for Acceleration {
+    type Output = Speed;
+
+    fn mul(self, rhs: Duration) -> Speed {
+        // 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);
+        Speed::from_meters_per_second(self.as_meters_per_second_per_second() * seconds)
+    }
+}
+
+/// Time * Acceleration = Speed
+impl ::std::ops::Mul<Acceleration> for Duration {
+    type Output = Speed;
+
+    fn mul(self, rhs: Acceleration) -> Speed {
+        rhs * self
+    }
+}
+
+impl Measurement for Acceleration {
+    fn get_base_units(&self) -> f64 {
+        self.meters_per_second_per_second
+    }
+
+    fn from_base_units(units: f64) -> Self {
+        Self::from_meters_per_second_per_second(units)
+    }
+
+    fn get_base_units_name(&self) -> &'static str {
+        "m/s\u{00B2}"
+    }
+}
+
+implement_measurement! { Acceleration }

src/length.rs

@@ -1,4 +1,6 @@
 use super::measurement::*;
+use std::time::Duration;
+use speed::Speed;
 
 // Constants, metric
 const METER_NANOMETER_FACTOR: f64 = 1000000000.0;
@@ -208,6 +210,28 @@ impl Length {
     }
 }
 
+/// Length / Time = Speed
+impl ::std::ops::Div<Duration> for Length {
+    type Output = Speed;
+
+    fn div(self, rhs: Duration) -> Speed {
+        // 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);
+        Speed::from_meters_per_second(self.as_meters() / seconds)
+    }
+}
+
+/// Length / Speed = Time
+impl ::std::ops::Div<Speed> for Length {
+    type Output = Duration;
+
+    fn div(self, rhs: Speed) -> Duration {
+        let seconds =  self.as_meters() / rhs.as_meters_per_second();
+        let nanosecs = (seconds * 1e9) % 1e9;
+        Duration::new(seconds as u64, nanosecs as u32)
+    }
+}
+
 impl Measurement for Length {
     fn get_base_units(&self) -> f64 {
         self.meters

src/lib.rs

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

src/speed.rs

@@ -1,5 +1,6 @@
 use super::measurement::*;
 use super::Length;
+use super::Acceleration;
 use std::time::Duration;
 
 /// The `Speed` struct can be used to deal with speeds in a common way.
@@ -62,13 +63,45 @@ impl Speed {
     }
 }
 
-impl ::std::ops::Div<Duration> for Length {
-    type Output = Speed;
+/// Speed / Acceleration = Time
+impl ::std::ops::Div<Acceleration> for Speed {
+    type Output = Duration;
 
-    fn div(self, rhs: Duration) -> Speed {
+    fn div(self, rhs: Acceleration) -> Duration {
+        let seconds =  self.as_meters_per_second() / rhs.as_meters_per_second_per_second();
+        let nanosecs = (seconds * 1e9) % 1e9;
+        Duration::new(seconds as u64, nanosecs as u32)
+    }
+}
+
+/// Speed / Time = Acceleration
+impl ::std::ops::Div<Duration> for Speed {
+    type Output = Acceleration;
+
+    fn div(self, rhs: Duration) -> Acceleration {
+        // 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);
+        Acceleration::from_meters_per_second_per_second(self.as_meters_per_second() / seconds)
+    }
+}
+
+/// Speed * Time = Length
+impl ::std::ops::Mul<Duration> for Speed {
+    type Output = Length;
+
+    fn mul(self, rhs: Duration) -> Length {
         // 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);
-        Speed::from_meters_per_second(self.as_meters() / seconds)
+        Length::from_meters(self.as_meters_per_second() * seconds)
+    }
+}
+
+/// Time * Speed = Length
+impl ::std::ops::Mul<Speed> for Duration {
+    type Output = Length;
+
+    fn mul(self, rhs: Speed) -> Length {
+        rhs * self
     }
 }
 

src/tests/acceleration_tests.rs

@@ -0,0 +1,76 @@
+use acceleration::*;
+use super::assert_almost_eq;
+use std::time::Duration;
+use speed::Speed;
+
+// Metric
+#[test]
+fn speed_over_time() {
+    let s1 = Speed::from_meters_per_second(10.0);
+    let t1 = Duration::new(5, 0);
+    let i1 = s1 / t1;
+    let r1 = i1.as_meters_per_second_per_second();
+    assert_almost_eq(r1, 2.0);
+}
+
+// Traits
+#[test]
+fn add() {
+    let a = Acceleration::from_meters_per_second_per_second(2.0);
+    let b = Acceleration::from_meters_per_second_per_second(4.0);
+    let c = a + b;
+    let d = b + a;
+    assert_almost_eq(c.as_meters_per_second_per_second(), 6.0);
+    assert_eq!(c, d);
+}
+
+#[test]
+fn sub() {
+    let a = Acceleration::from_meters_per_second_per_second(2.0);
+    let b = Acceleration::from_meters_per_second_per_second(4.0);
+    let c = a - b;
+    assert_almost_eq(c.as_meters_per_second_per_second(), -2.0);
+}
+
+#[test]
+fn mul() {
+    let a = Acceleration::from_meters_per_second_per_second(3.0);
+    let b = a * 2.0;
+    let c = 2.0 * a;
+    assert_almost_eq(b.as_meters_per_second_per_second(), 6.0);
+    assert_eq!(b, c);
+}
+
+#[test]
+fn div() {
+    let a = Acceleration::from_meters_per_second_per_second(2.0);
+    let b = Acceleration::from_meters_per_second_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_per_second(), 1.0);
+}
+
+#[test]
+fn eq() {
+    let a = Acceleration::from_meters_per_second_per_second(2.0);
+    let b = Acceleration::from_meters_per_second_per_second(2.0);
+    assert_eq!(a == b, true);
+}
+
+#[test]
+fn neq() {
+    let a = Acceleration::from_meters_per_second_per_second(2.0);
+    let b = Acceleration::from_meters_per_second_per_second(4.0);
+    assert_eq!(a == b, false);
+}
+
+#[test]
+fn cmp() {
+    let a = Acceleration::from_meters_per_second_per_second(2.0);
+    let b = Acceleration::from_meters_per_second_per_second(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

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

src/tests/speed_tests.rs

@@ -25,6 +25,15 @@ fn length_over_time() {
     assert_almost_eq(r1, 2.0);
 }
 
+#[test]
+fn acceleration() {
+    // To get to 100 m/s at 50 m/s/s takes 2.0 seconds
+    let s = Length::from_meters(100.0) / Duration::new(1, 0);
+    let a = Length::from_meters(50.0) / Duration::new(1, 0) / Duration::new(1, 0);
+    let t = s / a;
+    assert_eq!(t, Duration::new(2, 0));
+}
+
 #[test]
 fn kilometres_per_hour() {
     let i1 = Speed::from_metres_per_second(100.0);