Ran cargo fmt.

Author: thejpster

examples/format_test.rs

@@ -20,7 +20,10 @@ fn main() {
         println!("Volume of {0:.3}", Volume::from_litres(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));

src/acceleration.rs

@@ -1,5 +1,5 @@
 use super::measurement::*;
-use super::{Force, Mass, Speed};
+use super::*;
 use std::time::Duration;
 
 /// The `Acceleration` struct can be used to deal with Accelerations in a common way.
@@ -32,23 +32,29 @@ impl Acceleration {
         Acceleration::from_meters_per_second_per_second(metres_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)
+    }
+
     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()
     }
+
+    pub fn as_feet_per_second_per_second(&self) -> f64 {
+        self.meters_per_second_per_second * length::METER_FEET_FACTOR
+    }
 }
 
 /// 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)
+        Speed::from_meters_per_second(self.as_meters_per_second_per_second() * duration_as_f64(rhs))
     }
 }
 

src/area.rs

@@ -1,6 +1,5 @@
 use super::measurement::*;
-use length;
-use volume;
+use super::*;
 
 const SQUARE_METER_ACRE_FACTOR: f64 = 4046.86;
 
@@ -33,47 +32,59 @@ impl Area {
     }
 
     pub fn from_square_nanometers(square_nanometers: f64) -> Self {
-        Self::from_square_meters(square_nanometers / (length::METER_NANOMETER_FACTOR * length::METER_NANOMETER_FACTOR))
+        Self::from_square_meters(
+            square_nanometers / (length::METER_NANOMETER_FACTOR * length::METER_NANOMETER_FACTOR),
+        )
     }
 
     pub fn from_square_nanometres(square_nanometres: f64) -> Self {
         Self::from_square_nanometers(square_nanometres)
     }
 
     pub fn from_square_micrometers(square_micrometers: f64) -> Self {
-        Self::from_square_meters(square_micrometers / (length::METER_MICROMETER_FACTOR * length::METER_MICROMETER_FACTOR))
+        Self::from_square_meters(
+            square_micrometers / (length::METER_MICROMETER_FACTOR * length::METER_MICROMETER_FACTOR),
+        )
     }
 
     pub fn from_square_micrometres(square_micrometres: f64) -> Self {
         Self::from_square_micrometers(square_micrometres)
     }
 
     pub fn from_square_millimeters(square_millimeters: f64) -> Self {
-        Self::from_square_meters(square_millimeters / (length::METER_MILLIMETER_FACTOR * length::METER_MILLIMETER_FACTOR))
+        Self::from_square_meters(
+            square_millimeters / (length::METER_MILLIMETER_FACTOR * length::METER_MILLIMETER_FACTOR),
+        )
     }
 
     pub fn from_square_millimetres(square_millimetres: f64) -> Self {
         Self::from_square_millimeters(square_millimetres)
     }
 
     pub fn from_square_centimeters(square_centimeters: f64) -> Self {
-        Self::from_square_meters(square_centimeters / (length::METER_CENTIMETER_FACTOR * length::METER_CENTIMETER_FACTOR))
+        Self::from_square_meters(
+            square_centimeters / (length::METER_CENTIMETER_FACTOR * length::METER_CENTIMETER_FACTOR),
+        )
     }
 
     pub fn from_square_centimetres(square_centimetres: f64) -> Self {
         Self::from_square_centimeters(square_centimetres)
     }
 
     pub fn from_square_decameters(square_decameters: f64) -> Self {
-        Self::from_square_meters(square_decameters / (length::METER_DECAMETER_FACTOR * length::METER_DECAMETER_FACTOR))
+        Self::from_square_meters(
+            square_decameters / (length::METER_DECAMETER_FACTOR * length::METER_DECAMETER_FACTOR),
+        )
     }
 
     pub fn from_square_decametres(square_decametres: f64) -> Self {
         Self::from_square_decameters(square_decametres)
     }
 
     pub fn from_square_hectometers(square_hectometers: f64) -> Self {
-        Self::from_square_meters(square_hectometers / (length::METER_HECTOMETER_FACTOR * length::METER_HECTOMETER_FACTOR))
+        Self::from_square_meters(
+            square_hectometers / (length::METER_HECTOMETER_FACTOR * length::METER_HECTOMETER_FACTOR),
+        )
     }
 
     pub fn from_square_hectometres(square_hectometres: f64) -> Self {
@@ -85,7 +96,9 @@ impl Area {
     }
 
     pub fn from_square_kilometers(square_kilometers: f64) -> Self {
-        Self::from_square_meters(square_kilometers / (length::METER_KILOMETER_FACTOR * length::METER_KILOMETER_FACTOR))
+        Self::from_square_meters(
+            square_kilometers / (length::METER_KILOMETER_FACTOR * length::METER_KILOMETER_FACTOR),
+        )
     }
 
     pub fn from_square_kilometres(square_kilometres: f64) -> Self {
@@ -94,52 +107,60 @@ impl Area {
 
     // Inputs, imperial
     pub fn from_square_inches(square_inches: f64) -> Self {
-        Self::from_square_meters(square_inches / (length::METER_INCH_FACTOR * length::METER_INCH_FACTOR))
+        Self::from_square_meters(
+            square_inches / (length::METER_INCH_FACTOR * length::METER_INCH_FACTOR),
+        )
     }
 
     pub fn from_square_feet(square_feet: f64) -> Self {
-        Self::from_square_meters(square_feet / (length::METER_FEET_FACTOR * length::METER_FEET_FACTOR))
+        Self::from_square_meters(
+            square_feet / (length::METER_FEET_FACTOR * length::METER_FEET_FACTOR),
+        )
     }
 
     pub fn from_square_yards(square_yards: f64) -> Self {
-        Self::from_square_meters(square_yards / (length::METER_YARD_FACTOR * length::METER_YARD_FACTOR))
+        Self::from_square_meters(
+            square_yards / (length::METER_YARD_FACTOR * length::METER_YARD_FACTOR),
+        )
     }
 
     pub fn from_acres(acres: f64) -> Self {
         Self::from_square_meters(acres / SQUARE_METER_ACRE_FACTOR)
     }
 
     pub fn from_square_miles(square_miles: f64) -> Self {
-        Self::from_square_meters(square_miles / (length::METER_MILE_FACTOR * length::METER_MILE_FACTOR))
+        Self::from_square_meters(
+            square_miles / (length::METER_MILE_FACTOR * length::METER_MILE_FACTOR),
+        )
     }
 
     // Outputs, metric
     pub fn as_square_nanometers(&self) -> f64 {
-        self.square_meters * length::METER_NANOMETER_FACTOR * length::METER_NANOMETER_FACTOR
+        self.square_meters * (length::METER_NANOMETER_FACTOR * length::METER_NANOMETER_FACTOR)
     }
 
     pub fn as_square_nanometres(&self) -> f64 {
         self.as_square_nanometers()
     }
 
     pub fn as_square_micrometers(&self) -> f64 {
-        self.square_meters * length::METER_MICROMETER_FACTOR * length::METER_MICROMETER_FACTOR
+        self.square_meters * (length::METER_MICROMETER_FACTOR * length::METER_MICROMETER_FACTOR)
     }
 
     pub fn as_square_micrometres(&self) -> f64 {
         self.as_square_micrometers()
     }
 
     pub fn as_square_millimeters(&self) -> f64 {
-        self.square_meters * length::METER_MILLIMETER_FACTOR * length::METER_MILLIMETER_FACTOR
+        self.square_meters * (length::METER_MILLIMETER_FACTOR * length::METER_MILLIMETER_FACTOR)
     }
 
     pub fn as_square_millimetres(&self) -> f64 {
         self.as_square_millimeters()
     }
 
     pub fn as_square_centimeters(&self) -> f64 {
-        self.square_meters * length::METER_CENTIMETER_FACTOR * length::METER_CENTIMETER_FACTOR
+        self.square_meters * (length::METER_CENTIMETER_FACTOR * length::METER_CENTIMETER_FACTOR)
     }
 
     pub fn as_square_centimetres(&self) -> f64 {
@@ -155,15 +176,15 @@ impl Area {
     }
 
     pub fn as_square_decameters(&self) -> f64 {
-        self.square_meters * length::METER_DECAMETER_FACTOR * length::METER_DECAMETER_FACTOR
+        self.square_meters * (length::METER_DECAMETER_FACTOR * length::METER_DECAMETER_FACTOR)
     }
 
     pub fn as_square_decametres(&self) -> f64 {
         self.as_square_decameters()
     }
 
     pub fn as_square_hectometers(&self) -> f64 {
-        self.square_meters * length::METER_HECTOMETER_FACTOR * length::METER_HECTOMETER_FACTOR
+        self.square_meters * (length::METER_HECTOMETER_FACTOR * length::METER_HECTOMETER_FACTOR)
     }
 
     pub fn as_square_hectometres(&self) -> f64 {
@@ -175,7 +196,7 @@ impl Area {
     }
 
     pub fn as_square_kilometers(&self) -> f64 {
-        self.square_meters * length::METER_KILOMETER_FACTOR * length::METER_KILOMETER_FACTOR
+        self.square_meters * (length::METER_KILOMETER_FACTOR * length::METER_KILOMETER_FACTOR)
     }
 
     pub fn as_square_kilometres(&self) -> f64 {
@@ -184,41 +205,50 @@ impl Area {
 
     // Outputs, imperial
     pub fn as_square_inches(&self) -> f64 {
-        self.square_meters * length::METER_INCH_FACTOR * length::METER_INCH_FACTOR
+        self.square_meters * (length::METER_INCH_FACTOR * length::METER_INCH_FACTOR)
     }
 
     pub fn as_square_feet(&self) -> f64 {
-        self.square_meters * length::METER_FEET_FACTOR * length::METER_FEET_FACTOR
+        self.square_meters * (length::METER_FEET_FACTOR * length::METER_FEET_FACTOR)
     }
 
     pub fn as_square_yards(&self) -> f64 {
-        self.square_meters * length::METER_YARD_FACTOR * length::METER_YARD_FACTOR
+        self.square_meters * (length::METER_YARD_FACTOR * length::METER_YARD_FACTOR)
     }
 
     pub fn as_acres(&self) -> f64 {
         self.square_meters * SQUARE_METER_ACRE_FACTOR
     }
 
     pub fn as_square_miles(&self) -> f64 {
-        self.square_meters * length::METER_MILE_FACTOR * length::METER_MILE_FACTOR
+        self.square_meters * (length::METER_MILE_FACTOR * length::METER_MILE_FACTOR)
     }
 }
 
 /// Area / Length = Length
-impl ::std::ops::Div<length::Length> for Area {
-    type Output = length::Length;
+impl ::std::ops::Div<Length> for Area {
+    type Output = Length;
 
-    fn div(self, rhs: length::Length) -> length::Length {
-        length::Length::from_meters(self.as_square_meters() / rhs.as_meters())
+    fn div(self, rhs: Length) -> Length {
+        Length::from_meters(self.as_square_meters() / rhs.as_meters())
     }
 }
 
 /// Area * Length = Volume
-impl ::std::ops::Mul<length::Length> for Area {
-    type Output = volume::Volume;
+impl ::std::ops::Mul<Length> for Area {
+    type Output = Volume;
 
-    fn mul(self, rhs: length::Length) -> volume::Volume {
-        volume::Volume::from_cubic_meters(self.as_square_meters() * rhs.as_meters())
+    fn mul(self, rhs: Length) -> Volume {
+        Volume::from_cubic_meters(self.as_square_meters() * rhs.as_meters())
+    }
+}
+
+/// Area * Pressure = Force
+impl ::std::ops::Mul<Pressure> for Area {
+    type Output = Force;
+
+    fn mul(self, rhs: Pressure) -> Force {
+        Force::from_newtons(self.as_square_meters() * rhs.as_pascals())
     }
 }
 

src/energy.rs

@@ -1,5 +1,5 @@
 use super::measurement::*;
-use super::Power;
+use super::*;
 use std::time::Duration;
 
 /// The `Energy` struct can be used to deal with energies in a common way.
@@ -73,9 +73,7 @@ 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)
+        Power::from_watts(self.as_joules() / duration_as_f64(rhs))
     }
 }
 
@@ -84,12 +82,30 @@ 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 seconds = self.as_joules() / rhs.as_watts();
         let nanosecs = (seconds * 1e9) % 1e9;
         Duration::new(seconds as u64, nanosecs as u32)
     }
 }
 
+/// Energy / Length = Force
+impl ::std::ops::Div<Length> for Energy {
+    type Output = Force;
+
+    fn div(self, rhs: Length) -> Force {
+        Force::from_newtons(self.as_joules() / rhs.as_meters())
+    }
+}
+
+/// Energy / Force = Length
+impl ::std::ops::Div<Force> for Energy {
+    type Output = Length;
+
+    fn div(self, rhs: Force) -> Length {
+        Length::from_meters(self.as_joules() / rhs.as_newtons())
+    }
+}
+
 impl Measurement for Energy {
     fn get_base_units(&self) -> f64 {
         self.joules

src/force.rs

@@ -1,5 +1,5 @@
 use super::measurement::*;
-use super::{Acceleration, Area, Mass, Pressure};
+use super::*;
 
 /// The `Force` struct can be used to deal with force in a common way.
 ///
@@ -125,6 +125,15 @@ impl ::std::ops::Div<Pressure> for Force {
     }
 }
 
+/// Force * Length = Energy
+impl ::std::ops::Mul<Length> for Force {
+    type Output = Energy;
+
+    fn mul(self, rhs: Length) -> Energy {
+        Energy::from_joules(self.as_newtons() * rhs.as_meters())
+    }
+}
+
 impl Measurement for Force {
     fn get_base_units(&self) -> f64 {
         self.newtons
@@ -152,7 +161,6 @@ impl Measurement for Force {
         ];
         self.pick_appropriate_units(&list)
     }
-
 }
 
 implement_measurement! { Force }