Fast Fourier transform
A fast Fourier transform (FFT) is an algorithm that computes the discrete Fourier transform (DFT) of a sequence, or its inverse (IDFT). Fourier analysis converts a signal from its original domain (often time or space) to a representation in the frequency domain and vice versa. The DFT is obtained by decomposing a sequence of values into components of different frequencies.^{[1]} This operation is useful in many fields, but computing it directly from the definition is often too slow to be practical. An FFT rapidly computes such transformations by factorizing the DFT matrix into a product of sparse (mostly zero) factors.^{[2]} As a result, it manages to reduce the complexity of computing the DFT from [math]\displaystyle{ O\left(N^2\right) }[/math], which arises if one simply applies the definition of DFT, to [math]\displaystyle{ O(N \log N) }[/math], where [math]\displaystyle{ N }[/math] is the data size. The difference in speed can be enormous, especially for long data sets where N may be in the thousands or millions. In the presence of roundoff error, many FFT algorithms are much more accurate than evaluating the DFT definition directly or indirectly. There are many different FFT algorithms based on a wide range of published theories, from simple complexnumber arithmetic to group theory and number theory.
Fast Fourier transforms are widely used for applications in engineering, music, science, and mathematics. The basic ideas were popularized in 1965, but some algorithms had been derived as early as 1805.^{[1]} In 1994, Gilbert Strang described the FFT as "the most important numerical algorithm of our lifetime",^{[3]}^{[4]} and it was included in Top 10 Algorithms of 20th Century by the IEEE magazine Computing in Science & Engineering.^{[5]}
The bestknown FFT algorithms depend upon the factorization of N, but there are FFTs with O(N log N) complexity for all N, even for prime N. Many FFT algorithms depend only on the fact that [math]\displaystyle{ e^{2\pi i/N} }[/math] is an Nth primitive root of unity, and thus can be applied to analogous transforms over any finite field, such as numbertheoretic transforms. Since the inverse DFT is the same as the DFT, but with the opposite sign in the exponent and a 1/N factor, any FFT algorithm can easily be adapted for it.
History
The development of fast algorithms for DFT can be traced to Carl Friedrich Gauss's unpublished work in 1805 when he needed it to interpolate the orbit of asteroids Pallas and Juno from sample observations.^{[6]}^{[7]} His method was very similar to the one published in 1965 by James Cooley and John Tukey, who are generally credited for the invention of the modern generic FFT algorithm. While Gauss's work predated even Joseph Fourier's results in 1822, he did not analyze the computation time and eventually used other methods to achieve his goal.
Between 1805 and 1965, some versions of FFT were published by other authors. Frank Yates in 1932 published his version called interaction algorithm, which provided efficient computation of Hadamard and Walsh transforms.^{[8]} Yates' algorithm is still used in the field of statistical design and analysis of experiments. In 1942, G. C. Danielson and Cornelius Lanczos published their version to compute DFT for xray crystallography, a field where calculation of Fourier transforms presented a formidable bottleneck.^{[9]}^{[10]} While many methods in the past had focused on reducing the constant factor for [math]\displaystyle{ O\left(N^2\right) }[/math] computation by taking advantage of "symmetries", Danielson and Lanczos realized that one could use the "periodicity" and apply a "doubling trick" to "double [N] with only slightly more than double the labor", though like Gauss they did not analyze that this led to [math]\displaystyle{ O(N \log N) }[/math] scaling.^{[11]}
James Cooley and John Tukey independently rediscovered these earlier algorithms^{[7]} and published a more general FFT in 1965 that is applicable when N is composite and not necessarily a power of 2, as well as analyzing the [math]\displaystyle{ O(N \log N) }[/math] scaling.^{[12]} Tukey came up with the idea during a meeting of President Kennedy's Science Advisory Committee where a discussion topic involved detecting nuclear tests by the Soviet Union by setting up sensors to surround the country from outside. To analyze the output of these sensors, an FFT algorithm would be needed. In discussion with Tukey, Richard Garwin recognized the general applicability of the algorithm not just to national security problems, but also to a wide range of problems including one of immediate interest to him, determining the periodicities of the spin orientations in a 3D crystal of Helium3.^{[13]} Garwin gave Tukey's idea to Cooley (both worked at IBM's Watson labs) for implementation.^{[14]} Cooley and Tukey published the paper in a relatively short time of six months.^{[15]} As Tukey did not work at IBM, the patentability of the idea was doubted and the algorithm went into the public domain, which, through the computing revolution of the next decade, made FFT one of the indispensable algorithms in digital signal processing.
Definition
Let [math]\displaystyle{ x_0 }[/math], …, [math]\displaystyle{ x_{N1} }[/math] be complex numbers. The DFT is defined by the formula
 [math]\displaystyle{ X_k = \sum_{n=0}^{N1} x_n e^{i2\pi k n/N} \qquad k = 0,\ldots,N1, }[/math]
where [math]\displaystyle{ e^{i 2\pi/N} }[/math] is a primitive Nth root of 1.
Evaluating this definition directly requires [math]\displaystyle{ O\left(N^2\right) }[/math] operations: there are N outputs X_{k}, and each output requires a sum of N terms. An FFT is any method to compute the same results in [math]\displaystyle{ O(N \log N) }[/math] operations. All known FFT algorithms require [math]\displaystyle{ \Theta(N \log N) }[/math] operations, although there is no known proof that a lower complexity score is impossible.^{[16]}
To illustrate the savings of an FFT, consider the count of complex multiplications and additions for N=4096 data points. Evaluating the DFT's sums directly involves N^{2} complex multiplications and N(N − 1) complex additions, of which [math]\displaystyle{ O(N) }[/math] operations can be saved by eliminating trivial operations such as multiplications by 1, leaving about 30 million operations. In contrast, the radix2 Cooley–Tukey algorithm, for N a power of 2, can compute the same result with only (N/2)log_{2}(N) complex multiplications (again, ignoring simplifications of multiplications by 1 and similar) and N log_{2}(N) complex additions, in total about 30,000 operations – a thousand times less than with direct evaluation. In practice, actual performance on modern computers is usually dominated by factors other than the speed of arithmetic operations and the analysis is a complicated subject (for example, see Frigo & Johnson, 2005),^{[17]} but the overall improvement from [math]\displaystyle{ O\left(N^2\right) }[/math] to [math]\displaystyle{ O(N \log N) }[/math] remains.
Algorithms
Cooley–Tukey algorithm
By far the most commonly used FFT is the Cooley–Tukey algorithm. This is a divideandconquer algorithm that recursively breaks down a DFT of any composite size [math]\displaystyle{ N = N_1N_2 }[/math] into many smaller DFTs of sizes [math]\displaystyle{ N_1 }[/math] and [math]\displaystyle{ N_2 }[/math], along with [math]\displaystyle{ O(N) }[/math] multiplications by complex roots of unity traditionally called twiddle factors (after Gentleman and Sande, 1966^{[18]}).
This method (and the general idea of an FFT) was popularized by a publication of Cooley and Tukey in 1965,^{[12]} but it was later discovered^{[1]} that those two authors had independently reinvented an algorithm known to Carl Friedrich Gauss around 1805^{[19]} (and subsequently rediscovered several times in limited forms).
The best known use of the Cooley–Tukey algorithm is to divide the transform into two pieces of size N/2 at each step, and is therefore limited to poweroftwo sizes, but any factorization can be used in general (as was known to both Gauss and Cooley/Tukey^{[1]}). These are called the radix2 and mixedradix cases, respectively (and other variants such as the splitradix FFT have their own names as well). Although the basic idea is recursive, most traditional implementations rearrange the algorithm to avoid explicit recursion. Also, because the Cooley–Tukey algorithm breaks the DFT into smaller DFTs, it can be combined arbitrarily with any other algorithm for the DFT, such as those described below.
Other FFT algorithms
There are FFT algorithms other than Cooley–Tukey.
For N = N_{1}N_{2} with coprime N_{1} and N_{2}, one can use the primefactor (Good–Thomas) algorithm (PFA), based on the Chinese remainder theorem, to factorize the DFT similarly to Cooley–Tukey but without the twiddle factors. The Rader–Brenner algorithm (1976)^{[20]} is a Cooley–Tukeylike factorization but with purely imaginary twiddle factors, reducing multiplications at the cost of increased additions and reduced numerical stability; it was later superseded by the splitradix variant of Cooley–Tukey (which achieves the same multiplication count but with fewer additions and without sacrificing accuracy). Algorithms that recursively factorize the DFT into smaller operations other than DFTs include the Bruun and QFT algorithms. (The Rader–Brenner^{[20]} and QFT algorithms were proposed for poweroftwo sizes, but it is possible that they could be adapted to general composite N. Bruun's algorithm applies to arbitrary even composite sizes.) Bruun's algorithm, in particular, is based on interpreting the FFT as a recursive factorization of the polynomial z^{N} − 1, here into realcoefficient polynomials of the form z^{M} − 1 and z^{2M} + az^{M} + 1.
Another polynomial viewpoint is exploited by the Winograd FFT algorithm,^{[21]}^{[22]} which factorizes z^{N} − 1 into cyclotomic polynomials—these often have coefficients of 1, 0, or −1, and therefore require few (if any) multiplications, so Winograd can be used to obtain minimalmultiplication FFTs and is often used to find efficient algorithms for small factors. Indeed, Winograd showed that the DFT can be computed with only O(N) irrational multiplications, leading to a proven achievable lower bound on the number of multiplications for poweroftwo sizes; unfortunately, this comes at the cost of many more additions, a tradeoff no longer favorable on modern processors with hardware multipliers. In particular, Winograd also makes use of the PFA as well as an algorithm by Rader for FFTs of prime sizes.
Rader's algorithm, exploiting the existence of a generator for the multiplicative group modulo prime N, expresses a DFT of prime size N as a cyclic convolution of (composite) size N − 1, which can then be computed by a pair of ordinary FFTs via the convolution theorem (although Winograd uses other convolution methods). Another primesize FFT is due to L. I. Bluestein, and is sometimes called the chirpz algorithm; it also reexpresses a DFT as a convolution, but this time of the same size (which can be zeropadded to a power of two and evaluated by radix2 Cooley–Tukey FFTs, for example), via the identity
 [math]\displaystyle{ nk = \frac{(kn)^2} 2 + \frac{n^2} 2 + \frac{k^2} 2. }[/math]
Hexagonal fast Fourier transform (HFFT) aims at computing an efficient FFT for the hexagonallysampled data by using a new addressing scheme for hexagonal grids, called Array Set Addressing (ASA).
FFT algorithms specialized for real or symmetric data
In many applications, the input data for the DFT are purely real, in which case the outputs satisfy the symmetry
 [math]\displaystyle{ X_{Nk} = X_k^* }[/math]
and efficient FFT algorithms have been designed for this situation (see e.g. Sorensen, 1987).^{[23]}^{[24]} One approach consists 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 and memory. Alternatively, it is possible to express an evenlength realinput DFT as a complex DFT of half the length (whose real and imaginary parts are the even/odd elements of the original real data), followed by O(N) postprocessing operations.
It was once believed that realinput DFTs could be more efficiently computed by means of the discrete Hartley transform (DHT), but it was subsequently argued that a specialized realinput DFT algorithm (FFT) can typically be found that requires fewer operations than the corresponding DHT algorithm (FHT) for the same number of inputs.^{[23]} Bruun's algorithm (above) is another method that was initially proposed to take advantage of real inputs, but it has not proved popular.
There are further FFT specializations for the cases of real data that have even/odd symmetry, in which case one can gain another factor of roughly two in time and memory and the DFT becomes the discrete cosine/sine transform(s) (DCT/DST). Instead of directly modifying an FFT algorithm for these cases, DCTs/DSTs can also be computed via FFTs of real data combined with O(N) pre and postprocessing.
Computational issues
Bounds on complexity and operation counts
Unsolved problem in computer science: What is the lower bound on the complexity of fast Fourier transform algorithms? Can they be faster than [math]\displaystyle{ O(N\log N) }[/math]? (more unsolved problems in computer science)

A fundamental question of longstanding theoretical interest is to prove lower bounds on the complexity and exact operation counts of fast Fourier transforms, and many open problems remain. It is not rigorously proved whether DFTs truly require Ω(N log N) (i.e., order N log N or greater) operations, even for the simple case of power of two sizes, although no algorithms with lower complexity are known. In particular, the count of arithmetic operations is usually the focus of such questions, although actual performance on modernday computers is determined by many other factors such as cache or CPU pipeline optimization.
Following work by Shmuel Winograd (1978),^{[21]} a tight Θ(N) lower bound is known for the number of real multiplications required by an FFT. It can be shown that only [math]\displaystyle{ 4N  2\log_2^2(N)  2\log_2(N)  4 }[/math] irrational real multiplications are required to compute a DFT of poweroftwo length [math]\displaystyle{ N = 2^m }[/math]. Moreover, explicit algorithms that achieve this count are known (Heideman & Burrus, 1986;^{[25]} Duhamel, 1990^{[26]}). However, these algorithms require too many additions to be practical, at least on modern computers with hardware multipliers (Duhamel, 1990;^{[26]} Frigo & Johnson, 2005).^{[17]}
A tight lower bound is not known on the number of required additions, although lower bounds have been proved under some restrictive assumptions on the algorithms. In 1973, Morgenstern^{[27]} proved an Ω(N log N) lower bound on the addition count for algorithms where the multiplicative constants have bounded magnitudes (which is true for most but not all FFT algorithms). Pan (1986)^{[28]} proved an Ω(N log N) lower bound assuming a bound on a measure of the FFT algorithm's "asynchronicity", but the generality of this assumption is unclear. For the case of poweroftwo N, Papadimitriou (1979)^{[29]} argued that the number [math]\displaystyle{ N \log_2 N }[/math] of complexnumber additions achieved by Cooley–Tukey algorithms is optimal under certain assumptions on the graph of the algorithm (his assumptions imply, among other things, that no additive identities in the roots of unity are exploited). (This argument would imply that at least [math]\displaystyle{ 2N \log_2 N }[/math] real additions are required, although this is not a tight bound because extra additions are required as part of complexnumber multiplications.) Thus far, no published FFT algorithm has achieved fewer than [math]\displaystyle{ N \log_2 N }[/math] complexnumber additions (or their equivalent) for poweroftwo N.
A third problem is to minimize the total number of real multiplications and additions, sometimes called the "arithmetic complexity" (although in this context it is the exact count and not the asymptotic complexity that is being considered). Again, no tight lower bound has been proven. Since 1968, however, the lowest published count for poweroftwo N was long achieved by the splitradix FFT algorithm, which requires [math]\displaystyle{ 4N\log_2(N)  6N + 8 }[/math] real multiplications and additions for N > 1. This was recently reduced to [math]\displaystyle{ \sim \frac{34}{9} N \log_2 N }[/math] (Johnson and Frigo, 2007;^{[16]} Lundy and Van Buskirk, 2007^{[30]}). A slightly larger count (but still better than split radix for N ≥ 256) was shown to be provably optimal for N ≤ 512 under additional restrictions on the possible algorithms (splitradixlike flowgraphs with unitmodulus multiplicative factors), by reduction to a satisfiability modulo theories problem solvable by brute force (Haynal & Haynal, 2011).^{[31]}
Most of the attempts to lower or prove the complexity of FFT algorithms have focused on the ordinary complexdata case, because it is the simplest. However, complexdata FFTs are so closely related to algorithms for related problems such as realdata FFTs, discrete cosine transforms, discrete Hartley transforms, and so on, that any improvement in one of these would immediately lead to improvements in the others (Duhamel & Vetterli, 1990).^{[32]}
Approximations
All of the FFT algorithms discussed above compute the DFT exactly (i.e. neglecting floatingpoint errors). A few "FFT" algorithms have been proposed, however, that compute the DFT approximately, with an error that can be made arbitrarily small at the expense of increased computations. Such algorithms trade the approximation error for increased speed or other properties. For example, an approximate FFT algorithm by Edelman et al. (1999)^{[33]} achieves lower communication requirements for parallel computing with the help of a fast multipole method. A waveletbased approximate FFT by Guo and Burrus (1996)^{[34]} takes sparse inputs/outputs (time/frequency localization) into account more efficiently than is possible with an exact FFT. Another algorithm for approximate computation of a subset of the DFT outputs is due to Shentov et al. (1995).^{[35]} The Edelman algorithm works equally well for sparse and nonsparse data, since it is based on the compressibility (rank deficiency) of the Fourier matrix itself rather than the compressibility (sparsity) of the data. Conversely, if the data are sparse—that is, if only K out of N Fourier coefficients are nonzero—then the complexity can be reduced to O(K log(N) log(N/K)), and this has been demonstrated to lead to practical speedups compared to an ordinary FFT for N/K > 32 in a largeN example (N = 2^{22}) using a probabilistic approximate algorithm (which estimates the largest K coefficients to several decimal places).^{[36]}
Accuracy
FFT algorithms have errors when finiteprecision floatingpoint arithmetic is used, but these errors are typically quite small; most FFT algorithms, e.g. Cooley–Tukey, have excellent numerical properties as a consequence of the pairwise summation structure of the algorithms. The upper bound on the relative error for the Cooley–Tukey algorithm is O(ε log N), compared to O(εN^{3/2}) for the naïve DFT formula,^{[18]} where ε is the machine floatingpoint relative precision. In fact, the root mean square (rms) errors are much better than these upper bounds, being only O(ε √log N) for Cooley–Tukey and O(ε √N) for the naïve DFT (Schatzman, 1996).^{[37]} These results, however, are very sensitive to the accuracy of the twiddle factors used in the FFT (i.e. the trigonometric function values), and it is not unusual for incautious FFT implementations to have much worse accuracy, e.g. if they use inaccurate trigonometric recurrence formulas. Some FFTs other than Cooley–Tukey, such as the Rader–Brenner algorithm, are intrinsically less stable.
In fixedpoint arithmetic, the finiteprecision errors accumulated by FFT algorithms are worse, with rms errors growing as O(√N) for the Cooley–Tukey algorithm (Welch, 1969).^{[38]} Achieving this accuracy requires careful attention to scaling to minimize loss of precision, and fixedpoint FFT algorithms involve rescaling at each intermediate stage of decompositions like Cooley–Tukey.
To verify the correctness of an FFT implementation, rigorous guarantees can be obtained in O(N log N) time by a simple procedure checking the linearity, impulseresponse, and timeshift properties of the transform on random inputs (Ergün, 1995).^{[39]}
Multidimensional FFTs
As defined in the multidimensional DFT article, the multidimensional DFT
 [math]\displaystyle{ X_\mathbf{k} = \sum_{\mathbf{n}=0}^{\mathbf{N}1} e^{2\pi i \mathbf{k} \cdot (\mathbf{n} / \mathbf{N})} x_\mathbf{n} }[/math]
transforms an array x_{n} with a ddimensional vector of indices [math]\displaystyle{ \mathbf{n} = \left(n_1, \ldots, n_d\right) }[/math] by a set of d nested summations (over [math]\displaystyle{ n_j = 0 \ldots N_j  1 }[/math] for each j), where the division n/N, defined as [math]\displaystyle{ \mathbf{n} / \mathbf{N} = \left(n_1/N_1, \ldots, n_d/N_d\right) }[/math], is performed elementwise. Equivalently, it is the composition of a sequence of d sets of onedimensional DFTs, performed along one dimension at a time (in any order).
This compositional viewpoint immediately provides the simplest and most common multidimensional DFT algorithm, known as the rowcolumn algorithm (after the twodimensional case, below). That is, one simply performs a sequence of d onedimensional FFTs (by any of the above algorithms): first you transform along the n_{1} dimension, then along the n_{2} dimension, and so on (or actually, any ordering works). This method is easily shown to have the usual O(N log N) complexity, where [math]\displaystyle{ N = N_1 \cdot N_2 \cdot \cdots \cdot N_d }[/math] is the total number of data points transformed. In particular, there are N/N_{1} transforms of size N_{1}, etcetera, so the complexity of the sequence of FFTs is:
 [math]\displaystyle{ \begin{align} & \frac{N}{N_1} O(N_1 \log N_1) + \cdots + \frac{N}{N_d} O(N_d \log N_d) \\[6pt] ={} & O\left(N \left[\log N_1 + \cdots + \log N_d\right]\right) = O(N \log N). \end{align} }[/math]
In two dimensions, the x_{k} can be viewed as an [math]\displaystyle{ n_1 \times n_2 }[/math] matrix, and this algorithm corresponds to first performing the FFT of all the rows (resp. columns), grouping the resulting transformed rows (resp. columns) together as another [math]\displaystyle{ n_1 \times n_2 }[/math] matrix, and then performing the FFT on each of the columns (resp. rows) of this second matrix, and similarly grouping the results into the final result matrix.
In more than two dimensions, it is often advantageous for cache locality to group the dimensions recursively. For example, a threedimensional FFT might first perform twodimensional FFTs of each planar "slice" for each fixed n_{1}, and then perform the onedimensional FFTs along the n_{1} direction. More generally, an asymptotically optimal cacheoblivious algorithm consists of recursively dividing the dimensions into two groups [math]\displaystyle{ (n_1, \ldots, n_{d/2}) }[/math] and [math]\displaystyle{ (n_{d/2+1}, \ldots, n_d) }[/math] that are transformed recursively (rounding if d is not even) (see Frigo and Johnson, 2005).^{[17]} Still, this remains a straightforward variation of the rowcolumn algorithm that ultimately requires only a onedimensional FFT algorithm as the base case, and still has O(N log N) complexity. Yet another variation is to perform matrix transpositions in between transforming subsequent dimensions, so that the transforms operate on contiguous data; this is especially important for outofcore and distributed memory situations where accessing noncontiguous data is extremely timeconsuming.
There are other multidimensional FFT algorithms that are distinct from the rowcolumn algorithm, although all of them have O(N log N) complexity. Perhaps the simplest nonrowcolumn FFT is the vectorradix FFT algorithm, which is a generalization of the ordinary Cooley–Tukey algorithm where one divides the transform dimensions by a vector [math]\displaystyle{ \mathbf{r} = \left(r_1, r_2, \ldots, r_d\right) }[/math] of radices at each step. (This may also have cache benefits.) The simplest case of vectorradix is where all of the radices are equal (e.g. vectorradix2 divides all of the dimensions by two), but this is not necessary. Vector radix with only a single nonunit radix at a time, i.e. [math]\displaystyle{ \mathbf{r} = \left(1, \ldots, 1, r, 1, \ldots, 1\right) }[/math], is essentially a rowcolumn algorithm. Other, more complicated, methods include polynomial transform algorithms due to Nussbaumer (1977),^{[40]} which view the transform in terms of convolutions and polynomial products. See Duhamel and Vetterli (1990)^{[32]} for more information and references.
Other generalizations
An O(N^{5/2}log N) generalization to spherical harmonics on the sphere S^{2} with N^{2} nodes was described by Mohlenkamp,^{[41]} along with an algorithm conjectured (but not proven) to have O(N^{2} log^{2}(N)) complexity; Mohlenkamp also provides an implementation in the libftsh library.^{[42]} A sphericalharmonic algorithm with O(N^{2}log N) complexity is described by Rokhlin and Tygert.^{[43]}
The fast folding algorithm is analogous to the FFT, except that it operates on a series of binned waveforms rather than a series of real or complex scalar values. Rotation (which in the FFT is multiplication by a complex phasor) is a circular shift of the component waveform.
Various groups have also published "FFT" algorithms for nonequispaced data, as reviewed in Potts et al. (2001).^{[44]} Such algorithms do not strictly compute the DFT (which is only defined for equispaced data), but rather some approximation thereof (a nonuniform discrete Fourier transform, or NDFT, which itself is often computed only approximately). More generally there are various other methods of spectral estimation.
Applications
The FFT is used in digital recording, sampling, additive synthesis and pitch correction software.^{[45]}
The FFT's importance derives from the fact that it has made working in the frequency domain equally computationally feasible as working in the temporal or spatial domain. Some of the important applications of the FFT include:^{[15]}^{[46]}
 fast largeinteger and polynomial multiplication,
 efficient matrix–vector multiplication for Toeplitz, circulant and other structured matrices,
 filtering algorithms (see overlap–add and overlap–save methods),
 fast algorithms for discrete cosine or sine transforms (e.g. fast DCT used for JPEG and MPEG/MP3 encoding and decoding),
 fast Chebyshev approximation,
 solving difference equations,
 computation of isotopic distributions.^{[47]}
 modulation and demodulation of complex data symbols using orthogonal frequency division multiplexing (OFDM) for 5G, LTE, WiFi, DSL, and other modern communication systems.
Research areas
 Big FFTs
 With the explosion of big data in fields such as astronomy, the need for 512K FFTs has arisen for certain interferometry calculations. The data collected by projects such as WMAP and LIGO require FFTs of tens of billions of points. As this size does not fit into main memory, so called outofcore FFTs are an active area of research.^{[48]}
 Approximate FFTs
 For applications such as MRI, it is necessary to compute DFTs for nonuniformly spaced grid points and/or frequencies. Multipole based approaches can compute approximate quantities with factor of runtime increase.^{[49]}
 Group FFTs
 The FFT may also be explained and interpreted using group representation theory allowing for further generalization. A function on any compact group, including noncyclic, has an expansion in terms of a basis of irreducible matrix elements. It remains active area of research to find efficient algorithm for performing this change of basis. Applications including efficient spherical harmonic expansion, analyzing certain Markov processes, robotics etc.^{[50]}
 Quantum FFTs
 Shor's fast algorithm for integer factorization on a quantum computer has a subroutine to compute DFT of a binary vector. This is implemented as sequence of 1 or 2bit quantum gates now known as quantum FFT, which is effectively the Cooley–Tukey FFT realized as a particular factorization of the Fourier matrix. Extension to these ideas is currently being explored.
Language reference
Language  Command/Method  Prerequisites 

R  stats::fft(x)  None 
Octave/MATLAB  fft(x)  None 
Python  fft.fft(x)  numpy 
Mathematica  Fourier[x]  None 
Fortran  fftw_one(plan,in,out)  FFTW 
Julia  fft(A [,dims])  FFTW 
Rust  fft.process(&mut x);  rustfft 
Haskell  dft x  fft 
See also
FFTrelated algorithms:
 Goertzel algorithm – computes individual terms of discrete Fourier transform
FFT implementations:
 ALGLIB – a dual/GPLlicensed C++ and C# library (also supporting other languages), with real/complex FFT implementation
 FFTPACK – another Fortran FFT library (public domain)
 Architecturespecific:
 Arm Performance Libraries^{[51]}
 Intel Integrated Performance Primitives
 Intel Math Kernel Library
 Many more implementations are available,^{[52]} for CPUs and GPUs, such as PocketFFT for C++
Other links:
 Odlyzko–Schönhage algorithm applies the FFT to finite Dirichlet series
 Schönhage–Strassen algorithm – asymptotically fast multiplication algorithm for large integers
 Butterfly diagram – a diagram used to describe FFTs
 Spectral music (involves application of DFT analysis to musical composition)
 Spectrum analyzer – any of several devices that perform spectrum analysis, often via a DFT
 Time series
 Fast Walsh–Hadamard transform
 Generalized distributive law
 Leastsquares spectral analysis
 Multidimensional transform
 Multidimensional discrete convolution
 Fast Fourier Transform Telescope
References
 ↑ ^{1.0} ^{1.1} ^{1.2} ^{1.3} "Gauss and the history of the fast Fourier transform". IEEE ASSP Magazine 1 (4): 14–21. 1984. doi:10.1109/MASSP.1984.1162257. http://www.cis.rit.edu/class/simg716/Gauss_History_FFT.pdf.
 ↑ Computational Frameworks for the Fast Fourier Transform. SIAM. 1992.
 ↑ "Wavelets". American Scientist 82 (3): 250–255. May–June 1994.
 ↑ Acoustic Analysis of Speech. 2002. ISBN 0769301126.
 ↑ "Guest Editors Introduction to the top 10 algorithms". Computing in Science & Engineering 2 (1): 22–23. January 2000. doi:10.1109/MCISE.2000.814652. ISSN 15219615. Bibcode: 2000CSE.....2a..22D.
 ↑ "Theoria interpolationis methodo nova tractata" (in la, de). Nachlass (Unpublished manuscript). Werke. 3. Göttingen, Germany: Königlichen Gesellschaft der Wissenschaften zu Göttingen. 1866. pp. 265–303. https://babel.hathitrust.org/cgi/pt?id=uc1.c2857678;view=1up;seq=279.
 ↑ ^{7.0} ^{7.1} "Gauss and the history of the fast Fourier transform". Archive for History of Exact Sciences 34 (3): 265–277. 19850901. doi:10.1007/BF00348431. ISSN 00039519.
 ↑ "The design and analysis of factorial experiments". Technical Communication No. 35 of the Commonwealth Bureau of Soils 142 (3585): 90–92. 1937. doi:10.1038/142090a0. Bibcode: 1938Natur.142...90F.
 ↑ "Some improvements in practical Fourier analysis and their application to xray scattering from liquids". Journal of the Franklin Institute 233 (4): 365–380. 1942. doi:10.1016/S00160032(42)907671.
 ↑ Applied Analysis. Prentice–Hall. 1956. https://archive.org/details/appliedanalysis00lanc_0.
 ↑ "Historical notes on the fast Fourier transform". IEEE Transactions on Audio and Electroacoustics 15 (2): 76–79. June 1967. doi:10.1109/TAU.1967.1161903. ISSN 00189278.
 ↑ ^{12.0} ^{12.1} "An algorithm for the machine calculation of complex Fourier series". Mathematics of Computation 19 (90): 297–301. 1965. doi:10.1090/S00255718196501785861. ISSN 00255718. https://www.ams.org/mcom/196519090/S00255718196501785861/.
 ↑ The ReDiscovery of the Fast Fourier Transform Algorithm. III. Vienna, Austria. 1987. pp. 33–45. https://carma.newcastle.edu.au/jon/Preprints/Talks/CARMACE/FFT.pdf.
 ↑ "The Fast Fourier Transform As an Example of the Difficulty in Gaining Wide Use for a New Technique". IEEE Transactions on Audio and Electroacoustics AU17 (2): 68–72. June 1969. https://fas.org/rlg/690600fft.pdf.
 ↑ ^{15.0} ^{15.1} "The FFT: an algorithm the whole family can use". Computing in Science & Engineering 2 (1): 60–64. January 2000. doi:10.1109/5992.814659. ISSN 15219615. Bibcode: 2000CSE.....2a..60R.
 ↑ ^{16.0} ^{16.1} "A Modified SplitRadix FFT With Fewer Arithmetic Operations". IEEE Transactions on Signal Processing 55 (1): 111–119. January 2007. doi:10.1109/tsp.2006.882087. Bibcode: 2007ITSP...55..111J.
 ↑ ^{17.0} ^{17.1} ^{17.2} "The Design and Implementation of FFTW3". Proceedings of the IEEE 93 (2): 216–231. 2005. doi:10.1109/jproc.2004.840301. http://fftw.org/fftwpaperieee.pdf.
 ↑ ^{18.0} ^{18.1} "Fast Fourier transforms—for fun and profit". Proceedings of the AFIPS 29: 563–578. 1966. doi:10.1145/1464291.1464352.
 ↑ (in la, de) Theoria interpolationis methodo nova tractata. Werke. 3. Göttingen, Germany: Königliche Gesellschaft der Wissenschaften. 1866. pp. 265–327. https://www.deutschedigitalebibliothek.de/item/VAK3TPRSI57PWW6OSOSWAU52CN7CNRJP.
 ↑ ^{20.0} ^{20.1} "A New Principle for Fast Fourier Transformation". IEEE Transactions on Acoustics, Speech, and Signal Processing 24 (3): 264–266. 1976. doi:10.1109/TASSP.1976.1162805.
 ↑ ^{21.0} ^{21.1} "On computing the discrete Fourier transform". Mathematics of Computation 32 (141): 175–199. 1978. doi:10.1090/S00255718197804683064. PMID 16592303.
 ↑ "On the multiplicative complexity of the discrete Fourier transform". Advances in Mathematics 32 (2): 83–117. 1979. doi:10.1016/00018708(79)900379.
 ↑ ^{23.0} ^{23.1} "Realvalued fast Fourier transform algorithms". IEEE Transactions on Acoustics, Speech, and Signal Processing 35 (6): 849–863. 1987. doi:10.1109/TASSP.1987.1165220.
 ↑ "Corrections to "Realvalued fast Fourier transform algorithms"". IEEE Transactions on Acoustics, Speech, and Signal Processing 35 (9): 1353. 1987. doi:10.1109/TASSP.1987.1165284.
 ↑ "On the number of multiplications necessary to compute a length2^{n} DFT". IEEE Transactions on Acoustics, Speech, and Signal Processing 34 (1): 91–95. 1986. doi:10.1109/TASSP.1986.1164785.
 ↑ ^{26.0} ^{26.1} "Algorithms meeting the lower bounds on the multiplicative complexity of length2^{n} DFTs and their connection with practical algorithms". IEEE Transactions on Acoustics, Speech, and Signal Processing 38 (9): 1504–1511. 1990. doi:10.1109/29.60070.
 ↑ "Note on a lower bound of the linear complexity of the fast Fourier transform". Journal of the ACM 20 (2): 305–306. 1973. doi:10.1145/321752.321761.
 ↑ "The tradeoff between the additive complexity and the asynchronicity of linear and bilinear algorithms". Information Processing Letters 22 (1): 11–14. 19860102. doi:10.1016/00200190(86)900359. https://dl.acm.org/citation.cfm?id=8013. Retrieved 20171031.
 ↑ "Optimality of the fast Fourier transform". Journal of the ACM 26: 95–102. 1979. doi:10.1145/322108.322118.
 ↑ "A new matrix approach to real FFTs and convolutions of length 2^{k}". Computing 80 (1): 23–45. 2007. doi:10.1007/s0060700702226.
 ↑ "Generating and Searching Families of FFT Algorithms". Journal on Satisfiability, Boolean Modeling and Computation 7 (4): 145–187. 2011. doi:10.3233/SAT190084. Bibcode: 2011arXiv1103.5740H. http://jsat.ewi.tudelft.nl/content/volume7/JSAT7_13_Haynal.pdf.
 ↑ ^{32.0} ^{32.1} "Fast Fourier transforms: a tutorial review and a state of the art". Signal Processing 19 (4): 259–299. 1990. doi:10.1016/01651684(90)90158U. http://infoscience.epfl.ch/record/59946.
 ↑ "The Future Fast Fourier Transform?". SIAM Journal on Scientific Computing 20 (3): 1094–1114. 1999. doi:10.1137/S1064827597316266. http://www.cs.tau.ac.il/~stoledo/Bib/Pubs/pp97fft.pdf.
 ↑ "Fast approximate Fourier transform via wavelets transform". Proceedings of SPIE. Wavelet Applications in Signal and Image Processing IV 2825: 250–259. 1996. doi:10.1117/12.255236. Bibcode: 1996SPIE.2825..250G.
 ↑ "Subband DFT. I. Definition, interpretations and extensions". Signal Processing 41 (3): 261–277. 1995. doi:10.1016/01651684(94)001037.
 ↑ "Simple and Practical Algorithm for Sparse Fourier Transform". ACMSIAM Symposium on Discrete Algorithms. January 2012. https://www.mit.edu/~ecprice/papers/sparsefftsoda.pdf. (NB. See also the sFFT Web Page.)
 ↑ "Accuracy of the discrete Fourier transform and the fast Fourier transform". SIAM Journal on Scientific Computing 17 (5): 1150–1166. 1996. doi:10.1137/s1064827593247023. http://portal.acm.org/citation.cfm?id=240432.
 ↑ "A fixedpoint fast Fourier transform error analysis". IEEE Transactions on Audio and Electroacoustics 17 (2): 151–157. 1969. doi:10.1109/TAU.1969.1162035.
 ↑ Testing multivariate linear functions: Overcoming the generator bottleneck. Kyoto, Japan. 1995. 407–416. doi:10.1145/225058.225167. ISBN 9780897917186.
 ↑ "Digital filtering using polynomial transforms". Electronics Letters 13 (13): 386–387. 1977. doi:10.1049/el:19770280.
 ↑ "A Fast Transform for Spherical Harmonics". Journal of Fourier Analysis and Applications 5 (2–3): 159–184. 1999. doi:10.1007/BF01261607. http://www.ohiouniversityfaculty.com/mohlenka/research/MOHLEN1999P.pdf. Retrieved 20180111.
 ↑ "libftsh library". http://www.math.ohiou.edu/~mjm/research/libftsh.html.
 ↑ "Fast Algorithms for Spherical Harmonic Expansions". SIAM Journal on Scientific Computing 27 (6): 1903–1928. 2006. doi:10.1137/050623073. http://tygert.com/sph2.pdf. Retrieved 20140918. [1]
 ↑ "Fast Fourier transforms for nonequispaced data: A tutorial". Modern Sampling Theory: Mathematics and Applications. Birkhäuser. 2001. http://www.tuchemnitz.de/~potts/paper/ndft.pdf.
 ↑ Burgess, Richard James (2014). The History of Music Production. Oxford University Press. ISBN 9780199357178. https://books.google.com/books?id=qMKiAwAAQBAJ. Retrieved 1 August 2019.
 ↑ "Chapter 16". Inside the FFT Black Box: Serial and Parallel Fast Fourier Transform Algorithms. CRC Press. 19991111. pp. 153–168. ISBN 9781420049961.
 ↑ "Computation of Isotopic Peak CenterMass Distribution by Fourier Transform". Analytical Chemistry 84 (16): 7052–7056. 20120808. doi:10.1021/ac301296a. ISSN 00032700. PMID 22873736.
 ↑ "Performing outofcore FFTs on parallel disk systems". Parallel Computing 24 (1): 5–20. 1998. doi:10.1016/S01678191(97)001142.
 ↑ "Fast Fourier Transforms for Nonequispaced Data". SIAM Journal on Scientific Computing 14 (6): 1368–1393. 19931101. doi:10.1137/0914081. ISSN 10648275.
 ↑ Byrnes, Jim, ed (2004). "Recent Progress and Applications in Group FFTs". Computational Noncommutative Algebra and Applications. NATO Science Series II: Mathematics, Physics and Chemistry. 136. Springer Netherlands. pp. 227–254. doi:10.1007/1402023073_9. ISBN 9781402019821.
 ↑ "Arm Performance Libraries". Arm. 2020. https://www.arm.com/products/developmenttools/serverandhpc/allineastudio/performancelibraries.
 ↑ "Complete list of C/C++ FFT libraries" (in en). 20200405. https://community.vcvrack.com/t/completelistofccfftlibraries/9153.
Further reading
 The Fast Fourier Transform. New York, USA: PrenticeHall. 2002.
 "Chapter 30: Polynomials and the FFT". Introduction to Algorithms (2 ed.). MIT Press / McGrawHill. 2001. ISBN 0262032937.
 Fast transforms: Algorithms, analyses, applications. New York, USA: Academic Press. 1982.
 "The Quick Discrete Fourier Transform". Proceedings of ICASSP '94. IEEE International Conference on Acoustics, Speech and Signal Processing. 3. 1994. 445–448. doi:10.1109/ICASSP.1994.389994. ISBN 9780780317758.
 "A modified splitradix FFT with fewer arithmetic operations". IEEE Transactions on Signal Processing 55 (1): 111–119. 2007. doi:10.1109/tsp.2006.882087. Bibcode: 2007ITSP...55..111J. http://www.fftw.org/newsplit.pdf.
 "Chapter 12. Fast Fourier Transform". Numerical Recipes: The Art of Scientific Computing (3 ed.). New York, USA: Cambridge University Press. 2007. ISBN 9780521880688. http://apps.nrbook.com/empanel/index.html#pg=600.
 "A Short Bibliography on the Fast Fourier Transform". Special Issue on Fast Fourier Transform. AU17. IEEE Audio and Electroacoustics Group. June 1969. 166–169. doi:10.1109/TAU.1969.1162029. (NB. Contains extensive bibliography.)
 Elena Prestini: "The Evolution of Applied Harmonic Analysis", Springer, ISBN 9780817641252 (2004), Sec.3.10 'Gauss and the asteroids: history of the FFT'.
External links
 Fast Fourier Transform for Polynomial Multiplication – fast Fourier algorithm
 Fast Fourier Transforms, Connexions online book edited by Charles Sidney Burrus, with chapters by Charles Sidney Burrus, Ivan Selesnick, Markus Pueschel, Matteo Frigo, and Steven G. Johnson (2008)
 Fast Fourier transform — FFT – FFT programming in C++ – the Cooley–Tukey algorithm
 Online documentation, links, book, and code
 Sri Welaratna, "Thirty years of FFT analyzers", Sound and Vibration (January 1997, 30th anniversary issue) – a historical review of hardware FFT devices
 ALGLIB FFT Code – a dual/GPLlicensed multilanguage (VBA, C++, Pascal, etc.) numerical analysis and data processing library
 SFFT: Sparse Fast Fourier Transform – MIT's sparse (sublinear time) FFT algorithm, sFFT, and implementation
 VB6 FFT – a VB6 optimized library implementation with source code
 Interactive FFT Tutorial – a visual interactive intro to Fourier transforms and FFT methods
Original source: https://en.wikipedia.org/wiki/ Fast Fourier transform.
Read more 