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

src/fft.rs

@@ -31,7 +31,7 @@ pub trait DFTWindow {
 }
 
 pub fn create_fft(size: usize) -> Box<dyn DFT> {
-    if size == 1 || size < 16 {
+    if size <= 16 {
         println!("Naive {size}");
         return Box::new(NaiveDFT::create(size));
     }
@@ -39,6 +39,7 @@ pub fn create_fft(size: usize) -> Box<dyn DFT> {
         // TODO: Return hardcoded fft for small sized
         println!("Radix 2 {size}");
         return Box::new(Radix2FFT::create(size));
+        //return Box::new(::create(size));
     }
 
     if is_prime(size) {

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);

src/main.rs

@@ -1,8 +1,5 @@
 use std::{
-    f32::consts::PI,
-    fs::File,
-    io::{Read, Write},
-    ops::{Add, Div, Mul, Sub},
+    f32::consts::PI, fs::File, io::{Read, Write}, ops::{Add, Div, Mul, Sub}
 };
 
 mod bfsk;
@@ -40,8 +37,50 @@ fn euclid_mod(a: f32, m: f32) -> f32 {
     let r = a % m;
     if r < 0.0 { r + m } else { r }
 }
+
+struct QuickLCG(i32);
+impl QuickLCG
+{
+    pub fn seed(val: i32) -> QuickLCG
+    {
+        QuickLCG(val % 10)
+    }
+
+    pub fn next(&mut self) -> i32
+    {
+        self.0 = self.0.overflowing_mul(9321).0.overflowing_add(5672).0 % 10;
+        self.0
+    }
+}
+
 fn main() {
-    test();
+    //test();
+    simple_test();
+}
+
+fn simple_test()
+{
+    let sample_count = 7;
+    let mut dft = NaiveDFT::create(sample_count);
+    let mut fft = RaderFFT::create(sample_count);
+
+    let mut rand = QuickLCG::seed(2981237);
+    for (a, b) in dft.get_input().iter_mut().zip(fft.get_input().iter_mut())
+    {
+        let re = (rand.next() - 5) as f32;
+        let im = (rand.next() - 5) as f32;
+        *a = Complex32::new(re, im);
+        *b = Complex32::new(re, im);
+    }
+
+    dft.execute(windows::rectanguar);
+    fft.execute(windows::rectanguar);
+
+    
+    for (a, b) in dft.get_output().iter().zip(fft.get_output().iter())
+    {
+        println!("{:0<7.3} {:0<7.3} \t {:0<7.3} {:0<7.3}", a.re, a.im, b.re, b.im);
+    }
 }
 
 fn test() {
@@ -51,23 +90,25 @@ fn test() {
     //let sample_count = 71*71;
     //let sample_count = 71 * 71;
     //let sample_count = 4804;
-    let sample_count = 4799;
+    let sample_count = 4809;
 
     let mut o1 = Nco::new(freq1);
     let mut o2 = Nco::new(freq2);
 
-    let mut fft = RaderFFT::create(sample_count);
-    let mut dft = RaderFFT::create(sample_count);
-    for (x, y) in fft.get_input().iter_mut().zip(dft.get_input().iter_mut()) {
-        *y = o1.cexp();// + o2.cexp();
+    //let mut fft = ::create(sample_count);
+    //let mut dft = MixedRadixFFT::create(sample_count);
+    let mut fft = create_fft(sample_count);
+    //let mut dft = create_fft(sample_count);
+    for x in fft.get_input().iter_mut() {
+        *x = o1.cexp() + o2.cexp();
         //*y = *x;
 
         o1.step();
         o2.step();
     }
 
-    //fft.execute(windows::rectanguar);
-    dft.execute(windows::rectanguar);
+    fft.execute(windows::rectanguar);
+    //dft.execute(windows::rectanguar);
 
     let root = BitMapBackend::new("out.png", (640, 480)).into_drawing_area();
     root.fill(&WHITE).unwrap();
@@ -81,20 +122,22 @@ fn test() {
 
     //chart.configure_mesh().draw()?;
 
+    /*
     chart
         .draw_series(LineSeries::new(
             (0..sample_count)
                 .zip(dft.get_output().iter())
-                .map(|(x, y)| (x as f32, (*y).arg() * (*y).mag())),
+                .map(|(x, y)| (x as f32, (*y).arg() )),
             &RED,
         ))
         .unwrap()
         .legend(|(x, y)| PathElement::new(vec![(x, y), (x + 20, y)], RED));
+    */
 
     chart
         .draw_series(LineSeries::new(
             (0..sample_count)
-                .zip(dft.get_output().iter())
+                .zip(fft.get_output().iter())
                 .map(|(x, y)| (x as f32, (*y).mag() / sample_count as f32)),
             &BLUE,
         ))
@@ -109,6 +152,15 @@ fn test() {
         .unwrap();
 
     root.present().unwrap();
+
+    let mut f = File::create("out.csv").unwrap();
+    for x in fft.get_output().iter()
+    {
+        f.write_all(
+            format!("{},\n", x.mag() / sample_count as f32).to_string().as_bytes()
+        ).unwrap();
+    }
+
 }
 
 fn modulate() {