code: def ihfft(a, n=None, axis=-1, norm=None):
      """
      Compute the inverse FFT of a signal that has Hermitian symmetry.
  
      Parameters
      ----------
      a : array_like
          Input array.
      n : int, optional
          Length of the inverse FFT, the number of points along
          transformation axis in the input to use.  If `n` is smaller than
          the length of the input, the input is cropped.  If it is larger,
          the input is padded with zeros. If `n` is not given, the length of
          the input along the axis specified by `axis` is used.
      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 : complex 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//2 + 1``.
  
      See also
      --------
      hfft, irfft
  
      Notes
      -----
      `hfft`/`ihfft` are a pair analogous to `rfft`/`irfft`, but for the
      opposite case: here the signal has Hermitian symmetry in the time
      domain and is real in the frequency domain. So here it's `hfft` for
      which you must supply the length of the result if it is to be odd:
  
      * even: ``ihfft(hfft(a, 2*len(a) - 2)) == a``, within roundoff error,
      * odd: ``ihfft(hfft(a, 2*len(a) - 1)) == a``, within roundoff error.
  
      Examples
      --------
      >>> spectrum = np.array([ 15, -4, 0, -1, 0, -4])
      >>> np.fft.ifft(spectrum)
      array([1.+0.j,  2.+0.j,  3.+0.j,  4.+0.j,  3.+0.j,  2.+0.j]) # may vary
      >>> np.fft.ihfft(spectrum)
      array([ 1.-0.j,  2.-0.j,  3.-0.j,  4.-0.j]) # may vary
  
      """
      a = asarray(a)
      if n is None:
          n = a.shape[axis]
      new_norm = _swap_direction(norm)
      output = conjugate(rfft(a, n, axis, norm=new_norm))
      return output
  
imports: import functools
  import warnings
  from numpy.lib.array_utils import normalize_axis_index
  from numpy._core import asarray, zeros, swapaxes, conjugate, take, sqrt
  from .None import _pocketfft_internal
  from numpy._core import overrides
label_desc: Use image node_id 11 for calling a global function with example usage: ihfft(a, n, axis, norm) and returns: output