Expand description
RustFFT allows users to compute arbitrary-sized FFTs in O(nlogn) time.
The recommended way to use RustFFT is to create a FFTplanner
instance and then call its
plan_fft
method. This method will automatically choose which FFT algorithms are best
for a given size and initialize the required buffers and precomputed data.
// Perform a forward FFT of size 1234
use std::sync::Arc;
use rustfft::FFTplanner;
use rustfft::num_complex::Complex;
use rustfft::num_traits::Zero;
let mut input: Vec<Complex<f32>> = vec![Complex::zero(); 1234];
let mut output: Vec<Complex<f32>> = vec![Complex::zero(); 1234];
let mut planner = FFTplanner::new(false);
let fft = planner.plan_fft(1234);
fft.process(&mut input, &mut output);
// The fft instance returned by the planner is stored behind an `Arc`, so it's cheap to clone
let fft_clone = Arc::clone(&fft);
The planner returns trait objects of the FFT
trait, allowing for FFT sizes that aren’t known
until runtime.
RustFFT also exposes individual FFT algorithms. If you know beforehand that you need a power-of-two FFT, you can avoid the overhead of the planner and trait object by directly creating instances of the Radix4 algorithm:
// Computes a forward FFT of size 4096
use rustfft::algorithm::Radix4;
use rustfft::FFT;
use rustfft::num_complex::Complex;
use rustfft::num_traits::Zero;
let mut input: Vec<Complex<f32>> = vec![Complex::zero(); 4096];
let mut output: Vec<Complex<f32>> = vec![Complex::zero(); 4096];
let fft = Radix4::new(4096, false);
fft.process(&mut input, &mut output);
For the vast majority of situations, simply using the FFTplanner
will be enough, but
advanced users may have better insight than the planner into which algorithms are best for a specific size. See the
algorithm
module for a complete list of algorithms implemented by RustFFT.
Re-exports
pub extern crate num_complex;
pub extern crate num_traits;