#### Previous topic

numpy.fft.rfft

#### Next topic

numpy.fft.rfft2

# numpy.fft.irfft

`numpy.fft.``irfft`(a, n=None, axis=-1)

  Compute the inverse of the n-point DFT for real input.

  This function computes the inverse of the one-dimensional n-point discrete Fourier Transform of real input computed by `rfft`. In other words, `irfft(rfft(a), len(a)) == a` 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 Hermite-symmetric, the negative frequency terms are taken to be the complex conjugates of the corresponding positive frequency terms.

  Parameters : | a : 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 determined from the length of the input (along the axis specified by axis). axis : int, optional Axis over which to compute the inverse FFT.
  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 a.

  See also

  `numpy.fft`
    For definition of the DFT and conventions used.
  `rfft`
    The one-dimensional FFT of real input, of which `irfft` is inverse.
  `fft`
    The one-dimensional FFT.
  `irfft2`
    The inverse of the two-dimensional FFT of real input.
  `irfftn`
    The inverse of the n-dimensional FFT of real input.

  Notes

  Returns the real valued n-point inverse discrete Fourier transform of a, where a contains the non-negative frequency terms of a Hermite-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)`.

  Examples

      >>> np.fft.ifft([1, -1j, -1, 1j])
      array([ 0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j])
      >>> np.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.