Shortcuts

# 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 one-sided 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 zero-padded 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 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).

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 zero-padded 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 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).

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 one-sided 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 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]

• dim (Tuple[int], optional) – Dimensions to be transformed. Default: all dimensions, or the last 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).

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 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.

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 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]

• dim (Tuple[int], optional) – Dimensions to be transformed. Default: all dimensions, or the last 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).

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 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()

Parameters
• input (Tensor) – the real input tensor

• n (int, optional) – Signal length. If given, the input will either be zero-padded 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 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).

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 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.

Parameters
• input (Tensor) – the input tensor representing a half-Hermitian signal

• n (int, optional) – Output signal length. This determines the length of the output signal. If given, the input will either be zero-padded 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 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).

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 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.

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 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]

• dim (Tuple[int], optional) – Dimensions to be transformed. Default: all dimensions, or the last 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).

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 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.

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 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).

• dim (Tuple[int], optional) – Dimensions to be transformed. The last dimension must be the half-Hermitian compressed dimension. Default: all dimensions, or the last 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).

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 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.

Parameters
• input (Tensor) – the input tensor representing a half-Hermitian signal

• n (int, optional) – Output signal length. This determines the length of the real output. If given, the input will either be zero-padded 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 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).

Example

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().

Parameters
• input (Tensor) – the real input tensor

• n (int, optional) – Signal length. If given, the input will either be zero-padded 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 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).

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.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])


## Docs

Access comprehensive developer documentation for PyTorch

View Docs

## Tutorials

Get in-depth tutorials for beginners and advanced developers

View Tutorials

## Resources

Find development resources and get your questions answered

View Resources