Fast Fourier transform

“FFT” redirects here. For other uses, see FFT (disam-biguation).A fast Fourier transform (FFT) algorithm computes

Time signal of a five term cosine series. Frequencies are multiplesof 10 times sqrt(2). Amplitudes are 1, 2, 3, 4, 5. Time step is0.001 s

the discrete Fourier transform (DFT) of a sequence, or itsinverse. Fourier analysis converts a signal from its origi-nal domain (often time or space) to a representation in thefrequency domain and vice versa. An FFT rapidly com-putes such transformations by factorizing the DFTmatrixinto a product of sparse (mostly zero) factors.[1] As a re-sult, it manages to reduce the complexity of computingthe DFT from O(n2) , which arises if one simply appliesthe definition of DFT, toO(n logn) , where n is the datasize.Fast Fourier transforms are widely used for many applica-tions in engineering, science, andmathematics. The basicideas were popularized in 1965, but some algorithms hadbeen derived as early as 1805.[2] In 1994 Gilbert Strangdescribed the FFT as “the most important numerical al-gorithm of our lifetime”[3] and it was included in Top 10Algorithms of 20th Century by the IEEE journal Com-puting in Science & Engineering.[4]

1 Overview

There are many different FFT algorithms involvinga wide range of mathematics, from simple complex-number arithmetic to group theory and number theory;this article gives an overview of the available techniquesand some of their general properties, while the specificalgorithms are described in subsidiary articles linked be-low.The DFT is obtained by decomposing a sequence of val-ues into components of different frequencies.[2] This op-eration is useful in many fields (see discrete Fourier trans-

form for properties and applications of the transform) butcomputing it directly from the definition is often too slowto be practical. An FFT is a way to compute the same re-sult more quickly: computing the DFT of N points in thenaive way, using the definition, takes O(N2) arithmeti-cal operations, while an FFT can compute the same DFTin only O(N log N) operations. The difference in speedcan be enormous, especially for long data sets where Nmay be in the thousands or millions. In practice, thecomputation time can be reduced by several orders ofmagnitude in such cases, and the improvement is roughlyproportional to N / log(N). This huge improvement madethe calculation of the DFT practical; FFTs are of greatimportance to a wide variety of applications, from digitalsignal processing and solving partial differential equa-tions to algorithms for quick multiplication of large in-tegers.The best-known FFT algorithms depend upon thefactorization of N, but there are FFTs with O(N log N)complexity for all N, even for prime N. Many FFT al-gorithms only depend on the fact that e− 2πi

N is an N-thprimitive root of unity, and thus can be applied to anal-ogous transforms over any finite field, such as number-theoretic transforms. Since the inverse DFT is the sameas the DFT, but with the opposite sign in the exponent anda 1/N factor, any FFT algorithm can easily be adapted forit.

2 History

The development of fast algorithms for DFT can betraced to Gauss's unpublished work in 1805 when heneeded it to interpolate the orbit of asteroids Pallas andJuno from sample observations.[5] His method was verysimilar to the one published in 1965 byCooley and Tukey,who are generally credited for the invention of the mod-ern generic FFT algorithm. While Gauss’s work pre-dated even Fourier's results in 1822, he did not analyzethe computation time and eventually used other methodsto achieve his goal.Between 1805 and 1965, some versions of FFT werepublished by other authors. Yates in 1932 published hisversion called interaction algorithm, which provided effi-cient computation of Hadamard andWalsh transforms.[6]Yates’ algorithm is still used in the field of statistical de-sign and analysis of experiments. In 1942, Danielson andLanczos published their version to compute DFT for x-ray crystallography, a field where calculation of Fourier

1

2 4 ALGORITHMS

transforms presented a formidable bottleneck.[7] Whilemany methods in the past had focused on reducing theconstant factor for O(n2) computation by taking advan-tage of symmetries, Danielson and Lanczos realized thatone could use the periodicity and apply a “doubling trick”to get O(n logn) runtime.[8]

Cooley and Tukey published a more general version ofFFT in 1965 that is applicable when N is composite andnot necessarily a power of 2.[9] Tukey came up with theidea during a meeting of President Kennedy’s ScienceAdvisory Committee where a discussion topic involveddetecting nuclear tests by the Soviet Union by setting upsensors to surround the country from outside. To ana-lyze the output of these sensors, a fast Fourier transformalgorithm would be needed. Tukey’s idea was taken byRichard Garwin and given to Cooley (both worked atIBM’s Watson labs) for implementation while hiding theoriginal purpose from him for security reasons. The pairpublished the paper in a relatively short six months.[10]As Tukey didn't work at IBM, the patentability of theidea was doubted and the algorithm went into the pub-lic domain, which, through the computing revolution ofthe next decade, made FFT one of the indispensable al-gorithms in digital signal processing.

3 Definition and speed

An FFT computes the DFT and produces exactly thesame result as evaluating the DFT definition directly; themost important difference is that an FFT is much faster.(In the presence of round-off error, many FFT algorithmsare alsomuchmore accurate than evaluating theDFT def-inition directly, as discussed below.)Let x0, ...., xN−₁ be complex numbers. The DFT is de-fined by the formula

Xk =

N−1∑n=0

xne−i2πk n

N k = 0, . . . , N − 1.

Evaluating this definition directly requires O(N2) opera-tions: there are N outputs Xk, and each output requires asum of N terms. An FFT is any method to compute thesame results in O(N log N) operations. More precisely,all known FFT algorithms require Θ(N log N) operations(technically, O only denotes an upper bound), althoughthere is no known proof that a lower complexity score isimpossible.(Johnson and Frigo, 2007)To illustrate the savings of an FFT, consider the countof complex multiplications and additions. Evaluating theDFT’s sums directly involves N2 complex multiplicationsand N(N−1) complex additions [of which O(N) opera-tions can be saved by eliminating trivial operations such asmultiplications by 1]. The well-known radix-2 Cooley–Tukey algorithm, for N a power of 2, can compute the

same result with only (N/2)log2(N) complex multiplica-tions (again, ignoring simplifications of multiplications by1 and similar) and Nlog2(N) complex additions. In prac-tice, actual performance on modern computers is usuallydominated by factors other than the speed of arithmeticoperations and the analysis is a complicated subject (see,e.g., Frigo & Johnson, 2005), but the overall improve-ment from O(N2) to O(N log N) remains.

4 Algorithms

4.1 Cooley–Tukey algorithm

Main article: Cooley–Tukey FFT algorithm

By far themost commonly used FFT is the Cooley–Tukeyalgorithm. This is a divide and conquer algorithm thatrecursively breaks down a DFT of any composite sizeN = N1N2 into many smaller DFTs of sizes N1 andN2, along with O(N) multiplications by complex rootsof unity traditionally called twiddle factors (after Gentle-man and Sande, 1966[11]).This method (and the general idea of an FFT) was pop-ularized by a publication of J. W. Cooley and J. W.Tukey in 1965,[9] but it was later discovered[2] that thosetwo authors had independently re-invented an algorithmknown to Carl Friedrich Gauss around 1805[12] (and sub-sequently rediscovered several times in limited forms).The best known use of the Cooley–Tukey algorithm is todivide the transform into two pieces of size N/2 at eachstep, and is therefore limited to power-of-two sizes, butany factorization can be used in general (as was knownto both Gauss and Cooley/Tukey[2]). These are called theradix-2 and mixed-radix cases, respectively (and othervariants such as the split-radix FFT have their own namesas well). Although the basic idea is recursive, most tradi-tional implementations rearrange the algorithm to avoidexplicit recursion. Also, because the Cooley–Tukey algo-rithm breaks the DFT into smaller DFTs, it can be com-bined arbitrarily with any other algorithm for the DFT,such as those described below.

4.2 Other FFT algorithms

Main articles: Prime-factor FFT algorithm, Bruun’s FFTalgorithm, Rader’s FFT algorithm and Bluestein’s FFTalgorithm

There are other FFT algorithms distinct from Cooley–Tukey.Cornelius Lanczos did pioneering work on the FFS andFFT with G.C. Danielson (1940).For N = N1N2 with coprime N1 and N2, one can use the

3

Prime-Factor (Good-Thomas) algorithm (PFA), basedon the Chinese Remainder Theorem, to factorize theDFT similarly to Cooley–Tukey but without the twid-dle factors. The Rader-Brenner algorithm (1976) is aCooley–Tukey-like factorization but with purely imagi-nary twiddle factors, reducing multiplications at the costof increased additions and reduced numerical stability; itwas later superseded by the split-radix variant of Cooley–Tukey (which achieves the same multiplication countbut with fewer additions and without sacrificing accu-racy). Algorithms that recursively factorize the DFT intosmaller operations other than DFTs include the Bruunand QFT algorithms. (The Rader-Brenner and QFT al-gorithms were proposed for power-of-two sizes, but it ispossible that they could be adapted to general compositen. Bruun’s algorithm applies to arbitrary even compos-ite sizes.) Bruun’s algorithm, in particular, is based oninterpreting the FFT as a recursive factorization of thepolynomial zN−1, here into real-coefficient polynomialsof the form zM−1 and z2M + azM + 1.Another polynomial viewpoint is exploited by theWinograd algorithm, which factorizes zN−1 intocyclotomic polynomials—these often have coefficientsof 1, 0, or −1, and therefore require few (if any)multiplications, so Winograd can be used to obtainminimal-multiplication FFTs and is often used to findefficient algorithms for small factors. Indeed, Winogradshowed that the DFT can be computed with only O(N)irrational multiplications, leading to a proven achievablelower bound on the number of multiplications forpower-of-two sizes; unfortunately, this comes at the costof many more additions, a tradeoff no longer favorableon modern processors with hardware multipliers. Inparticular, Winograd also makes use of the PFA as wellas an algorithm by Rader for FFTs of prime sizes.Rader’s algorithm, exploiting the existence of a generatorfor the multiplicative group modulo prime N, expressesa DFT of prime size n as a cyclic convolution of (com-posite) size N−1, which can then be computed by a pairof ordinary FFTs via the convolution theorem (althoughWinograd uses other convolution methods). Anotherprime-size FFT is due to L. I. Bluestein, and is sometimescalled the chirp-z algorithm; it also re-expresses a DFTas a convolution, but this time of the same size (whichcan be zero-padded to a power of two and evaluated byradix-2 Cooley–Tukey FFTs, for example), via the iden-tity nk = −(k − n)2/2 + n2/2 + k2/2 .

5 FFT algorithms specialized forreal and/or symmetric data

In many applications, the input data for the DFT arepurely real, in which case the outputs satisfy the symme-try

XN−k = X∗k

and efficient FFT algorithms have been designed for thissituation (see e.g. Sorensen, 1987). One approach con-sists of taking an ordinary algorithm (e.g. Cooley–Tukey)and removing the redundant parts of the computation,saving roughly a factor of two in time andmemory. Alter-natively, it is possible to express an even-length real-inputDFT as a complex DFT of half the length (whose real andimaginary parts are the even/odd elements of the originalreal data), followed by O(N) post-processing operations.It was once believed that real-input DFTs could be moreefficiently computed by means of the discrete Hartleytransform (DHT), but it was subsequently argued that aspecialized real-input DFT algorithm (FFT) can typicallybe found that requires fewer operations than the corre-sponding DHT algorithm (FHT) for the same number ofinputs. Bruun’s algorithm (above) is another method thatwas initially proposed to take advantage of real inputs,but it has not proved popular.There are further FFT specializations for the cases ofreal data that have even/odd symmetry, in which caseone can gain another factor of (roughly) two in time andmemory and the DFT becomes the discrete cosine/sinetransform(s) (DCT/DST). Instead of directly modifyingan FFT algorithm for these cases, DCTs/DSTs can alsobe computed via FFTs of real data combined with O(N)pre/post processing.

6 Computational issues

6.1 Bounds on complexity and operationcounts

A fundamental question of longstanding theoretical in-terest is to prove lower bounds on the complexity and ex-act operation counts of fast Fourier transforms, and manyopen problems remain. It is not even rigorously provedwhether DFTs truly require Ω(N log(N)) (i.e., order Nlog(N) or greater) operations, even for the simple caseof power of two sizes, although no algorithms with lowercomplexity are known. In particular, the count of arith-metic operations is usually the focus of such questions, al-though actual performance on modern-day computers isdetermined by many other factors such as cache or CPUpipeline optimization.Following pioneering work by Winograd (1978), a tightΘ(N) lower bound is known for the number of real mul-tiplications required by an FFT. It can be shown that only4N − 2 log22 N − 2 log2 N − 4 irrational real multipli-cations are required to compute a DFT of power-of-twolength N = 2m . Moreover, explicit algorithms thatachieve this count are known (Heideman&Burrus, 1986;Duhamel, 1990). Unfortunately, these algorithms require

4 6 COMPUTATIONAL ISSUES

too many additions to be practical, at least on moderncomputers with hardware multipliers (Duhamel, 1990;Frigo & Johnson, 2005).A tight lower bound is not known on the number ofrequired additions, although lower bounds have beenproved under some restrictive assumptions on the algo-rithms. In 1973, Morgenstern proved an Ω(N log(N))lower bound on the addition count for algorithms wherethe multiplicative constants have bounded magnitudes(which is true for most but not all FFT algorithms). Thisresult, however, applies only to the unnormalized Fouriertransform (which is a scaling of a unitary matrix by a fac-tor of

√N ), and does not explain why the Fourier matrix

is harder to compute than any other unitary matrix (in-cluding the identity matrix) under the same scaling. Pan(1986) proved an Ω(N log(N)) lower bound assuming abound on a measure of the FFT algorithm’s “asynchronic-ity”, but the generality of this assumption is unclear. Forthe case of power-of-twoN, Papadimitriou (1979) arguedthat the number N log2 N of complex-number additionsachieved by Cooley–Tukey algorithms is optimal undercertain assumptions on the graph of the algorithm (hisassumptions imply, among other things, that no additiveidentities in the roots of unity are exploited). (This argu-ment would imply that at least 2N log2 N real additionsare required, although this is not a tight bound becauseextra additions are required as part of complex-numbermultiplications.) Thus far, no published FFT algorithmhas achieved fewer than N log2 N complex-number ad-ditions (or their equivalent) for power-of-two N.A third problem is to minimize the total number ofreal multiplications and additions, sometimes called the“arithmetic complexity” (although in this context it is theexact count and not the asymptotic complexity that is be-ing considered). Again, no tight lower bound has beenproven. Since 1968, however, the lowest published countfor power-of-two N was long achieved by the split-radixFFT algorithm, which requires 4N log2 N − 6N + 8real multiplications and additions for N > 1. This wasrecently reduced to ∼ 34

9 N log2 N (Johnson and Frigo,2007; Lundy and Van Buskirk, 2007). A slightly largercount (but still better than split radix for N≥256) wasshown to be provably optimal for N≤512 under addi-tional restrictions on the possible algorithms (split-radix-like flowgraphs with unit-modulus multiplicative factors),by reduction to a Satisfiability Modulo Theories problemsolvable by brute force (Haynal & Haynal, 2011).Most of the attempts to lower or prove the complexity ofFFT algorithms have focused on the ordinary complex-data case, because it is the simplest. However, complex-data FFTs are so closely related to algorithms for relatedproblems such as real-data FFTs, discrete cosine trans-forms, discrete Hartley transforms, and so on, that anyimprovement in one of these would immediately lead toimprovements in the others (Duhamel & Vetterli, 1990).

6.2 Approximations

All of the FFT algorithms discussed above compute theDFT exactly (in exact arithmetic, i.e. neglecting floating-point errors). A few “FFT” algorithms have been pro-posed, however, that compute the DFT approximately,with an error that can be made arbitrarily small at theexpense of increased computations. Such algorithmstrade the approximation error for increased speed or otherproperties. For example, an approximate FFT algorithmby Edelman et al. (1999) achieves lower communica-tion requirements for parallel computing with the helpof a fast multipole method. A wavelet-based approxi-mate FFT by Guo and Burrus (1996) takes sparse in-puts/outputs (time/frequency localization) into accountmore efficiently than is possible with an exact FFT. An-other algorithm for approximate computation of a subsetof the DFT outputs is due to Shentov et al. (1995). TheEdelman algorithmworks equally well for sparse and non-sparse data, since it is based on the compressibility (rankdeficiency) of the Fourier matrix itself rather than thecompressibility (sparsity) of the data. Conversely, if thedata are sparse—that is, if only K out ofN Fourier coeffi-cients are nonzero—then the complexity can be reducedto O(Klog(N)log(N/K)), and this has been demonstratedto lead to practical speedups compared to an ordinaryFFT for N/K>32 in a large-N example (N=222) using aprobabilistic approximate algorithm (which estimates thelargest K coefficients to several decimal places).[13]

6.3 Accuracy

Even the “exact” FFT algorithms have errors when finite-precision floating-point arithmetic is used, but these er-rors are typically quite small; most FFT algorithms, e.g.Cooley–Tukey, have excellent numerical properties as aconsequence of the pairwise summation structure of thealgorithms. The upper bound on the relative error forthe Cooley–Tukey algorithm is O(ε log N), compared toO(εN3/2) for the naïve DFT formula,[11] where ε is themachine floating-point relative precision. In fact, the rootmean square (rms) errors are much better than these up-per bounds, being only O(ε √log N) for Cooley–Tukeyand O(ε √N) for the naïve DFT (Schatzman, 1996).These results, however, are very sensitive to the accu-racy of the twiddle factors used in the FFT (i.e. thetrigonometric function values), and it is not unusual forincautious FFT implementations to have much worse ac-curacy, e.g. if they use inaccurate trigonometric recur-rence formulas. Some FFTs other than Cooley–Tukey,such as the Rader-Brenner algorithm, are intrinsically lessstable.In fixed-point arithmetic, the finite-precision errors ac-cumulated by FFT algorithms are worse, with rms er-rors growing as O(√N) for the Cooley–Tukey algorithm(Welch, 1969). Moreover, even achieving this accuracyrequires careful attention to scaling to minimize loss of

5

precision, and fixed-point FFT algorithms involve rescal-ing at each intermediate stage of decompositions likeCooley–Tukey.To verify the correctness of an FFT implementation, rig-orous guarantees can be obtained in O(Nlog(N)) timeby a simple procedure checking the linearity, impulse-response, and time-shift properties of the transform onrandom inputs (Ergün, 1995).

7 Multidimensional FFTs

As defined in the multidimensional DFT article, the mul-tidimensional DFT

Xk =N−1∑n=0

e−2πik·(n/N)xn

transforms an array x with a d-dimensional vector of in-dices n = (n1, . . . , nd) by a set of d nested summations(over nj = 0 . . . Nj − 1 for each j), where the divisionn/N, defined as n/N = (n1/N1, . . . , nd/Nd) , is per-formed element-wise. Equivalently, it is the compositionof a sequence of d sets of one-dimensional DFTs, per-formed along one dimension at a time (in any order).This compositional viewpoint immediately provides thesimplest and most common multidimensional DFT algo-rithm, known as the row-column algorithm (after thetwo-dimensional case, below). That is, one simply per-forms a sequence of d one-dimensional FFTs (by anyof the above algorithms): first you transform along then1 dimension, then along the n2 dimension, and so on(or actually, any ordering works). This method is easilyshown to have the usual O(Nlog(N)) complexity, whereN = N1 ·N2 · . . . ·Nd is the total number of data pointstransformed. In particular, there are N/N1 transforms ofsize N1, etcetera, so the complexity of the sequence ofFFTs is:

N

N1O(N1 logN1) + · · ·+ N

NdO(Nd logNd)

= O (N [logN1 + · · ·+ logNd]) = O(N logN).

In two dimensions, the x can be viewed as an n1 × n2

matrix, and this algorithm corresponds to first perform-ing the FFT of all the rows (resp. columns), grouping theresulting transformed rows (resp. columns) together asanother n1 × n2 matrix, and then performing the FFTon each of the columns (resp. rows) of this second ma-trix, and similarly grouping the results into the final resultmatrix.In more than two dimensions, it is often advantageous forcache locality to group the dimensions recursively. Forexample, a three-dimensional FFT might first perform

two-dimensional FFTs of each planar “slice” for eachfixed n1, and then perform the one-dimensional FFTsalong the n1 direction. More generally, an asymptoticallyoptimal cache-oblivious algorithm consists of recursivelydividing the dimensions into two groups (n1, . . . , nd/2)and (nd/2+1, . . . , nd) that are transformed recursively(rounding if d is not even) (see Frigo and Johnson, 2005).Still, this remains a straightforward variation of the row-column algorithm that ultimately requires only a one-dimensional FFT algorithm as the base case, and still hasO(Nlog(N)) complexity. Yet another variation is to per-form matrix transpositions in between transforming sub-sequent dimensions, so that the transforms operate oncontiguous data; this is especially important for out-of-core and distributed memory situations where accessingnon-contiguous data is extremely time-consuming.There are other multidimensional FFT algorithms that aredistinct from the row-column algorithm, although all ofthem have O(Nlog(N)) complexity. Perhaps the simplestnon-row-column FFT is the vector-radix FFT algorithm,which is a generalization of the ordinary Cooley–Tukeyalgorithm where one divides the transform dimensions bya vector r = (r1, r2, . . . , rd) of radices at each step.(This may also have cache benefits.) The simplest caseof vector-radix is where all of the radices are equal (e.g.vector-radix-2 divides all of the dimensions by two), butthis is not necessary. Vector radix with only a single non-unit radix at a time, i.e. r = (1, . . . , 1, r, 1, . . . , 1) , isessentially a row-column algorithm. Other, more compli-cated, methods include polynomial transform algorithmsdue to Nussbaumer (1977), which view the transformin terms of convolutions and polynomial products. SeeDuhamel and Vetterli (1990) for more information andreferences.

8 Other generalizations

An O(N5/2log(N)) generalization to spherical harmon-ics on the sphere S2 with N2 nodes was described byMohlenkamp,[14] along with an algorithm conjectured(but not proven) to have O(N2 log2(N)) complexity;Mohlenkamp also provides an implementation in thelibftsh library. A spherical-harmonic algorithm withO(N2log(N)) complexity is described by Rokhlin andTygert.[15]

The Fast Folding Algorithm is analogous to the FFT,except that it operates on a series of binned waveformsrather than a series of real or complex scalar values. Ro-tation (which in the FFT is multiplication by a complexphasor) is a circular shift of the component waveform.Various groups have also published “FFT” algorithms fornon-equispaced data, as reviewed in Potts et al. (2001).Such algorithms do not strictly compute the DFT (whichis only defined for equispaced data), but rather someapproximation thereof (a non-uniform discrete Fourier

6 11 SEE ALSO

transform, or NDFT, which itself is often computed onlyapproximately). More generally there are various othermethods of spectral estimation.

9 Applications

FFT’s importance derives from the fact that in signal pro-cessing and image processing it has made working in fre-quency domain equally computationally feasible as work-ing in temporal or spatial domain. Some of the importantapplications of FFT includes,[10][16]

• Fast large integer and polynomial multiplication

• Efficient matrix-vector multiplication for Toeplitz,circulant and other structured matrices

• Filtering algorithms

• Fast algorithms for discrete cosine or sine transforms(example, Fast DCT used for JPEG, MP3/MPEGencoding)

• Fast Chebyshev approximation

• Fast Discrete Hartley Transform

• Solving Difference Equations

10 Research areas

• Big FFTs: With the explosion of big data in fieldssuch as astronomy, the need for 512k FFTs hasarisen for certain interferometry calculations. Thedata collected by projects such as MAP and LIGOrequire FFTs of tens of billions of points. As thissize does not fit in to main memory, so called out-of-core FFTs are an active area of research.[17]

• Approximate FFTs: For applications such as MRI,it is necessary to compute DFTs for nonuniformlyspaced grid points and/or frequencies. Multipolebased approaches can compute approximate quan-tities with factor of runtime increase.[18]

• Group FFTs: The FFT may also be explained andinterpreted using group representation theory thatallows for further generalization. A function onany compact group, including non cyclic, has anexpansion in terms of a basis of irreducible ma-trix elements. It remains active area of research tofind efficient algorithm for performing this changeof basis. Applications including efficient sphericalharmonic expansion, analyzing certain markov pro-cesses, robotics etc.[19]

• Quantum FFTs: Shor’s fast algorithm for integerfactorization on a quantum computer has a subrou-tine to compute DFT of a binary vector. This is im-plemented as sequence of 1- or 2-bit quantum gatesnow known as quantum FFT, which is effectivelythe Cooley-Tukey FFT realized as a particular fac-torization of the Fourier matrix. Extension to theseideas is currently being explored.

11 See also

• Cooley–Tukey FFT algorithm

• Prime-factor FFT algorithm

• Bruun’s FFT algorithm

• Rader’s FFT algorithm

• Bluestein’s FFT algorithm

• Butterfly diagram – a diagram used to describeFFTs.

• Odlyzko–Schönhage algorithm applies the FFT tofinite Dirichlet series.

• Overlap add/Overlap save – efficient convolutionmethods using FFT for long signals

• Spectral music (involves application of FFT analysisto musical composition)

• Spectrum analyzers – Devices that perform an FFT

• FFTW “Fastest Fourier Transform in the West” – Clibrary for the discrete Fourier transform (DFT) inone or more dimensions.

• FFTS – The Fastest Fourier Transform in the South.

• FFTPACK – another Fortran FFT library (publicdomain)

• Goertzel algorithm – Computes individual terms ofdiscrete Fourier transform

• Time series

• Math Kernel Library

• Fast Walsh–Hadamard transform

• Generalized distributive law

• Multidimensional transform

• Multidimensional discrete convolution

7

12 References[1] Charles Van Loan, Computational Frameworks for the

Fast Fourier Transform (SIAM, 1992).

[2] Heideman, M. T.; Johnson, D. H.; Burrus, C. S.(1984). “Gauss and the history of the fast Fouriertransform”. IEEE ASSP Magazine 1 (4): 14–21.doi:10.1109/MASSP.1984.1162257.

[3] Strang, Gilbert (May–June 1994). “Wavelets”. AmericanScientist 82 (3): 253. JSTOR 29775194.

[4] Dongarra, J.; Sullivan, F. (January 2000). “GuestEditors Introduction to the top 10 algorithms”.Computing in Science Engineering 2 (1): 22–23.doi:10.1109/MCISE.2000.814652. ISSN 1521-9615.

[5] Heideman, Michael T.; Johnson, Don H.; Burrus, C. Sid-ney (1985-09-01). “Gauss and the history of the fastFourier transform”. Archive for History of Exact Sciences34 (3): 265–277. doi:10.1007/BF00348431. ISSN 0003-9519.

[6] Yates, Frank (1937). “The design and analysis of facto-rial experiments”. Technical Communication no. 35 of theCommonwealth Bureau of Soils.

[7] Danielson, Gordon C.; Lanczos, Cornelius (1942). “Someimprovements in practical Fourier analysis and their ap-plication to x-ray scattering from liquids”. Journal of theFranklin Institute 233 (4): 365–380. doi:10.1016/S0016-0032(42)90767-1. This was also described in 1956 inLanczos’s book Applied Analysis, (Prentice-Hall).

[8] Cooley, James W.; Lewis, Peter A. W.; Welch, Peter D.(June 1967). “Historical notes on the fast Fourier trans-form”. IEEE Transactions on Audio and Electroacoustics15 (2): 76–79. doi:10.1109/TAU.1967.1161903. ISSN0018-9278.

[9] Cooley, James W.; Tukey, John W. (1965). “An algo-rithm for the machine calculation of complex Fourier se-ries”. Mathematics of Computation 19 (90): 297–301.doi:10.1090/S0025-5718-1965-0178586-1. ISSN 0025-5718.

[10] Rockmore, D.N. (January 2000). “The FFT: an algorithmthe whole family can use”. Computing in Science Engi-neering 2 (1): 60–64. doi:10.1109/5992.814659. ISSN1521-9615.

[11] Gentleman, W. M.; Sande, G. (1966). “Fast Fouriertransforms—for fun and profit”. Proc. AFIPS 29: 563–578. doi:10.1145/1464291.1464352.

[12] Carl Friedrich Gauss, 1866. "Theoria interpolationismethodo nova tractata,” Werke band 3, 265–327. Göt-tingen: Königliche Gesellschaft der Wissenschaften.

[13] Haitham Hassanieh, Piotr Indyk, Dina Katabi, and EricPrice, “Simple and Practical Algorithm for Sparse FourierTransform” (PDF), ACM-SIAMSymposiumOnDiscreteAlgorithms (SODA), Kyoto, January 2012. See also thesFFT Web Page.

[14] Mohlenkamp, Martin J. (1999). “A F ast T ransform forSpherical Harmonics” (PDF). The Journal of F ourier Analysis and Applic ations 5 (2/3): 159–184. Retrieved 18September 2014.

[15] Rokhlin, Vladimir; Tygert, Mark (2006). “Fast Algo-rithms for spherical harmonic expansions” (PDF). SIAMJournal on Scientific Computing 27 (6): 903–1928. Re-trieved 2014-09-18.

[16] Chu and George. “16”. Inside the FFT Black Box: Se-rial and Parallel Fast Fourier Transform Algorithms. CRCPress. pp. 153–168. ISBN 9781420049961.

[17] Cormen and Nicol (1998). “Performing out-of-core FFTson parallel disk systems”. Parallel Computing 24 (1): 5–20. doi:10.1016/S0167-8191(97)00114-2.

[18] Dutt, A.; Rokhlin, V. (November 1, 1993). “FastFourier Transforms for Nonequispaced Data”. SIAMJournal on Scientific Computing 14 (6): 1368–1393.doi:10.1137/0914081. ISSN 1064-8275.

[19] Rockmore, Daniel N. (2004). Byrnes, Jim, ed. “RecentProgress and Applications in Group FFTs”. Computa-tional Noncommutative Algebra and Applications. NATOScience Series II: Mathematics, Physics and Chemistry(Springer Netherlands) 136: 227–254. doi:10.1007/1-4020-2307-3_9. ISBN 978-1-4020-1982-1.

The following articles are cited parenthetically in the ar-ticle:

• Brenner, N.; Rader, C. (1976). “A New Princi-ple for Fast Fourier Transformation”. IEEE Acous-tics, Speech & Signal Processing 24 (3): 264–266.doi:10.1109/TASSP.1976.1162805.

• Brigham, E. O. (2002). “The Fast Fourier Trans-form”. New York: Prentice-Hall.

• Cormen, Thomas H.; Leiserson, Charles E.; Rivest,Ronald L.; Stein, Clifford (2001). “30. (Polynomi-als and the FFT)". Introduction to Algorithms (2 ed.).MIT Press and McGraw-Hill. ISBN 0-262-03293-7.

• Duhamel, Pierre (1990). “Algorithms meeting thelower bounds on the multiplicative complexity oflength-2n DFTs and their connection with practicalalgorithms”. IEEE Trans. Acoust. Speech. Sig. Proc.38 (9): 1504–151. doi:10.1109/29.60070.

• Duhamel, P.; Vetterli, M. (1990). “Fast Fouriertransforms: a tutorial review and a state of the art”.Signal Processing 19: 259–299. doi:10.1016/0165-1684(90)90158-U.

• Edelman, A.; McCorquodale, P.; Toledo,S. (1999). “The Future Fast Fourier Trans-form?". SIAM J. Sci. Computing 20: 1094–1114.doi:10.1137/S1064827597316266.

8 13 EXTERNAL LINKS

• D. F. Elliott, & K. R. Rao, 1982, Fast transforms:Algorithms, analyses, applications. New York: Aca-demic Press.

• Funda Ergün, 1995, Testing multivariate linearfunctions: Overcoming the generator bottleneck,Proc. 27th ACM Symposium on the Theory of Com-puting: 407–416.

• Frigo, M.; Johnson, S. G. (2005). “TheDesign and Implementation of FFTW3”(PDF). Proceedings of the IEEE 93: 216–231.doi:10.1109/jproc.2004.840301.

• H. Guo and C. S. Burrus, 1996, Fast approximateFourier transform via wavelets transform, Proc.SPIE Intl. Soc. Opt. Eng. 2825: 250–259.

• H. Guo, G. A. Sitton, C. S. Burrus, 1994, TheQuick Discrete Fourier Transform, Proc. IEEEConf. Acoust. Speech and Sig. Processing (ICASSP)3: 445–448.

• Steve Haynal and Heidi Haynal, "Generating andSearching Families of FFT Algorithms", Journalon Satisfiability, Boolean Modeling and Computationvol. 7, pp. 145–187 (2011).

• Heideman, Michael T.; Burrus, C. Sidney (1986).“On the number of multiplications necessaryto compute a length-2n DFT”. IEEE Trans.Acoust. Speech. Sig. Proc. 34 (1): 91–95.doi:10.1109/TASSP.1986.1164785.

• Johnson, S. G.; Frigo, M. (2007). “A modified split-radix FFT with fewer arithmetic operations” (PDF).IEEE Trans. Signal Processing 55 (1): 111–119.doi:10.1109/tsp.2006.882087.

• T. Lundy and J. Van Buskirk, 2007. “A new matrixapproach to real FFTs and convolutions of length2k,” Computing 80 (1): 23–45.

• Kent, Ray D. and Read, Charles (2002). AcousticAnalysis of Speech. ISBN 0-7693-0112-6. CitesStrang, G. (1994)/May–June). Wavelets. AmericanScientist, 82, 250–255.

• Morgenstern, Jacques (1973). “Note on alower bound of the linear complexity of the fastFourier transform”. J. ACM 20 (2): 305–306.doi:10.1145/321752.321761.

• Mohlenkamp, M. J. (1999). “A fast transform forspherical harmonics” (PDF). J. Fourier Anal. Appl.5 (2–3): 159–184. doi:10.1007/BF01261607.

• Nussbaumer, H. J. (1977). “Digital filtering usingpolynomial transforms”. Electronics Lett. 13 (13):386–387. doi:10.1049/el:19770280.

• V. Pan, 1986, The trade-off between the additivecomplexity and the asyncronicity of linear and bilin-ear algorithms, Information Proc. Lett. 22: 11–14.

• Christos H. Papadimitriou, 1979, Optimality of thefast Fourier transform, J. ACM 26: 95–102.

• D. Potts, G. Steidl, and M. Tasche, 2001. "FastFourier transforms for nonequispaced data: A tuto-rial", in: J.J. Benedetto and P. Ferreira (Eds.),Mod-ern Sampling Theory: Mathematics and Applications(Birkhauser).

• Press, W.H.; Teukolsky, S.A.; Vetterling, W.T.;Flannery, B.P. (2007), “Chapter 12. Fast FourierTransform”, Numerical Recipes: The Art of Scien-tific Computing (3 ed.), New York: Cambridge Uni-versity Press, ISBN 978-0-521-88068-8

• Rokhlin, Vladimir; Tygert, Mark (2006). “Fastalgorithms for spherical harmonic expansions”.SIAM J. Sci. Computing 27 (6): 1903–1928.doi:10.1137/050623073.

• Schatzman, James C. (1996). “Accuracy of the dis-crete Fourier transform and the fast Fourier trans-form”. SIAM J. Sci. Comput 17: 1150–1166.doi:10.1137/s1064827593247023.

• Shentov, O. V.; Mitra, S. K.; Heute, U.; Hossen,A. N. (1995). “Subband DFT. I. Definition, inter-pretations and extensions”. Signal Processing 41 (3):261–277. doi:10.1016/0165-1684(94)00103-7.

• Sorensen, H. V.; Jones, D. L.; Heideman, M.T.; Burrus, C. S. (1987). “Real-valued fastFourier transform algorithms”. IEEE Trans.Acoust. Speech Sig. Processing 35 (35): 849–863. doi:10.1109/TASSP.1987.1165220. See alsoSorensen, H.; Jones, D.; Heideman, M.; Bur-rus, C. (1987). “Corrections to “Real-valued fastFourier transform algorithms"". IEEE Transactionson Acoustics, Speech, and Signal Processing 35 (9):1353–1353. doi:10.1109/TASSP.1987.1165284.

• Welch, Peter D. (1969). “A fixed-pointfast Fourier transform error analysis”. IEEETrans. Audio Electroacoustics 17 (2): 151–157.doi:10.1109/TAU.1969.1162035.

• Winograd, S. (1978). “On computing the dis-crete Fourier transform”. Math. Computation 32(141): 175–199. doi:10.1090/S0025-5718-1978-0468306-4. JSTOR 2006266.

13 External links• Fast Fourier Algorithm

• Fast Fourier Transforms, Connexions online bookedited by C. Sidney Burrus, with chapters by C. Sid-ney Burrus, Ivan Selesnick, Markus Pueschel, Mat-teo Frigo, and Steven G. Johnson (2008).

• Links to FFT code and information online.

9

• National Taiwan University – FFT

• FFT programming in C++ — Cooley–Tukey algo-rithm.

• Online documentation, links, book, and code.

• Using FFT to construct aggregate probability distri-butions

• Sri Welaratna, "Thirty years of FFT analyzers",Sound and Vibration (January 1997, 30th anniver-sary issue). A historical review of hardware FFTdevices.

• FFT Basics and Case Study Using Multi-Instrument

• FFT Textbook notes, PPTs, Videos at Holistic Nu-merical Methods Institute.

• ALGLIB FFT Code GPL Licensed multilanguage(VBA, C++, Pascal, etc.) numerical analysis anddata processing library.

• MIT’s sFFT MIT Sparse FFT algorithm and imple-mentation.

• VB6 FFT VB6 optimized library implementationwith source code.

• Fast Fourier transform illustrated Demo examplesand FFT calculator.

• Discrete Fourier Transform (Forward) A JavaScriptimplementation of FFTPACK code by Swarz-trauber.

10 14 TEXT AND IMAGE SOURCES, CONTRIBUTORS, AND LICENSES

14 Text and image sources, contributors, and licenses

14.1 Text• Fast Fourier transform Source: https://en.wikipedia.org/wiki/Fast_Fourier_transform?oldid=712035039 Contributors: AxelBoldt, The

Anome, Tarquin, Gareth Owen, Roadrunner, DrBob, David spector, Boud, Michael Hardy, Pit~enwiki, Nixdorf, Pnm, Ixfd64, Takuya-Murata, Delirium, SebastianHelm, Stevenj, Palfrey, Hashar, Dcoetzee, Bemoeial, Dmsar, Jitse Niesen, Wik, Furrykef, Hyacinth, Gren-delkhan, Cameronc, Bartosz, LMB, Vincent kraeutler, Twang, Donarreiskoffer, Robbot, Jaredwf, Fredrik, Academic Challenger, Yacht,Lupo, Giftlite, Dratman, Daniel Brockman, LiDaobing, Gunnar Larsson, Sam Hocevar, Mschlindwein, Adashiel, Guanabot, Smyth,Nagesh Anupindi, Ylai, Bender235, ZeroOne, Pt, Teorth, Jeltz, Artur Nowak~enwiki, Zxcvbnm, H2g2bob, Cxxl, Oleg Alexandrov,Mwilde, Decrease789, Eyreland, Eras-mus, Timendum, Marudubshinki, BD2412, Qwertyus, Coneslayer, Rjwilmsi, Captain Disdain,Amitparikh, R.e.b., Fresheneesz, Kri, Chobot, DVdm, YurikBot, Wavelength, David R. Ingham, Robertvan1, Herve661, Sangwine,CecilWard, Kkmurray, Squell, SmackBot, Geoffeg, Ulterior19802005, Unyoyega, HalfShadow, TimBentley, Oli Filth, Nbarth, Zven,MaxSem, Audriusa, JustUser, LouScheffer, Spectrogram, DMPalmer, IronGargoyle, 16@r, JHunterJ, Rogerbrent, Dicklyon, Norm mit,Domitori, MarylandArtLover, Lavaka, Vanished user sojweiorj34i4f, Requestion, HenningThielemann, Ntsimp, Djg2006, RobertM52,Sytelus, MauricioArayaPolo, Quibik, Headbomb, Electron9, LeoTrottier, BehnamFarid, Hcobb, Dawnseeker2000, Quintote, Gopimanne,Awilley, Thenub314, Timur lenk, Magioladitis, Hmo, JamesBWatson, Johnbibby, David Eppstein, MartinBot, Gah4, Crossz, Pankajp,Apexfreak, Adam Zivner, LokiClock, Omkar lon, Faestning, Felipebm, Maxim, Blablahblablah, ToePeu.bot, Le Pied-bot~enwiki, AnchorLink Bot, Melcombe, DonAByrd, Gene93k, GreenSpigot, Glutamin, Tuhinbhakta, Excirial, Tim32, Alexbot, Bender2k14, Rubin joseph10, Arjayay, The Yowser, Qwfp, Efryevt, Herry41341, Dekart, Avalcarce, Hess88, Dioioib, Fgnievinski, 2ganesh, MrOllie, Lightbot, Eu-geneZ, Apteva, Legobot, Luckas-bot, Yobot, Twexcom, Akoesters, QueenCake, AnomieBOT, Jim1138, Materialscientist, DeadTotoro,ArthurBot, Xqbot, Minibikini, David A se, AliceNovak, Smallman12q, Steina4, Aclassifier, FrescoBot, Klokbaske, Carbone1853, Ci-tation bot 1, Boxplot, Wikichicheng, Jonesey95, Dcwill1285, Davidmeo, Kellybundybrain, Gryllida, Bmitov, Jfmantis, Solongmarriane,Helwr, K6ka, R. J. Mathar, Dondervogel 2, Staszek Lem, Kuashio, Lorem Ip, Maschen, Alexander Misel, JFB80, Cgt, Matthiaspaul, Rie-mann’sZeta, Plantdrew, Koertefa, Stelpa, SciCompTeacher, Klilidiplomus, Haynals, Eflatmajor7th, YFdyh-bot, Sandeep.ps4, Donn300,Harsh 2580, Kushalsatrasala, Ogmark, Jiejie9988, FFTguy, Junkyardsparkle, Icarot, Michipedian, Debouch, Sattar91, LCS check, Math-truth, BioFluid, Iustin Diac, Monkbot, ErRied, D1ofBerks, ChiCheng, 115ash, Oiyarbepsy, Nir.ailon, Fourier1789, Thesejma, 89sec,PurpleLego, Draak13, Shaddowffax and Anonymous: 216

14.2 Images• File:Question_book-new.svg Source: https://upload.wikimedia.org/wikipedia/en/9/99/Question_book-new.svg License: Cc-by-sa-3.0Contributors:Created from scratch in Adobe Illustrator. Based on Image:Question book.png created by User:Equazcion Original artist:Tkgd2007

• File:Question_dropshade.png Source: https://upload.wikimedia.org/wikipedia/commons/d/dd/Question_dropshade.png License: Publicdomain Contributors: Image created by JRM Original artist: JRM

• File:Time_Signal_of_Five_Term_Cosine_Series.png Source: https://upload.wikimedia.org/wikipedia/commons/5/56/Time_Signal_of_Five_Term_Cosine_Series.png License: CC BY-SA 4.0 Contributors: Own work Original artist: Fourier1789

14.3 Content license• Creative Commons Attribution-Share Alike 3.0