octagonal/rdsp-experiments
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

begin cleaning ffts

Browse Source
This commit is contained in:
Albin Chaboissier
2025-09-24 19:24:40 +02:00
parent bd7ae2b19e
commit 3cc4144747
11 changed files with 152 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
src/fft/dft.rs
View File

@ -3,8 +3,6 @@ use crate::fft::{DFT, FFTDirection};
use std::f32::consts::PI;
pub struct NaiveDFT {
output_buffer: Box<[Complex32]>,
input_buffer: Box<[Complex32]>,
direction: FFTDirection,
size: usize,
}
@ -14,18 +12,13 @@ impl DFT for NaiveDFT {
where
Self: Sized,
{
NaiveDFT {
output_buffer: vec![Complex32::zero(); size].into_boxed_slice(),
input_buffer: vec![Complex32::zero(); size].into_boxed_slice(),
direction,
size,
}
NaiveDFT { direction, size }
}
fn execute(&mut self, window: fn(f32) -> f32) {
for (freq, out) in self.output_buffer.iter_mut().enumerate() {
fn execute(&mut self, input: &[Complex32], output: &mut [Complex32], window: fn(f32) -> f32) {
for (freq, out) in output.iter_mut().enumerate() {
*out = Complex32::zero();
for (i, inp) in self.input_buffer.iter().enumerate() {
for (i, inp) in input.iter().enumerate() {
*out = *out
+ ((*inp
* Complex32::cexp(
@ -35,12 +28,4 @@ impl DFT for NaiveDFT {
}
}
}
fn get_input(&mut self) -> &mut [Complex32] {
&mut self.input_buffer
}
fn get_output(&self) -> &[Complex32] {
&self.output_buffer
}
}

6
src/fft/mixed_radix.rs
View File

@ -8,8 +8,6 @@ use crate::{
};
pub struct MixedRadixFFT {
input_buffer: Box<[Complex32]>,
output_buffer: Box<[Complex32]>,
size: usize,
p: usize,
@ -33,8 +31,6 @@ impl DFT for MixedRadixFFT {
//let pfft = Box::new(NaiveDFT::create(p, direction));
MixedRadixFFT {
input_buffer: vec![Complex32::zero(); size].into_boxed_slice(),
output_buffer: vec![Complex32::zero(); size].into_boxed_slice(),
size,
twiddle_factors: compute_twiddle_factors(size, direction),
qfft,
@ -46,7 +42,7 @@ impl DFT for MixedRadixFFT {
}
}
fn execute(&mut self, window: fn(f32) -> f32) {
fn execute(&mut self, input: &[Complex32], output: &mut [Complex32], window: fn(f32) -> f32) {
// Perform p ffts of size q
for k0 in 0..self.p {
// Copy samples into input buffer

59
src/fft/rader.rs
View File

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

26
src/fft/radix2.rs
View File

@ -5,8 +5,6 @@ use crate::fft::{DFT, FFTDirection};
use std::f32::consts::PI;
pub struct Radix2FFT {
output_buffer: Box<[Complex32]>,
input_buffer: Box<[Complex32]>,
direction: FFTDirection,
size: usize,
length: usize,
@ -20,19 +18,17 @@ impl DFT for Radix2FFT {
}
Radix2FFT {
output_buffer: vec![Complex32::zero(); size].into_boxed_slice(),
input_buffer: vec![Complex32::zero(); size].into_boxed_slice(),
size: size.ilog2() as usize,
direction,
length: size,
}
}
fn execute(&mut self, window: fn(f32) -> f32) {
fn execute(&mut self, input: &[Complex32], output: &mut [Complex32], window: fn(f32) -> f32) {
// Reorder samples
for (i, x) in self.output_buffer.iter_mut().enumerate() {
for (i, x) in output.iter_mut().enumerate() {
let k = reverse_bits(i, self.size as u32);
*x = self.input_buffer[k] * window(k as f32 / self.size as f32);
*x = input[k] * window(k as f32 / self.size as f32);
}
for step in 1..(self.size + 1) {
@ -41,24 +37,16 @@ impl DFT for Radix2FFT {
for s in (0..(self.length / pol_length)).map(|i| i * pol_length) {
for i in 0..mid_point {
// Compute current polynomial at each unit root
let a = self.output_buffer[s + i];
let b = self.output_buffer[s + i + mid_point];
let a = output[s + i];
let b = output[s + i + mid_point];
let angle = -2. * self.direction.sign() * 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;
output[i + s] = a + phasor * b;
output[i + s + mid_point] = a - phasor * b;
}
}
}
}
fn get_input(&mut self) -> &mut [Complex32] {
&mut self.input_buffer
}
fn get_output(&self) -> &[Complex32] {
&self.output_buffer
}
}
// Utilities

2
src/fft/windows.rs
View File

@ -1,4 +1,4 @@
pub fn rectanguar(t: f32) -> f32 {
pub fn rectangular(t: f32) -> f32 {
1.
}