# [−][src]Crate rustfft

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.

### Normalization

RustFFT does not normalize outputs. Callers must manually normalize the results by scaling each element by
`1/len().sqrt()`

. Multiple normalization steps can be merged into one via pairwise multiplication, so when
doing a forward FFT followed by an inverse FFT, callers can normalize once by scaling each element by `1/len()`

### Output Order

Elements in the output are ordered by ascending frequency, with the first element corresponding to frequency 0.

## Re-exports

`pub extern crate num_complex;` |

`pub extern crate num_traits;` |

## Modules

algorithm | Individual FFT algorithms |

## Structs

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

## Traits

FFT | An umbrella trait for all available FFT algorithms |

FFTnum | Generic floating point number, implemented for f32 and f64 |

IsInverse | A trait that allows FFT algorithms to report whether they compute forward FFTs or inverse FFTs |

Length | A trait that allows FFT algorithms to report their expected input/output size |