NumPy FFT — np.fft module — Coding notes

WHY does this exist?

WHAT is the DFT? (derive it from scratch)

Where does $e^{-2\pi i kn/N}$ come from?

WHY this exact formula? Think of testing your signal against a probe wave.

A pure wave of frequency $k$ (over $N$ samples) is $w_n = e^{+2\pi i kn/N}$ — it spins around the unit circle $k$ full turns as $n$ goes $0\to N$ .
To ask "how much of wave $k$ is in $x$ ?", take the inner product (correlation): multiply each sample by the conjugate of the probe and sum.
Conjugate of $e^{+2\pi i kn/N}$ is $e^{-2\pi i kn/N}$ . Hence the minus sign.

We can prove orthogonality (geometric series of roots of unity): $\sum_{n=0}^{N-1} e^{2\pi i (k-m) n/N} = \begin{cases} N & k=m \\ 0 & k\neq m\end{cases}$ WHY: if $k=m$ each term is $1$ , sum $=N$ . If $k\ne m$ , it's a geometric series with ratio $r=e^{2\pi i(k-m)/N}\ne1$ and $r^N=1$ , so $\frac{1-r^N}{1-r}=0$ .

Inverse DFT

Because of orthogonality, we can recover $x_n$ : $x_n = \frac{1}{N}\sum_{k=0}^{N-1} X_k \, e^{+2\pi i kn/N}$ The $\tfrac1N$ and the $+$ sign are exactly what undo the forward transform (NumPy's default convention).

HOW NumPy organizes the output

Worked Example 1 — find a tone

import numpy as np
fs   = 1000.0            # sampling rate, Hz
N    = 1000              # number of samples
t    = np.arange(N) / fs # time axis, seconds
x    = 3*np.sin(2*np.pi*50*t)   # a 50 Hz sine, amplitude 3
 
X    = np.fft.rfft(x)              # complex spectrum
f    = np.fft.rfftfreq(N, d=1/fs) # frequency axis
amp  = np.abs(X) * 2 / N          # convert to physical amplitude
 
print(f[np.argmax(amp)], amp.max())   # ~50.0 Hz, ~3.0

Step	Why this step?
`t = arange(N)/fs`	builds correct time stamps; total window $T=N/f_s=1$ s
`rfft(x)`	real signal → half spectrum is enough
`rfftfreq(N,d=1/fs)`	tells you which frequency each bin is — never hard-code!
`*2/N`	DFT splits a real sine's energy into +f and −f; multiply by 2 and divide by $N$ to get the true amplitude 3

Worked Example 2 — reconstruct & verify inverse

x  = np.array([1.0, 2.0, 0.0, -1.0])
X  = np.fft.fft(x)
xr = np.fft.ifft(X)
print(np.allclose(x, xr.real))   # True

Why: ifft(fft(x)) == x exactly (up to float error) because the $1/N$ and sign conventions are matched. Always trust round-trips to debug.

Worked Example 3 — DC and Nyquist

x = np.array([2,2,2,2], dtype=float)
print(np.fft.fft(x))   # [8.+0.j 0 0 0]

Why: a constant signal has only zero frequency (DC). Bin 0 equals $\sum x_n = 8$ . All other bins are zero — there's no oscillation. The DC bin is always the sum of the samples.

Common mistake Steel-manning the classic blunders

1. "Bin index = frequency in Hz." Why it feels right: bin 50 held the 50 Hz tone in Example 1. Reality: that only worked because $N/f_s=1$ . In general $f_k=k f_s/N$ . Fix: always use fftfreq/rfftfreq.

2. "The peak height is the amplitude." Why it feels right: you expect 3 and... it's bigger. Reality: raw $|X_k|$ is scaled by $N/2$ for a real sine. Fix: multiply by $2/N$ (and use $1/N$ , not $2/N$ , for the DC bin).

3. "Forgetting the window length T." A short window gives coarse frequency resolution $\Delta f=f_s/N=1/T$ . Longer recording ⇒ finer pitch discrimination. Fix: remember resolution = $1/T$ .

4. "Using fft then plotting against arange." The high bins are negative frequencies. Fix: use fftshift + fftfreq so the plot is symmetric about 0.

Recall Feynman: explain to a 12-year-old

Imagine a music chord — many notes played at once, smashed into a single jiggle of the air. Your job: figure out which separate notes are inside. The FFT is a magic sieve: you hum each possible note at the jiggle, and whenever your hum matches a hidden note, it "rings" loudly; when it doesn't match, it stays silent. Do this for every note really cleverly (not one-by-one but all at once), and out pops a list: "this much of low note, this much of high note." That list is the spectrum. The "Fast" part is just a smart shortcut so it finishes before lunch.

Flashcards

What does np.fft.fft transform between?

Time (or spatial) domain ↔ frequency domain (complex output).

DFT formula for

X_k

X_k=\sum_{n=0}^{N-1}x_n e^{-2\pi i kn/N}

Why is the FFT "fast" — what complexity vs naive DFT?

O(N\log N)

O(N^2)

Frequency of bin

k

in Hz given rate

f_s

, length

N

f_k = k f_s / N

What does np.fft.fftfreq(N, d) return?

The frequency of each bin (incl. negative freqs), spacing

d=\Delta t

Difference between fft and rfft?

rfft assumes real input and returns only the

N/2+1

non-redundant bins.

What is the value of DFT bin 0 (DC)?

The sum of all samples

\sum_n x_n

For a real sine of amplitude

A

, how do you recover

A

from |rfft|?

Multiply by

2/N

(use

1/N

for the DC bin).

Why is there a minus sign in the forward DFT exponent?

It's the conjugate of the probe wave used to correlate/measure each frequency.

What's the frequency resolution of an FFT?

\Delta f = f_s/N = 1/T

, where

T

is the total record length.

What does fftshift do and why?

Moves the zero-frequency component to the array center so negative/positive freqs plot symmetrically.

Property linking

X_k

and

X_{N-k}

for real input?

X_{N-k}=\overline{X_k}

(conjugate symmetry).

Connections

Discrete Fourier Transform — the math the FFT computes
Sampling and Nyquist Theorem — why $f_s$ limits visible frequencies
Convolution Theorem — FFT turns convolution into multiplication
NumPy arrays — broadcasting — vectorized signal building
Spectral Leakage and Windowing — fixing non-periodic signals
Complex Numbers and Euler's Formula — $e^{i\theta}=\cos\theta+i\sin\theta$
scipy.signal — higher-level spectral tools built on np.fft

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Dekho, FFT ka basic idea simple hai: koi bhi signal jo time ke saath badalta hai (jaise sound ya sensor reading), use hum alag-alag frequency ki sine/cosine waves ke sum ke roop mein likh sakte hain. FFT ek fast algorithm hai jo batata hai ki har frequency kitni "strong" hai signal ke andar. Microphone time ka data deta hai, lekin matlab to frequency mein hota hai — jaise music ka note ya pitch. Isiliye time domain se frequency domain ka bridge chahiye, aur wahi FFT karta hai.

Formula yaad rakho: $X_k=\sum x_n e^{-2\pi i kn/N}$ . Yeh actually ek correlation hai — hum apne signal ko ek probe wave (frequency $k$ ) ke saath multiply karke sum karte hain. Agar wahi frequency signal mein present hai, to sum bada aata hai; warna doosri frequencies aapas mein cancel ho jaati hain (orthogonality). Minus sign isliye hai kyunki probe wave ka conjugate use hota hai. "Fast" ka matlab — naive DFT $O(N^2)$ hota, FFT $O(N\log N)$ , jo crores of samples ke liye game-changer hai.

NumPy mein practical cheezein: np.fft.fft ya real signal ke liye np.fft.rfft (yeh half spectrum deta hai, kyunki real signal symmetric hota hai). Aur sabse important — bin index ko Hz mat samajh lena! Hamesha np.fft.fftfreq(N, d=1/fs) ya rfftfreq use karke actual frequency nikalo, kyunki $f_k = k f_s/N$ . Amplitude recover karne ke liye real sine ko $2/N$ se multiply karo (DC bin ke liye $1/N$ ).

Galtiyan jo sab karte hain: peak ki height ko directly amplitude samajh lena, ya frequency resolution bhool jaana (resolution $=1/T$ , yaani jitna lamba recording, utni acchi pitch detection). Round-trip test (ifft(fft(x))==x) hamesha debugging ke liye use karo — confidence aata hai ki convention sahi hai. Bas itna samajh lo to FFT tumhare liye easy ho jayega!

NumPy FFT — np.fft module

WHY does this exist?

WHAT is the DFT? (derive it from scratch)

Where does $e^{-2\pi i kn/N}$ come from?

Inverse DFT

HOW NumPy organizes the output

Worked Example 1 — find a tone

Worked Example 2 — reconstruct & verify inverse

Worked Example 3 — DC and Nyquist

Flashcards

Connections

Concept Map

Hinglish (regional understanding)

Go deeper — visual, from zero

Test yourself — Scientific Computing (Python)

Connections