Mixed radix, begining rader

src/fft/radix2.rs

@@ -4,23 +4,23 @@ use crate::complex::Complex32;
 use crate::fft::DFT;
 use std::f32::consts::PI;
 
-pub struct Radix2FFT<'a> {
-    output_buffer: &'a mut [Complex32],
-    input_buffer: &'a [Complex32],
+pub struct Radix2FFT {
+    output_buffer: Box<[Complex32]>,
+    input_buffer: Box<[Complex32]>,
     size: usize,
     length: usize,
 }
 
-impl<'a> DFT<'a> for Radix2FFT<'a> {
+impl DFT for Radix2FFT {
     // Size as power of two
-    fn create(size: usize, input: &'a [Complex32], output: &'a mut [Complex32]) -> Self {
+    fn create(size: usize) -> Self {
         if !is_power_of_two(size) {
             panic!("Tried to create a Radix2 FFT with a non power of two size.");
         }
 
         Radix2FFT {
-            output_buffer: output,
-            input_buffer: input,
+            output_buffer: vec![Complex32::zero(); size].into_boxed_slice(),
+            input_buffer: vec![Complex32::zero(); size].into_boxed_slice(),
             size: size.ilog2() as usize,
             length: size,
         }
@@ -32,7 +32,7 @@ impl<'a> DFT<'a> for Radix2FFT<'a> {
             *x = self.input_buffer[reverse_bits(i, self.size as u32)];
         }
 
-        for step in 1..self.size {
+        for step in 1..(self.size + 1) {
             let pol_length = 2usize.pow(step as u32);
             let mid_point = pol_length / 2;
             for s in (0..(self.length / pol_length)).map(|i| i * pol_length) {
@@ -40,7 +40,7 @@ impl<'a> DFT<'a> for Radix2FFT<'a> {
                     // Compute current polynomial at each unit root
                     let a = self.output_buffer[s + i];
                     let b = self.output_buffer[s + i + mid_point];
-                    let angle = 2. * PI * (i as f32) / (pol_length as f32);
+                    let angle = - 2. * PI * (i as f32) / (pol_length as f32);
                     let phasor = Complex32::cexp(angle);
                     self.output_buffer[i + s] = a + phasor * b;
                     self.output_buffer[i + s + mid_point] = a - phasor * b;
@@ -48,6 +48,14 @@ impl<'a> DFT<'a> for Radix2FFT<'a> {
             }
         }
     }
+
+    fn get_input(&mut self) -> &mut [Complex32] {
+        &mut self.input_buffer
+    }
+
+    fn get_output(&self) -> &[Complex32] {
+        &self.output_buffer
+    }
 }
 
 // Utilities
@@ -56,7 +64,7 @@ pub fn reverse_bits(n: usize, bit_count: u32) -> usize {
     let mut output = 0usize;
     for _ in 0..bit_count {
         output <<= 1;
-        output |= if (num & 1) == 1 { 0 } else { 1 };
+        output |= num & 1;
         num >>= 1;
     }