Fast Fourier Transform (FFT) algorithm in Signal Processing - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the FFT function from the numpy library.

Signal Processing

from numpy.fft import [1]

Drag options to blanks, or click blank then click option'

Aifft

Brfft

Cfftshift

Dfft

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'ifft' which computes the inverse FFT instead.

Using 'fftshift' which shifts zero frequency component.

Using 'rfft' which computes FFT for real inputs only.

The fft function computes the Fast Fourier Transform of a signal.

2fill in blank

medium

Complete the code to compute the FFT of the signal stored in variable 'signal'.

Signal Processing

spectrum = [1](signal)

Drag options to blanks, or click blank then click option'

Anp.fft.fft

Bnp.fft.ifft

Cnp.fft.rfft

Dnp.fft.fftshift

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'ifft' which computes inverse FFT.

Using 'fftshift' which rearranges FFT output.

Using 'rfft' which is for real-valued inputs only.

The np.fft.fft function computes the FFT of the input signal.

3fill in blank

hard

Fix the error in the code to correctly compute the magnitude spectrum from FFT output.

Signal Processing

magnitude = [1](spectrum)

Drag options to blanks, or click blank then click option'

Anp.abs

Bnp.real

Cnp.angle

Dnp.imag

Attempts:

3 left

💡 Hint

Common Mistakes

Using np.angle which gives phase, not magnitude.

Using np.real which only gives real part.

Using np.imag which gives imaginary part.

The magnitude of the FFT output is obtained using np.abs, which calculates the absolute value of complex numbers.

4fill in blank

hard

Fill both blanks to create a frequency array matching the FFT output length.

Signal Processing

freqs = np.fft.[1](len(signal)) * [2]

Drag options to blanks, or click blank then click option'

Afftfreq

Bfftshift

Csampling_rate

Dnp.pi

Attempts:

3 left

💡 Hint

Common Mistakes

Using fftshift instead of fftfreq for frequency bins.

Multiplying by np.pi instead of sampling rate.

Not multiplying frequency bins by sampling rate.

np.fft.fftfreq generates frequency bins for FFT output. Multiplying by the sampling rate converts to actual frequency values.

5fill in blank

hard

Fill all three blanks to compute the inverse FFT and retrieve the original signal.

Signal Processing

recovered_signal = np.fft.[1]( [2] )
real_signal = np.[3](recovered_signal)

Drag options to blanks, or click blank then click option'

Aifft

Bspectrum

Creal

Dabs

Attempts:

3 left

💡 Hint

Common Mistakes

Using fft instead of ifft for inverse transform.

Using abs instead of real to get original signal.

Passing wrong variable to ifft.

The inverse FFT is computed with np.fft.ifft on the spectrum. The result is complex, so np.real extracts the real part as the original signal.

Practice

1. What is the main purpose of the Fast Fourier Transform (FFT) algorithm in signal processing?

easy

A. To compress the signal data for storage

B. To convert a signal from time domain to frequency domain

C. To filter out noise from the signal

D. To increase the amplitude of the signal

Solution

1. Step 1: Understand FFT role and compare options

   FFT transforms time-domain signal to frequency domain. A matches exactly; B is compression, C filtering, D amplification.

2. Final Answer:

   To convert a signal from time domain to frequency domain -> Option B

3. Quick Check:

   FFT = Time to Frequency conversion [OK]

Hint: FFT changes signal view from time to frequency fast [OK]

Common Mistakes:

• Confusing FFT with noise filtering
• Thinking FFT compresses data
• Assuming FFT amplifies signals

2. Which of the following is the correct way to import the FFT function from NumPy in Python?

easy

A. from numpy import fft

B. import numpy.fft as fft

C. import fft from numpy

D. from numpy.fft import fft

Solution

1. Step 1: Recall and match Python import syntax

   Correct for specific function: 'from numpy.fft import fft' (C). A imports submodule, B aliases submodule (requires fft.fft()), D invalid.

2. Final Answer:

   from numpy.fft import fft -> Option D

3. Quick Check:

   Correct import syntax = from numpy.fft import fft [OK]

Hint: Use 'from module import function' to import FFT [OK]

Common Mistakes:

• Using 'import fft from numpy' which is invalid syntax
• Importing whole numpy.fft as fft causing confusion
• Trying 'from numpy import fft' which imports the module, not function

3. Given the Python code:

import numpy as np
signal = np.array([1, 0, -1, 0])
fft_result = np.fft.fft(signal)
print(np.round(fft_result, 2))

What is the output?

medium

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

B. [0.+0.j 0.+0.j 0.+0.j 0.+0.j]

C. [0.+0.j 2.+0.j 0.+0.j 2.+0.j]

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

Solution

1. Step 1: Compute and verify FFT output

   np.fft.fft([1,0,-1,0]) corresponds to a sine wave component, resulting in imaginary parts at k=1 and k=3. The output is [0.+0.j 0.+2.j 0.+0.j 0.-2.j], matching [0.+0.j 0.+2.j 0.+0.j 0.-2.j].

2. Final Answer:

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

3. Quick Check:

   FFT sine wave = imaginary components at k=1,3 [OK]

Hint: Sine-like signals yield imaginary FFT components [OK]

Common Mistakes:

• Confusing cosine signal with sine (imaginary output)
• Confusing zeros with non-zero frequency components
• Rounding incorrectly or not at all

4. Consider this Python code snippet:

import numpy as np
signal = [1, 2, 3, 4]
fft_result = fft(signal)
print(fft_result.real)

It raises an error. What is the most likely cause?

medium

A. signal should be a NumPy array, not a list

B. np.fft.fft does not have a real attribute

C. Missing import statement for fft

D. print statement syntax is incorrect

Solution

1. Step 1: Trace code execution for error

   fft(signal) raises NameError: 'fft' undefined. Import is numpy as np (use np.fft.fft); no direct fft import (e.g., from numpy.fft import fft). A, B, D unrelated.

2. Final Answer:

   Missing import statement for fft -> Option C

3. Quick Check:

   Undefined fft = missing import [OK]

Hint: Import fft properly: from numpy.fft import fft [OK]

Common Mistakes:

• Not importing the fft function when using fft()
• Thinking .real is invalid on FFT output
• Confusing print syntax errors

5. You have a noisy signal sampled at 1000 Hz stored in a NumPy array data. You want to remove frequencies above 100 Hz using FFT. Which approach correctly achieves this?

hard

A. Compute FFT, zero out components with frequency > 100 Hz, then inverse FFT

B. Compute FFT, keep only first 100 components, then inverse FFT

C. Apply FFT and multiply all values by 0.1 to reduce noise

D. Use FFT to find max frequency and subtract it from signal

Solution

1. Step 1: Outline correct FFT low-pass filtering

   FFT to freq domain (use fftfreq for bins), zero coeffs where |freq| > 100 (fs=1000, cutoff index ~100/500=0.2*N), ifft back. Matches B precisely; A ignores freq mapping, C/D ineffective.

2. Final Answer:

   Compute FFT, zero out components with frequency > 100 Hz, then inverse FFT -> Option A

3. Quick Check:

   Zero high freq + ifft = low-pass filter [OK]

Hint: Zero unwanted FFT frequencies, then inverse transform [OK]

Common Mistakes:

• Confusing component count with frequency
• Scaling FFT values instead of zeroing
• Misusing FFT to subtract frequencies directly