Fast Fourier transform: Difference between revisions

← Previous edit

VisualWikitext

Latest revision as of 23:39, 17 November 2025

Template:Short description Script error: No such module "redirect hatnote". Template:Use American English

File:DIT-FFT-butterfly.svg

An example FFT algorithm structure, using a decomposition into half-size FFTs

File:FFT of Cosine Summation Function.svg

A discrete Fourier analysis of a sum of cosine waves at 10, 20, 30, 40, and 50 Hz

File:Simple time domain vs frequency domain.svg

Time-based representation (above) and frequency-based representation (below) of the same signal, where the lower representation can be obtained from the upper one by Fourier transformation

A fast Fourier transform (FFT) is an algorithm that computes the discrete Fourier transform (DFT) of a sequence, or its inverse (IDFT). A Fourier transform 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 $O (n^{2})$ , which arises if one simply applies the definition of DFT, to $O (n \log n)$ , where Template:Mvar is the data size. The difference in speed can be enormous, especially for long data sets where Template:Mvar may be in the thousands or millions.

As the FFT is merely an algebraic refactoring of terms within the DFT, the DFT and the FFT both perform mathematically equivalent and interchangeable operations, assuming that all terms are computed with infinite precision. However, in the presence of round-off 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 complex-number arithmetic to group theory and number theory. The best-known FFT algorithms depend upon the factorization of Template:Mvar, but there are FFTs with $O (n \log n)$ complexity for all, even prime, Template:Mvar. Many FFT algorithms depend only on the fact that $e^{- 2 π i / n}$ is an Template:Mvarth primitive root of unity, and thus can be applied to analogous transforms over any finite field, such as number-theoretic transforms. Since the inverse DFT is the same as the DFT, but with the opposite sign in the exponent and a Template:Math factor, any FFT algorithm can easily be adapted for it.

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]

History

The development of fast algorithms for DFT was prefigured in Carl Friedrich Gauss's unpublished 1805 work on the orbits of asteroids Pallas and Juno. Gauss wanted to interpolate the orbits from sample observations;^[6]^[7] his method was very similar to the one that would be 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 1822 results, he did not analyze the method's complexity, and eventually used other methods to achieve the same end.

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 x-ray 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 $O (n^{2})$ computation by taking advantage of symmetries, Danielson and Lanczos realized that one could use the periodicity and apply a doubling trick to "double [[[:Template:Mvar]]] with only slightly more than double the labor", though like Gauss they did not do the analysis to discover that this led to $O (n \log n)$ scaling.^[11] In 1958, I. J. Good published a paper establishing the prime-factor FFT algorithm that applies to discrete Fourier transforms of size $n = n_{1} n_{2}$ , where $n_{1}$ and $n_{2}$ are coprime.^[12]

James Cooley and John Tukey independently rediscovered these earlier algorithms^[7] and published a more general FFT in 1965 that is applicable when Template:Mvar is composite and not necessarily a power of 2, as well as analyzing the $O (n \log n)$ scaling.^[13] 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 3-D crystal of Helium-3.^[14] Garwin gave Tukey's idea to Cooley (both worked at IBM's Watson labs) for implementation.^[15] Cooley and Tukey published the paper in a relatively short time of six months.^[16] 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 $x_{0}, \dots, x_{n - 1}$ be complex numbers. The DFT is defined by the formula

X_{k} = \sum_{m = 0}^{n - 1} x_{m} e^{- i 2 π k m / n} k = 0, \dots, n - 1,

where $e^{i 2 π / n}$ is a primitive Template:Mvarth root of 1.

Evaluating this definition directly requires $O (n^{2})$ operations: there are Template:Mvar outputs Template:Mvar Template:Hairsp, and each output requires a sum of Template:Mvar terms. An FFT is any method to compute the same results in $O (n \log n)$ operations. All known FFT algorithms require $O (n \log n)$ operations, although there is no known proof that lower complexity is impossible.^[17]

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 $O (n)$ operations can be saved by eliminating trivial operations such as multiplications by 1, leaving about 30 million operations. In contrast, the radix-2 Cooley–Tukey algorithm, for Template:Mvar 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 70,000 operations — more than four-hundred 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),^[18] but the overall improvement from $O (n^{2})$ to $O (n \log n)$ remains.

Algorithms

Cooley–Tukey algorithm

Script error: No such module "Labelled list hatnote".

By far the most commonly used FFT is the Cooley–Tukey algorithm. This is a divide-and-conquer algorithm that recursively breaks down a DFT of any composite size $n = n_{1} n_{2}$ into $n_{1}$ smaller DFTs of size $n_{2}$ , along with $O (n)$ multiplications by complex roots of unity traditionally called twiddle factors (after Gentleman and Sande, 1966).^[19]

This method (and the general idea of an FFT) was popularized by a publication of Cooley and Tukey in 1965,^[13] but it was later discovered^[1] that those two authors had together independently re-invented an algorithm known to Carl Friedrich Gauss around 1805^[20] (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 Template:Math at each step, and is therefore limited to power-of-two sizes, but any factorization can be used in general (as was known to both Gauss and Cooley/Tukey^[1]). These are called the radix-2 and mixed-radix cases, respectively (and other variants such as the split-radix 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

Script error: No such module "Labelled list hatnote".

For $n = n_{1} n_{2}$ with coprime $n_{1}$ and $n_{2}$ , one can use the prime-factor (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)^[21] is a Cooley–Tukey-like 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 split-radix 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^[21] and QFT algorithms were proposed for power-of-two sizes, but it is possible that they could be adapted to general composite Template:Mvar. 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 real-coefficient polynomials of the form $z^{m} - 1$ and $z^{2 m} + a z^{m} + 1$ .

Another polynomial viewpoint is exploited by the Winograd FFT algorithm,^[22]^[23] 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 minimal-multiplication 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 power-of-two sizes; 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 Template:Mvar, expresses a DFT of prime size Template:Mvar as a cyclic convolution of (composite) size Template:Math, which can then be computed by a pair of ordinary FFTs via the convolution theorem (although Winograd uses other convolution methods). Another prime-size FFT is due to L. I. Bluestein, and is sometimes called the chirp-z algorithm; it also re-expresses a DFT as a convolution, but this time of the same size (which can be zero-padded to a power of two and evaluated by radix-2 Cooley–Tukey FFTs, for example), via the identity

n k = - \frac{(k - n)^{2}}{2} + \frac{n^{2}}{2} + \frac{k^{2}}{2} .

Hexagonal fast Fourier transform (HFFT) aims at computing an efficient FFT for the hexagonally-sampled 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

X_{n - k} = X_{k}^{*}

and efficient FFT algorithms have been designed for this situation (see e.g., Sorensen, 1987).^[24]^[25] 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 even-length real-input 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)$ post-processing operations.

It was once believed that real-input DFTs could be more efficiently computed by means of the discrete Hartley transform (DHT), but it was subsequently argued that a specialized real-input DFT algorithm (FFT) can typically be found that requires fewer operations than the corresponding DHT algorithm (FHT) for the same number of inputs.^[24] 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 post-processing.

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

O (N \log N)

?

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 modern-day computers is determined by many other factors such as cache or CPU pipeline optimization.

Following work by Shmuel Winograd (1978),^[22] a tight $Θ (n)$ lower bound is known for the number of real multiplications required by an FFT. It can be shown that only $4 n - 2 \log_{2}^{2} (n) - 2 \log_{2} (n) - 4$ irrational real multiplications are required to compute a DFT of power-of-two length $n = 2^{m}$ . Moreover, explicit algorithms that achieve this count are known (Heideman & Burrus, 1986;^[26] Duhamel, 1990^[27]). However, these algorithms require too many additions to be practical, at least on modern computers with hardware multipliers (Duhamel, 1990;^[27] Frigo & Johnson, 2005).^[18]

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^[28] 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)^[29] 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 power-of-two Template:Mvar, Papadimitriou (1979)^[30] argued that the number $n \log_{2} n$ of complex-number 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 $2 N \log_{2} N$ real additions are required, although this is not a tight bound because extra additions are required as part of complex-number multiplications.) Thus far, no published FFT algorithm has achieved fewer than $n \log_{2} n$ complex-number additions (or their equivalent) for power-of-two Template:Mvar.

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 power-of-two Template:Mvar was long achieved by the split-radix FFT algorithm, which requires $4 n \log_{2} (n) - 6 n + 8$ real multiplications and additions for Template:Math. This was recently reduced to $\sim \frac{34}{9} n \log_{2} n$ (Johnson and Frigo, 2007;^[17] Lundy and Van Buskirk, 2007^[31]). A slightly larger count (but still better than split radix for Template:Math) was shown to be provably optimal for Template:Math under additional restrictions on the possible algorithms (split-radix-like flowgraphs with unit-modulus multiplicative factors), by reduction to a satisfiability modulo theories problem solvable by brute force (Haynal & Haynal, 2011).^[32]

Most of the attempts to lower or prove the complexity of FFT 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 related problems such as real-data 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).^[33]

Approximations

All of the FFT algorithms discussed above compute the DFT exactly (i.e., neglecting floating-point 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)^[34] achieves lower communication requirements for parallel computing with the help of a fast multipole method. A wavelet-based approximate FFT by Guo and Burrus (1996)^[35] 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).^[36] The Edelman algorithm works equally well for sparse and non-sparse 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 Template:Mvar out of Template:Mvar 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 Template:Math in a large-Template:Mvar example (Template:Math) using a probabilistic approximate algorithm (which estimates the largest Template:Mvar coefficients to several decimal places).^[37]

Accuracy

FFT algorithms have errors when finite-precision floating-point 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,^[19] where Template:Math is the machine floating-point relative precision. In fact, the root mean square (rms) errors are much better than these upper bounds, being only $O (ε \sqrt{\log n})$ for Cooley–Tukey and $O (ε \sqrt{n})$ for the naïve DFT (Schatzman, 1996).^[38] 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 fixed-point arithmetic, the finite-precision errors accumulated by FFT algorithms are worse, with rms errors growing as $O (\sqrt{n})$ for the Cooley–Tukey algorithm (Welch, 1969).^[39] Achieving this accuracy requires careful attention to scaling to minimize loss of precision, and fixed-point 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, impulse-response, and time-shift properties of the transform on random inputs (Ergün, 1995).^[40]

The values for intermediate frequencies may be obtained by various averaging methods.

Multidimensional FFTs

As defined in the multidimensional DFT article, the multidimensional DFT

X_{𝐤} = \sum_{𝐧 = 0}^{𝐍 - 1} e^{- 2 π i 𝐤 \cdot (𝐧 / 𝐍)} x_{𝐧}

transforms an array Template:Math with a Template:Mvar-dimensional vector of indices $𝐧 = (n_{1}, \dots, n_{d})$ by a set of Template:Mvar nested summations (over $n_{j} = 0 \dots N_{j} - 1$ for each Template:Mvar), where the division $𝐧 / 𝐍 = (n_{1} / N_{1}, \dots, n_{d} / N_{d})$ is performed element-wise. Equivalently, it is the composition of a sequence of d sets of one-dimensional 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 row-column algorithm (after the two-dimensional case, below). That is, one simply performs a sequence of Template:Mvar one-dimensional FFTs (by any of the above algorithms): first you transform along the Template:Math dimension, then along the Template:Math dimension, and so on (actually, any ordering works). This method is easily shown to have the usual $O (n \log n)$ complexity, where $n = n_{1} \cdot n_{2} \dots n_{d}$ is the total number of data points transformed. In particular, there are Template:Math transforms of size Template:Math, etc., so the complexity of the sequence of FFTs is:

\begin{aligned} \frac{n}{n_{1}} O (n_{1} \log n_{1}) + \dots + \frac{n}{n_{d}} O (n_{d} \log n_{d}) \\ = & O (n [\log n_{1} + \dots + \log n_{d}]) = O (n \log n) . \end{aligned}

In two dimensions, the x_k can be viewed as an $n_{1} \times n_{2}$ 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 $n_{1} \times n_{2}$ 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 three-dimensional FFT might first perform two-dimensional FFTs of each planar slice for each fixed n₁, and then perform the one-dimensional FFTs along the n₁ direction. More generally, an asymptotically optimal cache-oblivious algorithm consists of recursively dividing the dimensions into two groups $(n_{1}, \dots, n_{d / 2})$ and $(n_{d / 2 + 1}, \dots, n_{d})$ that are transformed recursively (rounding if Template:Mvar is not even) (see Frigo and Johnson, 2005).^[18] 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 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 out-of-core and distributed memory situations where accessing non-contiguous data is extremely time-consuming.

There are other multidimensional FFT algorithms that are distinct from the row-column algorithm, although all of them have $O (n \log n)$ complexity. Perhaps the simplest non-row-column FFT is the vector-radix FFT algorithm, which is a generalization of the ordinary Cooley–Tukey algorithm where one divides the transform dimensions by a vector $𝐫 = (r_{1}, r_{2}, \dots, r_{d})$ of radices at each step. (This may also have cache benefits.) The simplest case of vector-radix is where all of the radices are equal (e.g., vector-radix-2 divides all of the dimensions by two), but this is not necessary. Vector radix with only a single non-unit radix at a time, i.e. $𝐫 = (1, \dots, 1, r, 1, \dots, 1)$ , is essentially a row-column algorithm. Other, more complicated, methods include polynomial transform algorithms due to Nussbaumer (1977),^[41] which view the transform in terms of convolutions and polynomial products. See Duhamel and Vetterli (1990)^[33] for more information and references.

Other generalizations

An $O (n^{5 / 2} \log n)$ generalization to spherical harmonics on the sphere Template:Math with Template:Math nodes was described by Mohlenkamp,^[42] 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.^[43] A spherical-harmonic algorithm with $O (n^{2} \log n)$ complexity is described by Rokhlin and Tygert.^[44]

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 non-equispaced data, as reviewed in Potts et al. (2001).^[45] Such algorithms do not strictly compute the DFT (which is only defined for equispaced data), but rather some approximation thereof (a non-uniform 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.^[46]

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:^[16]^[47]

fast large-integer multiplication algorithms 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.^[48]
modulation and demodulation of complex data symbols using orthogonal frequency-division multiplexing (OFDM) for 5G, LTE, Wi-Fi, DSL, and other modern communication systems.

Alternatives

Script error: No such module "Labelled list hatnote". The FFT can be a poor choice for analyzing signals with non-stationary frequency content—where the frequency characteristics change over time. DFTs provide a global frequency estimate, assuming that all frequency components are present throughout the entire signal, which makes it challenging to detect short-lived or transient features within signals.

For cases where frequency information appears briefly in the signal or generally varies over time, alternatives like the short-time Fourier transform, discrete wavelet transforms, or discrete Hilbert transform can be more suitable.^[49]^[50] These transforms allow for localized frequency analysis by capturing both frequency and time-based information.

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 out-of-core FFTs are an active area of research.^[51]
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.^[52]
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 non-cyclic, has an expansion in terms of a basis of irreducible matrix elements. It remains an active area of research to find an efficient algorithm for performing this change of basis. Applications including efficient spherical harmonic expansion, analyzing certain Markov processes, robotics etc.^[53]
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 a sequence of 1- or 2-bit quantum gates now known as quantum FFT, which is effectively the Cooley–Tukey FFT realized as a particular factorization of the Fourier matrix. Extensions to these ideas are currently being explored.^[54]

Language reference

Template:Aligned table

References

Template:Reflist

External links

Fast Fourier Transform for Polynomial Multiplication Template:Snd fast Fourier algorithm
Fast Fourier transform — FFT Template:Snd FFT programming in C++Template:Snd the Cooley–Tukey algorithm
Online documentation, links, book, and code
Sri Welaratna, "Thirty years of FFT analyzers Template:Webarchive", Sound and Vibration (January 1997, 30th anniversary issue)Template:Snd a historical review of hardware FFT devices
ALGLIB FFT Code Template:Snd a dual/GPL-licensed multilanguage (VBA, C++, Pascal, etc.) numerical analysis and data processing library
SFFT: Sparse Fast Fourier Transform Template:Snd MIT's sparse (sub-linear time) FFT algorithm, sFFT, and implementation
VB6 FFT Template:Snd a VB6 optimized library implementation with source code
Interactive FFT Tutorial Template:Snd a visual interactive intro to Fourier transforms and FFT methods
Introduction to Fourier analysis of time series Template:Snd tutorial how to use of the Fourier transform in time series analysis

Template:Authority control

↑ ^a ^b ^c ^d Cite error: Invalid <ref> tag; no text was provided for refs named Heideman_Johnson_Burrus_1984
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Loan_1992
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Strang_1994
↑ Script error: No such module "citation/CS1".
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Dongarra_Sullivan_2000
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Gauss_1866
↑ ^a ^b Cite error: Invalid <ref> tag; no text was provided for refs named Heideman_Johnson_Burrus_1985
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Yates_1937
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Danielson_Lanczos_1942
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Lanczos_1956
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Cooley_Lewis_Welch_1967
↑ Script error: No such module "Citation/CS1".
↑ ^a ^b Cite error: Invalid <ref> tag; no text was provided for refs named Cooley_Tukey_1965
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Cooley_1987
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Garwin_1969
↑ ^a ^b Cite error: Invalid <ref> tag; no text was provided for refs named Rockmore_2000
↑ ^a ^b Cite error: Invalid <ref> tag; no text was provided for refs named Frigo_Johnson_2007
↑ ^a ^b ^c Cite error: Invalid <ref> tag; no text was provided for refs named Frigo_Johnson_2005
↑ ^a ^b Cite error: Invalid <ref> tag; no text was provided for refs named Gentleman_Sande_1966
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Gauss_1805
↑ ^a ^b Cite error: Invalid <ref> tag; no text was provided for refs named Brenner_Rader_1976
↑ ^a ^b Cite error: Invalid <ref> tag; no text was provided for refs named Winograd_1978
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Winograd_1979
↑ ^a ^b Cite error: Invalid <ref> tag; no text was provided for refs named Sorensen_Jones_Heideman_Burrus_1987_1
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Sorensen_Jones_Heideman_Burrus_1987_2
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Heideman_Burrus_1986
↑ ^a ^b Cite error: Invalid <ref> tag; no text was provided for refs named Duhamel_1990
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Morgenstern_1973
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Pan_1986
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Papadimitriou_1979
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Lundy_Buskirk_2007
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Haynal_2011
↑ ^a ^b Cite error: Invalid <ref> tag; no text was provided for refs named Duhamel_Vetterli_1990
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Edelman_McCorquodale_Toledo_1999
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Guo_Burrus_1996
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Shentov_Mitra_Heute_Hossen_1995
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Hassanieh_2012
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Schatzman_1996
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Welch_1969
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Ergün_1995
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Nussbaumer_1977
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Mohlenkamp_1999
↑ Cite error: Invalid <ref> tag; no text was provided for refs named libftsh
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Rokhlin_Tygert_2006
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Potts_Steidl_Tasche_2001
↑ Script error: No such module "citation/CS1".
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Chu_George_1999
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Fernandez-de-Cossio_2012
↑ Script error: No such module "Citation/CS1".
↑ Script error: No such module "citation/CS1".
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Cormen_Nicol_1998
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Dutt_Rokhlin_1993
↑ Cite error: Invalid <ref> tag; no text was provided for refs named Rockmore_2004
↑ Script error: No such module "Citation/CS1".
↑ Script error: No such module "citation/CS1".
↑ Script error: No such module "citation/CS1".

[Heideman_Johnson_Burrus_1984-1] Cite error: Invalid <ref> tag; no text was provided for refs named Heideman_Johnson_Burrus_1984

[Loan_1992-2] Cite error: Invalid <ref> tag; no text was provided for refs named Loan_1992

[Strang_1994-3] Cite error: Invalid <ref> tag; no text was provided for refs named Strang_1994

[4] Script error: No such module "citation/CS1".

[Dongarra_Sullivan_2000-5] Cite error: Invalid <ref> tag; no text was provided for refs named Dongarra_Sullivan_2000

[Gauss_1866-6] Cite error: Invalid <ref> tag; no text was provided for refs named Gauss_1866

[Heideman_Johnson_Burrus_1985-7] Cite error: Invalid <ref> tag; no text was provided for refs named Heideman_Johnson_Burrus_1985

[Yates_1937-8] Cite error: Invalid <ref> tag; no text was provided for refs named Yates_1937

[Danielson_Lanczos_1942-9] Cite error: Invalid <ref> tag; no text was provided for refs named Danielson_Lanczos_1942

[Lanczos_1956-10] Cite error: Invalid <ref> tag; no text was provided for refs named Lanczos_1956

[Cooley_Lewis_Welch_1967-11] Cite error: Invalid <ref> tag; no text was provided for refs named Cooley_Lewis_Welch_1967

[12] Script error: No such module "Citation/CS1".

[Cooley_Tukey_1965-13] Cite error: Invalid <ref> tag; no text was provided for refs named Cooley_Tukey_1965

[Cooley_1987-14] Cite error: Invalid <ref> tag; no text was provided for refs named Cooley_1987

[Garwin_1969-15] Cite error: Invalid <ref> tag; no text was provided for refs named Garwin_1969

[Rockmore_2000-16] Cite error: Invalid <ref> tag; no text was provided for refs named Rockmore_2000

[Frigo_Johnson_2007-17] Cite error: Invalid <ref> tag; no text was provided for refs named Frigo_Johnson_2007

[Frigo_Johnson_2005-18] Cite error: Invalid <ref> tag; no text was provided for refs named Frigo_Johnson_2005

[Gentleman_Sande_1966-19] Cite error: Invalid <ref> tag; no text was provided for refs named Gentleman_Sande_1966

[Gauss_1805-20] Cite error: Invalid <ref> tag; no text was provided for refs named Gauss_1805

[Brenner_Rader_1976-21] Cite error: Invalid <ref> tag; no text was provided for refs named Brenner_Rader_1976

[Winograd_1978-22] Cite error: Invalid <ref> tag; no text was provided for refs named Winograd_1978

[Winograd_1979-23] Cite error: Invalid <ref> tag; no text was provided for refs named Winograd_1979

[Sorensen_Jones_Heideman_Burrus_1987_1-24] Cite error: Invalid <ref> tag; no text was provided for refs named Sorensen_Jones_Heideman_Burrus_1987_1

[Sorensen_Jones_Heideman_Burrus_1987_2-25] Cite error: Invalid <ref> tag; no text was provided for refs named Sorensen_Jones_Heideman_Burrus_1987_2

[Heideman_Burrus_1986-26] Cite error: Invalid <ref> tag; no text was provided for refs named Heideman_Burrus_1986

[Duhamel_1990-27] Cite error: Invalid <ref> tag; no text was provided for refs named Duhamel_1990

[Morgenstern_1973-28] Cite error: Invalid <ref> tag; no text was provided for refs named Morgenstern_1973

[Pan_1986-29] Cite error: Invalid <ref> tag; no text was provided for refs named Pan_1986

[Papadimitriou_1979-30] Cite error: Invalid <ref> tag; no text was provided for refs named Papadimitriou_1979

[Lundy_Buskirk_2007-31] Cite error: Invalid <ref> tag; no text was provided for refs named Lundy_Buskirk_2007

[Haynal_2011-32] Cite error: Invalid <ref> tag; no text was provided for refs named Haynal_2011

[Duhamel_Vetterli_1990-33] Cite error: Invalid <ref> tag; no text was provided for refs named Duhamel_Vetterli_1990

[Edelman_McCorquodale_Toledo_1999-34] Cite error: Invalid <ref> tag; no text was provided for refs named Edelman_McCorquodale_Toledo_1999

[Guo_Burrus_1996-35] Cite error: Invalid <ref> tag; no text was provided for refs named Guo_Burrus_1996

[Shentov_Mitra_Heute_Hossen_1995-36] Cite error: Invalid <ref> tag; no text was provided for refs named Shentov_Mitra_Heute_Hossen_1995

[Hassanieh_2012-37] Cite error: Invalid <ref> tag; no text was provided for refs named Hassanieh_2012

[Schatzman_1996-38] Cite error: Invalid <ref> tag; no text was provided for refs named Schatzman_1996

[Welch_1969-39] Cite error: Invalid <ref> tag; no text was provided for refs named Welch_1969

[Ergün_1995-40] Cite error: Invalid <ref> tag; no text was provided for refs named Ergün_1995

[Nussbaumer_1977-41] Cite error: Invalid <ref> tag; no text was provided for refs named Nussbaumer_1977

[Mohlenkamp_1999-42] Cite error: Invalid <ref> tag; no text was provided for refs named Mohlenkamp_1999

[libftsh-43] Cite error: Invalid <ref> tag; no text was provided for refs named libftsh

[Rokhlin_Tygert_2006-44] Cite error: Invalid <ref> tag; no text was provided for refs named Rokhlin_Tygert_2006

[Potts_Steidl_Tasche_2001-45] Cite error: Invalid <ref> tag; no text was provided for refs named Potts_Steidl_Tasche_2001

[46] Script error: No such module "citation/CS1".

[Chu_George_1999-47] Cite error: Invalid <ref> tag; no text was provided for refs named Chu_George_1999

[Fernandez-de-Cossio_2012-48] Cite error: Invalid <ref> tag; no text was provided for refs named Fernandez-de-Cossio_2012

[49] Script error: No such module "Citation/CS1".

[50] Script error: No such module "citation/CS1".

[Cormen_Nicol_1998-51] Cite error: Invalid <ref> tag; no text was provided for refs named Cormen_Nicol_1998

[Dutt_Rokhlin_1993-52] Cite error: Invalid <ref> tag; no text was provided for refs named Dutt_Rokhlin_1993

[Rockmore_2004-53] Cite error: Invalid <ref> tag; no text was provided for refs named Rockmore_2004

[54] Script error: No such module "Citation/CS1".

[Arm_Performance_Libraries-55] Script error: No such module "citation/CS1".

[56] Script error: No such module "citation/CS1".

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

[10]

[11]

[12]

[13]

[14]

[15]

[16]

[17]

[18]

[19]

[20]

[21]

[22]

[23]

[24]

[25]

[26]

[27]

[28]

[29]

[30]

[31]

[32]

[33]

[34]

[35]

[36]

[37]

[38]

[39]

[40]

[41]

[42]

[43]

[44]

[45]

[46]

[47]

[48]

[49]

[50]

[51]

[52]

[53]

[54]

[55]

[56]

@@ Line 4: / Line 4: @@
 [[File:DIT-FFT-butterfly.svg|thumb|An example FFT algorithm structure, using a decomposition into half-size FFTs]]
 [[File:FFT of Cosine Summation Function.svg|thumb|A discrete Fourier analysis of a sum of cosine waves at 10, 20, 30, 40, and 50&nbsp;Hz]]
+[[File:Simple time domain vs frequency domain.svg|thumb|Time-based representation (above) and frequency-based representation (below) of the same signal, where the lower representation can be obtained from the upper one by Fourier transformation]]
 A '''fast Fourier transform''' ('''FFT''') is an [[algorithm]] that computes the [[discrete Fourier transform]] (DFT) of a sequence, or its inverse (IDFT). A [[Fourier transform]] converts a signal from its original domain (often time or space) to a representation in the [[frequency domain]] and vice versa.
@@ Line 9: / Line 10: @@
 The DFT is obtained by decomposing a [[sequence]] of values into components of different frequencies.<ref name="Heideman_Johnson_Burrus_1984" /> 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 [[Matrix decomposition|factorizing]] the [[DFT matrix]] into a product of [[Sparse matrix|sparse]] (mostly zero) factors.<ref name="Loan_1992" /> As a result, it manages to reduce the [[Computational complexity theory|complexity]] of computing the DFT from <math display="inline">O(n^2)</math>, which arises if one simply applies the definition of DFT, to <math display="inline">O(n \log n)</math>, where {{mvar|n}} is the data size. The difference in speed can be enormous, especially for long data sets where {{mvar|n}} may be in the thousands or millions.
-As the FFT is merely an algebraic refactoring of terms within the DFT, then the DFT and the FFT both perform mathematically equivalent and interchangeable operations, assuming that all terms are computed with infinite precision.  However, in the presence of [[round-off error]], many FFT algorithms are much more accurate than evaluating the DFT definition directly or indirectly.
+As the FFT is merely an algebraic refactoring of terms within the DFT, the DFT and the FFT both perform mathematically equivalent and interchangeable operations, assuming that all terms are computed with infinite precision.  However, in the presence of [[round-off 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 [[complex number|complex-number arithmetic]] to [[group theory]] and [[number theory]]. The best-known FFT algorithms depend upon the [[factorization]] of {{mvar|n}}, but there are FFTs with <math>O(n \log n)</math> complexity for all, even [[prime]], {{mvar|n}}. Many FFT algorithms depend only on the fact that <math display="inline">e^{-2\pi i/n}</math> is an {{mvar|n}}th [[primitive root of unity]], and thus can be applied to analogous transforms over any [[finite field]], such as [[number-theoretic transform]]s. Since the inverse DFT is the same as the DFT, but with the opposite sign in the exponent and a {{math|1/''n''}} factor, any FFT algorithm can easily be adapted for it.
-[[File:Simple time domain vs frequency domain.svg|thumb|Time-based representation (above) and frequency-based representation (below) of the same signal, where the lower representation can be obtained from the upper one by Fourier transformation]]
+Fast Fourier transforms are widely used for [[discrete Fourier transform#Applications|applications]] in engineering, music, science, and mathematics. The basic ideas were popularized in 1965, but some algorithms had been derived as early as 1805.<ref name="Heideman_Johnson_Burrus_1984"/> In 1994, [[Gilbert Strang]] described the FFT as "the most important [[numerical algorithm]] of our lifetime",<ref name="Strang_1994"/><ref>{{Cite book |last1=Kent |first1=Raymond D. |url=https://archive.org/details/acousticanalysis0000kent_r5w4/page/61 |title=The Acoustic Analysis of Speech |last2=Read |first2=Charles |date=2002 |publisher=Singular/Thomson Learning |isbn=978-0-7693-0112-9 |edition=2nd |location= |pages=61}}</ref> and it was included in Top 10 Algorithms of 20th Century by the [[IEEE]] magazine ''Computing in Science & Engineering''.<ref name="Dongarra_Sullivan_2000"/>
-Fast Fourier transforms are widely used for [[discrete Fourier transform#Applications|applications]] in engineering, music, science, and mathematics. The basic ideas were popularized in 1965, but some algorithms had been derived as early as 1805.<ref name="Heideman_Johnson_Burrus_1984"/> In 1994, [[Gilbert Strang]] described the FFT as "the most important [[numerical algorithm]] of our lifetime",<ref name="Strang_1994"/><ref name="Kent_2002"/> and it was included in Top 10 Algorithms of 20th Century by the [[IEEE]] magazine ''Computing in Science & Engineering''.<ref name="Dongarra_Sullivan_2000"/>
-There are many different FFT algorithms based on a wide range of published theories, from simple [[complex number|complex-number arithmetic]] to [[group theory]] and [[number theory]]. The best-known FFT algorithms depend upon the [[factorization]] of {{mvar|n}}, but there are FFTs with <math>O(n \log n)</math> complexity for all, even [[prime]], {{mvar|n}}. Many FFT algorithms depend only on the fact that <math display="inline">e^{-2\pi i/n}</math> is an {{mvar|n}}th [[primitive root of unity]], and thus can be applied to analogous transforms over any [[finite field]], such as [[number-theoretic transform]]s. Since the inverse DFT is the same as the DFT, but with the opposite sign in the exponent and a {{math|1/''n''}} factor, any FFT algorithm can easily be adapted for it.
 ==History==
@@ Line 33: / Line 30: @@
 Evaluating this definition directly requires <math display="inline">O(n^2)</math> operations: there are {{mvar|n}} outputs {{mvar|X{{sub|k}}}}{{hairsp}}, and each output requires a sum of {{mvar|n}} terms. An FFT is any method to compute the same results in <math display="inline">O(n \log n)</math> operations. All known FFT algorithms require <math display="inline">O(n \log n)</math> operations, although there is no known proof that lower complexity is impossible.<ref name="Frigo_Johnson_2007"/>
-To illustrate the savings of an FFT, consider the count of complex multiplications and additions for <math display="inline">n=4096</math> data points. Evaluating the DFT's sums directly involves <math display="inline">n^2</math> complex multiplications and <math display="inline">n(n-1)</math> complex additions, of which <math display="inline">O(n)</math> operations can be saved by eliminating trivial operations such as multiplications by 1, leaving about 30 million operations. In contrast, the radix-2 [[#Cooley–Tukey algorithm|Cooley–Tukey algorithm]], for {{mvar|n}} a power of 2, can compute the same result with only <math display="inline">(n/2)\log_2(n)</math> complex multiplications (again, ignoring simplifications of multiplications by 1 and similar) and <math display="inline">n\log_2(n)</math> 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 & [[Steven G. Johnson|Johnson]], 2005),<ref name="Frigo_Johnson_2005"/> but the overall improvement from <math display="inline">O(n^2)</math> to <math display="inline">O(n \log n)</math> remains.
+To illustrate the savings of an FFT, consider the count of complex multiplications and additions for <math display="inline">n=4096</math> data points. Evaluating the DFT's sums directly involves <math display="inline">n^2</math> complex multiplications and <math display="inline">n(n-1)</math> complex additions, of which <math display="inline">O(n)</math> operations can be saved by eliminating trivial operations such as multiplications by 1, leaving about 30 million operations. In contrast, the radix-2 [[#Cooley–Tukey algorithm|Cooley–Tukey algorithm]], for {{mvar|n}} a power of 2, can compute the same result with only <math display="inline">(n/2)\log_2(n)</math> complex multiplications (again, ignoring simplifications of multiplications by 1 and similar) and <math display="inline">n\log_2(n)</math> complex additions, in total about 70,000 operations — more than four-hundred 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 & [[Steven G. Johnson|Johnson]], 2005),<ref name="Frigo_Johnson_2005"/> but the overall improvement from <math display="inline">O(n^2)</math> to <math display="inline">O(n \log n)</math> remains.
 ==Algorithms==
@@ Line 64: / Line 61: @@
 :<math>X_{n-k} = X_k^*</math>
-and efficient FFT algorithms have been designed for this situation (see e.g. Sorensen, 1987).<ref name="Sorensen_Jones_Heideman_Burrus_1987_1"/><ref name="Sorensen_Jones_Heideman_Burrus_1987_2"/> 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 ''even''-length real-input 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 <math>O(n)</math> post-processing operations.
+and efficient FFT algorithms have been designed for this situation (see e.g., Sorensen, 1987).<ref name="Sorensen_Jones_Heideman_Burrus_1987_1"/><ref name="Sorensen_Jones_Heideman_Burrus_1987_2"/> 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 ''even''-length real-input 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 <math>O(n)</math> post-processing operations.
 It was once believed that real-input DFTs could be more efficiently computed by means of the [[discrete Hartley transform]] (DHT), but it was subsequently argued that a specialized real-input DFT algorithm (FFT) can typically be found that requires fewer operations than the corresponding DHT algorithm (FHT) for the same number of inputs.<ref name="Sorensen_Jones_Heideman_Burrus_1987_1"/> Bruun's algorithm (above) is another method that was initially proposed to take advantage of real inputs, but it has not proved popular.
@@ Line 85: / Line 82: @@
 ===Approximations===
-All of the FFT algorithms discussed above compute the DFT exactly (i.e. neglecting [[floating-point]] 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)<ref name="Edelman_McCorquodale_Toledo_1999"/> achieves lower communication requirements for [[parallel computing]] with the help of a [[fast multipole method]]. A [[wavelet]]-based approximate FFT by Guo and Burrus (1996)<ref name="Guo_Burrus_1996"/> 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).<ref name="Shentov_Mitra_Heute_Hossen_1995"/> The Edelman algorithm works equally well for sparse and non-sparse 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 {{mvar|k}} out of {{mvar|n}} Fourier coefficients are nonzero—then the complexity can be reduced to <math>O(k \log n \log n/k)</math>, and this has been demonstrated to lead to practical speedups compared to an ordinary FFT for {{math|''n''/''k'' > 32}} in a large-{{mvar|n}} example ({{math|''n'' {{=}} 2{{sup|22}}}}) using a probabilistic approximate algorithm (which estimates the largest {{mvar|k}} coefficients to several decimal places).<ref name="Hassanieh_2012"/>
+All of the FFT algorithms discussed above compute the DFT exactly (i.e., neglecting [[floating-point]] 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)<ref name="Edelman_McCorquodale_Toledo_1999"/> achieves lower communication requirements for [[parallel computing]] with the help of a [[fast multipole method]]. A [[wavelet]]-based approximate FFT by Guo and Burrus (1996)<ref name="Guo_Burrus_1996"/> 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).<ref name="Shentov_Mitra_Heute_Hossen_1995"/> The Edelman algorithm works equally well for sparse and non-sparse 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 {{mvar|k}} out of {{mvar|n}} Fourier coefficients are nonzero—then the complexity can be reduced to <math>O(k \log n \log n/k)</math>, and this has been demonstrated to lead to practical speedups compared to an ordinary FFT for {{math|''n''/''k'' > 32}} in a large-{{mvar|n}} example ({{math|''n'' {{=}} 2{{sup|22}}}}) using a probabilistic approximate algorithm (which estimates the largest {{mvar|k}} coefficients to several decimal places).<ref name="Hassanieh_2012"/>
 ===Accuracy===
@@ Line 116: / Line 113: @@
 In more than two dimensions, it is often advantageous for [[Cache (computing)|cache]] locality to group the dimensions recursively.  For example, a three-dimensional FFT might first perform two-dimensional FFTs of each planar slice for each fixed ''n''<sub>1</sub>, and then perform the one-dimensional FFTs along the ''n''<sub>1</sub> direction. More generally, an [[asymptotically optimal]] [[cache-oblivious algorithm]] consists of recursively dividing the dimensions into two groups <math display="inline">(n_1, \ldots, n_{d/2})</math> and <math display="inline">(n_{d/2+1}, \ldots, n_d)</math> that are transformed recursively (rounding if {{mvar|d}} is not even) (see Frigo and Johnson, 2005).<ref name="Frigo_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 has <math>O(n \log n)</math> complexity.  Yet another variation is to perform matrix [[transpose|transpositions]] in between transforming subsequent dimensions, so that the transforms operate on contiguous data; this is especially important for [[out-of-core]] and [[distributed memory]] situations where accessing non-contiguous data is extremely time-consuming.
-There are other multidimensional FFT algorithms that are distinct from the row-column algorithm, although all of them have <math display="inline">O(n \log n)</math> complexity. Perhaps the simplest non-row-column FFT is the [[vector-radix FFT algorithm]], which is a generalization of the ordinary Cooley–Tukey algorithm where one divides the transform dimensions by a vector <math display="inline">\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 vector-radix is where all of the radices are equal (e.g. vector-radix-2 divides ''all'' of the dimensions by two), but this is not necessary.  Vector radix with only a single non-unit radix at a time, i.e. <math display="inline">\mathbf{r} = \left(1, \ldots, 1, r, 1, \ldots, 1\right)</math>, is essentially a row-column algorithm. Other, more complicated, methods include polynomial transform algorithms due to Nussbaumer (1977),<ref name="Nussbaumer_1977"/> which view the transform in terms of convolutions and polynomial products. See Duhamel and Vetterli (1990)<ref name="Duhamel_Vetterli_1990"/> for more information and references.
+There are other multidimensional FFT algorithms that are distinct from the row-column algorithm, although all of them have <math display="inline">O(n \log n)</math> complexity. Perhaps the simplest non-row-column FFT is the [[vector-radix FFT algorithm]], which is a generalization of the ordinary Cooley–Tukey algorithm where one divides the transform dimensions by a vector <math display="inline">\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 vector-radix is where all of the radices are equal (e.g., vector-radix-2 divides ''all'' of the dimensions by two), but this is not necessary.  Vector radix with only a single non-unit radix at a time, i.e. <math display="inline">\mathbf{r} = \left(1, \ldots, 1, r, 1, \ldots, 1\right)</math>, is essentially a row-column algorithm. Other, more complicated, methods include polynomial transform algorithms due to Nussbaumer (1977),<ref name="Nussbaumer_1977"/> which view the transform in terms of convolutions and polynomial products. See Duhamel and Vetterli (1990)<ref name="Duhamel_Vetterli_1990"/> for more information and references.
 ==Other generalizations==
@@ Line 123: / Line 120: @@
 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 non-equispaced data, as reviewed in Potts ''et al.'' (2001).<ref name="Potts_Steidl_Tasche_2001"/> Such algorithms do not strictly compute the DFT (which is only defined for equispaced data), but rather some approximation thereof (a [[non-uniform discrete Fourier transform]], or NDFT, which itself is often computed only approximately). More generally there are various other methods of [[spectral estimation]].
+Various groups have also published FFT algorithms for non-equispaced data, as reviewed in Potts ''et al.'' (2001).<ref name="Potts_Steidl_Tasche_2001"/> Such algorithms do not strictly compute the DFT (which is only defined for equispaced data), but rather some approximation thereof (a [[non-uniform discrete Fourier transform]], or NDFT, which itself is often computed only approximately). More generally, there are various other methods of [[spectral estimation]].
 ==Applications==
@@ Line 138: / Line 135: @@
 * computation of [[Mass spectrometry|isotopic distributions]].<ref name="Fernandez-de-Cossio_2012"/>
 * modulation and demodulation of complex data symbols using [[orthogonal frequency-division multiplexing]] (OFDM) for 5G, LTE, Wi-Fi, DSL, and other modern communication systems.
-An original application of the FFT in [[finance]] particularly in the [[Valuation of options]] was developed by Marcello Minenna.<ref name="MinennaJBF">{{cite journal |title=A revisited and stable Fourier transform method for affine jump diffusion models |author-first1=Marcello |author-last1=Minenna |date=October 2008 |journal=Journal of Banking and Finance |doi=10.1016/j.jbankfin.2007.05.019|volume=32 |issue=10 |pages=2064–2075}}</ref>
 == Alternatives ==
@@ Line 150: / Line 145: @@
 ; 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 out-of-core FFTs are an active area of research.<ref name="Cormen_Nicol_1998"/>
 ; 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.<ref name="Dutt_Rokhlin_1993"/>
-; [[Fourier transform on finite groups|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 non-cyclic, has an expansion in terms of a basis of irreducible matrix elements. It remains an active area of research to find an efficient algorithm for performing this change of basis. Applications including efficient [[spherical harmonic]] expansion, analyzing certain [[Markov process]]es, robotics etc.<ref name="Rockmore_2004"/>
+; [[Fourier transform on finite groups|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 non-cyclic, has an expansion in terms of a basis of irreducible matrix elements. It remains an active area of research to find an efficient algorithm for performing this change of basis. Applications including efficient [[spherical harmonic]] expansion, analyzing certain [[Markov process]]es, robotics etc.<ref name="Rockmore_2004"/>
-; [[Quantum Fourier transform|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 a sequence of 1- or 2-bit 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.<ref>{{Cite journal |title=Quantum circuit for the fast Fourier transform |journal=Quantum Information Processing |volume=19 |issue=277 |year=2020 |first1=Asaka |last1=Ryo |first2=Sakai |last2=Kazumitsu |first3=Yahagi |last3=Ryoko |page=277 |doi=10.1007/s11128-020-02776-5 |arxiv=1911.03055 |bibcode=2020QuIP...19..277A |s2cid=207847474 |url=https://link.springer.com/article/10.1007/s11128-020-02776-5}}</ref>
+; [[Quantum Fourier transform|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 a sequence of 1- or 2-bit quantum gates now known as quantum FFT, which is effectively the Cooley–Tukey FFT realized as a particular factorization of the Fourier matrix. Extensions to these ideas are currently being explored.<ref>{{Cite journal |title=Quantum circuit for the fast Fourier transform |journal=Quantum Information Processing |volume=19 |issue=277 |year=2020 |first1=Asaka |last1=Ryo |first2=Sakai |last2=Kazumitsu |first3=Yahagi |last3=Ryoko |page=277 |doi=10.1007/s11128-020-02776-5 |arxiv=1911.03055 |bibcode=2020QuIP...19..277A |s2cid=207847474 |url=https://link.springer.com/article/10.1007/s11128-020-02776-5}}</ref>
 ==Language reference==
@@ Line 200: / Line 195: @@
 * [[Bit-reversal permutation]]
-* [[Goertzel algorithm]] – computes individual terms of discrete Fourier transform
+* [[Goertzel algorithm]] – computes individual terms of the discrete Fourier transform
 FFT implementations:
+* [[FFTReal]] - a highly optimized clean and concise implementation with support for scalar or a SIMD vector in C++ class by Dmitry Boldyrev hosted at GITHUB https://github.com/mewza/realfft/
 * [[ALGLIB]] – a dual/GPL-licensed C++ and C# library (also supporting other languages), with real/complex FFT implementation
 * [[FFTPACK]] – another Fortran FFT library (public domain)
@@ Line 228: / Line 224: @@
 {{Reflist|refs=
 <ref name="Loan_1992">{{cite book |author-first=Charles |author-last=Van Loan |title=Computational Frameworks for the Fast Fourier Transform |publisher=[[SIAM]] |date=1992}}</ref>
-<ref name="Heideman_Johnson_Burrus_1984">{{cite journal |author-last1=Heideman |author-first1=Michael T. |author-first2=Don H. |author-last2=Johnson |author-first3=Charles Sidney |author-last3=Burrus |author-link3=Charles Sidney Burrus |doi=10.1109/MASSP.1984.1162257 |citeseerx=10.1.1.309.181 |title=Gauss and the history of the fast Fourier transform |journal=IEEE ASSP Magazine |volume=1 |issue=4 |pages=14–21 |date=1984 |s2cid=10032502 |url=http://www.cis.rit.edu/class/simg716/Gauss_History_FFT.pdf |archive-url=https://web.archive.org/web/20130319053449/http://www.cis.rit.edu/class/simg716/Gauss_History_FFT.pdf |archive-date=2013-03-19 |url-status=live}}</ref>
+<ref name="Heideman_Johnson_Burrus_1984">{{cite journal |author-last1=Heideman |author-first1=Michael T. |author-first2=Don H. |author-last2=Johnson |author-first3=Charles Sidney |author-last3=Burrus |author-link3=Charles Sidney Burrus |doi=10.1109/MASSP.1984.1162257 |citeseerx=10.1.1.309.181 |title=Gauss and the history of the fast Fourier transform |journal=IEEE ASSP Magazine |volume=1 |issue=4 |pages=14–21 |date=1984 |bibcode=1984IASSP...1...14H |s2cid=10032502 |url=http://www.cis.rit.edu/class/simg716/Gauss_History_FFT.pdf |archive-url=https://web.archive.org/web/20130319053449/http://www.cis.rit.edu/class/simg716/Gauss_History_FFT.pdf |archive-date=2013-03-19 |url-status=live}}</ref>
-<ref name="Heideman_Burrus_1986">{{cite journal |author-first1=Michael T. |author-last1=Heideman |author-first2=Charles Sidney |author-last2=Burrus |author-link2=Charles Sidney Burrus |date=1986 |doi=10.1109/TASSP.1986.1164785 |title=On the number of multiplications necessary to compute a length-2<sup>''n''</sup> DFT |journal=[[IEEE Transactions on Acoustics, Speech, and Signal Processing]] |volume=34 |issue=1 |pages=91–95}}</ref>
+<ref name="Heideman_Burrus_1986">{{cite journal |author-first1=Michael T. |author-last1=Heideman |author-first2=Charles Sidney |author-last2=Burrus |author-link2=Charles Sidney Burrus |date=1986 |doi=10.1109/TASSP.1986.1164785 |title=On the number of multiplications necessary to compute a length-2<sup>''n''</sup> DFT |journal=[[IEEE Transactions on Acoustics, Speech, and Signal Processing]] |volume=34 |issue=1 |pages=91–95 |bibcode=1986ITASS..34...91H }}</ref>
 <ref name="Dongarra_Sullivan_2000">{{cite journal |title=Guest Editors' Introduction to the top 10 algorithms |journal=  Computing in Science & Engineering|date=January 2000 |issn=1521-9615 |pages=22–23 |volume=2 |issue=1 |doi=10.1109/MCISE.2000.814652 |author-first1=Jack |author-last1=Dongarra |author-first2=Francis |author-last2=Sullivan|bibcode=2000CSE.....2a..22D }}</ref>
-<ref name="Brenner_Rader_1976">{{cite journal |author-first1=Norman M. |author-last1=Brenner |author-first2=Charles M. |author-last2=Rader |date=1976 |title=A New Principle for Fast Fourier Transformation |journal=[[IEEE Transactions on Acoustics, Speech, and Signal Processing]] |volume=24 |issue=3 |doi=10.1109/TASSP.1976.1162805 |pages=264–266}}</ref>
+<ref name="Brenner_Rader_1976">{{cite journal |author-first1=Norman M. |author-last1=Brenner |author-first2=Charles M. |author-last2=Rader |date=1976 |title=A New Principle for Fast Fourier Transformation |journal=[[IEEE Transactions on Acoustics, Speech, and Signal Processing]] |volume=24 |issue=3 |doi=10.1109/TASSP.1976.1162805 |pages=264–266 |bibcode=1976ITASS..24..264R }}</ref>
-<ref name="Kent_2002">{{cite book |author-last1=Kent |author-first1=Ray D. |author-last2=Read |author-first2=Charles |date=2002 |title=Acoustic Analysis of Speech |publisher=Singular/Thomson Learning |isbn=0-7693-0112-6 }}</ref>
 <ref name="Strang_1994">{{cite journal |author-last=Strang |author-first=Gilbert |author-link=Gilbert Strang |date=May–June 1994 |title=Wavelets |journal=[[American Scientist]] |volume=82 |issue=3 |pages=250–255 |jstor=29775194|bibcode=1994AmSci..82..250S }}</ref>
 <ref name="Ergün_1995">{{cite book |author-first=Funda |author-last=Ergün|author-link=Funda Ergun |title=Proceedings of the twenty-seventh annual ACM symposium on Theory of computing - STOC '95 |chapter=Testing multivariate linear functions |date=1995 |doi=10.1145/225058.225167 |location=Kyoto, Japan |pages=407–416 |isbn=978-0897917186|s2cid=15512806 }}</ref>
@@ Line 246: / Line 241: @@
 <ref name="Lundy_Buskirk_2007">{{cite journal |author-first1=Thomas J. |author-last1=Lundy |author-first2=James |author-last2=Van Buskirk |date=2007 |title=A new matrix approach to real FFTs and convolutions of length 2<sup>k</sup> |journal=[[Computing (journal)|Computing]] |volume=80 |issue=1 |pages=23–45 |doi=10.1007/s00607-007-0222-6|s2cid=27296044 }}</ref>
 <ref name="Papadimitriou_1979">{{cite journal |author-first=Christos H. |author-last=Papadimitriou |date=1979 |doi=10.1145/322108.322118 |title=Optimality of the fast Fourier transform |journal=[[Journal of the ACM]] |volume=26 |issue=1 |pages=95–102|s2cid=850634 |doi-access=free }}</ref>
-<ref name="Sorensen_Jones_Heideman_Burrus_1987_1">{{cite journal |author-first1=Henrik V. |author-last1=Sorensen |author-first2=Douglas L. |author-last2=Jones |author-link2=Douglas L. Jones |author-first3=Michael T. |author-last3=Heideman |author-first4=Charles Sidney |author-last4=Burrus |author-link4=Charles Sidney Burrus |date=1987 |doi=10.1109/TASSP.1987.1165220 |title=Real-valued fast Fourier transform algorithms |journal=[[IEEE Transactions on Acoustics, Speech, and Signal Processing]] |volume=35 |issue=6 |pages=849–863 |citeseerx=10.1.1.205.4523}}</ref>
+<ref name="Sorensen_Jones_Heideman_Burrus_1987_1">{{cite journal |author-first1=Henrik V. |author-last1=Sorensen |author-first2=Douglas L. |author-last2=Jones |author-link2=Douglas L. Jones |author-first3=Michael T. |author-last3=Heideman |author-first4=Charles Sidney |author-last4=Burrus |author-link4=Charles Sidney Burrus |date=1987 |doi=10.1109/TASSP.1987.1165220 |title=Real-valued fast Fourier transform algorithms |journal=[[IEEE Transactions on Acoustics, Speech, and Signal Processing]] |volume=35 |issue=6 |pages=849–863 |bibcode=1987ITASS..35..849S |citeseerx=10.1.1.205.4523}}</ref>
-<ref name="Sorensen_Jones_Heideman_Burrus_1987_2">{{cite journal |doi=10.1109/TASSP.1987.1165284 |author-last1=Sorensen |author-first1=Henrik V. |author-last2=Jones |author-first2=Douglas L. |author-link2=Douglas L. Jones |author-last3=Heideman |author-first3=Michael T. |author-last4=Burrus |author-first4=Charles Sidney |author-link4=Charles Sidney Burrus |date=1987 |pages=1353 |issue=9 |volume=35 |title=Corrections to "Real-valued fast Fourier transform algorithms" |journal=[[IEEE Transactions on Acoustics, Speech, and Signal Processing]]}}</ref>
+<ref name="Sorensen_Jones_Heideman_Burrus_1987_2">{{cite journal |doi=10.1109/TASSP.1987.1165284 |author-last1=Sorensen |author-first1=Henrik V. |author-last2=Jones |author-first2=Douglas L. |author-link2=Douglas L. Jones |author-last3=Heideman |author-first3=Michael T. |author-last4=Burrus |author-first4=Charles Sidney |author-link4=Charles Sidney Burrus |date=1987 |pages=1353 |issue=9 |volume=35 |title=Corrections to "Real-valued fast Fourier transform algorithms" |journal=[[IEEE Transactions on Acoustics, Speech, and Signal Processing]] |bibcode=1987ITASS..35R1353S }}</ref>
 <ref name="Winograd_1978">{{cite journal |author-first=Shmuel |author-last=Winograd |date=1978 |doi=10.1090/S0025-5718-1978-0468306-4 |title=On computing the discrete Fourier transform |journal=[[Mathematics of Computation]] |volume=32 |issue=141 |pages=175–199 |jstor=2006266 |pmc=430186 |pmid=16592303}}</ref>
 <ref name="Winograd_1979">{{cite journal |author-first=Shmuel |author-last=Winograd |title=On the multiplicative complexity of the discrete Fourier transform |journal=[[Advances in Mathematics]] |volume=32 |issue=2 |date=1979 |pages=83–117 |doi=10.1016/0001-8708(79)90037-9 |doi-access= }}</ref>
@@ Line 257: / Line 252: @@
 <ref name="Potts_Steidl_Tasche_2001">{{cite book |author-first1=Daniel |author-last1=Potts |author-first2=Gabriele |author-last2=Steidl|author2-link= Gabriele Steidl |author-first3=Manfred |author-last3=Tasche |date=2001 |chapter-url=http://www.tu-chemnitz.de/~potts/paper/ndft.pdf |archive-url=https://web.archive.org/web/20070926222858/http://www.tu-chemnitz.de/~potts/paper/ndft.pdf |archive-date=2007-09-26 |url-status=live |chapter=Fast Fourier transforms for nonequispaced data: A tutorial |editor-first1=J. J. |editor-last1=Benedetto |editor-first2=P. |editor-last2=Ferreira |title=Modern Sampling Theory: Mathematics and Applications |publisher=[[Birkhäuser]]}}</ref>
 <ref name="Rokhlin_Tygert_2006">{{cite journal |author-first1=Vladimir |author-last1=Rokhlin |author-first2=Mark |author-last2=Tygert |date=2006 |title=Fast Algorithms for Spherical Harmonic Expansions |journal=[[SIAM Journal on Scientific Computing]] |volume=27 |issue=6 |doi=10.1137/050623073 |pages=1903–1928 |bibcode=2006SJSC...27.1903R |url=http://tygert.com/sph2.pdf |archive-url=https://web.archive.org/web/20141217212000/http://tygert.com/sph2.pdf |archive-date=2014-12-17 |url-status=live |access-date=2014-09-18 |citeseerx=10.1.1.125.7415}} [http://www.cs.yale.edu/publications/techreports/tr1309.pdf]</ref>
-<ref name="Welch_1969">{{cite journal |author-first1=Peter D. |author-last1=Welch |date=1969 |doi=10.1109/TAU.1969.1162035 |title=A fixed-point fast Fourier transform error analysis |journal=[[IEEE Transactions on Audio and Electroacoustics]] |volume=17 |issue=2 |pages=151–157}}</ref>
+<ref name="Welch_1969">{{cite journal |author-first1=Peter D. |author-last1=Welch |date=1969 |doi=10.1109/TAU.1969.1162035 |title=A fixed-point fast Fourier transform error analysis |journal=[[IEEE Transactions on Audio and Electroacoustics]] |volume=17 |issue=2 |pages=151–157 |bibcode=1969ITAuE..17..151W }}</ref>
 <ref name="Gauss_1866">{{cite book |author-first=Carl Friedrich |author-last=Gauss |author-link=Carl Friedrich Gauss |chapter-url=https://babel.hathitrust.org/cgi/pt?id=uc1.c2857678;view=1up;seq=279 |title=Nachlass |chapter=Theoria interpolationis methodo nova tractata |type=Unpublished manuscript |trans-chapter=Theory regarding a new method of interpolation |series=Werke |location=Göttingen, Germany |publisher=Königlichen Gesellschaft der Wissenschaften zu Göttingen |date=1866 |volume=3 |pages=265–303 |language=la, de}}</ref>
 <ref name="Heideman_Johnson_Burrus_1985">{{cite journal |title=Gauss and the history of the fast Fourier transform |journal=Archive for History of Exact Sciences |date=1985-09-01 |issn=0003-9519 |pages=265–277 |volume=34 |issue=3 |doi=10.1007/BF00348431 |author-first1=Michael T. |author-last1=Heideman |author-first2=Don H. |author-last2=Johnson |author-first3=Charles Sidney |author-last3=Burrus |author-link3=Charles Sidney Burrus |citeseerx=10.1.1.309.181|s2cid=122847826 }}</ref>
 <ref name="Yates_1937">{{cite journal |title=The design and analysis of factorial experiments |author-last=Yates |author-first=Frank |author-link=Frank Yates |date=1937 |journal=Technical Communication No. 35 of the Commonwealth Bureau of Soils|volume=142 |issue=3585 |pages=90–92 |bibcode=1938Natur.142...90F |doi=10.1038/142090a0 |s2cid=23501205 }}</ref>
-<ref name="Cooley_Lewis_Welch_1967">{{cite journal |title=Historical notes on the fast Fourier transform |journal=[[IEEE Transactions on Audio and Electroacoustics]] |date=June 1967 |issn=0018-9278 |pages=76–79 |volume=15 |issue=2 |doi=10.1109/TAU.1967.1161903 |author-first1=James W. |author-last1=Cooley |author-link1=James Cooley |author-first2=Peter A. W. |author-last2=Lewis |author-first3=Peter D. |author-last3=Welch |citeseerx=10.1.1.467.7209}}</ref>
+<ref name="Cooley_Lewis_Welch_1967">{{cite journal |title=Historical notes on the fast Fourier transform |journal=[[IEEE Transactions on Audio and Electroacoustics]] |date=June 1967 |issn=0018-9278 |pages=76–79 |volume=15 |issue=2 |doi=10.1109/TAU.1967.1161903 |author-first1=James W. |author-last1=Cooley |author-link1=James Cooley |author-first2=Peter A. W. |author-last2=Lewis |author-first3=Peter D. |author-last3=Welch |bibcode=1967ITAuE..15...76C |citeseerx=10.1.1.467.7209}}</ref>
 <ref name="Cooley_Tukey_1965">{{cite journal |title=An algorithm for the machine calculation of complex Fourier series |url=https://www.ams.org/mcom/1965-19-090/S0025-5718-1965-0178586-1/ |journal=[[Mathematics of Computation]] |date=1965 |issn=0025-5718 |pages=297–301 |volume=19 |issue=90 |doi=10.1090/S0025-5718-1965-0178586-1 |author-first1=James W. |author-last1=Cooley |author-link1=James Cooley |author-first2=John W. |author-last2=Tukey |author-link2=John Tukey|doi-access=free |url-access=subscription }}</ref>
 <ref name="Danielson_Lanczos_1942">{{cite journal |title=Some improvements in practical Fourier analysis and their application to x-ray scattering from liquids |author-first1=Gordon C. |author-last1=Danielson |author-link1=Gordon C. Danielson |author-first2=Cornelius |author-last2=Lanczos |author-link2=Cornelius Lanczos |date=1942 |journal=Journal of the Franklin Institute |doi=10.1016/S0016-0032(42)90767-1 |volume=233 |issue=4 |pages=365–380}}</ref>
@@ Line 334: / Line 329: @@
   |last2=Sitton |first2=G.A.
   |last3=Burrus |first3=C.S. |author-link3=Charles Sidney Burrus
- |url=https://ieeexplore.ieee.org/document/389994
   |title=Proceedings of ICASSP '94. IEEE International Conference on Acoustics, Speech and Signal Processing
   |date=1994
@@ Line 384: / Line 378: @@
   |date=June 1969
   |title=A short bibliography on the fast Fourier transform
- |url=https://ieeexplore.ieee.org/document/1162040
   |journal=[[IEEE Transactions on Audio and Electroacoustics]]
   |volume=17 |issue=2 |pages=166–169
-  |doi=10.1109/TAU.1969.1162040 |issn=0018-9278
+  |doi=10.1109/TAU.1969.1162040 |bibcode=1969ITAuE..17..166S
-|url-access=subscription
+ |issn=0018-9278
- }} (NB. Contains extensive bibliography.)
+}} (NB. Contains extensive bibliography.)
 * {{Cite book
   |last=Prestini |first=Elena
@@ Line 432: / Line 425: @@
 {{Authority control}}
-[[Category:FFT algorithms]]
+[[Category:Fast Fourier transforms]]
 [[Category:Digital signal processing]]
 [[Category:Discrete transforms]]

Fast Fourier transform: Difference between revisions

Latest revision as of 23:39, 17 November 2025

Contents

History

Definition

Algorithms

Cooley–Tukey algorithm

Other FFT algorithms

FFT algorithms specialized for real or symmetric data

Computational issues

Bounds on complexity and operation counts

Approximations

Accuracy

Multidimensional FFTs

Other generalizations

Applications

Alternatives

Research areas

Language reference

See also

References

Further reading

External links

Navigation menu

Fast Fourier transform: Difference between revisions

Latest revision as of 23:39, 17 November 2025

History

Definition

Algorithms

Cooley–Tukey algorithm

Other FFT algorithms

FFT algorithms specialized for real or symmetric data

Computational issues

Bounds on complexity and operation counts

Approximations

Accuracy

Multidimensional FFTs

Other generalizations

Applications

Alternatives

Research areas

Language reference

See also

References

Further reading

External links

Navigation menu

Search