Extend range of electrical units downwards

Signed-off-by: Daniel Egger <[email protected]>

Author: Daniel Egger

src/current.rs

@@ -36,6 +36,11 @@ impl Current {
         Self::from_amperes(microamperes / 1000.0 / 1000.0)
     }
 
+    /// Create a new Current from a floating point value in nanoamperes
+    pub fn from_nanoamperes(nanoamperes: f64) -> Self {
+        Self::from_amperes(nanoamperes / 1_000_000_000.0)
+    }
+
     /// Convert this Current into a floating point value in amperes
     pub fn as_amperes(&self) -> f64 {
         self.amperes
@@ -50,6 +55,11 @@ impl Current {
     pub fn as_microamperes(&self) -> f64 {
         self.amperes * 1000.0 * 1000.0
     }
+
+    /// Convert this Current into a floating point value in nanoamperes
+    pub fn as_nanoamperes(&self) -> f64 {
+        self.amperes * 1_000_000_000.0
+    }
 }
 
 impl Measurement for Current {
@@ -110,6 +120,12 @@ mod test {
         assert_almost_eq(u.as_microamperes(), 1000.0);
     }
 
+    #[test]
+    pub fn as_nanoamperes() {
+        let u = Current::from_amperes(0.000001);
+        assert_almost_eq(u.as_nanoamperes(), 1000.0);
+    }
+
     // Traits
     #[test]
     fn add() {
@@ -148,7 +164,10 @@ mod test {
     fn eq() {
         let a = Current::from_microamperes(1_000_000.0);
         let b = Current::from_milliamperes(1_000.0);
+        let c = Current::from_nanoamperes(1_000_000_000.0);
         assert_eq!(a, b);
+        assert_eq!(b, c);
+        assert_eq!(a, c);
     }
 
     #[test]

src/power.rs

@@ -8,6 +8,10 @@ pub const WATT_HORSEPOWER_FACTOR: f64 = 1.0 / 745.6998715822702;
 pub const WATT_BTU_MIN_FACTOR: f64 = 1.0 / 17.58426666666667;
 /// Number of kW in a W
 pub const WATT_KILOWATT_FACTOR: f64 = 1e-3;
+/// Number of mW in a W
+pub const WATT_MILLIWATT_FACTOR: f64 = 1e3;
+/// Number of µW in a W
+pub const WATT_MICROWATT_FACTOR: f64 = 1e6;
 /// Number of pferdstarken (PS) in a W
 pub const WATT_PS_FACTOR: f64 = 1.0 / 735.499;
 
@@ -34,6 +38,16 @@ impl Power {
         Power { watts: watts }
     }
 
+    /// Create a new Power from a floating point value in milliwatts
+    pub fn from_milliwatts(milliwatts: f64) -> Power {
+        Self::from_watts(milliwatts / WATT_MILLIWATT_FACTOR)
+    }
+
+    /// Create a new Power from a floating point value in microwatts
+    pub fn from_microwatts(microwatts: f64) -> Power {
+        Self::from_watts(microwatts / WATT_MICROWATT_FACTOR)
+    }
+
     /// Create a new Power from a floating point value in horsepower (hp)
     pub fn from_horsepower(horsepower: f64) -> Power {
         Self::from_watts(horsepower / WATT_HORSEPOWER_FACTOR)
@@ -88,6 +102,16 @@ impl Power {
     pub fn as_kilowatts(&self) -> f64 {
         self.watts * WATT_KILOWATT_FACTOR
     }
+
+    /// Convert this Power into a floating point value in milliwatts (mW)
+    pub fn as_milliwatts(&self) -> f64 {
+        self.watts * WATT_MILLIWATT_FACTOR
+    }
+
+    /// Convert this Power into a floating point value in microwatts (µW)
+    pub fn as_microwatts(&self) -> f64 {
+        self.watts * WATT_MICROWATT_FACTOR
+    }
 }
 
 impl Measurement for Power {
@@ -168,6 +192,30 @@ mod test {
         assert_almost_eq(r2, 0.1);
     }
 
+    #[test]
+    pub fn as_milliwatts() {
+        let i1 = Power::from_milliwatts(100.0);
+        let r1 = i1.as_watts();
+
+        let i2 = Power::from_watts(100.0);
+        let r2 = i2.as_milliwatts();
+
+        assert_almost_eq(r1, 0.1);
+        assert_almost_eq(r2, 100_000.0);
+    }
+
+    #[test]
+    pub fn as_microwatts() {
+        let i1 = Power::from_microwatts(100.0);
+        let r1 = i1.as_milliwatts();
+
+        let i2 = Power::from_milliwatts(100.0);
+        let r2 = i2.as_microwatts();
+
+        assert_almost_eq(r1, 0.1);
+        assert_almost_eq(r2, 100_000.0);
+    }
+
     // Traits
     #[test]
     fn add() {

src/voltage.rs

@@ -26,6 +26,11 @@ impl Voltage {
         Voltage { volts }
     }
 
+    /// Create a new Voltage from a floating point value in Microvolts
+    pub fn from_microvolts(microvolts: f64) -> Self {
+        Self::from_volts(microvolts / 1_000_000.0)
+    }
+
     /// Create a new Voltage from a floating point value in Millivolts
     pub fn from_millivolts(millivolts: f64) -> Self {
         Self::from_volts(millivolts / 1000.0)
@@ -41,6 +46,11 @@ impl Voltage {
         self.volts
     }
 
+    /// Convert this Voltage into a floating point value in Microvolts
+    pub fn as_microvolts(&self) -> f64 {
+        self.volts * 1_000_000.0
+    }
+
     /// Convert this Voltage into a floating point value in Millivolts
     pub fn as_millivolts(&self) -> f64 {
         self.volts * 1000.0
@@ -106,6 +116,12 @@ mod test {
         assert_almost_eq(u.as_volts(), 1234.0);
     }
 
+    #[test]
+    pub fn as_microvolts() {
+        let u = Voltage::from_volts(1.234567);
+        assert_almost_eq(u.as_microvolts(), 1234567.0);
+    }
+
     #[test]
     pub fn as_millivolts() {
         let u = Voltage::from_volts(1.234);
@@ -150,7 +166,10 @@ mod test {
     fn eq() {
         let a = Voltage::from_kilovolts(1.0);
         let b = Voltage::from_millivolts(1_000_000.0);
+        let c = Voltage::from_microvolts(1_000_000_000.0);
         assert_eq!(a, b);
+        assert_eq!(a, c);
+        assert_eq!(b, c);
     }
 
     #[test]