More updates.

Switch deca for deci (more common?)
Added area tests.
Fix for issue #1.

Author: thejpster

src/area.rs

@@ -1,7 +1,7 @@
 use super::measurement::*;
 use super::length;
 
-const SQUARE_METER_ACRE_FACTOR: f64 = 4046.86;
+const SQUARE_METER_ACRE_FACTOR: f64 = 1.0 / 4046.86;
 
 /// The `Area` struct can be used to deal with areas in a common way.
 /// Common metric and imperial units are supported.
@@ -71,14 +71,14 @@ impl Area {
         Self::from_square_centimeters(square_centimetres)
     }
 
-    pub fn from_square_decameters(square_decameters: f64) -> Self {
+    pub fn from_square_decimeters(square_decimeters: f64) -> Self {
         Self::from_square_meters(
-            square_decameters / (length::METER_DECAMETER_FACTOR * length::METER_DECAMETER_FACTOR),
+            square_decimeters / (length::METER_DECIMETER_FACTOR * length::METER_DECIMETER_FACTOR),
         )
     }
 
-    pub fn from_square_decametres(square_decametres: f64) -> Self {
-        Self::from_square_decameters(square_decametres)
+    pub fn from_square_decimetres(square_decimetres: f64) -> Self {
+        Self::from_square_decimeters(square_decimetres)
     }
 
     pub fn from_square_hectometers(square_hectometers: f64) -> Self {
@@ -175,12 +175,12 @@ impl Area {
         self.as_square_meters()
     }
 
-    pub fn as_square_decameters(&self) -> f64 {
-        self.square_meters * (length::METER_DECAMETER_FACTOR * length::METER_DECAMETER_FACTOR)
+    pub fn as_square_decimeters(&self) -> f64 {
+        self.square_meters * (length::METER_DECIMETER_FACTOR * length::METER_DECIMETER_FACTOR)
     }
 
-    pub fn as_square_decametres(&self) -> f64 {
-        self.as_square_decameters()
+    pub fn as_square_decimetres(&self) -> f64 {
+        self.as_square_decimeters()
     }
 
     pub fn as_square_hectometers(&self) -> f64 {

src/length.rs

@@ -5,7 +5,7 @@ pub const METER_NANOMETER_FACTOR: f64 = 1000000000.0;
 pub const METER_MICROMETER_FACTOR: f64 = 1000000.0;
 pub const METER_MILLIMETER_FACTOR: f64 = 1000.0;
 pub const METER_CENTIMETER_FACTOR: f64 = 100.0;
-pub const METER_DECAMETER_FACTOR: f64 = 0.1;
+pub const METER_DECIMETER_FACTOR: f64 = 10.0;
 pub const METER_HECTOMETER_FACTOR: f64 = 0.01;
 pub const METER_KILOMETER_FACTOR: f64 = 0.001;
 
@@ -76,12 +76,12 @@ impl Length {
         Self::from_centimeters(centimeters)
     }
 
-    pub fn from_decameters(decameters: f64) -> Self {
-        Self::from_meters(decameters / METER_DECAMETER_FACTOR)
+    pub fn from_decimeters(decimeters: f64) -> Self {
+        Self::from_meters(decimeters / METER_DECIMETER_FACTOR)
     }
 
-    pub fn from_decametres(decameters: f64) -> Self {
-        Self::from_decameters(decameters)
+    pub fn from_decimetres(decimeters: f64) -> Self {
+        Self::from_decimeters(decimeters)
     }
 
     pub fn from_hectometers(hectometers: f64) -> Self {
@@ -162,12 +162,12 @@ impl Length {
         self.as_meters()
     }
 
-    pub fn as_decameters(&self) -> f64 {
-        self.meters * METER_DECAMETER_FACTOR
+    pub fn as_decimeters(&self) -> f64 {
+        self.meters * METER_DECIMETER_FACTOR
     }
 
-    pub fn as_decametres(&self) -> f64 {
-        self.as_decameters()
+    pub fn as_decimetres(&self) -> f64 {
+        self.as_decimeters()
     }
 
     pub fn as_hectometers(&self) -> f64 {

src/measurement.rs

@@ -69,11 +69,9 @@ macro_rules! implement_display {
 
         impl ::std::fmt::Display for $t {
             fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-                let p = f.precision().unwrap_or(1);
-                let w = f.width().unwrap_or(0);
                 let (unit, value) = self.get_appropriate_units();
-                write!(f, "{value:width$.prec$}\u{00A0}{unit}",
-                    prec=p, width=w, value=value, unit=unit)
+                value.fmt(f)?;
+                write!(f, "\u{00A0}{0}", unit)
             }
         }
     )*)

src/tests/area_tests.rs

@@ -0,0 +1,222 @@
+use area::*;
+use super::assert_almost_eq;
+
+#[test]
+fn square_meters() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_square_meters();
+	let i2 = Area::from_square_meters(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 100.0);
+	assert_almost_eq(r2, 100.0);
+}
+
+#[test]
+fn square_metres() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_square_metres();
+	let i2 = Area::from_square_metres(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 100.0);
+	assert_almost_eq(r2, 100.0);
+}
+
+#[test]
+fn square_nanometers() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_square_nanometers();
+	let i2 = Area::from_square_nanometers(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 1e20);
+	assert_almost_eq(r2, 1e-16);
+}
+
+#[test]
+fn square_nanometres() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_square_nanometres();
+	let i2 = Area::from_square_nanometres(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 1e20);
+	assert_almost_eq(r2, 1e-16);
+}
+
+#[test]
+fn square_micrometers() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_square_micrometers();
+	let i2 = Area::from_square_micrometers(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 1e14);
+	assert_almost_eq(r2, 1e-10);
+}
+
+#[test]
+fn square_micrometres() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_square_micrometres();
+	let i2 = Area::from_square_micrometres(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 1e14);
+	assert_almost_eq(r2, 1e-10);
+}
+
+#[test]
+fn square_millimeters() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_square_millimeters();
+	let i2 = Area::from_square_millimeters(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 1e8);
+	assert_almost_eq(r2, 1e-4);
+}
+
+#[test]
+fn square_millimetres() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_square_millimetres();
+	let i2 = Area::from_square_millimetres(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 1e8);
+	assert_almost_eq(r2, 1e-4);
+}
+
+#[test]
+fn square_centimeters() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_square_centimeters();
+	let i2 = Area::from_square_centimeters(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 1e6);
+	assert_almost_eq(r2, 1e-2);
+}
+
+#[test]
+fn square_centimetres() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_square_centimetres();
+	let i2 = Area::from_square_centimetres(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 1e6);
+	assert_almost_eq(r2, 1e-2);
+}
+
+#[test]
+fn square_decimeters() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_square_decimeters();
+	let i2 = Area::from_square_decimeters(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 1e4);
+	assert_almost_eq(r2, 1.0);
+}
+
+#[test]
+fn square_decimetres() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_square_decimetres();
+	let i2 = Area::from_square_decimetres(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 1e4);
+	assert_almost_eq(r2, 1.0);
+}
+
+#[test]
+fn square_hectometers() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_square_hectometers();
+	let i2 = Area::from_square_hectometers(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 1e-2);
+	assert_almost_eq(r2, 1e6);
+}
+
+#[test]
+fn square_hectometres() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_square_hectometres();
+	let i2 = Area::from_square_hectometres(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 1e-2);
+	assert_almost_eq(r2, 1e6);
+}
+
+#[test]
+fn hectares() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_hectares();
+	let i2 = Area::from_hectares(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 1e-2);
+	assert_almost_eq(r2, 1e6);
+}
+
+#[test]
+fn square_kilometers() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_square_kilometers();
+	let i2 = Area::from_square_kilometers(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 1e-4);
+	assert_almost_eq(r2, 1e8);
+}
+
+#[test]
+fn square_kilometres() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_square_kilometres();
+	let i2 = Area::from_square_kilometres(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 1e-4);
+	assert_almost_eq(r2, 1e8);
+}
+
+#[test]
+fn square_inches() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_square_inches();
+	let i2 = Area::from_square_inches(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 155000.0);
+	assert_almost_eq(r2, 0.06451587097);
+}
+
+#[test]
+fn square_feet() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_square_feet();
+	let i2 = Area::from_square_feet(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 1076.39);
+	assert_almost_eq(r2, 9.2902950097728);
+}
+
+#[test]
+fn square_yards() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_square_yards();
+	let i2 = Area::from_square_yards(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 119.599);
+	assert_almost_eq(r2, 83.612732764187);
+}
+
+#[test]
+fn acres() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_acres();
+	let i2 = Area::from_acres(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 0.0247105);
+	assert_almost_eq(r2, 404686.0);
+}
+
+#[test]
+fn square_miles() {
+	let i1 = Area::from_square_meters(100.0);
+	let r1 = i1.as_square_miles();
+	let i2 = Area::from_square_miles(100.0);
+	let r2 = i2.as_square_meters();
+	assert_almost_eq(r1, 3.86102e-5);
+	assert_almost_eq(r2, 258998704.7);
+}

src/tests/length_tests.rs

@@ -51,15 +51,15 @@ fn centimeters() {
 }
 
 #[test]
-fn decameter() {
+fn decimeter() {
     let i1 = Length::from_meters(100.0);
-    let r1 = i1.as_decameters();
+    let r1 = i1.as_decimeters();
 
-    let i2 = Length::from_decameters(100.0);
+    let i2 = Length::from_decimeters(100.0);
     let r2 = i2.as_meters();
 
-    assert_almost_eq(r1, 10.0);
-    assert_almost_eq(r2, 1000.0);
+    assert_almost_eq(r1, 1000.0);
+    assert_almost_eq(r2, 10.0);
 }
 
 #[test]

src/tests/mod.rs

@@ -6,6 +6,7 @@ mod speed_tests;
 mod acceleration_tests;
 mod energy_tests;
 mod power_tests;
+mod area_tests;
 
 const DEFAULT_DELTA: f64 = 0.00001;
 
@@ -14,7 +15,7 @@ fn almost_eq(a: f64, b: f64) -> bool {
 }
 
 fn almost_eq_delta(a: f64, b: f64, d: f64) -> bool {
-    (a - b).abs() < d
+    ((a - b).abs() / a) < d
 }
 
 fn assert_almost_eq(a: f64, b: f64) {