Why Fourier transforms reveal frequencies in SciPy - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Fourier Transform on a Simple Signal

What is the output magnitude array when applying the Fourier transform to a pure sine wave?

SciPy

import numpy as np
from scipy.fft import fft

# Create a sine wave signal
fs = 100  # Sampling frequency
T = 1/fs  # Sampling interval
t = np.arange(0, 1, T)  # Time vector
f = 1  # Frequency of sine wave
signal = np.sin(2 * np.pi * f * t)

# Compute Fourier transform
fft_result = fft(signal)
magnitude = np.abs(fft_result)
print(magnitude[:10])

A [0.0, 100.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

B [0.0, 25.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

C [0.0, 50.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

D [0.0, 49.99999999999999, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

💡 Hint

Recall that the magnitude at the sine wave frequency is related to half the number of samples.

The Fourier transform of a sine wave of frequency 1 Hz sampled 100 times over 1 second has a peak magnitude near 50 at the corresponding frequency bin. Due to numerical precision, the value is very close to 50 but slightly less.

🧠 Conceptual

intermediate

Why does Fourier transform reveal frequencies?

Which explanation best describes why the Fourier transform reveals the frequency components of a signal?

A It breaks the signal into a sum of sine and cosine waves of different frequencies, showing how much each frequency contributes.

B It sorts the signal values from smallest to largest to find dominant values.

C It counts the number of peaks in the time domain signal to estimate frequency.

D It averages the signal values over time to find the main frequency.

💡 Hint

Think about how sine and cosine waves relate to frequency.

The Fourier transform expresses any signal as a combination of sine and cosine waves at different frequencies. The coefficients show how much each frequency is present.

❓ data_output

advanced

Frequency bins from FFT of a sampled signal

Given a signal sampled at 200 Hz with 400 samples, what is the frequency value of the 50th FFT bin?

SciPy

import numpy as np
fs = 200  # Sampling frequency
N = 400   # Number of samples
freqs = np.fft.fftfreq(N, 1/fs)
print(round(freqs[50], 2))

A 200.0

B 50.0

C 25.0

D 100.0

💡 Hint

Frequency bin = index * sampling_rate / number_of_samples

The frequency for bin k is k * fs / N. Here, 50 * 200 / 400 = 25 Hz.

🔧 Debug

advanced

Identify the error in FFT frequency calculation

What error does the following code produce?

import numpy as np
fs = 100
N = 256
freqs = np.fft.fftfreq(N, fs)
print(freqs[:5])

A SyntaxError due to missing parentheses.

B The output is incorrect frequencies because the sampling interval is passed incorrectly.

C TypeError because fs is not an integer.

D No error, correct output frequencies.

💡 Hint

Check the meaning of the second argument in np.fft.fftfreq.

The second argument to np.fft.fftfreq is the sampling interval (1/fs), not the sampling frequency fs. Passing fs directly causes wrong frequency values.

🚀 Application

expert

Detect dominant frequency in noisy signal

You have a noisy signal composed of a 10 Hz sine wave plus random noise, sampled at 100 Hz for 2 seconds. Which code snippet correctly identifies the dominant frequency?

SciPy

import numpy as np
from scipy.fft import fft
fs = 100
T = 2
N = fs * T
t = np.linspace(0, T, N, endpoint=False)
signal = np.sin(2 * np.pi * 10 * t) + 0.5 * np.random.randn(N)

# Which code finds dominant frequency?

A

freqs = np.fft.fftfreq(N, 1/fs)
fft_vals = fft(signal)
idx = np.argmax(np.abs(fft_vals))
dominant_freq = abs(freqs[idx])
print(round(dominant_freq, 2))

B

freqs = np.fft.fftfreq(N, fs)
fft_vals = fft(signal)
idx = np.argmax(np.abs(fft_vals))
dominant_freq = freqs[idx]
print(dominant_freq)

C

freqs = np.fft.fftfreq(N, 1/fs)
fft_vals = np.abs(fft(signal))
dominant_freq = freqs[np.argmax(fft_vals)]
print(dominant_freq)

D

freqs = np.fft.fftfreq(N, 1/fs)
fft_vals = fft(signal)
idx = np.argmin(np.abs(fft_vals))
dominant_freq = freqs[idx]
print(dominant_freq)

💡 Hint

Remember to use the correct sampling interval and find the index of the maximum magnitude.

Option A correctly uses 1/fs as the sampling interval, computes FFT, finds the index of the maximum magnitude, and prints the absolute frequency.

Option A uses fs instead of 1/fs, causing wrong frequencies.

Option A does not take absolute value of frequency index, which can be negative.

Option A finds minimum magnitude, which is incorrect.