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.

Practice

1. Why does a Fourier transform help us understand a signal better?

easy

A. Because it averages the signal values over time

B. Because it removes noise from the signal

C. Because it changes the signal into a longer time series

D. Because it shows the different frequencies inside the signal

Solution

1. Step 1: Understand what a Fourier transform does

   A Fourier transform breaks a signal into its frequency parts, showing which frequencies are present.

2. Step 2: Compare options to this understanding

   Only Because it shows the different frequencies inside the signal correctly states that it reveals the different frequencies inside the signal.

3. Final Answer:

   Because it shows the different frequencies inside the signal -> Option D

4. Quick Check:

   Fourier transform = frequency breakdown [OK]

Hint: Fourier transform = signal to frequency parts [OK]

Common Mistakes:

• Thinking Fourier transform removes noise
• Confusing time and frequency domains
• Believing it averages signal values

2. Which of the following is the correct way to import the Fourier transform function from scipy?

easy

A. import scipy.fftpack.fft

B. from scipy.fft import fft

C. from scipy import fourier_transform

D. import fft from scipy

Solution

1. Step 1: Recall the correct scipy module for Fourier transforms

   The modern scipy module for Fourier transforms is scipy.fft, and the function is fft.

2. Step 2: Check each import statement

   Only 'from scipy.fft import fft' is valid Python syntax and correct module usage.

3. Final Answer:

   from scipy.fft import fft -> Option B

4. Quick Check:

   Correct import = from scipy.fft import fft [OK]

Hint: Use scipy.fft for Fourier transforms in recent versions [OK]

Common Mistakes:

• Using scipy.fftpack which is older
• Wrong import syntax causing errors
• Assuming function name is fourier_transform

3. What is the output of this code snippet?

import numpy as np
from scipy.fft import fft

signal = np.array([1, 0, -1, 0])
result = fft(signal)
print(np.round(result, 2))

medium

A. [0.+0.j 2.+0.j 0.+0.j 2.+0.j]

B. [0.+0.j 2.+0.j 0.-0.j 2.-0.j]

C. [0.+0.j 1.+0.j 0.+0.j 1.+0.j]

D. [0.+0.j 0.+0.j 0.+0.j 0.+0.j]

Solution

1. Step 1: Understand the input signal and FFT output

   The signal is [1, 0, -1, 0], a simple wave. FFT returns complex numbers representing frequency components.

2. Step 2: Calculate FFT and round results

   FFT of this signal is [0.+0.j 2.+0.j 0.+0.j 2.+0.j]. Rounding to 2 decimals keeps these values.

3. Final Answer:

   [0.+0.j 2.+0.j 0.+0.j 2.+0.j] -> Option A

4. Quick Check:

   FFT output matches [0.+0.j 2.+0.j 0.+0.j 2.+0.j] [OK]

Hint: FFT output shows complex frequency components [OK]

Common Mistakes:

• Ignoring complex part signs
• Confusing zeros with small imaginary parts
• Misreading array values

4. Identify the error in this code that tries to compute the Fourier transform:

import numpy as np
from scipy.fft import fft

signal = [1, 2, 3, 4]
result = fft(signal, n=2)
print(result)

medium

A. fft does not accept the parameter n

B. The signal must be a numpy array, not a list

C. The parameter n=2 truncates the signal incorrectly

D. The import statement is incorrect

Solution

1. Step 1: Check fft function parameters

   The fft function accepts n, which sets the length of the transform. Setting n=2 truncates or pads the signal to length 2.

2. Step 2: Understand effect of n=2 on signal length

   The original signal length is 4, but n=2 means fft uses only first 2 elements, effectively truncating the signal.

3. Final Answer:

   The parameter n=2 truncates the signal incorrectly -> Option C

4. Quick Check:

   n parameter changes transform length [OK]

Hint: n parameter sets FFT length, can truncate signal [OK]

Common Mistakes:

• Thinking fft requires numpy array input
• Believing fft does not accept n parameter
• Assuming import is wrong

5. You have a noisy signal composed of two sine waves at 5 Hz and 20 Hz. How can Fourier transform help you separate these frequencies?

hard

A. By converting the signal to frequency domain, peaks at 5 Hz and 20 Hz appear clearly

B. By filtering the signal in time domain before transform

C. By averaging the signal values over time to remove noise

D. By applying inverse Fourier transform directly

Solution

1. Step 1: Understand the purpose of Fourier transform on noisy signals

   Fourier transform converts time signals into frequency domain, showing frequency peaks clearly.

2. Step 2: Identify how frequency peaks help separate components

   In frequency domain, the 5 Hz and 20 Hz sine waves appear as distinct peaks, allowing separation despite noise.

3. Final Answer:

   By converting the signal to frequency domain, peaks at 5 Hz and 20 Hz appear clearly -> Option A

4. Quick Check:

   Frequency peaks reveal signal components [OK]

Hint: Fourier transform reveals frequency peaks in noisy signals [OK]

Common Mistakes:

• Thinking noise is removed before transform
• Confusing time and frequency domain filtering
• Using inverse transform without frequency analysis