code: def hfft(
      x,
      n=None,
      axis=-1,
      norm=None,
      overwrite_x=False,
      workers=None,
      *,
      plan=None,
  ):
      """
      Compute the FFT of a signal that has Hermitian symmetry, i.e., a real
      spectrum.
  
      Parameters
      ----------
      x : 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 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 : 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 - 2``, where ``m`` is the length of the transformed axis of
          the input. To get an odd number of output points, `n` must be
          specified, for instance, as ``2*m - 1`` in the typical case,
  
      Raises
      ------
      IndexError
          If `axis` is larger than the last axis of `a`.
  
      See Also
      --------
      rfft : Compute the 1-D FFT for real input.
      ihfft : The inverse of `hfft`.
      hfftn : Compute the N-D FFT of a Hermitian signal.
  
      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 fft, hfft
      >>> a = 2 * np.pi * np.arange(10) / 10
      >>> signal = np.cos(a) + 3j * np.sin(3 * a)
      >>> fft(signal).round(10)
      array([ -0.+0.j,   5.+0.j,  -0.+0.j,  15.-0.j,   0.+0.j,   0.+0.j,
              -0.+0.j, -15.-0.j,   0.+0.j,   5.+0.j])
      >>> hfft(signal[:6]).round(10) # Input first half of signal
      array([  0.,   5.,   0.,  15.,  -0.,   0.,   0., -15.,  -0.,   5.])
      >>> hfft(signal, 10)  # Input entire signal and truncate
      array([  0.,   5.,   0.,  15.,  -0.,   0.,   0., -15.,  -0.,   5.])
      """
      return (Dispatchable(x, np.ndarray),)
  
imports: from scipy._lib.uarray import generate_multimethod, Dispatchable
  import numpy
label_desc: Use image node_id 7 for calling a global function with example usage: hfft(x, n, axis, norm, overwrite_x, workers) and returns: Dispatchable