code: def irfft(a, n=None, axis=-1, norm=None):
      """
      Computes the inverse of `rfft`.
  
      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 Hermitian-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 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
          .. versionadded:: 1.10.0
  
          Normalization mode (see `numpy.fft`). Default is "backward".
          Indicates which direction of the forward/backward pair of transforms
          is scaled and with what normalization factor.
  
          .. versionadded:: 1.20.0
  
              The "backward", "forward" values were added.
  
      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 not a valid 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
      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 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, `irfft`
      assumes an even output length which puts the last entry at the Nyquist
      frequency; aliasing with its symmetric counterpart. By Hermitian symmetry,
      the value is thus treated as purely real. To avoid losing information, the
      correct length of the real input **must** be given.
  
      Examples
      --------
      >>> np.fft.ifft([1, -1j, -1, 1j])
      array([0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j]) # may vary
      >>> 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.
  
      """
      a = asarray(a)
      if n is None:
          n = (a.shape[axis] - 1) * 2
      inv_norm = _get_backward_norm(n, norm)
      output = _raw_fft(a, n, axis, True, False, inv_norm)
      return output
  
imports: import functools
  from numpy.core import asarray, zeros, swapaxes, conjugate, take, sqrt
  from .None import _pocketfft_internal
  from numpy.core.multiarray import normalize_axis_index
  from numpy.core import overrides
label_desc: Use image node_id 9 for calling a global function with example usage: irfft(a, n, axis, norm) and returns: output