COOLEY-TUKEY FFT ALGORITHM

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'' = ''N''₁''N''₂ in terms of smaller DFTs of sizes ''N''₁ and ''N''₂, recursively, in order 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.
See also the fast Fourier transform for information on other FFT algorithms, specializations for real and/or symmetric data, and accuracy in the face of finite floating-point precision.

Contents

History

The radix-2 DIT case

General factorizations

Data reordering, bit reversal, and in-place algorithms

References

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); Gauss did not analyze the asymptotic computational time, however. Various limited forms were also rediscovered several times throughout the 19th and early 20th centuries. FFTs became popular after J. W. Cooley of IBM and John W. Tukey of Princeton published a paper in 1965 reinventing the algorithm and describing how to perform it conveniently on a computer.
Tukey reportedly came up with the idea during a meeting of a US presidential advisory committee discussing ways to detect nuclear-weapon tests in the Soviet Union (Rockmore, 2000). Another participant at that meeting, Richard Garwin of IBM, recognized the potential of the method and put Tukey in touch with Cooley, who implemented it for a different (and less-classified) problem: analyzing 3d crystallographic data (see also: multidimensional FFTs). Cooley and Tukey subsequently published their joint paper, and wide adoption quickly followed.
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. Their paper cited as inspiration only work by I. J. Good on what is now called the prime-factor FFT algorithm (PFA), but it was not realized until later that PFA is a quite different algorithm (only working for sizes that have relatively prime factors, unlike any composite size for Cooley-Tukey).

The radix-2 DIT case

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 of size ''N''/2 with each recursive stage.
The DFT is defined by the formula:
:
where $k$ is an integer ranging from $0$ to $N-1$.
Radix-2 DIT first computes the Fourier transforms of the even-indexed numbers
$e\_m\; =\; x\_\{2m\}$ ($x\_0,\; x\_2,\; ldots,\; x\_\{N-2\}$)
and of the odd-indexed numbers $o\_m\; =\; x\_\{2m+1\}$ ($x\_1,\; x\_3,\; ldots,\; x\_\{N-1\}$), and then combines those two results to produce the Fourier transform 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.
More explicitly, let us write $M=N/2$ and denote the DFT of the even-indexed numbers $e\_m$ by $E\_j$ and the DFT of the odd-indexed numbers $o\_m$ by $O\_j$ ($m=0,ldots,M-1$, $j=0,ldots,M-1$). Then it follows:
:
X_k & = & sum_{m=0}^{rac{N}{2}-1} x_{2m} e^{-rac{2pi i}{N} (2m)k}
+ sum_{m=0}^{rac{N}{2}-1} x_{2m+1} e^{-rac{2pi i}{N} (2m+1)k} \ \
& = & sum_{m=0}^{M-1} e_m e^{-rac{2pi i}{M} mk}
+ e^{-rac{2pi i}{N}k} sum_{m=0}^{M-1} o_m e^{-rac{2pi i}{M} mk} \ \
& = & left{ egin{matrix}
E_k + e^{-rac{2pi i}{N}k} O_k & mbox{if } k E_{k-M} - e^{-rac{2pi i}{N}(k-M)} O_{k-M} & mbox{if } k geq M end{matrix}
ight.
end{matrix}

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 'Danielson-Lanczos' lemma, since the identity was noted by those two authors in 1942 (influenced by Runge's 1903 work). 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 asymptotic complexity they had achieved). The Danielson-Lanczos work predated widespread availability of computers and required hand calculation (possibly with mechanical aides 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). Rescaling the time by the number of operations, this corresponds roughly to a speedup factor of around 800,000. (140 minutes for size 64 may sound like a long time, but it corresponds to an average of at most 16 seconds per floating-point operation, around 20% of which are multiplications...this is a fairly impressive rate for a human being to sustain for almost two and a half hours, especially considering the bookkeeping overhead.)

General factorizations

More generally, Cooley-Tukey algorithms recursively re-express a DFT of a composite size ''N'' = ''N''₁''N''₂ as:
# Perform ''N''₁ DFTs of size ''N''₂.
# Multiply by complex roots of unity called twiddle factors.
# Perform ''N''₂ DFTs of size ''N''₁.
Typically, either ''N''₁ or ''N''₂ is a small factor (''not'' necessarily prime), called the 'radix' (which can differ between stages of the recursion). If ''N''₁ is the radix, it is called a 'decimation in time' (DIT) algorithm, whereas if ''N''₂ 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.)
There are many other variations on the Cooley-Tukey algorithm. 'Mixed-radix' implementations handle composite sizes with a variety of (typically small) factors in addition to two, usually (but not always) employing the O(''N''²) algorithm for the prime base cases of the recursion. Split radix merges radices 2 and 4, exploiting the fact that the first transform of radix 2 requires no twiddle factor, in order to achieve the lowest known arithmetic operation count for power-of-two sizes. (On present-day computers, performance is determined more by cache and CPU pipeline considerations than by strict operation counts; well-optimized FFT implementations often employ larger radices and/or hard-coded base-case transforms of significant size.) Another way of looking at the Cooley-Tukey algorithm is that it re-expresses a size ''N'' one-dimensional DFT as an ''N''₁ by ''N''₂ two-dimensional DFT (plus twiddles), where the output matrix is transposed. The net result of all of these transpositions, for a radix-2 algorithm, corresponds to a bit reversal of the input (DIF) or output (DIT) indices. If, instead of using a small radix, one employs a radix of roughly √''N'' and explicit input/output matrix transpositions, it is called a 'four-step' algorithm (or ''six-step'', depending on the number of transpositions), initially proposed to improve memory locality (Gentleman and Sande, 1966; also Bailey, 1990) e.g. for cache optimization or out-of-core operation.
The general Cooley-Tukey factorization rewrites the indices ''k'' and ''n'' as $k\; =\; N\_2\; k\_1\; +\; k\_2$ and $n\; =\; N\_1\; n\_2\; +\; n\_1$, respectively, where the indices ''k''_a and ''n''_a run from 0..''N''_a-1 (for ''a'' of 1 or 2). That is, it re-indexes the input (''n'') and output (''k'') as ''N''₁ by ''N''₂ 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 $N\_1\; n\_2\; N\_2\; k\_1$ cross term vanishes (its exponential is unity), and the remaining terms give
:$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^{-rac{2pi i}{N_1 N_2} cdot (N_1 n_2 + n_1) cdot (N_2 k_1 + k_2) }
::$=$
sum_{n_1=0}^{N_1-1}
left[ e^{-rac{2pi i}{N} n_1 k_2 }
ight]
left( sum_{n_2=0}^{N_2-1} x_{N_1 n_2 + n_1}
e^{-rac{2pi i}{N_2} n_2 k_2 }
ight)
e^{-rac{2pi i}{N_1} n_1 k_1 }

where the inner sum is a DFT of size ''N''₂, the outer sum is a DFT of size ''N''₁, and the [...] bracketed term is the twiddle factor.
The 1965 Cooley-Tukey paper noted that one can employ an arbitrary radix ''r'' (as well as mixed radices), but failed to realize that the radix butterfly is itself a DFT that can use FFT algorithms. Hence, they reckoned the complexity to be O(''r''² ''N''/''r'' log_''r''''N''), and erroneously concluded that the optimal radix was 3 (the closest integer to ''e''). Gauss also derived the algorithm for arbitrary radices, and gave explicit examples of both radix-3 and radix-6 steps.

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 ''b''₄''b''₃''b''₂''b''₁''b''₀ (e.g. 5 digits for ''N''=32 inputs), is transferred to the index with reversed digits ''b''₀''b''₁''b''₂''b''₃''b''₄ . 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 $E\_k$ and $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 ''b''₄ (for ''N''=32); whereas the two inputs $E\_k$ and $O\_k$ are interleaved in the even and odd elements, corresponding to the ''least'' significant bit ''b''₀. Thus, in order to get the output in the correct place, these two bits must be swapped in the input. If you include all of the recursive stages of a radix-2 DIT algorithm, ''all'' the bits must be swapped and thus one must pre-process the ''input'' with a bit reversal to get in-order output. Correspondingly, the reversed (dual) algorithm is radix-2 DIF, and this takes in-order input and produces bit-reversed ''output'', requiring a bit-reversal post-processing step. Alternatively, some applications (such as convolution) work equally well on bit-reversed data, so one can do radix-2 DIF without bit reversal, followed by processing, followed by the radix-2 DIT inverse DFT 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, even though bit reversal can be done in O(''N'') time and has been the subject of much research (e.g. Karp, 1996; Carter, 1998; and Rubio, 2002). 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 (Stockham, 1966) 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 (Swarztrauber, 1982). Even greater potential SIMD advantages (more consecutive accesses) have been proposed for the 'Pease' (1968) algorithm, 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 and can be argued to have cache-oblivious locality benefits on systems with hierarchical memory (Singleton, 1967; Frigo & Johnson, 2005).
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 (Johnson & Burrus, 1984; Temperton, 1991; Qian ''et al.'', 1994; Hegland, 1994).

References

★ James W. Cooley and John W. Tukey, "An algorithm for the machine calculation of complex Fourier series," ''Math. Comput.'' '19', 297–301 (1965).

★ Carl Friedrich Gauss, "Nachlass: Theoria interpolationis methodo nova tractata," ''Werke'' band '3', 265–327 (Königliche Gesellschaft der Wissenschaften, Göttingen, 1866). See also M. T. Heideman, D. H. Johnson, and C. S. Burrus, "Gauss and the history of the fast Fourier transform," ''IEEE ASSP Magazine'' '1' (4), 14–21 (1984).

★ James W. Cooley, Peter A. W. Lewis, and Peter D. Welch, "Historical notes on the fast Fourier transform," ''IEEE Trans. on Audio and Electroacoustics'' '15' (2), 76–79 (1967).

★ Daniel N. Rockmore, "The FFT — an algorithm the whole family can use", ''Comput. Sci. Eng.'' '2' (1), 60 (2000). Special issue on "top ten" algorithms of the century.

★ G. C. Danielson 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).

★ W. M. Gentleman and G. Sande, "Fast Fourier transforms—for fun and profit," ''Proc. AFIPS'' '29', 563–578 (1966).

★ P. Duhamel and M. Vetterli, "Fast Fourier transforms: a tutorial review and a state of the art," ''Signal Processing'' '19', 259–299 (1990).

★ David H. Bailey, "FFTs in external or hierarchical memory," ''J. Supercomputing'' '4' (1), 23–35 (1990).

★ Alan H. Karp, "Bit reversal on uniprocessors," ''SIAM Review'' '38' (1), 1–26 (1996).

★ Larry Carter and Kang Su Gatlin, "Towards an optimal bit-reversal permutation program," ''Proc. 39th Ann. Symp. on Found. of Comp. Sci. (FOCS)'', 544–553 (1998).

★ M. Rubio, P. Gómez, and K. Drouiche, "A new superfast bit reversal algorithm," ''Intl. J. Adaptive Control and Signal Processing'' '16', 703–707 (2002).

★ T. G. Stockham, "High speed convolution and correlation", ''Spring Joint Computer Conference, Proc. AFIPS'' '28', 229–233 (1966).

★ P. N. Swarztrauber, "Vectorizing the FFTs", in G. Rodrigue (Ed.), ''Parallel Computations'' (Academic Press, New York, 1982), pp. 51–83.

★ M. C. Pease, "An adaptation of the fast Fourier transform for parallel processing", ''J. ACM'' '15' (2), 252–264 (1968).

★ Richard C. Singleton, "On computing the fast Fourier transform", ''Commun. of the ACM'' '10' (1967), 647–654.

★ H. W. Johnson and C. S. Burrus, "An in-place in-order radix-2 FFT," ''Proc. ICASSP'', 28A.2.1–28A.2.4 (1984).

★ C. Temperton, "Self-sorting in-place fast Fourier transform," ''SIAM J. Sci. Stat. Comput.'' '12' (4), 808–823 (1991).

★ Z. Qian, C. Lu, M. An, and R. Tolimieri, "Self-sorting in-place FFT algorithm with minimum working space," ''IEEE Trans. ASSP'' '52' (10), 2835–2836 (1994).

★ M. Hegland, "A self-sorting in-place fast Fourier transform algorithm suitable for vector and parallel processing," ''Numerische Mathematik'' '68' (4), 507–547 (1994).

★ Matteo Frigo and Steven G. Johnson: ''FFTW'', http://www.fftw.org/. A free (GPL) C library for computing discrete Fourier transforms in one or more dimensions, of arbitrary size, using the Cooley-Tukey algorithm. Also M. Frigo and S. G. Johnson, "The Design and Implementation of FFTW3," ''Proceedings of the IEEE'' '93' (2), 216–231 (2005).