# Cooley–Tukey FFT algorithm

(Redirected from Danielson-Lanczos lemma)

The Cooley–Tukey algorithm, named after J. W. Cooley and John Tukey, is the most common fast Fourier transform (FFT) algorithm. It re-expresses the discrete Fourier transform (DFT) of an arbitrary composite size N = N1N2 in terms of N1 smaller DFTs of sizes N2, recursively, to reduce the computation time to O(N log N) for highly composite N (smooth numbers). Because of the algorithm's importance, specific variants and implementation styles have become known by their own names, as described below.

Because the Cooley–Tukey algorithm breaks the DFT into smaller DFTs, it can be combined arbitrarily with any other algorithm for the DFT. For example, Rader's or Bluestein's algorithm can be used to handle large prime factors that cannot be decomposed by Cooley–Tukey, or the prime-factor algorithm can be exploited for greater efficiency in separating out relatively prime factors.

The algorithm, along with its recursive application, was invented by Carl Friedrich Gauss. Cooley and Tukey independently rediscovered and popularized it 160 years later.

## History

This algorithm, including its recursive application, was invented around 1805 by Carl Friedrich Gauss, who used it to interpolate the trajectories of the asteroids Pallas and Juno, but his work was not widely recognized (being published only posthumously and in neo-Latin).[1][2] Gauss did not analyze the asymptotic computational time, however. Various limited forms were also rediscovered several times throughout the 19th and early 20th centuries.[2] FFTs became popular after James Cooley of IBM and John Tukey of Princeton published a paper in 1965 reinventing the algorithm and describing how to perform it conveniently on a computer.[3]

Tukey reportedly came up with the idea during a meeting of President Kennedy’s Science Advisory Committee discussing ways to detect nuclear-weapon tests in the Soviet Union by employing seismometers located outside the country. These sensors would generate seismological time series. However, analysis of this data would require fast algorithms for computing DFT due to number of sensors and length of time. This task was critical for the ratification of the proposed nuclear test ban so that any violations could be detected without need to visit Soviet facilities.[4][5] Another participant at that meeting, Richard Garwin of IBM, recognized the potential of the method and put Tukey in touch with Cooley however making sure that Cooley did not know the original purpose. Instead Cooley was told that this was needed to determine periodicities of the spin orientations in a 3-D crystal of Helium-3. Cooley and Tukey subsequently published their joint paper, and wide adoption quickly followed due to the simultaneous development of Analog-to-digital converters capable of sampling at rates up to 300 kHz.

The fact that Gauss had described the same algorithm (albeit without analyzing its asymptotic cost) was not realized until several years after Cooley and Tukey's 1965 paper.[2] Their paper cited as inspiration only the work by I. J. Good on what is now called the prime-factor FFT algorithm (PFA);[3] although Good's algorithm was initially thought to be equivalent to the Cooley–Tukey algorithm, it was quickly realized that PFA is a quite different algorithm (only working for sizes that have relatively prime factors and relying on the Chinese Remainder Theorem, unlike the support for any composite size in Cooley–Tukey).[6]

A radix-2 decimation-in-time (DIT) FFT is the simplest and most common form of the Cooley–Tukey algorithm, although highly optimized Cooley–Tukey implementations typically use other forms of the algorithm as described below. Radix-2 DIT divides a DFT of size N into two interleaved DFTs (hence the name "radix-2") of size N/2 with each recursive stage.

The discrete Fourier transform (DFT) is defined by the formula:

${\displaystyle X_{k}=\sum _{n=0}^{N-1}x_{n}e^{-{\frac {2\pi i}{N}}nk},}$

where ${\displaystyle k}$ is an integer ranging from ${\displaystyle 0}$ to ${\displaystyle N-1}$.

Radix-2 DIT first computes the DFTs of the even-indexed inputs ${\displaystyle (x_{2m}=x_{0},x_{2},\ldots ,x_{N-2})}$ and of the odd-indexed inputs ${\displaystyle (x_{2m+1}=x_{1},x_{3},\ldots ,x_{N-1})}$, and then combines those two results to produce the DFT of the whole sequence. This idea can then be performed recursively to reduce the overall runtime to O(N log N). This simplified form assumes that N is a power of two; since the number of sample points N can usually be chosen freely by the application, this is often not an important restriction.

The Radix-2 DIT algorithm rearranges the DFT of the function ${\displaystyle x_{n}}$ into two parts: a sum over the even-numbered indices ${\displaystyle n={2m}}$ and a sum over the odd-numbered indices ${\displaystyle n={2m+1}}$:

${\displaystyle {\begin{matrix}X_{k}&=&\sum \limits _{m=0}^{N/2-1}x_{2m}e^{-{\frac {2\pi i}{N}}(2m)k}+\sum \limits _{m=0}^{N/2-1}x_{2m+1}e^{-{\frac {2\pi i}{N}}(2m+1)k}\end{matrix}}}$

One can factor a common multiplier ${\displaystyle e^{-{\frac {2\pi i}{N}}k}}$ out of the second sum, as shown in the equation below. It is then clear that the two sums are the DFT of the even-indexed part ${\displaystyle x_{2m}}$ and the DFT of odd-indexed part ${\displaystyle x_{2m+1}}$ of the function ${\displaystyle x_{n}}$. Denote the DFT of the Even-indexed inputs ${\displaystyle x_{2m}}$ by ${\displaystyle E_{k}}$ and the DFT of the Odd-indexed inputs ${\displaystyle x_{2m+1}}$ by ${\displaystyle O_{k}}$ and we obtain:

${\displaystyle {\begin{matrix}X_{k}=\underbrace {\sum \limits _{m=0}^{N/2-1}x_{2m}e^{-{\frac {2\pi i}{N/2}}mk}} _{\mathrm {DFT\;of\;even-indexed\;part\;of\;} x_{n}}{}+e^{-{\frac {2\pi i}{N}}k}\underbrace {\sum \limits _{m=0}^{N/2-1}x_{2m+1}e^{-{\frac {2\pi i}{N/2}}mk}} _{\mathrm {DFT\;of\;odd-indexed\;part\;of\;} x_{n}}=E_{k}+e^{-{\frac {2\pi i}{N}}k}O_{k}.\end{matrix}}}$

Thanks to the periodicity of the complex exponential, ${\displaystyle X_{k+{\frac {N}{2}}}}$ is also obtained from ${\displaystyle E_{k}}$ and ${\displaystyle O_{k}}$:

{\displaystyle {\begin{aligned}X_{k+{\frac {N}{2}}}&=\sum \limits _{m=0}^{N/2-1}x_{2m}e^{-{\frac {2\pi i}{N/2}}m(k+{\frac {N}{2}})}+e^{-{\frac {2\pi i}{N}}(k+{\frac {N}{2}})}\sum \limits _{m=0}^{N/2-1}x_{2m+1}e^{-{\frac {2\pi i}{N/2}}m(k+{\frac {N}{2}})}\\&=\sum \limits _{m=0}^{N/2-1}x_{2m}e^{-{\frac {2\pi i}{N/2}}mk}e^{-2\pi mi}+e^{-{\frac {2\pi i}{N}}k}e^{-\pi i}\sum \limits _{m=0}^{N/2-1}x_{2m+1}e^{-{\frac {2\pi i}{N/2}}mk}e^{-2\pi mi}\\&=\sum \limits _{m=0}^{N/2-1}x_{2m}e^{-{\frac {2\pi i}{N/2}}mk}-e^{-{\frac {2\pi i}{N}}k}\sum \limits _{m=0}^{N/2-1}x_{2m+1}e^{-{\frac {2\pi i}{N/2}}mk}\\&=E_{k}-e^{-{\frac {2\pi i}{N}}k}O_{k}\end{aligned}}}

We can rewrite ${\displaystyle X_{k}}$ as:

${\displaystyle {\begin{matrix}X_{k}&=&E_{k}+e^{-{\frac {2\pi i}{N}}k}O_{k}\\X_{k+{\frac {N}{2}}}&=&E_{k}-e^{-{\frac {2\pi i}{N}}{k}}O_{k}\end{matrix}}}$

This result, expressing the DFT of length N recursively in terms of two DFTs of size N/2, is the core of the radix-2 DIT fast Fourier transform. The algorithm gains its speed by re-using the results of intermediate computations to compute multiple DFT outputs. Note that final outputs are obtained by a +/− combination of ${\displaystyle E_{k}}$ and ${\displaystyle O_{k}\exp(-2\pi ik/N)}$, which is simply a size-2 DFT (sometimes called a butterfly in this context); when this is generalized to larger radices below, the size-2 DFT is replaced by a larger DFT (which itself can be evaluated with an FFT).

Data flow diagram for N=8: a decimation-in-time radix-2 FFT breaks a length-N DFT into two length-N/2 DFTs followed by a combining stage consisting of many size-2 DFTs called "butterfly" operations (so-called because of the shape of the data-flow diagrams).

This process is an example of the general technique of divide and conquer algorithms; in many traditional implementations, however, the explicit recursion is avoided, and instead one traverses the computational tree in breadth-first fashion.

The above re-expression of a size-N DFT as two size-N/2 DFTs is sometimes called the DanielsonLanczos lemma, since the identity was noted by those two authors in 1942[7] (influenced by Runge's 1903 work[2]). They applied their lemma in a "backwards" recursive fashion, repeatedly doubling the DFT size until the transform spectrum converged (although they apparently didn't realize the linearithmic [i.e., order N log N] asymptotic complexity they had achieved). The Danielson–Lanczos work predated widespread availability of computers and required hand calculation (possibly with mechanical aids such as adding machines); they reported a computation time of 140 minutes for a size-64 DFT operating on real inputs to 3–5 significant digits. Cooley and Tukey's 1965 paper reported a running time of 0.02 minutes for a size-2048 complex DFT on an IBM 7094 (probably in 36-bit single precision, ~8 digits).[3] Rescaling the time by the number of operations, this corresponds roughly to a speedup factor of around 800,000. (To put the time for the hand calculation in perspective, 140 minutes for size 64 corresponds to an average of at most 16 seconds per floating-point operation, around 20% of which are multiplications.)

### Pseudocode

In pseudocode, the below procedure could be written:[8]

X0,...,N−1 ← ditfft2(x, N, s):             DFT of (x0, xs, x2s, ..., x(N-1)s):
if N = 1 then
X0 ← x0                                      trivial size-1 DFT base case
else
X0,...,N/2−1 ← ditfft2(x, N/2, 2s)             DFT of (x0, x2s, x4s, ...)
XN/2,...,N−1 ← ditfft2(x+s, N/2, 2s)           DFT of (xs, xs+2s, xs+4s, ...)
for k = 0 to N/2−1                           combine DFTs of two halves into full DFT:
t ← Xk
Xk ← t + exp(−2πi k/N) Xk+N/2
Xk+N/2 ← t − exp(−2πi k/N) Xk+N/2
endfor
endif


Here, ditfft2(x,N,1), computes X=DFT(x) out-of-place by a radix-2 DIT FFT, where N is an integer power of 2 and s=1 is the stride of the input x array. x+s denotes the array starting with xs.

(The results are in the correct order in X and no further bit-reversal permutation is required; the often-mentioned necessity of a separate bit-reversal stage only arises for certain in-place algorithms, as described below.)

High-performance FFT implementations make many modifications to the implementation of such an algorithm compared to this simple pseudocode. For example, one can use a larger base case than N=1 to amortize the overhead of recursion, the twiddle factors ${\displaystyle \exp[-2\pi ik/N]}$ can be precomputed, and larger radices are often used for cache reasons; these and other optimizations together can improve the performance by an order of magnitude or more.[8] (In many textbook implementations the depth-first recursion is eliminated entirely in favor of a nonrecursive breadth-first approach, although depth-first recursion has been argued to have better memory locality.[8][9]) Several of these ideas are described in further detail below.

### C++ Example Code

/* fft.cpp
*
* This is a KISS implementation of
* the Cooley-Tukey recursive FFT algorithm.
* This works, and is visibly clear about what is happening where.
*
* To compile this with the GNU/GCC compiler:
* g++ -o fft fft.cpp -lm
*
* To run the compiled version from a *nix command line:
* ./fft
*
*/
#include <complex>
#include <cstdio>

#define M_PI 3.14159265358979323846 // Pi constant with double precision

using namespace std;

// separate even/odd elements to lower/upper halves of array respectively.
// Due to Butterfly combinations, this turns out to be the simplest way
// to get the job done without clobbering the wrong elements.
void separate (complex<double>* a, int n) {
complex<double>* b = new complex<double>[n/2];  // get temp heap storage
for(int i=0; i<n/2; i++)    // copy all odd elements to heap storage
b[i] = a[i*2+1];
for(int i=0; i<n/2; i++)    // copy all even elements to lower-half of a[]
a[i] = a[i*2];
for(int i=0; i<n/2; i++)    // copy all odd (from heap) to upper-half of a[]
a[i+n/2] = b[i];
delete[] b;                 // delete heap storage
}

// N must be a power-of-2, or bad things will happen.
// Currently no check for this condition.
//
// N input samples in X[] are FFT'd and results left in X[].
// Because of Nyquist theorem, N samples means
// only first N/2 FFT results in X[] are the answer.
// (upper half of X[] is a reflection with no new information).
void fft2 (complex<double>* X, int N) {
if(N < 2) {
// bottom of recursion.
// Do nothing here, because already X[0] = x[0]
} else {
separate(X,N);      // all evens to lower half, all odds to upper half
fft2(X,     N/2);   // recurse even items
fft2(X+N/2, N/2);   // recurse odd  items
// combine results of two half recursions
for(int k=0; k<N/2; k++) {
complex<double> e = X[k    ];   // even
complex<double> o = X[k+N/2];   // odd
// w is the "twiddle-factor"
complex<double> w = exp( complex<double>(0,-2.*M_PI*k/N) );
X[k    ] = e + w * o;
X[k+N/2] = e - w * o;
}
}
}

// simple test program
int main () {
const int nSamples = 64;
double nSeconds = 1.0;                      // total time for sampling
double sampleRate = nSamples / nSeconds;    // n Hz = n / second
double freqResolution = sampleRate / nSamples; // freq step in FFT result
complex<double> x[nSamples];                // storage for sample data
complex<double> X[nSamples];                // storage for FFT answer
const int nFreqs = 5;
double freq[nFreqs] = { 2, 5, 11, 17, 29 }; // known freqs for testing

// generate samples for testing
for(int i=0; i<nSamples; i++) {
x[i] = complex<double>(0.,0.);
// sum several known sinusoids into x[]
for(int j=0; j<nFreqs; j++)
x[i] += sin( 2*M_PI*freq[j]*i/nSamples );
X[i] = x[i];        // copy into X[] for FFT work & result
}
// compute fft for this data
fft2(X,nSamples);

// loop to print values
for(int i=0; i<nSamples; i++) {
printf("% 3d\t%+.3f\t%+.3f\t%g\n",
i, x[i].real(), abs(X[i]), i*freqResolution );
}
}

// eof


### C# Example Code

A C# translation of the C++ Code above:

using System;
using System.Numerics;

class FT
{
public Complex[] x;                // storage for sample data
public Complex[] X;                // storage for FFT answer

// separate even/odd elements to lower/upper halves of array respectively.
// Due to Butterfly combinations, this turns out to be the simplest way
// to get the job done without clobbering the wrong elements.
void Separate(ref Complex[] a, int m, int n)
{
Complex[] b = new Complex[(n - m) / 2];
for (int i = 0; i < (n - m) / 2; i++)    // copy all odd elements to b
b[i] = a[m + i * 2 + 1];
for (int i = 0; i < (n - m) / 2; i++)    // copy all even elements to lower-half of a
a[m + i] = a[m + i * 2];
for (int i = 0; i < (n - m) / 2; i++)    // copy all odd (from b) to upper-half of a[]
a[m + i + (n - m) / 2] = b[i];
}

void FFT2(ref Complex[] X, int m, int n) // m: the first element of the array X
// n - 1: the last element of the array X
{
if (n - m < 2)
{
// bottom of recursion.
// Do nothing here, because already X[0] = x[0]
}
else
{
Separate(ref X, m, n);      // all evens to lower half, all odds to upper half
FFT2(ref X, m, m + (n - m) / 2);   // recurse even items
FFT2(ref X, m + (n - m) / 2, n);   // recurse odd  items
for (int k = 0; k < (n - m) / 2; k++)// combine results of two half recursions
{
Complex e = X[m + k];   // even
Complex o = X[m + k + (n - m) / 2];   // odd
Complex w = Complex.Exp(new Complex(0, -2 * Math.PI * k / (n - m))); // w is the "twiddle-factor"
X[m + k] = e + w * o;
X[m + k + (n - m) / 2] = e - w * o;
}
}
}
double signal(double t)
{
double[] freq = { 2, 5, 11, 17, 29 }; // known freqs for testing
double sum = 0;
for (int j = 0; j < freq.GetLength(0); j++) // sum several known sinusoids into x[]
sum += Math.Sin(2 * Math.PI * freq[j] * t);
return sum;
}

void Fill()
{
// generate samples for testing
int N = x.Length;
for (int i = 0; i < N; i++)
{
x[i] = signal((double)i / N);
X[i] = x[i];  // copy into X[] for FFT work & result
}
}

public FT(int N)
{
x = new Complex[N];                // storage for sample data
X = new Complex[N];                // storage for FFT answer
Fill();
FFT2(ref X, 0, N);
}
}

class Program
{
static void Main()
{
int N = 64;
FT ft = new FT(N);
Console.WriteLine("  n\tx[]\tX[]\tf");
for (int i = 0; i < N; i++)
{
Console.WriteLine(i.ToString() + "\t" + ft.x[i].Real.ToString("0.###") + "\t"
+ Complex.Abs(ft.X[i]).ToString("0.###") + "\t" + i);
}
}
}


## General factorizations

The basic step of the Cooley–Tukey FFT for general factorizations can be viewed as re-interpreting a 1d DFT as something like a 2d DFT. The 1d input array of length N = N1N2 is reinterpreted as a 2d N1×N2 matrix stored in column-major order. One performs smaller 1d DFTs along the N2 direction (the non-contiguous direction), then multiplies by phase factors (twiddle factors), and finally performs 1d DFTs along the N1 direction. The transposition step can be performed in the middle, as shown here, or at the beginning or end. This is done recursively for the smaller transforms.
Illustration of row- and column-major order

More generally, Cooley–Tukey algorithms recursively re-express a DFT of a composite size N = N1N2 as:[10]

1. Perform N1 DFTs of size N2.
2. Multiply by complex roots of unity called twiddle factors.
3. Perform N2 DFTs of size N1.

Typically, either N1 or N2 is a small factor (not necessarily prime), called the radix (which can differ between stages of the recursion). If N1 is the radix, it is called a decimation in time (DIT) algorithm, whereas if N2 is the radix, it is decimation in frequency (DIF, also called the Sande–Tukey algorithm). The version presented above was a radix-2 DIT algorithm; in the final expression, the phase multiplying the odd transform is the twiddle factor, and the +/- combination (butterfly) of the even and odd transforms is a size-2 DFT. (The radix's small DFT is sometimes known as a butterfly, so-called because of the shape of the dataflow diagram for the radix-2 case.)

The general Cooley–Tukey factorization rewrites the indices k and n as ${\displaystyle k=N_{2}k_{1}+k_{2}}$ and ${\displaystyle n=N_{1}n_{2}+n_{1}}$, respectively, where the indices ka and na run from 0..Na-1 (for a of 1 or 2). That is, it re-indexes the input (n) and output (k) as N1 by N2 two-dimensional arrays in column-major and row-major order, respectively; the difference between these indexings is a transposition, as mentioned above. When this re-indexing is substituted into the DFT formula for nk, the ${\displaystyle N_{1}n_{2}N_{2}k_{1}}$ cross term vanishes (its exponential is unity), and the remaining terms give

${\displaystyle X_{N_{2}k_{1}+k_{2}}=\sum _{n_{1}=0}^{N_{1}-1}\sum _{n_{2}=0}^{N_{2}-1}x_{N_{1}n_{2}+n_{1}}e^{-{\frac {2\pi i}{N_{1}N_{2}}}\cdot (N_{1}n_{2}+n_{1})\cdot (N_{2}k_{1}+k_{2})}}$
${\displaystyle =\sum _{n_{1}=0}^{N_{1}-1}\left[e^{-{\frac {2\pi i}{N}}n_{1}k_{2}}\right]\left(\sum _{n_{2}=0}^{N_{2}-1}x_{N_{1}n_{2}+n_{1}}e^{-{\frac {2\pi i}{N_{2}}}n_{2}k_{2}}\right)e^{-{\frac {2\pi i}{N_{1}}}n_{1}k_{1}}}$

where each inner sum is a DFT of size N2, each outer sum is a DFT of size N1, and the [...] bracketed term is the twiddle factor.

## Data reordering, bit reversal, and in-place algorithms

Although the abstract Cooley–Tukey factorization of the DFT, above, applies in some form to all implementations of the algorithm, much greater diversity exists in the techniques for ordering and accessing the data at each stage of the FFT. Of special interest is the problem of devising an in-place algorithm that overwrites its input with its output data using only O(1) auxiliary storage.

The most well-known reordering technique involves explicit bit reversal for in-place radix-2 algorithms. Bit reversal is the permutation where the data at an index n, written in binary with digits b4b3b2b1b0 (e.g. 5 digits for N=32 inputs), is transferred to the index with reversed digits b0b1b2b3b4 . Consider the last stage of a radix-2 DIT algorithm like the one presented above, where the output is written in-place over the input: when ${\displaystyle E_{k}}$ and ${\displaystyle O_{k}}$ are combined with a size-2 DFT, those two values are overwritten by the outputs. However, the two output values should go in the first and second halves of the output array, corresponding to the most significant bit b4 (for N=32); whereas the two inputs ${\displaystyle E_{k}}$ and ${\displaystyle O_{k}}$ are interleaved in the even and odd elements, corresponding to the least significant bit b0. Thus, in order to get the output in the correct place, b0 should take the place of b4 and the index becomes b0b4b3b2b1. And for next recursive stage, those 4 least significant bits will become b1b4b3b2, If you include all of the recursive stages of a radix-2 DIT algorithm, all the bits must be reversed and thus one must pre-process the input (or post-process the output) with a bit reversal to get in-order output. (If each size-N/2 subtransform is to operate on contiguous data, the DIT input is pre-processed by bit-reversal.) Correspondingly, if you perform all of the steps in reverse order, you obtain a radix-2 DIF algorithm with bit reversal in post-processing (or pre-processing, respectively).

The following is pseudocode for iterative radix-2 FFT algorithm implemented using bit-reversal permutation.[18]

 algorithm iterative-fft is
input: Array a of n complex values where n is a power of 2
output: Array A the DFT of a

bit-reverse-copy(a,A)
n ← a.length
for s = 1 to log(n)
m ← 2s
ωm ← exp(−2πi/m)
for k = 0 to n-1 by m
ω ← 1
for j = 0 to m/2 – 1
t ← ω A[k + j + m/2]
u ← A[k + j]
A[k + j] ← u + t
A[k + j + m/2] ← u – t
ω ← ω ωm

return A


The bit-reverse-copy procedure can be implemented as follows.

 algorithm bit-reverse-copy(a,A) is
input: Array a of n complex values where n is a power of 2,
output: Array A of size n

n ← a.length
for k = 0 to n – 1
A[rev(k)] = a[k]


Alternatively, some applications (such as convolution) work equally well on bit-reversed data, so one can perform forward transforms, processing, and then inverse transforms all without bit reversal to produce final results in the natural order.

Many FFT users, however, prefer natural-order outputs, and a separate, explicit bit-reversal stage can have a non-negligible impact on the computation time,[13] even though bit reversal can be done in O(N) time and has been the subject of much research.[19][20][21] Also, while the permutation is a bit reversal in the radix-2 case, it is more generally an arbitrary (mixed-base) digit reversal for the mixed-radix case, and the permutation algorithms become more complicated to implement. Moreover, it is desirable on many hardware architectures to re-order intermediate stages of the FFT algorithm so that they operate on consecutive (or at least more localized) data elements. To these ends, a number of alternative implementation schemes have been devised for the Cooley–Tukey algorithm that do not require separate bit reversal and/or involve additional permutations at intermediate stages.

The problem is greatly simplified if it is out-of-place: the output array is distinct from the input array or, equivalently, an equal-size auxiliary array is available. The Stockham auto-sort algorithm[22][23] performs every stage of the FFT out-of-place, typically writing back and forth between two arrays, transposing one "digit" of the indices with each stage, and has been especially popular on SIMD architectures.[23][24] Even greater potential SIMD advantages (more consecutive accesses) have been proposed for the Pease algorithm,[25] which also reorders out-of-place with each stage, but this method requires separate bit/digit reversal and O(N log N) storage. One can also directly apply the Cooley–Tukey factorization definition with explicit (depth-first) recursion and small radices, which produces natural-order out-of-place output with no separate permutation step (as in the pseudocode above) and can be argued to have cache-oblivious locality benefits on systems with hierarchical memory.[9][13][26]

A typical strategy for in-place algorithms without auxiliary storage and without separate digit-reversal passes involves small matrix transpositions (which swap individual pairs of digits) at intermediate stages, which can be combined with the radix butterflies to reduce the number of passes over the data.[13][27][28][29][30]

## References

1. ^ Gauss, Carl Friedrich (1876) [n.d.]. Theoria Interpolationis Methodo Nova Tractata. Carl Friedrich Gauss Werke. Band 3. Göttingen: Königliche Gesellschaft der Wissenschaften. pp. 265–327.
2. Heideman, M. T., D. H. Johnson, and C. S. Burrus, "Gauss and the history of the fast Fourier transform," IEEE ASSP Magazine, 1, (4), 14–21 (1984)
3. Cooley, James W.; Tukey, John W. (1965). "An algorithm for the machine calculation of complex Fourier series". Math. Comput. 19: 297–301. doi:10.2307/2003354.
4. ^ Cooley, James W.; Lewis, Peter A. W.; Welch, Peter D. (1967). "Historical notes on the fast Fourier transform" (PDF). IEEE Trans. on Audio and Electroacoustics. 15 (2): 76–79. doi:10.1109/tau.1967.1161903.
5. ^ Rockmore, Daniel N. , Comput. Sci. Eng. 2 (1), 60 (2000). The FFT — an algorithm the whole family can use Special issue on "top ten algorithms of the century ""Archived copy" (PDF). Archived from the original (PDF) on 2009-04-07. Retrieved 2009-03-31.
6. ^ James W. Cooley, Peter A. W. Lewis, and Peter W. Welch, "Historical notes on the fast Fourier transform," Proc. IEEE, vol. 55 (no. 10), p. 1675–1677 (1967).
7. ^ Danielson, G. C., and C. Lanczos, "Some improvements in practical Fourier analysis and their application to X-ray scattering from liquids," J. Franklin Inst. 233, 365–380 and 435–452 (1942).
8. ^ a b c S. G. Johnson and M. Frigo, "Implementing FFTs in practice," in Fast Fourier Transforms (C. S. Burrus, ed.), ch. 11, Rice University, Houston TX: Connexions, September 2008.
9. ^ a b Singleton, Richard C. (1967). "On computing the fast Fourier transform". Commun. ACM. 10 (10): 647–654. doi:10.1145/363717.363771.
10. ^ a b Duhamel, P., and M. Vetterli, "Fast Fourier transforms: a tutorial review and a state of the art," Signal Processing 19, 259–299 (1990)
11. ^ Lundy, T., and J. Van Buskirk, "A new matrix approach to real FFTs and convolutions of length 2k," Computing 80, 23–45 (2007).
12. ^ Johnson, S. G., and M. Frigo, "A modified split-radix FFT with fewer arithmetic operations," IEEE Trans. Signal Processing 55 (1), 111–119 (2007).
13. Frigo, M.; Johnson, S. G. (2005). "The Design and Implementation of FFTW3" (PDF). Proceedings of the IEEE. 93 (2): 216–231. doi:10.1109/JPROC.2004.840301.
14. ^ a b Gentleman W. M., and G. Sande, "Fast Fourier transforms—for fun and profit," Proc. AFIPS 29, 563–578 (1966).
15. ^ a b Bailey, David H., "FFTs in external or hierarchical memory," J. Supercomputing 4 (1), 23–35 (1990)
16. ^ a b M. Frigo, C. E. Leiserson, H. Prokop, and S. Ramachandran. Cache-oblivious algorithms. In Proceedings of the 40th IEEE Symposium on Foundations of Computer Science (FOCS 99), p.285-297. 1999. Extended abstract at IEEE, at Citeseer.
17. ^ Cooley, J. W., P. Lewis and P. Welch, "The Fast Fourier Transform and its Applications", IEEE Trans on Education 12, 1, 28–34 (1969)
18. ^ al.], Thomas H. Cormen ... [et; Leiserson, Charles; Rivest, Ronald; Stein, Clifford (2009). Introduction to algorithms (3rd ed.). Cambridge, Mass.: MIT Press. pp. 915–918. ISBN 978-0-262-03384-8.
19. ^ Karp, Alan H. (1996). "Bit reversal on uniprocessors". SIAM Review. 38 (1): 1–26. doi:10.1137/1038001. JSTOR 2132972.
20. ^ Carter, Larry; Gatlin, Kang Su (1998). "Towards an optimal bit-reversal permutation program". Proc. 39th Ann. Symp. on Found. of Comp. Sci. (FOCS): 544–553. doi:10.1109/SFCS.1998.743505.
21. ^ Rubio, M.; Gómez, P.; Drouiche, K. (2002). "A new superfast bit reversal algorithm". Intl. J. Adaptive Control and Signal Processing. 16 (10): 703–707. doi:10.1002/acs.718.
22. ^ Originally attributed to Stockham in W. T. Cochran et al., What is the fast Fourier transform?, Proc. IEEE vol. 55, 1664–1674 (1967).
23. ^ a b P. N. Swarztrauber, FFT algorithms for vector computers, Parallel Computing vol. 1, 45–63 (1984).
24. ^ Swarztrauber, P. N. (1982). "Vectorizing the FFTs". In Rodrigue, G. Parallel Computations. New York: Academic Press. pp. 51–83. ISBN 0-12-592101-2.
25. ^ Pease, M. C. (1968). "An adaptation of the fast Fourier transform for parallel processing". J. ACM. 15 (2): 252–264. doi:10.1145/321450.321457.
26. ^ Frigo, Matteo; Johnson, Steven G. "FFTW". A free (GPL) C library for computing discrete Fourier transforms in one or more dimensions, of arbitrary size, using the Cooley–Tukey algorithm
27. ^ Johnson, H. W.; Burrus, C. S. (1984). "An in-place in-order radix-2 FFT". Proc. ICASSP: 28A.2.1–28A.2.4.
28. ^ Temperton, C. (1991). "Self-sorting in-place fast Fourier transform". SIAM Journal on Scientific and Statistical Computing. 12 (4): 808–823. doi:10.1137/0912043.
29. ^ Qian, Z.; Lu, C.; An, M.; Tolimieri, R. (1994). "Self-sorting in-place FFT algorithm with minimum working space". IEEE Trans. ASSP. 52 (10): 2835–2836. doi:10.1109/78.324749.
30. ^ Hegland, M. (1994). "A self-sorting in-place fast Fourier transform algorithm suitable for vector and parallel processing". Numerische Mathematik. 68 (4): 507–547. doi:10.1007/s002110050074.