Fast Fourier Transforms are efficient algorithms for calculating the discrete fourier transform (DFT),
The DFT usually arises as an approximation to the continuous fourier transform when functions are sampled at discrete intervals in space or time. The naive evaluation of the discrete fourier transform is a matrix-vector multiplication @math{W\vec{z}}. A general matrix-vector multiplication takes @math{O(N^2)} operations for @math{N} data-points. Fast fourier transform algorithms use a divide-and-conquer strategy to factorize the matrix @math{W} into smaller sub-matrices, corresponding to the integer factors of the length @math{N}. If @math{N} can be factorized into a product of integers @math{f_1 f_2 ... f_n} then the DFT can be computed in @math{O(N \sum f_i)} operations. For a radix-2 FFT this gives an operation count of @math{O(N \log_2 N)}.
All the FFT functions offer three types of transform: forwards, inverse and backwards, based on the same mathematical definitions. The definition of the forward fourier transform, @math{x = FFT(z)}, is,
and the definition of the inverse fourier transform, @math{x = IFFT(z)}, is,
The factor of @math{1/N} makes this a true inverse. For example, a call
to gsl_fft_complex_forward followed by a call to
gsl_fft_complex_inverse should return the original data (within
numerical errors).
In general there are two possible choices for the sign of the exponential in the transform/ inverse-transform pair. GSL follows the same convention as FFTPACK, using a negative exponential for the forward transform. The advantage of this convention is that the inverse transform recreates the original function with simple fourier synthesis. Numerical Recipes uses the opposite convention, a positive exponential in the forward transform.
The backwards FFT is simply our terminology for an unscaled version of the inverse FFT,
When the overall scale of the result is unimportant it is often convenient to use the backwards FFT instead of the inverse to save unnecessary divisions.