begin cleaning ffts

src/fft/rader.rs

@@ -9,11 +9,9 @@ use crate::{
 };
 
 pub struct RaderFFT {
-    input_buffer: Box<[Complex32]>,
-    output_buffer: Box<[Complex32]>,
-
     permutations: Box<[usize]>,
     convolution_op: Box<[Complex32]>,
+    staging_buffer: Box<[Complex32]>,
     inv_fft: Box<dyn DFT>,
     conv_fft: Box<dyn DFT>,
 
@@ -31,23 +29,20 @@ impl DFT for RaderFFT {
 
         let mut conv_fft = create_fft(size - 1, FFTDirection::Forward);
         //let mut conv_fft = create_fft(size - 1);
-        conv_fft
-            .get_input()
-            .iter_mut()
-            .enumerate()
-            .for_each(|(i, x)| {
-                *x = Complex32::cexp(
+        let mut convolution_op = vec![Complex32::zero(); size - 1];
+        let conv_fft_input: Vec<Complex32> = (0..(size - 1))
+            .map(|i| {
+                Complex32::cexp(
                     -2. * direction.sign() * PI * (permutations[i] as f32) / (size as f32),
                 )
-            });
-        conv_fft.execute(windows::rectanguar);
+            })
+            .collect();
+        conv_fft.execute(&conv_fft_input, &mut convolution_op, windows::rectangular);
 
         RaderFFT {
-            input_buffer: vec![Complex32::zero(); size].into(),
-            output_buffer: vec![Complex32::zero(); size].into(),
-
             permutations,
-            convolution_op: conv_fft.get_output().iter().copied().collect(),
+            convolution_op: convolution_op.into(),
+            staging_buffer: vec![Complex32::zero(); size - 1].into(),
             inv_fft: create_fft(size - 1, FFTDirection::Inverse),
             conv_fft,
 
@@ -55,41 +50,33 @@ impl DFT for RaderFFT {
         }
     }
 
-    fn execute(&mut self, window: fn(f32) -> f32) {
+    fn execute(&mut self, input: &[Complex32], output: &mut [Complex32], window: fn(f32) -> f32) {
         // Compute fft of input signal
         for i in 0..(self.size - 1) {
             let k = self.permutations[self.size - 1 - i - 1];
-            self.conv_fft.get_input()[i] = self.input_buffer[k];
+            self.staging_buffer[i] = input[k] * window(k as f32 / (self.size as f32));
         }
 
-        self.conv_fft.execute(windows::rectanguar);
+        self.conv_fft
+            .execute(&self.staging_buffer, output, windows::rectangular);
 
         for i in 0..(self.size - 1) {
-            self.output_buffer[i] = self.conv_fft.get_output()[i] * self.convolution_op[i];
+            self.staging_buffer[i] = output[i] * self.convolution_op[i];
         }
 
-        for i in 0..(self.size - 1) {
-            //self.conv_fft.get_input()[i] = self.output_buffer[i];
-            self.inv_fft.get_input()[i] = self.output_buffer[i];
-        }
-
-        self.inv_fft.execute(windows::rectanguar);
+        self.inv_fft
+            .execute(&self.staging_buffer, output, windows::rectangular);
 
         for i in 0..(self.size - 1) {
             let k = self.permutations[i];
-            self.output_buffer[k] =
-                (self.inv_fft.get_output()[i] / (self.size - 1) as f32) + self.input_buffer[0];
+            self.staging_buffer[k - 1] = output[i];
         }
 
-        self.output_buffer[0] = self.input_buffer.iter().copied().sum();
-    }
-
-    fn get_input(&mut self) -> &mut [Complex32] {
-        &mut self.input_buffer
-    }
-
-    fn get_output(&self) -> &[Complex32] {
-        &self.output_buffer
+        output[0] = input[0] * window(0.0);
+        for i in 0..(self.size - 1) {
+            output[i + 1] = (self.staging_buffer[i] / (self.size - 1) as f32) + input[0];
+            output[0] = output[0] + (input[i + 1] * window((i + 1) as f32 / self.size as f32));
+        }
     }
 }