code: def hfft(a, n=None, axis=-1, norm=None):
      """
      Compute the FFT of a signal that has Hermitian symmetry, i.e., a real
      spectrum.
  
      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 FFT. If not given, the last
          axis is used.
      norm : {None, "ortho"}, optional
          Normalization mode (see `numpy.fft`). Default is None.
  
          .. versionadded:: 1.10.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 one-dimensional FFT for real input.
      ihfft : The inverse of `hfft`.
  
      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
      --------
      >>> signal = np.array([1, 2, 3, 4, 3, 2])
      >>> np.fft.fft(signal)
      array([ 15.+0.j,  -4.+0.j,   0.+0.j,  -1.-0.j,   0.+0.j,  -4.+0.j])
      >>> np.fft.hfft(signal[:4]) # Input first half of signal
      array([ 15.,  -4.,   0.,  -1.,   0.,  -4.])
      >>> np.fft.hfft(signal, 6)  # Input entire signal and truncate
      array([ 15.,  -4.,   0.,  -1.,   0.,  -4.])
  
  
      >>> signal = np.array([[1, 1.j], [-1.j, 2]])
      >>> np.conj(signal.T) - signal   # check Hermitian symmetry
      array([[ 0.-0.j,  0.+0.j],
             [ 0.+0.j,  0.-0.j]])
      >>> freq_spectrum = np.fft.hfft(signal)
      >>> freq_spectrum
      array([[ 1.,  1.],
             [ 2., -2.]])
  
      """
      # The copy may be required for multithreading.
      a = array(a, copy=True, dtype=complex)
      if n is None:
          n = (a.shape[axis] - 1) * 2
      unitary = _unitary(norm)
      return irfft(conjugate(a), n, axis) * (sqrt(n) if unitary else n)
  
imports: from __future__ import division, absolute_import, print_function
  import functools
  from numpy.core import array, asarray, zeros, swapaxes, shape, conjugate, take, sqrt
  from numpy.core.multiarray import normalize_axis_index
  from numpy.core import overrides
  from .None import fftpack_lite
  from .helper import _FFTCache
label_desc: Use image node_id 8 for calling a global function with example usage: hfft(a, n, axis, norm) and returns: unknown