Discrete Fourier Transform (numpy.fft
)#
The SciPy module scipy.fft
is a more comprehensive superset
of numpy.fft
, which includes only a basic set of routines.
Standard FFTs#

Compute the onedimensional discrete Fourier Transform. 

Compute the onedimensional inverse discrete Fourier Transform. 

Compute the 2dimensional discrete Fourier Transform. 

Compute the 2dimensional inverse discrete Fourier Transform. 

Compute the Ndimensional discrete Fourier Transform. 

Compute the Ndimensional inverse discrete Fourier Transform. 
Real FFTs#

Compute the onedimensional discrete Fourier Transform for real input. 

Computes the inverse of 

Compute the 2dimensional FFT of a real array. 

Computes the inverse of 

Compute the Ndimensional discrete Fourier Transform for real input. 

Computes the inverse of 
Hermitian FFTs#

Compute the FFT of a signal that has Hermitian symmetry, i.e., a real spectrum. 

Compute the inverse FFT of a signal that has Hermitian symmetry. 
Helper routines#

Return the Discrete Fourier Transform sample frequencies. 

Return the Discrete Fourier Transform sample frequencies (for usage with rfft, irfft). 

Shift the zerofrequency component to the center of the spectrum. 

The inverse of 
Background information#
Fourier analysis is fundamentally a method for expressing a function as a sum of periodic components, and for recovering the function from those components. When both the function and its Fourier transform are replaced with discretized counterparts, it is called the discrete Fourier transform (DFT). The DFT has become a mainstay of numerical computing in part because of a very fast algorithm for computing it, called the Fast Fourier Transform (FFT), which was known to Gauss (1805) and was brought to light in its current form by Cooley and Tukey [CT]. Press et al. [NR] provide an accessible introduction to Fourier analysis and its applications.
Because the discrete Fourier transform separates its input into components that contribute at discrete frequencies, it has a great number of applications in digital signal processing, e.g., for filtering, and in this context the discretized input to the transform is customarily referred to as a signal, which exists in the time domain. The output is called a spectrum or transform and exists in the frequency domain.
Implementation details#
There are many ways to define the DFT, varying in the sign of the exponent, normalization, etc. In this implementation, the DFT is defined as
The DFT is in general defined for complex inputs and outputs, and a singlefrequency component at linear frequency \(f\) is represented by a complex exponential \(a_m = \exp\{2\pi i\,f m\Delta t\}\), where \(\Delta t\) is the sampling interval.
The values in the result follow socalled “standard” order: If A =
fft(a, n)
, then A[0]
contains the zerofrequency term (the sum of
the signal), which is always purely real for real inputs. Then A[1:n/2]
contains the positivefrequency terms, and A[n/2+1:]
contains the
negativefrequency terms, in order of decreasingly negative frequency.
For an even number of input points, A[n/2]
represents both positive and
negative Nyquist frequency, and is also purely real for real input. For
an odd number of input points, A[(n1)/2]
contains the largest positive
frequency, while A[(n+1)/2]
contains the largest negative frequency.
The routine np.fft.fftfreq(n)
returns an array giving the frequencies
of corresponding elements in the output. The routine
np.fft.fftshift(A)
shifts transforms and their frequencies to put the
zerofrequency components in the middle, and np.fft.ifftshift(A)
undoes
that shift.
When the input a is a timedomain signal and A = fft(a)
, np.abs(A)
is its amplitude spectrum and np.abs(A)**2
is its power spectrum.
The phase spectrum is obtained by np.angle(A)
.
The inverse DFT is defined as
It differs from the forward transform by the sign of the exponential argument and the default normalization by \(1/n\).
Type Promotion#
numpy.fft
promotes float32
and complex64
arrays to float64
and
complex128
arrays respectively. For an FFT implementation that does not
promote input arrays, see scipy.fftpack
.
Normalization#
The argument norm
indicates which direction of the pair of direct/inverse
transforms is scaled and with what normalization factor.
The default normalization ("backward"
) has the direct (forward) transforms
unscaled and the inverse (backward) transforms scaled by \(1/n\). It is
possible to obtain unitary transforms by setting the keyword argument norm
to "ortho"
so that both direct and inverse transforms are scaled by
\(1/\sqrt{n}\). Finally, setting the keyword argument norm
to
"forward"
has the direct transforms scaled by \(1/n\) and the inverse
transforms unscaled (i.e. exactly opposite to the default "backward"
).
None is an alias of the default option "backward"
for backward
compatibility.
Real and Hermitian transforms#
When the input is purely real, its transform is Hermitian, i.e., the
component at frequency \(f_k\) is the complex conjugate of the
component at frequency \(f_k\), which means that for real
inputs there is no information in the negative frequency components that
is not already available from the positive frequency components.
The family of rfft
functions is
designed to operate on real inputs, and exploits this symmetry by
computing only the positive frequency components, up to and including the
Nyquist frequency. Thus, n
input points produce n/2+1
complex
output points. The inverses of this family assumes the same symmetry of
its input, and for an output of n
points uses n/2+1
input points.
Correspondingly, when the spectrum is purely real, the signal is
Hermitian. The hfft
family of functions exploits this symmetry by
using n/2+1
complex points in the input (time) domain for n
real
points in the frequency domain.
In higher dimensions, FFTs are used, e.g., for image analysis and filtering. The computational efficiency of the FFT means that it can also be a faster way to compute large convolutions, using the property that a convolution in the time domain is equivalent to a pointbypoint multiplication in the frequency domain.
Higher dimensions#
In two dimensions, the DFT is defined as
which extends in the obvious way to higher dimensions, and the inverses in higher dimensions also extend in the same way.
References#
Cooley, James W., and John W. Tukey, 1965, “An algorithm for the machine calculation of complex Fourier series,” Math. Comput. 19: 297301.
Press, W., Teukolsky, S., Vetterline, W.T., and Flannery, B.P., 2007, Numerical Recipes: The Art of Scientific Computing, ch. 1213. Cambridge Univ. Press, Cambridge, UK.
Examples#
For examples, see the various functions.