What is the difference between numpy.fft.fft and numpy.fft.rfft?

Question

The documentation says that np.fft.fft does this:

Compute the one-dimensional discrete Fourier Transform.

and np.fft.rfft does this:

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

I also see that for my data (audio data, real valued), np.fft.fft returns a 2 dimensional array of shape (number_of_frames, fft_length) containing complex numbers.

For np.fft.rfft returns a 2 dimensional array of shape (number_of_frames, ((fft_length/2) + 1)) containing complex numbers. I am led to believe that this only contains nonredundant FFT bins.

Can someone explain in more depth the difference between the commands and why the shape of the returned array is different. Thank you.

Possible duplicate of [What is numpy.fft.rfft and numpy.fft.irfft and its equivalent code in MATLAB](https://stackoverflow.com/questions/45778504/what-is-numpy-fft-rfft-and-numpy-fft-irfft-and-its-equivalent-code-in-matlab) — Mohammad Zain Abbas, Sep 18 '18 at 13:33
I don't want to know the difference between the fft and its inverse, and this is python not matlab — MichaelAndroidNewbie, Sep 18 '18 at 14:12
I know it's not MATLAB, but the basic concepts of fft is the same. — Mohammad Zain Abbas, Sep 18 '18 at 14:13
Fair enough, i am reading through the answers now. Thank you — MichaelAndroidNewbie, Sep 18 '18 at 14:15

score 25 · Answer 1 · edited Dec 18 '19 at 22:49

25

the reason is explained in the docs:

When the DFT is computed for purely real input, the output is Hermitian-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.

As a consequence, the algorithm is optimized and rfft is twice as fast. Furthermore, the spectrum is easier to plot :

In [124]: s=abs(sin(arange(0,2**13,3)))

In [125]: sp=rfft(s)

In [126]: plot(abs(sp))

edited Dec 18 '19 at 22:49

Hameem

29
1
6

answered Sep 18 '18 at 13:53

B. M.

18,243
2
35
54

1

I like the plot addition to the answer and so upvoted you. If we were to plot the complex conjugates, would that just be symmetrical over the amplitude axis? – MichaelAndroidNewbie Sep 18 '18 at 14:19
2

Yes it will be. Not useful. So I fell rfft more convenient. – B. M. Sep 18 '18 at 14:56
I feel dumb, but where +/- 1 comes from? Why not NFFT/2 ? – Andoriyu Feb 26 '21 at 01:43
2

since the frequency are proportional to -n,-n+1,.....-1,0,1,... n-1,n. the +1 is for the central term which is is own symetric. – B. M. Feb 26 '21 at 07:53

score 14 · Accepted Answer · answered Sep 18 '18 at 13:44

Basic difference is explained here via example. As it says:

import numpy as np

data = [0, 1, 2, 1, 0]

print("FFT output\n", np.fft.fft(data))
print("RFFT output\n", np.fft.rfft(data))

will result in:

FFT output
 [ 4.        +0.j         -2.11803399-1.53884177j  0.11803399+0.36327126j
  0.11803399-0.36327126j -2.11803399+1.53884177j]
RFFT output
 [ 4.        +0.j         -2.11803399-1.53884177j  0.11803399+0.36327126j]

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.

What is the difference between numpy.fft.fft and numpy.fft.rfft?

2 Answers2