Add International spelling of metre/litre.

Use US spelling by default.

Author: Jonathan Pallant

src/length.rs

@@ -34,39 +34,72 @@ pub struct Length {
 }
 
 impl Length {
-    // Inputs, metric
+    // Inputs, metric, with both spellings of meter/metre
+
     pub fn from_meters(meters: f64) -> Self {
         Length { meters: meters }
     }
 
+    pub fn from_metres(metres: f64) -> Self {
+        Self::from_meters(metres)
+    }
+
     pub fn from_nanometers(nanometers: f64) -> Self {
         Self::from_meters(nanometers / METER_NANOMETER_FACTOR)
     }
 
+    pub fn from_nanometres(nanometers: f64) -> Self {
+        Self::from_nanometers(nanometers)
+    }
+
     pub fn from_micrometers(micrometers: f64) -> Self {
         Self::from_meters(micrometers / METER_MICROMETER_FACTOR)
     }
 
+    pub fn from_micrometres(micrometers: f64) -> Self {
+        Self::from_micrometers(micrometers)
+    }
+
     pub fn from_millimeters(millimeters: f64) -> Self {
         Self::from_meters(millimeters / METER_MILLIMETER_FACTOR)
     }
 
+    pub fn from_millimetres(millimeters: f64) -> Self {
+        Self::from_millimeters(millimeters)
+    }
+
     pub fn from_centimeters(centimeters: f64) -> Self {
         Self::from_meters(centimeters / METER_CENTIMETER_FACTOR)
     }
 
+    pub fn from_centimetres(centimeters: f64) -> Self {
+        Self::from_centimeters(centimeters)
+    }
+
     pub fn from_decameters(decameters: f64) -> Self {
         Self::from_meters(decameters / METER_DECAMETER_FACTOR)
     }
 
+    pub fn from_decametres(decameters: f64) -> Self {
+        Self::from_decameters(decameters)
+    }
+
     pub fn from_hectometers(hectometers: f64) -> Self {
         Self::from_meters(hectometers / METER_HECTOMETER_FACTOR)
     }
 
+    pub fn from_hectometres(hectometers: f64) -> Self {
+        Self::from_hectometers(hectometers)
+    }
+
     pub fn from_kilometers(kilometers: f64) -> Self {
         Self::from_meters(kilometers / METER_KILOMETER_FACTOR)
     }
 
+    pub fn from_kilometres(kilometers: f64) -> Self {
+        Self::from_kilometers(kilometers)
+    }
+
     // Inputs, imperial
     pub fn from_inches(inches: f64) -> Self {
         Self::from_meters(inches / METER_INCH_FACTOR)
@@ -93,34 +126,66 @@ impl Length {
         self.meters * METER_NANOMETER_FACTOR
     }
 
+    pub fn as_nanometres(&self) -> f64 {
+        self.as_nanometers()
+    }
+
     pub fn as_micrometers(&self) -> f64 {
         self.meters * METER_MICROMETER_FACTOR
     }
 
+    pub fn as_micrometres(&self) -> f64 {
+        self.as_micrometers()
+    }
+
     pub fn as_millimeters(&self) -> f64 {
         self.meters * METER_MILLIMETER_FACTOR
     }
 
+    pub fn as_millimetres(&self) -> f64 {
+        self.as_millimeters()
+    }
+
     pub fn as_centimeters(&self) -> f64 {
         self.meters * METER_CENTIMETER_FACTOR
     }
 
+    pub fn as_centimetres(&self) -> f64 {
+        self.as_centimeters()
+    }
+
     pub fn as_meters(&self) -> f64 {
         self.meters
     }
 
+    pub fn as_metres(&self) -> f64 {
+        self.as_meters()
+    }
+
     pub fn as_decameters(&self) -> f64 {
         self.meters * METER_DECAMETER_FACTOR
     }
 
-    pub fn as_hectometer(&self) -> f64 {
+    pub fn as_decametres(&self) -> f64 {
+        self.as_decameters()
+    }
+
+    pub fn as_hectometers(&self) -> f64 {
         self.meters * METER_HECTOMETER_FACTOR
     }
 
+    pub fn as_hectometres(&self) -> f64 {
+        self.as_hectometers()
+    }
+
     pub fn as_kilometers(&self) -> f64 {
         self.meters * METER_KILOMETER_FACTOR
     }
 
+    pub fn as_kilometres(&self) -> f64 {
+        self.as_kilometers()
+    }
+
     // Outputs, imperial
     pub fn as_inches(&self) -> f64 {
         self.meters * METER_INCH_FACTOR

src/tests/length_tests.rs

@@ -65,7 +65,7 @@ fn decameter() {
 #[test]
 fn hectometer() {
     let i1 = Length::from_meters(100.0);
-    let r1 = i1.as_hectometer();
+    let r1 = i1.as_hectometers();
 
     let i2 = Length::from_hectometers(100.0);
     let r2 = i2.as_meters();