Expand description
Library for computing fast fourier transforms on embedded systems.
microfft provides an in-place implementation of the Radix-2 FFT algorithm.
All computations are performed directly on the input buffer and require no
additional allocations. This makes microfft suitable for no_std
environments.
This crate provides three FFT implementations:
complex
: FFT onComplex32
input values (CFFT).real
: FFT on real (f32
) input values (RFFT). AnN
-point RFFT internally computes anN/2
-point CFFT, making it roughly twice as fast as the complex variant.inverse
: Inverse FFT (IFFT), implemented in terms of a CFFT.
§Example
use std::convert::TryInto;
use std::f32::consts::PI;
// generate 16 samples of a sine wave at frequency 3
let sample_count = 16;
let signal_freq = 3.;
let sample_interval = 1. / sample_count as f32;
let mut samples: Vec<_> = (0..sample_count)
.map(|i| (2. * PI * signal_freq * sample_interval * i as f32).sin())
.collect();
// compute the RFFT of the samples
let mut samples: [_; 16] = samples.try_into().unwrap();
let spectrum = microfft::real::rfft_16(&mut samples);
// since the real-valued coefficient at the Nyquist frequency is packed into the
// imaginary part of the DC bin, it must be cleared before computing the amplitudes
spectrum[0].im = 0.0;
// the spectrum has a spike at index `signal_freq`
let amplitudes: Vec<_> = spectrum.iter().map(|c| c.norm() as u32).collect();
assert_eq!(&litudes, &[0, 0, 0, 8, 0, 0, 0, 0]);
Modules§
- FFT on complex inputs (CFFT)
- Inverse FFT (IFFT)
- FFT on real inputs (RFFT)