Merge pull request #6 from thejpster/precision

Merging theJPster's latest changes (precision, new types, etc)

Author: James O'Cull

.gitignore

@@ -1,4 +1,4 @@
 target
 Cargo.lock
 *.bk
-
+.vscode

examples/format_test.rs

@@ -0,0 +1,26 @@
+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;
+
+fn main() {
+    for power in -12..12 {
+        let val: f64 = 123.456 * (10f64.powf(power as f64));
+        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!("Speed of {0:.3}", Speed::from_meters_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));
+    }
+}

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/energy.rs

@@ -0,0 +1,126 @@
+use super::measurement::*;
+use super::Power;
+use std::time::Duration;
+
+/// The `Energy` struct can be used to deal with energies in a common way.
+/// Common metric and imperial units are supported.
+///
+/// # Example
+///
+/// ```
+/// use measurements::Energy;
+///
+/// let energy = Energy::from_kcalories(2500.0);
+/// println!("Some say a health adult male should consume {} per day", energy);
+/// ```
+#[derive(Copy, Clone, Debug)]
+pub struct Energy {
+    joules: f64,
+}
+
+impl Energy {
+    pub fn from_joules(joules: f64) -> Energy {
+        Energy { joules: joules }
+    }
+
+    pub fn from_kcalories(kcalories: f64) -> Energy {
+        Self::from_joules(kcalories * 4186.8)
+    }
+
+    pub fn from_btu(btu: f64) -> Energy {
+        Self::from_joules(btu * 1055.056)
+    }
+
+    pub fn from_e_v(e_v: f64) -> Energy {
+        Self::from_joules(e_v / 6.241509479607718e+18)
+    }
+
+    pub fn from_watt_hours(wh: f64) -> Energy {
+        Self::from_joules(wh * 3600.0)
+    }
+
+    pub fn from_kilowatt_hours(kwh: f64) -> Energy {
+        Self::from_joules(kwh * 3600.0 * 1000.0)
+    }
+
+    pub fn as_joules(&self) -> f64 {
+        self.joules
+    }
+
+    pub fn as_kcalories(&self) -> f64 {
+        self.joules / 4186.8
+    }
+
+    pub fn as_btu(&self) -> f64 {
+        self.joules / 1055.056
+    }
+
+    pub fn as_e_v(&self) -> f64 {
+        self.joules * 6.241509479607718e+18
+    }
+
+    pub fn as_watt_hours(&self) -> f64 {
+        self.joules / 3600.0
+    }
+
+    pub fn as_kilowatt_hours(&self) -> f64 {
+        self.joules / (3600.0 * 1000.0)
+    }
+}
+
+/// Energy / Time = Power
+impl ::std::ops::Div<Duration> for Energy {
+    type Output = Power;
+
+    fn div(self, rhs: Duration) -> Power {
+        // 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);
+        Power::from_watts(self.as_joules() / seconds)
+    }
+}
+
+/// Energy / Power = Time
+impl ::std::ops::Div<Power> for Energy {
+    type Output = Duration;
+
+    fn div(self, rhs: Power) -> Duration {
+        let seconds =  self.as_joules() / rhs.as_watts();
+        let nanosecs = (seconds * 1e9) % 1e9;
+        Duration::new(seconds as u64, nanosecs as u32)
+    }
+}
+
+impl Measurement for Energy {
+    fn get_base_units(&self) -> f64 {
+        self.joules
+    }
+
+    fn from_base_units(units: f64) -> Self {
+        Self::from_joules(units)
+    }
+
+    fn get_base_units_name(&self) -> &'static str {
+        "J"
+    }
+
+    fn get_appropriate_units(&self) -> (&'static str, f64) {
+        // Smallest to Largest
+        let list = [
+            ("fJ", 1e-15),
+            ("pJ", 1e-12),
+            ("nJ", 1e-9),
+            ("\u{00B5}J", 1e-6),
+            ("mJ", 1e-3),
+            ("J", 1e0),
+            ("kJ", 1e3),
+            ("MJ", 1e6),
+            ("GJ", 1e9),
+            ("TJ", 1e12),
+            ("PJ", 1e15),
+            ("EJ", 1e18),
+        ];
+        self.pick_appropriate_units(&list)
+    }
+}
+
+implement_measurement! { Energy }