Skip to main content
`Ctrl`+`K`
scipy.fft.

# irfft

scipy.fft.irfft(x, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, *, plan=None)

  Computes the inverse of `rfft`.

  This function computes the inverse of the 1-D n-point discrete Fourier Transform of real input computed by `rfft`. In other words, `irfft(rfft(x), len(x)) == x` to within numerical accuracy. (See Notes below for why `len(a)` is necessary here.)

  The input is expected to be in the form returned by `rfft`, i.e., the real zero-frequency term followed by the complex positive frequency terms in order of increasing frequency. Since the discrete Fourier Transform of real input is Hermitian-symmetric, the negative frequency terms are taken to be the complex conjugates of the corresponding positive frequency terms.

  Parameters:
    x array_like

      The input array.

    n int, optional

      Length of the transformed axis of the output. For n output points, `n//2+1` input points are necessary. If the input is longer than this, it is cropped. If it is shorter than this, it is padded with zeros. If n is not given, it is taken to be `2*(m-1)`, where `m` is the length of the input along the axis specified by axis.

    axis int, optional

      Axis over which to compute the inverse FFT. If not given, the last axis is used.

    norm{“backward”, “ortho”, “forward”}, optional

      Normalization mode (see `fft`). Default is “backward”.

    overwrite_x bool, optional

      If True, the contents of x can be destroyed; the default is False. See `fft` for more details.

    workers int, optional

      Maximum number of workers to use for parallel computation. If negative, the value wraps around from `os.cpu_count()`. See `fft` for more details.

    plan object, optional

      This argument is reserved for passing in a precomputed plan provided by downstream FFT vendors. It is currently not used in SciPy.

      Added in version 1.5.0.

  Returns:
    out ndarray

      The truncated or zero-padded input, transformed along the axis indicated by axis, or the last one if axis is not specified. The length of the transformed axis is n, or, if n is not given, `2*(m-1)` where `m` is the length of the transformed axis of the input. To get an odd number of output points, n must be specified.

  Raises:
    IndexError

      If axis is larger than the last axis of x.

  See also

  `rfft`

    The 1-D FFT of real input, of which `irfft` is inverse.

  `fft`

    The 1-D FFT.

  `irfft2`

    The inverse of the 2-D FFT of real input.

  `irfftn`

    The inverse of the N-D FFT of real input.

  Notes

  Returns the real valued n-point inverse discrete Fourier transform of x, where x contains the non-negative frequency terms of a Hermitian-symmetric sequence. n is the length of the result, not the input.

  If you specify an n such that a must be zero-padded or truncated, the extra/removed values will be added/removed at high frequencies. One can thus resample a series to m points via Fourier interpolation by: `a_resamp = irfft(rfft(a), m)`.

  The default value of n assumes an even output length. By the Hermitian symmetry, the last imaginary component must be 0 and so is ignored. To avoid losing information, the correct length of the real input must be given.

  Array API Standard Support

  `irfft` has experimental support for Python Array API Standard compatible backends in addition to NumPy. Please consider testing these features by setting an environment variable `SCIPY_ARRAY_API=1` and providing CuPy, PyTorch, JAX, or Dask arrays as array arguments. The following combinations of backend and device (or other capability) are supported.

  Library | CPU | GPU
  --- | --- | ---
  NumPy | ✅ | n/a
  CuPy | n/a | ✅
  PyTorch | ✅ | ✅
  JAX | ✅ | ✅
  Dask | ⚠️ computes graph | n/a

  See Support for the array API standard for more information.

  Examples

      >>> import scipy.fft
      >>> scipy.fft.ifft([1, -1j, -1, 1j])
      array([0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j]) # may vary
      >>> scipy.fft.irfft([1, -1j, -1])
      array([0.,  1.,  0.,  0.])

  Notice how the last term in the input to the ordinary `ifft` is the complex conjugate of the second term, and the output has zero imaginary part everywhere. When calling `irfft`, the negative frequencies are not specified, and the output array is purely real.