# scipy.fft.hfft

scipy.fft.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 `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.

      New in version 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
      >>> import numpy as np
      >>> 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.])