torch.fft¶
Discrete Fourier transforms and related functions.
To use these functions the torch.fft module must be imported since its name
conflicts with the torch.fft()
function.
Functions¶

torch.fft.
fft
(input, n=None, dim=1, norm=None) → Tensor¶ Computes the one dimensional discrete Fourier transform of
input
.Note
The Fourier domain representation of any real signal satisfies the Hermitian property: X[i] = conj(X[i]). This function always returns both the positive and negative frequency terms even though, for real inputs, the negative frequencies are redundant.
rfft()
returns the more compact onesided representation where only the positive frequencies are returned. Parameters
input (Tensor) – the input tensor
n (int, optional) – Signal length. If given, the input will either be zeropadded or trimmed to this length before computing the FFT.
dim (int, optional) – The dimension along which to take the one dimensional FFT.
norm (str, optional) –
Normalization mode. For the forward transform (
fft()
), these correspond to:"forward"
 normalize by1/n
"backward"
 no normalization"ortho"
 normalize by1/sqrt(n)
(making the FFT orthonormal)
Calling the backward transform (
ifft()
) with the same normalization mode will apply an overall normalization of1/n
between the two transforms. This is required to makeifft()
the exact inverse.Default is
"backward"
(no normalization).
Example
>>> import torch.fft >>> t = torch.arange(4) >>> t tensor([0, 1, 2, 3]) >>> torch.fft.fft(t) tensor([ 6.+0.j, 2.+2.j, 2.+0.j, 2.2.j])
>>> t = tensor([0.+1.j, 2.+3.j, 4.+5.j, 6.+7.j]) >>> torch.fft.fft(t) tensor([12.+16.j, 8.+0.j, 4.4.j, 0.8.j])

torch.fft.
ifft
(input, n=None, dim=1, norm=None) → Tensor¶ Computes the one dimensional inverse discrete Fourier transform of
input
. Parameters
input (Tensor) – the input tensor
n (int, optional) – Signal length. If given, the input will either be zeropadded or trimmed to this length before computing the IFFT.
dim (int, optional) – The dimension along which to take the one dimensional IFFT.
norm (str, optional) –
Normalization mode. For the backward transform (
ifft()
), these correspond to:"forward"
 no normalization"backward"
 normalize by1/n
"ortho"
 normalize by1/sqrt(n)
(making the IFFT orthonormal)
Calling the forward transform (
fft()
) with the same normalization mode will apply an overall normalization of1/n
between the two transforms. This is required to makeifft()
the exact inverse.Default is
"backward"
(normalize by1/n
).
Example
>>> import torch.fft >>> t = torch.tensor([ 6.+0.j, 2.+2.j, 2.+0.j, 2.2.j]) >>> torch.fft.ifft(t) tensor([0.+0.j, 1.+0.j, 2.+0.j, 3.+0.j])

torch.fft.
fftn
(input, s=None, dim=None, norm=None) → Tensor¶ Computes the N dimensional discrete Fourier transform of
input
.Note
The Fourier domain representation of any real signal satisfies the Hermitian property:
X[i_1, ..., i_n] = conj(X[i_1, ..., i_n])
. This function always returns all positive and negative frequency terms even though, for real inputs, half of these values are redundant.rfftn()
returns the more compact onesided representation where only the positive frequencies of the last dimension are returned. Parameters
input (Tensor) – the input tensor
s (Tuple[int], optional) – Signal size in the transformed dimensions. If given, each dimension
dim[i]
will either be zeropadded or trimmed to the lengths[i]
before computing the FFT. If a length1
is specified, no padding is done in that dimension. Default:s = [input.size(d) for d in dim]
dim (Tuple[int], optional) – Dimensions to be transformed. Default: all dimensions, or the last
len(s)
dimensions ifs
is given.norm (str, optional) –
Normalization mode. For the forward transform (
fftn()
), these correspond to:"forward"
 normalize by1/n
"backward"
 no normalization"ortho"
 normalize by1/sqrt(n)
(making the FFT orthonormal)
Where
n = prod(s)
is the logical FFT size. Calling the backward transform (ifftn()
) with the same normalization mode will apply an overall normalization of1/n
between the two transforms. This is required to makeifftn()
the exact inverse.Default is
"backward"
(no normalization).
Example
>>> import torch.fft >>> x = torch.rand(10, 10, dtype=torch.complex64) >>> fftn = torch.fft.fftn(t)
The discrete Fourier transform is separable, so
fftn()
here is equivalent to two onedimensionalfft()
calls:>>> two_ffts = torch.fft.fft(torch.fft.fft(x, dim=0), dim=1) >>> torch.allclose(fftn, two_ffts)

torch.fft.
ifftn
(input, s=None, dim=None, norm=None) → Tensor¶ Computes the N dimensional inverse discrete Fourier transform of
input
. Parameters
input (Tensor) – the input tensor
s (Tuple[int], optional) – Signal size in the transformed dimensions. If given, each dimension
dim[i]
will either be zeropadded or trimmed to the lengths[i]
before computing the IFFT. If a length1
is specified, no padding is done in that dimension. Default:s = [input.size(d) for d in dim]
dim (Tuple[int], optional) – Dimensions to be transformed. Default: all dimensions, or the last
len(s)
dimensions ifs
is given.norm (str, optional) –
Normalization mode. For the backward transform (
ifftn()
), these correspond to:"forward"
 no normalization"backward"
 normalize by1/n
"ortho"
 normalize by1/sqrt(n)
(making the IFFT orthonormal)
Where
n = prod(s)
is the logical IFFT size. Calling the forward transform (fftn()
) with the same normalization mode will apply an overall normalization of1/n
between the two transforms. This is required to makeifftn()
the exact inverse.Default is
"backward"
(normalize by1/n
).
Example
>>> import torch.fft >>> x = torch.rand(10, 10, dtype=torch.complex64) >>> ifftn = torch.fft.ifftn(t)
The discrete Fourier transform is separable, so
ifftn()
here is equivalent to two onedimensionalifft()
calls:>>> two_iffts = torch.fft.ifft(torch.fft.ifft(x, dim=0), dim=1) >>> torch.allclose(ifftn, two_iffts)

torch.fft.
rfft
(input, n=None, dim=1, norm=None) → Tensor¶ Computes the one dimensional Fourier transform of realvalued
input
.The FFT of a real signal is Hermitiansymmetric,
X[i] = conj(X[i])
so the output contains only the positive frequencies below the Nyquist frequency. To compute the full output, usefft()
 Parameters
input (Tensor) – the real input tensor
n (int, optional) – Signal length. If given, the input will either be zeropadded or trimmed to this length before computing the real FFT.
dim (int, optional) – The dimension along which to take the one dimensional real FFT.
norm (str, optional) –
Normalization mode. For the forward transform (
rfft()
), these correspond to:"forward"
 normalize by1/n
"backward"
 no normalization"ortho"
 normalize by1/sqrt(n)
(making the FFT orthonormal)
Calling the backward transform (
irfft()
) with the same normalization mode will apply an overall normalization of1/n
between the two transforms. This is required to makeirfft()
the exact inverse.Default is
"backward"
(no normalization).
Example
>>> import torch.fft >>> t = torch.arange(4) >>> t tensor([0, 1, 2, 3]) >>> torch.fft.rfft(t) tensor([ 6.+0.j, 2.+2.j, 2.+0.j])
Compare against the full output from
fft()
:>>> torch.fft.fft(t) tensor([ 6.+0.j, 2.+2.j, 2.+0.j, 2.2.j])
Notice that the symmetric element
T[1] == T[1].conj()
is omitted. At the Nyquist frequencyT[2] == T[2]
is it’s own symmetric pair, and therefore must always be realvalued.

torch.fft.
irfft
(input, n=None, dim=1, norm=None) → Tensor¶ Computes the inverse of
rfft()
.input
is interpreted as a onesided Hermitian signal in the Fourier domain, as produced byrfft()
. By the Hermitian property, the output will be realvalued.Note
Some input frequencies must be realvalued to satisfy the Hermitian property. In these cases the imaginary component will be ignored. For example, any imaginary component in the zerofrequency term cannot be represented in a real output and so will always be ignored.
Note
The correct interpretation of the Hermitian input depends on the length of the original data, as given by
n
. This is because each input shape could correspond to either an odd or even length signal. By default, the signal is assumed to be even length and odd signals will not roundtrip properly. So, it is recommended to always pass the signal lengthn
. Parameters
input (Tensor) – the input tensor representing a halfHermitian signal
n (int, optional) – Output signal length. This determines the length of the output signal. If given, the input will either be zeropadded or trimmed to this length before computing the real IFFT. Defaults to even output:
n=2*(input.size(dim)  1)
.dim (int, optional) – The dimension along which to take the one dimensional real IFFT.
norm (str, optional) –
Normalization mode. For the backward transform (
irfft()
), these correspond to:"forward"
 no normalization"backward"
 normalize by1/n
"ortho"
 normalize by1/sqrt(n)
(making the real IFFT orthonormal)
Calling the forward transform (
rfft()
) with the same normalization mode will apply an overall normalization of1/n
between the two transforms. This is required to makeirfft()
the exact inverse.Default is
"backward"
(normalize by1/n
).
Example
>>> import torch.fft >>> t = torch.arange(5) >>> t tensor([0, 1, 2, 3, 4]) >>> T = torch.fft.rfft(t) >>> T tensor([10.0000+0.0000j, 2.5000+3.4410j, 2.5000+0.8123j])
Without specifying the output length to
irfft()
, the output will not roundtrip properly because the input is oddlength:>>> torch.fft.irfft(T) tensor([0.6250, 1.4045, 3.1250, 4.8455])
So, it is recommended to always pass the signal length
n
:>>> torch.fft.irfft(T, t.numel()) tensor([0.0000, 1.0000, 2.0000, 3.0000, 4.0000])

torch.fft.
rfftn
(input, s=None, dim=None, norm=None) → Tensor¶ Computes the Ndimensional discrete Fourier transform of real
input
.The FFT of a real signal is Hermitiansymmetric,
X[i_1, ..., i_n] = conj(X[i_1, ..., i_n])
so the fullfftn()
output contains redundant information.rfftn()
instead omits the negative frequencies in the last dimension. Parameters
input (Tensor) – the input tensor
s (Tuple[int], optional) – Signal size in the transformed dimensions. If given, each dimension
dim[i]
will either be zeropadded or trimmed to the lengths[i]
before computing the real FFT. If a length1
is specified, no padding is done in that dimension. Default:s = [input.size(d) for d in dim]
dim (Tuple[int], optional) – Dimensions to be transformed. Default: all dimensions, or the last
len(s)
dimensions ifs
is given.norm (str, optional) –
Normalization mode. For the forward transform (
rfftn()
), these correspond to:"forward"
 normalize by1/n
"backward"
 no normalization"ortho"
 normalize by1/sqrt(n)
(making the real FFT orthonormal)
Where
n = prod(s)
is the logical FFT size. Calling the backward transform (irfftn()
) with the same normalization mode will apply an overall normalization of1/n
between the two transforms. This is required to makeirfftn()
the exact inverse.Default is
"backward"
(no normalization).
Example
>>> import torch.fft >>> t = torch.rand(10, 10) >>> rfftn = torch.fft.rfftn(t) >>> rfftn.size() torch.Size([10, 6])
Compared against the full output from
fftn()
, we have all elements up to the Nyquist frequency.>>> fftn = torch.fft.fftn(t) >>> torch.allclose(fftn[..., :6], rfftn) True
The discrete Fourier transform is separable, so
rfftn()
here is equivalent to a combination offft()
andrfft()
:>>> two_ffts = torch.fft.fft(torch.fft.rfft(x, dim=1), dim=0) >>> torch.allclose(rfftn, two_ffts)

torch.fft.
irfftn
(input, s=None, dim=None, norm=None) → Tensor¶ Computes the inverse of
rfftn()
.input
is interpreted as a onesided Hermitian signal in the Fourier domain, as produced byrfftn()
. By the Hermitian property, the output will be realvalued.Note
Some input frequencies must be realvalued to satisfy the Hermitian property. In these cases the imaginary component will be ignored. For example, any imaginary component in the zerofrequency term cannot be represented in a real output and so will always be ignored.
Note
The correct interpretation of the Hermitian input depends on the length of the original data, as given by
s
. This is because each input shape could correspond to either an odd or even length signal. By default, the signal is assumed to be even length and odd signals will not roundtrip properly. So, it is recommended to always pass the signal shapes
. Parameters
input (Tensor) – the input tensor
s (Tuple[int], optional) – Signal size in the transformed dimensions. If given, each dimension
dim[i]
will either be zeropadded or trimmed to the lengths[i]
before computing the real FFT. If a length1
is specified, no padding is done in that dimension. Defaults to even output in the last dimension:s[1] = 2*(input.size(dim[1])  1)
.dim (Tuple[int], optional) – Dimensions to be transformed. The last dimension must be the halfHermitian compressed dimension. Default: all dimensions, or the last
len(s)
dimensions ifs
is given.norm (str, optional) –
Normalization mode. For the backward transform (
irfftn()
), these correspond to:"forward"
 no normalization"backward"
 normalize by1/n
"ortho"
 normalize by1/sqrt(n)
(making the real IFFT orthonormal)
Where
n = prod(s)
is the logical IFFT size. Calling the forward transform (rfftn()
) with the same normalization mode will apply an overall normalization of1/n
between the two transforms. This is required to makeirfftn()
the exact inverse.Default is
"backward"
(normalize by1/n
).
Example
>>> import torch.fft >>> t = torch.rand(10, 9) >>> T = torch.fft.rfftn(t)
Without specifying the output length to
irfft()
, the output will not roundtrip properly because the input is oddlength in the last dimension:>>> torch.fft.irfftn(T).size() torch.Size([10, 10])
So, it is recommended to always pass the signal shape
s
.>>> roundtrip = torch.fft.irfftn(T, t.size()) >>> roundtrip.size() torch.Size([10, 9]) >>> torch.allclose(roundtrip, t) True

torch.fft.
hfft
(input, n=None, dim=1, norm=None) → Tensor¶ Computes the one dimensional discrete Fourier transform of a Hermitian symmetric
input
signal.Note
hfft()
/ihfft()
are analogous torfft()
/irfft()
. The real FFT expects a real signal in the timedomain and gives a Hermitian symmetry in the frequencydomain. The Hermitian FFT is the opposite; Hermitian symmetric in the timedomain and realvalued in the frequencydomain. For this reason, special care needs to be taken with the length argumentn
, in the same way as withirfft()
.Note
Because the signal is Hermitian in the timedomain, the result will be real in the frequency domain. Note that some input frequencies must be realvalued to satisfy the Hermitian property. In these cases the imaginary component will be ignored. For example, any imaginary component in
input[0]
would result in one or more complex frequency terms which cannot be represented in a real output and so will always be ignored.Note
The correct interpretation of the Hermitian input depends on the length of the original data, as given by
n
. This is because each input shape could correspond to either an odd or even length signal. By default, the signal is assumed to be even length and odd signals will not roundtrip properly. So, it is recommended to always pass the signal lengthn
. Parameters
input (Tensor) – the input tensor representing a halfHermitian signal
n (int, optional) – Output signal length. This determines the length of the real output. If given, the input will either be zeropadded or trimmed to this length before computing the Hermitian FFT. Defaults to even output:
n=2*(input.size(dim)  1)
.dim (int, optional) – The dimension along which to take the one dimensional Hermitian FFT.
norm (str, optional) –
Normalization mode. For the forward transform (
hfft()
), these correspond to:"forward"
 normalize by1/n
"backward"
 no normalization"ortho"
 normalize by1/sqrt(n)
(making the Hermitian FFT orthonormal)
Calling the backward transform (
ihfft()
) with the same normalization mode will apply an overall normalization of1/n
between the two transforms. This is required to makeihfft()
the exact inverse.Default is
"backward"
(no normalization).
Example
Taking a realvalued frequency signal and bringing it into the time domain gives Hermitian symmetric output:
>>> import torch.fft >>> t = torch.arange(5) >>> t tensor([0, 1, 2, 3, 4]) >>> T = torch.fft.ifft(t) >>> T tensor([ 2.0000+0.0000j, 0.50000.6882j, 0.50000.1625j, 0.5000+0.1625j, 0.5000+0.6882j])
Note that
T[1] == T[1].conj()
andT[2] == T[2].conj()
is redundant. We can thus compute the forward transform without considering negative frequencies:>>> torch.fft.hfft(T[:3], n=5) tensor([0., 1., 2., 3., 4.])
Like with
irfft()
, the output length must be given in order to recover an even length output:>>> torch.fft.hfft(T[:3]) tensor([0.5000, 1.1236, 2.5000, 3.8764])

torch.fft.
ihfft
(input, n=None, dim=1, norm=None) → Tensor¶ Computes the inverse of
hfft()
.input
must be a realvalued signal, interpreted in the Fourier domain. The IFFT of a real signal is Hermitiansymmetric,X[i] = conj(X[i])
.ihfft()
represents this in the onesided form where only the positive frequencies below the Nyquist frequency are included. To compute the full output, useifft()
. Parameters
input (Tensor) – the real input tensor
n (int, optional) – Signal length. If given, the input will either be zeropadded or trimmed to this length before computing the Hermitian IFFT.
dim (int, optional) – The dimension along which to take the one dimensional Hermitian IFFT.
norm (str, optional) –
Normalization mode. For the backward transform (
ihfft()
), these correspond to:"forward"
 no normalization"backward"
 normalize by1/n
"ortho"
 normalize by1/sqrt(n)
(making the IFFT orthonormal)
Calling the forward transform (
hfft()
) with the same normalization mode will apply an overall normalization of1/n
between the two transforms. This is required to makeihfft()
the exact inverse.Default is
"backward"
(normalize by1/n
).
Example
>>> import torch.fft >>> t = torch.arange(5) >>> t tensor([0, 1, 2, 3, 4]) >>> torch.fft.ihfft(t) tensor([ 2.0000+0.0000j, 0.50000.6882j, 0.50000.1625j])
Compare against the full output from
ifft()
:>>> torch.fft.ifft(t) tensor([ 2.0000+0.0000j, 0.50000.6882j, 0.50000.1625j, 0.5000+0.1625j, 0.5000+0.6882j])