Added Torque and TorqueEnergy.

Author: thejpster

examples/engine.rs

@@ -0,0 +1,16 @@
+extern crate measurements;
+use measurements::{Power, AngularVelocity};
+
+fn main() {
+    let power = Power::from_ps(225.0);
+    let peak_revs = AngularVelocity::from_rpm(6000.0);
+    let torque = power / peak_revs;
+    println!(
+        "At {:.0} rpm, a {:.1} ({:.1} PS) engine, produces {:.1} ({:.1} lbf·ft)",
+        peak_revs.as_rpm(),
+        power,
+        power.as_ps(),
+        torque,
+        torque.as_pound_foot()
+    );
+}

src/angular_velocity.rs

@@ -0,0 +1,85 @@
+//! Types and constants for handling speed of rotation (angular velocity)
+
+use super::measurement::*;
+use std::f64::consts::PI;
+
+/// The 'AngularVelocity' struct can be used to deal with angular velocities in a common way.
+///
+/// # Example
+///
+/// ```
+/// use measurements::AngularVelocity;
+///
+/// const cylinders: f64 = 6.0;
+/// let engine_speed = AngularVelocity::from_rpm(9000.0);
+/// let sparks_per_second = (engine_speed.as_hertz() / 2.0) * cylinders;
+/// ```
+#[derive(Copy, Clone, Debug)]
+pub struct AngularVelocity {
+    radians_per_second: f64,
+}
+
+impl AngularVelocity {
+    /// Create a new AngularVelocity from a floating point value in radians per second
+    pub fn from_radians_per_second(radians_per_second: f64) -> Self {
+        AngularVelocity { radians_per_second: radians_per_second }
+    }
+
+    /// Create a new AngularVelocity from a floating point value in revolutions per minute (RPM)
+    pub fn from_rpm(rpm: f64) -> Self {
+        let revs_per_second = rpm / 60.0;
+        AngularVelocity::from_radians_per_second(revs_per_second * PI * 2.0)
+    }
+
+    /// Create a new AngularVelocity from a floating point value in revolutions per second (Hz)
+    pub fn from_hertz(hz: f64) -> Self {
+        AngularVelocity::from_radians_per_second(hz * PI * 2.0)
+    }
+
+    /// Convert this AngularVelocity to a floating point value in radians per second
+    pub fn as_radians_per_second(&self) -> f64 {
+        self.radians_per_second
+    }
+
+    /// Convert this AngularVelocity to a floating point value in degrees
+    pub fn as_rpm(&self) -> f64 {
+        (self.radians_per_second * 60.0) / (2.0 * PI)
+    }
+
+    /// Convert this AngularVelocity to a floating point value in revolutions per second (Hz)
+    pub fn as_hertz(&self) -> f64 {
+        self.radians_per_second / (2.0 * PI)
+    }
+}
+
+impl Measurement for AngularVelocity {
+    fn as_base_units(&self) -> f64 {
+        self.radians_per_second
+    }
+
+    fn from_base_units(units: f64) -> Self {
+        Self::from_radians_per_second(units)
+    }
+
+    fn as_base_units_name(&self) -> &'static str {
+        "rad/s"
+    }
+}
+
+implement_measurement! { AngularVelocity }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use test_utils::assert_almost_eq;
+
+    #[test]
+    fn rpm() {
+        let i1 = AngularVelocity::from_rpm(6000.0);
+        let r1 = i1.as_radians_per_second();
+        let i2 = AngularVelocity::from_radians_per_second(100.0);
+        let r2 = i2.as_rpm();
+        assert_almost_eq(r1, 628.31853);
+        assert_almost_eq(r2, 954.929659642538);
+    }
+}

src/lib.rs

@@ -51,8 +51,19 @@ pub use angle::Angle;
 pub mod frequency;
 pub use frequency::Frequency;
 
+pub mod angular_velocity;
+pub use angular_velocity::AngularVelocity;
+
+pub mod torque;
+pub use torque::Torque;
+
 pub mod prelude;
 
+mod torque_energy;
+pub use torque_energy::TorqueEnergy;
+
+pub mod test_utils;
+
 /// For given types A, B and C, implement, using base units:
 ///     - A = B * C
 ///     - A = C * B
@@ -129,13 +140,51 @@ impl Measurement for std::time::Duration {
 }
 
 impl_maths!(Area, Length);
-impl_maths!(Energy, Force, Length);
 impl_maths!(Energy, std::time::Duration, Power);
 impl_maths!(Force, Mass, Acceleration);
 impl_maths!(Force, Pressure, Area);
 impl_maths!(Length, std::time::Duration, Speed);
 impl_maths!(Power, Force, Speed);
 impl_maths!(Speed, std::time::Duration, Acceleration);
 impl_maths!(Volume, Length, Area);
+impl_maths!(Power, AngularVelocity, Torque);
 
-pub mod test_utils;
+// Force * Distance is ambiguous. Create an ambiguous struct the user can then
+// cast into either Torque or Energy.
+
+impl_maths!(TorqueEnergy, Force, Length);
+
+// Implement the divisions manually (the above macro only implemented the
+// TorqueEnergy / X operations).
+
+impl ::std::ops::Div<Length> for Torque {
+    type Output = Force;
+
+    fn div(self, rhs: Length) -> Self::Output {
+        Self::Output::from_base_units(self.as_base_units() / rhs.as_base_units())
+    }
+}
+
+impl ::std::ops::Div<Force> for Torque {
+    type Output = Length;
+
+    fn div(self, rhs: Force) -> Self::Output {
+        Self::Output::from_base_units(self.as_base_units() / rhs.as_base_units())
+    }
+}
+
+impl ::std::ops::Div<Length> for Energy {
+    type Output = Force;
+
+    fn div(self, rhs: Length) -> Self::Output {
+        Self::Output::from_base_units(self.as_base_units() / rhs.as_base_units())
+    }
+}
+
+impl ::std::ops::Div<Force> for Energy {
+    type Output = Length;
+
+    fn div(self, rhs: Force) -> Self::Output {
+        Self::Output::from_base_units(self.as_base_units() / rhs.as_base_units())
+    }
+}

src/speed.rs

@@ -108,7 +108,6 @@ impl Measurement for Speed {
         ];
         self.pick_appropriate_units(&list)
     }
-
 }
 
 implement_measurement! { Speed }

src/torque.rs

@@ -0,0 +1,85 @@
+//! Types and constants for handling torque
+
+use super::measurement::*;
+
+/// Number of pound-foot in a newton-metre
+const NEWTON_METRE_POUND_FOOT_FACTOR: f64 = 0.73756326522588;
+
+/// The 'Torque' struct can be used to deal with torque in a common way.
+///
+/// # Example
+///
+/// ```
+/// use measurements::Torque;
+///
+/// let engine_torque = Torque::from_pound_foot(250.0);
+/// println!("In metric, that's {} Nm", engine_torque.as_newton_metres());
+/// ```
+#[derive(Copy, Clone, Debug)]
+pub struct Torque {
+    newton_metres: f64,
+}
+
+impl Torque {
+    /// Create a new Torque from a floating point value in newton metres
+    pub fn from_newton_metres(newton_metres: f64) -> Self {
+        Torque { newton_metres: newton_metres }
+    }
+
+    /// Create a new Torque from a floating point value in newton meters
+    pub fn from_newton_meters(newton_meters: f64) -> Self {
+        Torque::from_newton_metres(newton_meters)
+    }
+
+    /// Create a new Torque from a floating point value in pound-foot (lbf.ft)
+    pub fn from_pound_foot(pound_foot: f64) -> Self {
+        Torque::from_newton_metres(pound_foot / NEWTON_METRE_POUND_FOOT_FACTOR)
+    }
+
+    /// Convert this Torque to a floating point value in newton metres
+    pub fn as_newton_metres(&self) -> f64 {
+        self.newton_metres
+    }
+
+    /// Convert this Torque to a floating point value in newton meters
+    pub fn as_newton_meters(&self) -> f64 {
+        self.newton_metres
+    }
+
+    /// Convert this Torque to a floating point value in pound-foot (lbf-ft)
+    pub fn as_pound_foot(&self) -> f64 {
+        self.newton_metres * NEWTON_METRE_POUND_FOOT_FACTOR
+    }
+}
+
+impl Measurement for Torque {
+    fn as_base_units(&self) -> f64 {
+        self.newton_metres
+    }
+
+    fn from_base_units(units: f64) -> Self {
+        Self::from_newton_metres(units)
+    }
+
+    fn as_base_units_name(&self) -> &'static str {
+        "Nm"
+    }
+}
+
+implement_measurement! { Torque }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use test_utils::assert_almost_eq;
+
+    #[test]
+    fn lbf_ft() {
+        let i1 = Torque::from_pound_foot(250.0);
+        let r1 = i1.as_newton_metres();
+        let i2 = Torque::from_newton_metres(300.0);
+        let r2 = i2.as_pound_foot();
+        assert_almost_eq(r1, 338.954);
+        assert_almost_eq(r2, 221.269);
+    }
+}

src/torque_energy.rs

@@ -0,0 +1,38 @@
+//! Implements a bridging structure to distinguish between Torque and Energy
+
+use super::*;
+
+/// If you multiply a Force by a Length, we can't tell if you're
+/// pushing something along (which requires Energy) or rotating
+/// something (which creates a Torque). This struct is what results
+/// from the multiplication, and you have to then convert
+/// it to whichever you want.
+pub struct TorqueEnergy {
+    newton_metres: f64,
+}
+
+impl std::convert::From<TorqueEnergy> for Torque {
+    fn from(t: TorqueEnergy) -> Torque {
+        Torque::from_newton_metres(t.newton_metres)
+    }
+}
+
+impl std::convert::From<TorqueEnergy> for Energy {
+    fn from(t: TorqueEnergy) -> Energy {
+        Energy::from_joules(t.newton_metres)
+    }
+}
+
+impl Measurement for TorqueEnergy {
+    fn as_base_units(&self) -> f64 {
+        self.newton_metres
+    }
+
+    fn from_base_units(units: f64) -> Self {
+        TorqueEnergy { newton_metres: units }
+    }
+
+    fn as_base_units_name(&self) -> &'static str {
+        "Nm||J"
+    }
+}

tests/torque_and_energy.rs

@@ -0,0 +1,26 @@
+extern crate measurements;
+
+use measurements::*;
+
+#[test]
+fn create() -> () {
+    let f = Force::from_newtons(10.0);
+    let d = Length::from_metres(1.0);
+    let w: Energy = Energy::from(f * d);
+    let t: Torque = Torque::from(f * d);
+    println!("That's {} as energy", w);
+    println!("That's {} as torque", t);
+}
+
+#[test]
+fn divide() -> () {
+    let w = Energy::from_joules(100.0);
+    let d = Length::from_metres(10.0);
+    let f: Force = w / d;
+    test_utils::assert_almost_eq(f.as_newtons(), 10.0);
+
+    let t = Torque::from_newton_metres(100.0);
+    let d = Length::from_metres(10.0);
+    let f: Force = t / d;
+    test_utils::assert_almost_eq(f.as_newtons(), 10.0);
+}