code: def ihfft(
      x,
      n=None,
      axis=-1,
      norm=None,
      overwrite_x=False,
      workers=None,
      *,
      plan=None,
  ):
      """
      Compute the inverse FFT of a signal that has Hermitian symmetry.
  
      Parameters
      ----------
      x : 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
          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 :func:`~scipy.fft.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.
  
          .. versionadded:: 1.5.0
  
      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
      --------
      >>> from scipy.fft import ifft, ihfft
      >>> import numpy as np
      >>> spectrum = np.array([ 15, -4, 0, -1, 0, -4])
      >>> ifft(spectrum)
      array([1.+0.j,  2.+0.j,  3.+0.j,  4.+0.j,  3.+0.j,  2.+0.j]) # may vary
      >>> ihfft(spectrum)
      array([ 1.-0.j,  2.-0.j,  3.-0.j,  4.-0.j]) # may vary
      """
      return (Dispatchable(x, np.ndarray),)
  
imports: from scipy._lib.uarray import generate_multimethod, Dispatchable
  import numpy
label_desc: Use image node_id 8 for calling a global function with example usage: ihfft(x, n, axis, norm, overwrite_x, workers) and returns: Dispatchable