cargo fmt

Author: arnolddevos

src/elec.rs

@@ -1,49 +1,49 @@
-use core::ops::{Add, BitOr, Neg};
 use core::fmt;
+use core::ops::{Add, BitOr, Neg};
 
 use crate::units::*;
 
 #[derive(Debug, Copy, Clone)]
 pub enum Cct {
-    Thevenin( Volt, Ohm),
-    Norton( Amp, Siemen )
+    Thevenin(Volt, Ohm),
+    Norton(Amp, Siemen),
 }
 use self::Cct::*;
 
 impl Cct {
-    pub fn i_short(self) -> Amp { 
+    pub fn i_short(self) -> Amp {
         match self {
-            Thevenin(v, r) => v/r,
-            Norton(i, _) => i
+            Thevenin(v, r) => v / r,
+            Norton(i, _) => i,
         }
     }
-    pub fn v_open(self) -> Volt { 
+    pub fn v_open(self) -> Volt {
         match self {
             Thevenin(v, _) => v,
-            Norton(i, g) => i*(1.0/g)
+            Norton(i, g) => i * (1.0 / g),
         }
     }
-    pub fn r_equiv(self) -> Ohm { 
+    pub fn r_equiv(self) -> Ohm {
         match self {
             Thevenin(_, r) => r,
-            Norton(_, g) => 1.0/g
+            Norton(_, g) => 1.0 / g,
         }
     }
-    pub fn g_equiv(self) -> Siemen { 
+    pub fn g_equiv(self) -> Siemen {
         match self {
-            Thevenin(_, r) => 1.0/r,
-            Norton(_, g) => g
+            Thevenin(_, r) => 1.0 / r,
+            Norton(_, g) => g,
         }
     }
 }
 
 fn norton_wins(lhs: Cct, rhs: Cct) -> bool {
     match (lhs, rhs) {
         (Thevenin(_, _), Thevenin(_, _)) => false,
-        (Norton(_, _), Norton(_, _))     => true,
-        (Norton(_, g), _) if g.0 < n     => true,
-        (_, Norton(_, g)) if g.0 < n     => true,
-        _                                => false
+        (Norton(_, _), Norton(_, _)) => true,
+        (Norton(_, g), _) if g.0 < n => true,
+        (_, Norton(_, g)) if g.0 < n => true,
+        _ => false,
     }
 }
 
@@ -54,12 +54,11 @@ impl BitOr<Cct> for Cct {
             let ge = self.g_equiv() + rhs.g_equiv();
             let ie = self.i_short() + rhs.i_short();
             Norton(ie, ge)
-        }
-        else {
+        } else {
             let re = self.r_equiv() | rhs.r_equiv();
             let rs = self.r_equiv() + rhs.r_equiv();
-            let n1 = rhs.r_equiv()/rs;
-            let n2 = self.r_equiv()/rs;
+            let n1 = rhs.r_equiv() / rs;
+            let n2 = self.r_equiv() / rs;
             let ve = self.v_open() * n1 + rhs.v_open() * n2;
             Thevenin(ve, re)
         }
@@ -72,12 +71,11 @@ impl Add<Cct> for Cct {
         if norton_wins(self, rhs) {
             let ge = self.g_equiv() | rhs.g_equiv();
             let gp = self.g_equiv() + rhs.g_equiv();
-            let n1 = rhs.g_equiv()/gp;
-            let n2 = self.g_equiv()/gp;
+            let n1 = rhs.g_equiv() / gp;
+            let n2 = self.g_equiv() / gp;
             let ie = self.i_short() * n1 + rhs.i_short() * n2;
             Norton(ie, ge)
-        }
-        else {
+        } else {
             let re = self.r_equiv() + rhs.r_equiv();
             let ve = self.v_open() + rhs.v_open();
             Thevenin(ve, re)
@@ -90,7 +88,7 @@ impl Neg for Cct {
     fn neg(self) -> Cct {
         match self {
             Thevenin(v, r) => Thevenin(-v, r),
-            Norton(i, g) => Norton(-i, g)
+            Norton(i, g) => Norton(-i, g),
         }
     }
 }
@@ -99,77 +97,86 @@ impl fmt::Display for Cct {
     fn fmt(&self, dst: &mut fmt::Formatter) -> fmt::Result {
         match self {
             Thevenin(v, r) => write!(dst, "{} + {}", v, r),
-            Norton(i, g)   => write!(dst, "{} | {}", i, g),
+            Norton(i, g) => write!(dst, "{} | {}", i, g),
         }
-        
     }
 }
 
 // Conversions from elec units to Cct
 
 impl Add<Ohm> for Volt {
     type Output = Cct;
-    fn add(self, rhs: Ohm) -> Cct { Thevenin(self, rhs) }
+    fn add(self, rhs: Ohm) -> Cct {
+        Thevenin(self, rhs)
+    }
 }
 
 impl BitOr<Siemen> for Amp {
     type Output = Cct;
-    fn bitor(self, rhs: Siemen) -> Cct { Norton(self, rhs) }
+    fn bitor(self, rhs: Siemen) -> Cct {
+        Norton(self, rhs)
+    }
 }
 
 impl BitOr<Ohm> for Cct {
     type Output = Cct;
-    fn bitor(self, rhs: Ohm) -> Cct { self | Thevenin(Volt(0.0), rhs) }
+    fn bitor(self, rhs: Ohm) -> Cct {
+        self | Thevenin(Volt(0.0), rhs)
+    }
 }
 
 impl Add<Ohm> for Cct {
     type Output = Cct;
-    fn add(self, rhs: Ohm) -> Cct { self + Thevenin(Volt(0.0), rhs) }
+    fn add(self, rhs: Ohm) -> Cct {
+        self + Thevenin(Volt(0.0), rhs)
+    }
 }
 
 impl BitOr<Siemen> for Cct {
     type Output = Cct;
-    fn bitor(self, rhs: Siemen) -> Cct { self | Norton(Amp(0.0), rhs) }
+    fn bitor(self, rhs: Siemen) -> Cct {
+        self | Norton(Amp(0.0), rhs)
+    }
 }
 
 impl Add<Siemen> for Cct {
     type Output = Cct;
-    fn add(self, rhs: Siemen) -> Cct { self + Norton(Amp(0.0), rhs) }
+    fn add(self, rhs: Siemen) -> Cct {
+        self + Norton(Amp(0.0), rhs)
+    }
 }
 
 #[test]
 fn open_evse_cp_example() {
-    let r7 = 200.0*Ohm(k);
-    let r6 = 100.0*Ohm(k);
-    let r5 = 56.0*Ohm(k);
+    let r7 = 200.0 * Ohm(k);
+    let r6 = 100.0 * Ohm(k);
+    let r5 = 56.0 * Ohm(k);
 
     let vcc = Volt(5.0);
     let v_cp_hi = Volt(12.0);
     let gnd = Volt(0.0);
 
-    let cct = v_cp_hi + r7 |  gnd + r6 | vcc + r5;
-   
+    let cct = v_cp_hi + r7 | gnd + r6 | vcc + r5;
+
     fn divider3(v1: Volt, r1: Ohm, v2: Volt, r2: Ohm, v3: Volt, r3: Ohm) -> Volt {
-        (v1/r1 + v2/r2 + v3/r3)*(r1|r2|r3)
+        (v1 / r1 + v2 / r2 + v3 / r3) * (r1 | r2 | r3)
     }
 
     let v1 = cct.v_open();
-    let v2 = divider3(v_cp_hi, r7, gnd, r6, vcc,r5);
+    let v2 = divider3(v_cp_hi, r7, gnd, r6, vcc, r5);
 
-    assert_eq!( v1, v2 )
+    assert_eq!(v1, v2)
 }
 
 #[test]
 fn doc_example() {
     let vcc = Volt(5.0);
-    let r1 = Ohm(10.0*k);
-    let r2 = Ohm(5.0*k);
-    
-    let circuit =
-        vcc + r1    // A voltage source vcc in series with resistor r1 forms a Cct,
-        | r2;       // which is extended by resistor r2 in parallel
-    
+    let r1 = Ohm(10.0 * k);
+    let r2 = Ohm(5.0 * k);
+
+    let circuit = vcc + r1    // A voltage source vcc in series with resistor r1 forms a Cct,
+        | r2; // which is extended by resistor r2 in parallel
+
     let v1 = circuit.v_open(); // v1 is the voltage produced
-    assert_eq!( v1, r2/(r1 + r2) * vcc)
-    
+    assert_eq!(v1, r2 / (r1 + r2) * vcc)
 }

src/macros.rs

@@ -1,62 +1,62 @@
 macro_rules! measure {
     ($id:ident, $symbol:expr) => {
-
         #[derive(Debug, Copy, Clone, PartialOrd, PartialEq, Default)]
         pub struct $id(pub f64);
 
         impl fmt::Display for $id {
             fn fmt(&self, dst: &mut fmt::Formatter) -> fmt::Result {
                 let (prefix, scale) = engineering(self.0);
-                let value = self.0/scale;
+                let value = self.0 / scale;
                 let fract = precision(value);
                 write!(dst, "{:.*}{}{}", fract, value, prefix, $symbol)
             }
         }
 
         impl Neg for $id {
             type Output = $id;
-            fn neg(self) -> $id { $id(-self.0) }
+            fn neg(self) -> $id {
+                $id(-self.0)
+            }
         }
 
         impl Add<$id> for $id {
             type Output = $id;
-            fn add(self, rhs: $id) -> $id { 
+            fn add(self, rhs: $id) -> $id {
                 $id(self.0 + rhs.0)
             }
         }
- 
 
         impl Sub<$id> for $id {
             type Output = $id;
-            fn sub(self, rhs: $id) -> $id { 
+            fn sub(self, rhs: $id) -> $id {
                 $id(self.0 - rhs.0)
             }
         }
- 
+
         impl Div<$id> for $id {
             type Output = f64;
-            fn div(self, rhs: $id) -> f64 { 
+            fn div(self, rhs: $id) -> f64 {
                 self.0 / rhs.0
             }
         }
 
         impl Div<f64> for $id {
             type Output = $id;
-            fn div(self, rhs: f64) -> $id { 
+            fn div(self, rhs: f64) -> $id {
                 $id(self.0 / rhs)
             }
         }
 
         impl Mul<f64> for $id {
             type Output = $id;
-            fn mul(self, rhs: f64) -> $id { 
+            fn mul(self, rhs: f64) -> $id {
                 $id(self.0 * rhs)
             }
         }
 
         impl Mul<$id> for f64 {
             type Output = $id;
-            fn mul(self, rhs: $id) -> $id { 
+            fn mul(self, rhs: $id) -> $id {
                 $id(self * rhs.0)
             }
         }
@@ -65,7 +65,7 @@ macro_rules! measure {
 
 pub(crate) use measure;
 
-macro_rules!  product {
+macro_rules! product {
     ($a:ident, $b:ident, $c:ident) => {
         impl Mul<$b> for $a {
             type Output = $c;
@@ -100,12 +100,11 @@ macro_rules! inverse_sum_inverse {
     ($id:ident) => {
         impl BitOr<$id> for $id {
             type Output = $id;
-            fn bitor(self, rhs: $id) -> $id { 
+            fn bitor(self, rhs: $id) -> $id {
                 if self.0 == 0.0 && rhs.0 == 0.0 {
                     $id(0.0)
-                }
-                else {
-                    $id(self.0 * rhs.0/(self.0 + rhs.0))
+                } else {
+                    $id(self.0 * rhs.0 / (self.0 + rhs.0))
                 }
             }
         }
@@ -114,7 +113,7 @@ macro_rules! inverse_sum_inverse {
 
 pub(crate) use inverse_sum_inverse;
 
-macro_rules!  inverse {
+macro_rules! inverse {
     ($a:ident, $b:ident) => {
         impl Mul<$b> for $a {
             type Output = f64;
@@ -143,4 +142,4 @@ macro_rules!  inverse {
     };
 }
 
-pub(crate) use inverse;
+pub(crate) use inverse;

src/rcnet.rs

@@ -1,22 +1,21 @@
-use core::fmt::Display;
-use crate::units::*;
 use crate::elec::*;
+use crate::units::*;
+use core::fmt::Display;
 
-pub struct Net<Drive : Display + Copy + Default> {
+pub struct Net<Drive: Display + Copy + Default> {
     pub title: &'static str,
     pub drive: [Drive; 3],
     pub cap: Farad,
     pub cct: fn(Drive) -> Cct,
 }
 
-impl<Drive : Display + Copy + Default> Net<Drive> {
+impl<Drive: Display + Copy + Default> Net<Drive> {
     pub fn describe_ac(&self) {
         let x: Drive = Default::default();
         let r: Ohm = (self.cct)(x).r_equiv();
         println!("{} 3db f = {}", self.title, f3db(r * self.cap))
     }
 
-
     pub fn describe_dc(&self) {
         println!("{} in -> out", self.title);
         for &x in &self.drive {
@@ -33,25 +32,26 @@ impl<Drive : Display + Copy + Default> Net<Drive> {
     }
 }
 
-
 /// Design a voltage divider to convert +/-vin to 0/+vout
 /// The assumed circuit is:
-/// 
+///
 /// ```
 /// vout + r1 | r2 | vin + r_input
 /// ```
-/// 
+///
 /// Provide atten = vout/vin
 /// and r_input
-/// 
+///
 /// The fn returns (r1, r2)
-/// 
+///
 pub fn double_to_single_ended(atten: f64, r_input: Ohm) -> (Ohm, Ohm) {
-    let r1 = atten*r_input;
-    let r2 = r1/(1.0 - atten); 
+    let r1 = atten * r_input;
+    let r2 = r1 / (1.0 - atten);
     (r1, r2)
 }
 
 use core::f64::consts::PI;
 
-pub fn f3db(t: Second) -> Hertz { 1.0 / (2.0 * PI * t) }
+pub fn f3db(t: Second) -> Hertz {
+    1.0 / (2.0 * PI * t)
+}