Struct rustfft::FFTplanner

pub struct FFTplanner<T> { /* fields omitted */ }

The FFT planner is used to make new FFT algorithm instances.

RustFFT has several FFT algorithms available; For a given FFT size, the FFTplanner decides which of the available FFT algorithms to use and then initializes them.

// 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![Zero::zero(); 1234];
let mut output: Vec<Complex<f32>> = vec![Zero::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);

If you plan on creating multiple FFT instances, it is recommnded to reuse the same planner for all of them. This is because the planner re-uses internal data across FFT instances wherever possible, saving memory and reducing setup time. (FFT instances created with one planner will never re-use data and buffers with FFT instances created by a different planner)

Each FFT instance owns Arcs to its internal data, rather than borrowing it from the planner, so it's perfectly safe to drop the planner after creating FFT instances.

Implementations

impl<T: FFTnum> FFTplanner<T>

pub fn new(inverse: bool) -> Self

Creates a new FFT planner.

If inverse is false, this planner will plan forward FFTs. If inverse is true, it will plan inverse FFTs.

pub fn plan_fft(&mut self, len: usize) -> Arc<dyn FFT<T>>

Returns a FFT instance which processes signals of size len If this is called multiple times, it will attempt to re-use internal data between instances