Prime Numbers

9.5 Large-integer multiplication 479
Algorithm 9.5.4 (FFT, recursive form). Given a length-(D =2 d ) signal x
whose DFT (Definition 9.5.3) exists, this algorithm calculates said transform via
a single call FFT(x). We employ the signal-length function len(), and within the
recursion the root g of unity is to have order equal to current signal length.
1. [Recursive FFT function]
FFT(x) {
n = len(x);
if(n == 1) return x;
m = n/2;
X =(x2j) m−1
j=0 ; // The even part of x.
Y =(x2j+1) m−1
j=0 ; // The odd part of x.
X = FFT(X);
Y = FFT(Y ); // Two recursive calls of half length.
U =(Xkmod m) n−1
k=0 ;
V =(g−kYk mod m) n−1
k=0 ; // Use root g of order n.
return U + V ; // Realization of identity (9.22).
}
A little thought shows that the number of operations in the algebraic domain
of interest is
O(D ln D),
and this estimate holds for both multiplies and add/subtracts. The D ln D
complexity is typical of divide-and-conquer algorithms, another example of
which would be the several methods for rapid sorting of elements in a list.
This recursive form is instructive, and does have its applications, but the
overwhelming majority of FFT implementations use a clever loop structure
first achieved in [Cooley and Tukey 1965]. The Cooley–Tukey algorithm uses
the fact that if the elements of the original length-(D = 2 d )signalx are
given a certain “bit-scrambling” permutation, then the FFT can be carried
out with convenient nested loops. The scrambling intended is reverse-binary
reindexing, meaning that xj gets replaced by xk, wherek is the reverse-binary
representation of j. For example, for signal length D =2 5 , the new element
x5 after scrambling is the old x20, because the binary reversal of 5 = 001012
is 101002 = 20. Note that this bit-scrambling of indices could in principle be
carried out via sheer manipulation of indices to create a new, scrambled list;
but it is often more efficient to do the scrambling in place, by using a certain
sequence of two-element transpositions. It is this latter scheme that appears
in the next algorithm.
A most important observation is that the Cooley–Tukey scheme actually
allows the FFT to be performed in place, meaning that an original signal x
is replaced, element by element, with the DFT values. This is an extremely
memory-efficient way to proceed, accounting for a great deal of the popularity
of the Cooley–Tukey and related forms. With bit-scrambling properly done,
the overall Cooley–Tukey scheme yields an in-place, in-order (meaning natural
DFT order) FFT. Historically, the phrase “decimation in time” is attributed to