### Navigation

- index
- modules |
- modules |
- next |
- previous |
- NumPy v1.7 Manual (DRAFT) »
- NumPy Reference »
- Routines »
- Discrete Fourier Transform (`numpy.fft`) »

# numpy.fft.rfft

`numpy.fft.``rfft`(a, n=None, axis=-1)

  Compute the one-dimensional discrete Fourier Transform for real input.

  This function computes the one-dimensional n-point discrete Fourier Transform (DFT) of a real-valued array by means of an efficient algorithm called the Fast Fourier Transform (FFT).

  Parameters : | a : array_like Input array n : int, optional 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 FFT. If not given, the last axis is used.
  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`.
  Raises : | IndexError : If axis is larger than the last axis of a.

  See also

  `numpy.fft`
    For definition of the DFT and conventions used.
  `irfft`
    The inverse of `rfft`.
  `fft`
    The one-dimensional FFT of general (complex) input.
  `fftn`
    The n-dimensional FFT.
  `rfftn`
    The n-dimensional FFT of real input.

  Notes

  When the DFT is computed for purely real input, the output is Hermite-symmetric, i.e. the negative frequency terms are just the complex conjugates of the corresponding positive-frequency terms, and the negative-frequency terms are therefore redundant. This function does not compute the negative frequency terms, and the length of the transformed axis of the output is therefore `n/2+1`.

  When `A = rfft(a)`, `A[0]` contains the zero-frequency term, which must be purely real due to the Hermite symmetry.

  If n is even, `A[-1]` contains the term for frequencies `n/2` and `-n/2`, and must also be purely real. If n is odd, `A[-1]` contains the term for frequency `A[(n-1)/2]`, and is complex in the general case.

  If the input a contains an imaginary part, it is silently discarded.

  Examples

      >>> np.fft.fft([0, 1, 0, 0])
      array([ 1.+0.j,  0.-1.j, -1.+0.j,  0.+1.j])
      >>> np.fft.rfft([0, 1, 0, 0])
      array([ 1.+0.j,  0.-1.j, -1.+0.j])

  Notice how the final element of the `fft` output is the complex conjugate of the second element, for real input. For `rfft`, this symmetry is exploited to compute only the non-negative frequency terms.

### Navigation

- index
- modules |
- modules |
- next |
- previous |
- NumPy v1.7 Manual (DRAFT) »
- NumPy Reference »
- Routines »
- Discrete Fourier Transform (`numpy.fft`) »