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.
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 one-sided representation where only the positive frequencies are returned.
norm (str, optional) –
Normalization mode. For the forward transform (fft()
), these correspond to:
"forward"
- normalize by 1/n
"backward"
- no normalization"ortho"
- normalize by 1/sqrt(n)
(making the FFT orthonormal)Calling the backward transform (ifft()
) with the same normalization mode will apply an overall normalization of 1/n
between the two transforms. This is required to make ifft()
the exact inverse.
Default is "backward"
(no normalization).
>>> 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
.
norm (str, optional) –
Normalization mode. For the backward transform (ifft()
), these correspond to:
"forward"
- no normalization"backward"
- normalize by 1/n
"ortho"
- normalize by 1/sqrt(n)
(making the IFFT orthonormal)Calling the forward transform (fft()
) with the same normalization mode will apply an overall normalization of 1/n
between the two transforms. This is required to make ifft()
the exact inverse.
Default is "backward"
(normalize by 1/n
).
>>> 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 one-sided representation where only the positive frequencies of the last dimension are returned.
dim[i]
will either be zero-padded or trimmed to the length s[i]
before computing the FFT. If a length -1
is specified, no padding is done in that dimension. Default: s = [input.size(d) for d in dim]
len(s)
dimensions if s
is given.norm (str, optional) –
Normalization mode. For the forward transform (fftn()
), these correspond to:
"forward"
- normalize by 1/n
"backward"
- no normalization"ortho"
- normalize by 1/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 of 1/n
between the two transforms. This is required to make ifftn()
the exact inverse.
Default is "backward"
(no normalization).
>>> 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 one-dimensional fft()
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
.
dim[i]
will either be zero-padded or trimmed to the length s[i]
before computing the IFFT. If a length -1
is specified, no padding is done in that dimension. Default: s = [input.size(d) for d in dim]
len(s)
dimensions if s
is given.norm (str, optional) –
Normalization mode. For the backward transform (ifftn()
), these correspond to:
"forward"
- no normalization"backward"
- normalize by 1/n
"ortho"
- normalize by 1/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 of 1/n
between the two transforms. This is required to make ifftn()
the exact inverse.
Default is "backward"
(normalize by 1/n
).
>>> 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 one-dimensional ifft()
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 real-valued input
.
The FFT of a real signal is Hermitian-symmetric, X[i] = conj(X[-i])
so the output contains only the positive frequencies below the Nyquist frequency. To compute the full output, use fft()
norm (str, optional) –
Normalization mode. For the forward transform (rfft()
), these correspond to:
"forward"
- normalize by 1/n
"backward"
- no normalization"ortho"
- normalize by 1/sqrt(n)
(making the FFT orthonormal)Calling the backward transform (irfft()
) with the same normalization mode will apply an overall normalization of 1/n
between the two transforms. This is required to make irfft()
the exact inverse.
Default is "backward"
(no normalization).
>>> 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 frequency T[-2] == T[2]
is it’s own symmetric pair, and therefore must always be real-valued.
torch.fft.irfft(input, n=None, dim=-1, norm=None) → Tensor
Computes the inverse of rfft()
.
input
is interpreted as a one-sided Hermitian signal in the Fourier domain, as produced by rfft()
. By the Hermitian property, the output will be real-valued.
Note
Some input frequencies must be real-valued to satisfy the Hermitian property. In these cases the imaginary component will be ignored. For example, any imaginary component in the zero-frequency 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 round-trip properly. So, it is recommended to always pass the signal length n
.
n=2*(input.size(dim) - 1)
.norm (str, optional) –
Normalization mode. For the backward transform (irfft()
), these correspond to:
"forward"
- no normalization"backward"
- normalize by 1/n
"ortho"
- normalize by 1/sqrt(n)
(making the real IFFT orthonormal)Calling the forward transform (rfft()
) with the same normalization mode will apply an overall normalization of 1/n
between the two transforms. This is required to make irfft()
the exact inverse.
Default is "backward"
(normalize by 1/n
).
>>> 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 round-trip properly because the input is odd-length:
>>> 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 N-dimensional discrete Fourier transform of real input
.
The FFT of a real signal is Hermitian-symmetric, X[i_1, ..., i_n] = conj(X[-i_1, ..., -i_n])
so the full fftn()
output contains redundant information. rfftn()
instead omits the negative frequencies in the last dimension.
dim[i]
will either be zero-padded or trimmed to the length s[i]
before computing the real FFT. If a length -1
is specified, no padding is done in that dimension. Default: s = [input.size(d) for d in dim]
len(s)
dimensions if s
is given.norm (str, optional) –
Normalization mode. For the forward transform (rfftn()
), these correspond to:
"forward"
- normalize by 1/n
"backward"
- no normalization"ortho"
- normalize by 1/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 of 1/n
between the two transforms. This is required to make irfftn()
the exact inverse.
Default is "backward"
(no normalization).
>>> 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 of fft()
and rfft()
:
>>> 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 one-sided Hermitian signal in the Fourier domain, as produced by rfftn()
. By the Hermitian property, the output will be real-valued.
Note
Some input frequencies must be real-valued to satisfy the Hermitian property. In these cases the imaginary component will be ignored. For example, any imaginary component in the zero-frequency 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 round-trip properly. So, it is recommended to always pass the signal shape s
.
dim[i]
will either be zero-padded or trimmed to the length s[i]
before computing the real FFT. If a length -1
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)
.len(s)
dimensions if s
is given.norm (str, optional) –
Normalization mode. For the backward transform (irfftn()
), these correspond to:
"forward"
- no normalization"backward"
- normalize by 1/n
"ortho"
- normalize by 1/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 of 1/n
between the two transforms. This is required to make irfftn()
the exact inverse.
Default is "backward"
(normalize by 1/n
).
>>> import torch.fft >>> t = torch.rand(10, 9) >>> T = torch.fft.rfftn(t)
Without specifying the output length to irfft()
, the output will not round-trip properly because the input is odd-length 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 to rfft()
/irfft()
. The real FFT expects a real signal in the time-domain and gives a Hermitian symmetry in the frequency-domain. The Hermitian FFT is the opposite; Hermitian symmetric in the time-domain and real-valued in the frequency-domain. For this reason, special care needs to be taken with the length argument n
, in the same way as with irfft()
.
Note
Because the signal is Hermitian in the time-domain, the result will be real in the frequency domain. Note that some input frequencies must be real-valued 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 round-trip properly. So, it is recommended to always pass the signal length n
.
n=2*(input.size(dim) - 1)
.norm (str, optional) –
Normalization mode. For the forward transform (hfft()
), these correspond to:
"forward"
- normalize by 1/n
"backward"
- no normalization"ortho"
- normalize by 1/sqrt(n)
(making the Hermitian FFT orthonormal)Calling the backward transform (ihfft()
) with the same normalization mode will apply an overall normalization of 1/n
between the two transforms. This is required to make ihfft()
the exact inverse.
Default is "backward"
(no normalization).
Taking a real-valued 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.5000-0.6882j, -0.5000-0.1625j, -0.5000+0.1625j, -0.5000+0.6882j])
Note that T[1] == T[-1].conj()
and T[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 real-valued signal, interpreted in the Fourier domain. The IFFT of a real signal is Hermitian-symmetric, X[i] = conj(X[-i])
. ihfft()
represents this in the one-sided form where only the positive frequencies below the Nyquist frequency are included. To compute the full output, use ifft()
.
norm (str, optional) –
Normalization mode. For the backward transform (ihfft()
), these correspond to:
"forward"
- no normalization"backward"
- normalize by 1/n
"ortho"
- normalize by 1/sqrt(n)
(making the IFFT orthonormal)Calling the forward transform (hfft()
) with the same normalization mode will apply an overall normalization of 1/n
between the two transforms. This is required to make ihfft()
the exact inverse.
Default is "backward"
(normalize by 1/n
).
>>> import torch.fft >>> t = torch.arange(5) >>> t tensor([0, 1, 2, 3, 4]) >>> torch.fft.ihfft(t) tensor([ 2.0000+-0.0000j, -0.5000-0.6882j, -0.5000-0.1625j])
Compare against the full output from ifft()
:
>>> torch.fft.ifft(t) tensor([ 2.0000+-0.0000j, -0.5000-0.6882j, -0.5000-0.1625j, -0.5000+0.1625j, -0.5000+0.6882j])
© 2019 Torch Contributors
Licensed under the 3-clause BSD License.
https://pytorch.org/docs/1.7.0/fft.html