I'm gonna rewrite everything : IFFT ISN'T JUST REVERSING THE TERMS RETARD

src/fft/dft.rs

@@ -30,21 +30,6 @@ impl DFT for NaiveDFT {
             }
         }
 
-        /*
-        self.output_buffer
-            .iter_mut()
-            .enumerate()
-            .for_each(|(freq, out)| {
-                *out = self
-                    .input_buffer
-                    .iter()
-                    .enumerate()
-                    .map(|(i, s)| {
-                        (*s) * Complex32::cexp(-2. * PI * (i * freq) as f32 / self.size as f32)
-                    })
-                    .sum()
-            })
-        */
     }
 
     fn get_input(&mut self) -> &mut [Complex32] {
@@ -55,3 +40,18 @@ impl DFT for NaiveDFT {
         &self.output_buffer
     }
 }
+
+impl NaiveDFT
+{
+    pub fn execute_inv(&mut self, window: fn(f32) -> f32) {
+        for (freq, out) in self.output_buffer.iter_mut().enumerate() {
+            *out = Complex32::zero();
+            for (i, inp) in self.input_buffer.iter().enumerate() {
+                *out = *out
+                    + ((*inp * Complex32::cexp(2. * PI * (i * freq) as f32 / self.size as f32))
+                        * window(i as f32 / self.size as f32));
+            }
+        }
+
+    }
+}

src/fft/mixed_radix.rs

@@ -28,9 +28,9 @@ impl DFT for MixedRadixFFT {
         let p = size / q;
         println!("{} {}", p, q);
         // TODO: Figure out why it does not work in the other direction ...
-        let (p, q) = (q, p);
-        //let qfft = create_fft(q);
-        //let pfft = create_fft(p);
+        //let (p, q) = (q, p);
+        let qfft = create_fft(q);
+        let pfft = create_fft(p);
 
         let qfft = Box::new(NaiveDFT::create(q));
         let pfft = Box::new(NaiveDFT::create(p));

src/fft/rader.rs

@@ -14,7 +14,7 @@ pub struct RaderFFT {
 
     permutations: Box<[usize]>,
     convolution_op: Box<[Complex32]>,
-    conv_fft: Box<dyn DFT>,
+    conv_fft: Box<NaiveDFT>,
 
     size: usize,
 }
@@ -26,9 +26,10 @@ impl DFT for RaderFFT {
     {
         assert!(is_prime(size));
         let g = compute_prime_primitive_root(size);
-        let permutations: Box<[usize]> = (0..(size - 1)).map(|i| exp_mod(g, i, size)).collect();
+        let permutations: Box<[usize]> = (0..(size - 1)).map(|i| exp_mod(g, i + 1, size)).collect();
 
         let mut conv_fft = Box::new(NaiveDFT::create(size - 1));
+        //let mut conv_fft = create_fft(size - 1);
         conv_fft
             .get_input()
             .iter_mut()
@@ -53,7 +54,7 @@ impl DFT for RaderFFT {
     fn execute(&mut self, window: fn(f32) -> f32) {
         // Compute fft of input signal
         for i in 0..(self.size - 1) {
-            let k = self.permutations[i];
+            let k = self.permutations[self.size - 1 - i - 1];
             self.conv_fft.get_input()[i] = self.input_buffer[k];
         }
 
@@ -61,12 +62,12 @@ impl DFT for RaderFFT {
 
         for i in 0..(self.size - 1) {
             self.output_buffer[i] =
-                self.conv_fft.get_output()[self.size - 1 - i - 1] * self.convolution_op[i];
+                self.conv_fft.get_output()[i] * self.convolution_op[i];
         }
 
         for i in 0..(self.size - 1) {
-            //self.conv_fft.get_input()[i] = self.output_buffer[self.size - 1 - i - 1];
-            self.conv_fft.get_input()[i] = self.output_buffer[i];
+            //self.conv_fft.get_input()[i] = self.output_buffer[i];
+            self.conv_fft.get_input()[i] = -self.output_buffer[self.size - 1 - i - 1];
         }
 
         self.conv_fft.execute(windows::rectanguar);