Merge pull request #8 from thejpster/weight_and_mass

Split weight into mass and force, and add area.

Author: James O'Cull

.gitignore

@@ -2,3 +2,4 @@ target
 Cargo.lock
 *.bk
 .vscode
+*.sublime-workspace

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "measurements"
-version = "0.5.0"
+version = "0.6.0"
 authors = ["James O'Cull <[email protected]>",
           "Jonathan Pallant <[email protected]>",
           "Hannah McLaughlin <[email protected]>"]

clippy.toml

@@ -0,0 +1 @@
+doc-valid-idents = ["MHz", "THz", "GHz", "kHz"]

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()
+    );
+}

examples/format_test.rs

@@ -1,28 +1,28 @@
 extern crate measurements;
-use measurements::Temperature;
-use measurements::Length;
-use measurements::Pressure;
-use measurements::Volume;
-use measurements::Weight;
-use measurements::Speed;
-use measurements::Acceleration;
-use measurements::Energy;
-use measurements::Power;
-use measurements::Data;
+use measurements::*;
 
 fn main() {
     for power in -12..12 {
-        let val: f64 = 123.456 * (10f64.powf(power as f64));
+        let val: f64 = 123.456 * (10f64.powf(f64::from(power)));
         println!("10^{}...", power);
         println!("Temp of {0:.3} outside", Temperature::from_kelvin(val));
         println!("Distance of {0:.3}", Length::from_meters(val));
         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!("Mass of {0:.3}", Mass::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));
+        println!(
+            "Acceleration of {0:.3}",
+            Acceleration::from_meters_per_second_per_second(val)
+        );
         println!("Energy of {0:.3}", Energy::from_joules(val));
         println!("Power of {0:.3}", Power::from_watts(val));
+        println!("Force of {0:.3}", Force::from_newtons(val));
+        println!("Force of {0:.3}", Torque::from_newton_metres(val));
+        println!(
+            "Force of {0:.3}",
+            AngularVelocity::from_radians_per_second(val)
+        );
         println!("Data size is {0:.3}", Data::from_octets(val));
     }
 }

examples/frequency.rs

@@ -0,0 +1,16 @@
+extern crate measurements;
+
+fn main() {
+    // Sinusiodal Oscilator moves at 5 Hz across 50 mm
+    let f = measurements::Frequency::from_hertz(5.0);
+    let d = measurements::Distance::from_millimeters(50.0);
+    // Speed = PI * Frequency * Displacement
+    // Speed = PI * Displacement / Period
+    let v = ::std::f64::consts::PI * d / f.as_period();
+    println!(
+        "Maximum speed of a pendulum at {:.1} with max displacement {:.1} is {:.1}",
+        f,
+        d,
+        v
+    );
+}

src/acceleration.rs

@@ -1,6 +1,7 @@
+//! Types and constants for handling acceleration.
+
 use super::measurement::*;
-use super::Speed;
-use std::time::Duration;
+use super::length;
 
 /// The `Acceleration` struct can be used to deal with Accelerations in a common way.
 /// Common metric and imperial units are supported.
@@ -15,7 +16,7 @@ use std::time::Duration;
 /// 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;
+/// let accel: Acceleration = finish / time;
 /// println!("You accelerated over {} at an average of {}", track, accel);
 /// ```
 #[derive(Copy, Clone, Debug)]
@@ -24,45 +25,41 @@ pub struct Acceleration {
 }
 
 impl Acceleration {
+    /// Create a new Acceleration from a floating point value in meters per second per second
     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 }
     }
 
+    /// Create a new Acceleration from a floating point value in metres 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)
     }
 
+    /// Create a new Acceleration from a floating point value in feet per second per second
+    pub fn from_feet_per_second_per_second(feet_per_second_per_second: f64) -> Acceleration {
+        Acceleration::from_metres_per_second_per_second(
+            feet_per_second_per_second / length::METER_FEET_FACTOR,
+        )
+    }
+
+    /// Convert this Acceleration to a value in meters per second per second
     pub fn as_meters_per_second_per_second(&self) -> f64 {
         self.meters_per_second_per_second
     }
 
+    /// Convert this Acceleration to a value in metres 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
+    /// Convert this Acceleration to a value in feet per second per second
+    pub fn as_feet_per_second_per_second(&self) -> f64 {
+        self.meters_per_second_per_second * length::METER_FEET_FACTOR
     }
 }
 
 impl Measurement for Acceleration {
-    fn get_base_units(&self) -> f64 {
+    fn as_base_units(&self) -> f64 {
         self.meters_per_second_per_second
     }
 
@@ -76,3 +73,85 @@ impl Measurement for Acceleration {
 }
 
 implement_measurement! { Acceleration }
+
+#[cfg(test)]
+mod test {
+
+    use super::*;
+    use test_utils::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/angle.rs

@@ -0,0 +1,110 @@
+//! Types and constants for handling angles
+
+use super::measurement::*;
+
+/// The 'Angle' struct can be used to deal with angles in a common way.
+///
+/// # Example
+///
+/// ```
+/// use measurements::Angle;
+///
+/// let whole_cake = Angle::from_degrees(360.0);
+/// let pieces = 6.0;
+/// let slice = whole_cake / pieces;
+/// println!("Each slice will be {} degrees", slice.as_degrees());
+/// ```
+#[derive(Copy, Clone, Debug)]
+pub struct Angle {
+    radians: f64,
+}
+
+impl Angle {
+    /// Create a new Angle from a floating point value in degrees
+    pub fn from_degrees(degrees: f64) -> Self {
+        Angle::from_radians(degrees.to_radians())
+    }
+
+    /// Create a new Angle from a floating point value in radians
+    pub fn from_radians(radians: f64) -> Self {
+        Angle { radians: radians }
+    }
+
+    /// Convert this Angle to a floating point value in degrees
+    pub fn as_degrees(&self) -> f64 {
+        self.radians.to_degrees()
+    }
+
+    /// Convert this Angle to a floating point value in radians
+    pub fn as_radians(&self) -> f64 {
+        self.radians
+    }
+
+    /// Calculate the cosine of this angle
+    pub fn cos(&self) -> f64 {
+        self.radians.cos()
+    }
+
+    /// Calculate the sine of this angle
+    pub fn sin(&self) -> f64 {
+        self.radians.sin()
+    }
+
+    /// Calculate the sine and cosine of this angle
+    pub fn sin_cos(&self) -> (f64, f64) {
+        self.radians.sin_cos()
+    }
+
+    /// Calculate the tangent of this angle
+    pub fn tan(&self) -> f64 {
+        self.radians.tan()
+    }
+
+    /// Calculate the arcsine of a number
+    pub fn asin(num: f64) -> Self {
+        Angle::from_radians(num.asin())
+    }
+
+    /// Calculate the arccosine of a number
+    pub fn acos(num: f64) -> Self {
+        Angle::from_radians(num.acos())
+    }
+
+    /// Calculate the arctangent of a number
+    pub fn atan(num: f64) -> Self {
+        Angle::from_radians(num.atan())
+    }
+}
+
+impl Measurement for Angle {
+    fn as_base_units(&self) -> f64 {
+        self.radians
+    }
+
+    fn from_base_units(units: f64) -> Self {
+        Self::from_radians(units)
+    }
+
+    fn get_base_units_name(&self) -> &'static str {
+        "rad"
+    }
+}
+
+implement_measurement! { Angle }
+
+#[cfg(test)]
+mod test {
+    use angle::*;
+    use std::f64::consts::PI;
+    use test_utils::assert_almost_eq;
+
+    #[test]
+    fn radians() {
+        let i1 = Angle::from_degrees(360.0);
+        let r1 = i1.as_radians();
+        let i2 = Angle::from_radians(PI);
+        let r2 = i2.as_degrees();
+        assert_almost_eq(r1, 2.0 * PI);
+        assert_almost_eq(r2, 180.0);
+    }
+}