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:
    xarray_like

      The input array.

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

    axisint, 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_xbool, optional

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

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

    planobject, 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:
    outndarray

      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.

  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.