Fix styles

src/complex.rs

@@ -27,40 +27,38 @@ pub fn inverse(data: &mut [c64], scaling: bool) {
 }
 
 fn rearrange(data: &mut [c64], n: usize) {
-    let mut target = 0;
-    for position in 0..n {
-        if target > position {
-            data.swap(position, target);
+    let mut j = 0;
+    for i in 0..n {
+        if j > i {
+            data.swap(i, j);
         }
         let mut mask = n >> 1;
-        while target & mask != 0 {
-            target &= !mask;
+        while j & mask != 0 {
+            j &= !mask;
             mask >>= 1;
         }
-        target |= mask;
+        j |= mask;
     }
 }
 
 fn perform(data: &mut [c64], n: usize, inverse: bool) {
-    use std::f64::consts::PI;
-
     let sign = if inverse { 1.0 } else { -1.0 };
     let mut step = 1;
     while step < n {
         let jump = step << 1;
         let (multiplier, mut factor) = {
-            let delta = sign * PI / step as f64;
-            let sine = (0.5 * delta).sin();
-            (c64(-2.0 * sine * sine, delta.sin()), c64(1.0, 0.0))
+            use std::f64::consts::PI;
+            let theta = sign * PI / step as f64;
+            let sine = (0.5 * theta).sin();
+            (c64(-2.0 * sine * sine, theta.sin()), c64(1.0, 0.0))
         };
-        for group in 0..step {
-            let mut pair = group;
-            while pair < n {
-                let match_pair = pair + step;
-                let product = factor * data[match_pair];
-                data[match_pair] = data[pair] - product;
-                data[pair] = data[pair] + product;
-                pair += jump;
+        for mut i in 0..step {
+            while i < n {
+                let j = i + step;
+                let product = factor * data[j];
+                data[j] = data[i] - product;
+                data[i] = data[i] + product;
+                i += jump;
             }
             factor = multiplier * factor + factor;
         }
@@ -70,7 +68,7 @@ fn perform(data: &mut [c64], n: usize, inverse: bool) {
 
 fn scale(data: &mut [c64], n: usize) {
     let factor = 1.0 / n as f64;
-    for position in 0..n {
-        data[position] = data[position] * factor;
+    for i in 0..n {
+        data[i] = data[i] * factor;
     }
 }

src/real.rs

@@ -58,29 +58,26 @@ pub fn unpack(data: &[f64]) -> Vec<c64> {
 }
 
 fn compose(data: &mut [c64], n: usize, inverse: bool) {
-    use std::f64::consts::PI;
-
     data[0] = c64(data[0].re() + data[0].im(), data[0].re() - data[0].im());
     if inverse {
         data[0] = data[0] * 0.5;
     }
 
+    let sign = if inverse { 1.0 } else { -1.0 };
     let (multiplier, mut factor) = {
-        let sign = if inverse { 1.0 } else { -1.0 };
-        let delta = sign * PI / n as f64;
-        let sine = (0.5 * delta).sin();
-        (c64(-2.0 * sine * sine, delta.sin()), c64(0.0, -sign))
+        use std::f64::consts::PI;
+        let theta = sign * PI / n as f64;
+        let sine = (0.5 * theta).sin();
+        (c64(-2.0 * sine * sine, theta.sin()), c64(1.0, 0.0))
     };
-
     for i in 1..(n / 2) {
         let j = n - i;
-
-        let part1 = (data[i] + data[j].conj()) * 0.5;
-        let part2 = -(data[i] - data[j].conj()) * 0.5;
-
         factor = multiplier * factor + factor;
-        data[i] = part1 + factor * part2;
-        data[j] = (part1 - factor * part2).conj();
+        let part1 = (data[i] + data[j].conj()) * 0.5;
+        let part2 = (data[i] - data[j].conj()) * 0.5;
+        let product = c64(0.0, sign) * factor * part2;
+        data[i] = part1 + product;
+        data[j] = (part1 - product).conj();
     }
 
     data[n / 2] = data[n / 2].conj();