Why frequency analysis matters in Signal Processing - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to compute the frequency components of a signal using FFT.

Signal Processing

import numpy as np
signal = np.array([1, 2, 3, 4, 5])
freq_components = np.fft.[1](signal)

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

Aifft

Brfft

Cfftshift

Dfft

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'ifft' which is the inverse transform.

Using 'fftshift' which rearranges FFT output but does not compute it.

Using 'rfft' which is for real-valued signals but not the basic FFT.

The fft function computes the Fast Fourier Transform, which converts a signal from time domain to frequency domain.

2fill in blank

medium

Complete the code to calculate the magnitude spectrum from the FFT result.

Signal Processing

import numpy as np
signal = np.array([1, 2, 3, 4, 5])
freq_components = np.fft.fft(signal)
magnitude = np.abs([1])

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

Afreq_components

Bsignal

Cnp.fft.fft(signal)

Dnp.abs(signal)

Attempts:

3 left

💡 Hint

Common Mistakes

Taking absolute value of the original signal instead of FFT result.

Using the FFT function call inside abs instead of the variable.

The magnitude spectrum is the absolute value of the FFT output, which is stored in freq_components.

3fill in blank

hard

Fix the error in the code to correctly compute the frequency bins for the FFT of a signal sampled at 1000 Hz.

Signal Processing

import numpy as np
sampling_rate = 1000
signal = np.array([0, 1, 0, -1] * 10)
n = len(signal)
freq_bins = np.fft.fftfreq(n, d=[1])

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

An / sampling_rate

B1 / sampling_rate

Csampling_rate

Dsampling_rate / n

Attempts:

3 left

💡 Hint

Common Mistakes

Using sampling rate directly instead of its inverse.

Confusing sample count with sample spacing.

The d parameter in fftfreq is the sample spacing, which is the inverse of the sampling rate.

4fill in blank

hard

Fill both blanks to create a dictionary of frequencies and their magnitudes for frequencies above 10 Hz.

Signal Processing

import numpy as np
signal = np.array([1, 2, 3, 4, 5, 6, 7, 8])
sampling_rate = 100
n = len(signal)
freqs = np.fft.fftfreq(n, d=1/sampling_rate)
fft_vals = np.fft.fft(signal)
magnitude = np.abs(fft_vals)
freq_mag_dict = {freqs[i]: magnitude[i] for i in range(n) if freqs[i] [1] [2]

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

A>

B10

C<

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using less than sign instead of greater than.

Using 0 instead of 10 as the threshold.

The dictionary comprehension filters frequencies greater than 10 Hz using freqs[i] > 10.

5fill in blank

hard

Fill all three blanks to create a dictionary of frequencies and magnitudes for positive frequencies only.

Signal Processing

import numpy as np
signal = np.array([1, 2, 3, 4, 5])
sampling_rate = 50
n = len(signal)
freqs = np.fft.fftfreq(n, d=1/sampling_rate)
fft_vals = np.fft.fft(signal)
magnitude = np.abs(fft_vals)
positive_freqs = { [1]: [2] for i in range(n) if freqs[i] [3] 0 }

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

Afreqs[i]

Bmagnitude[i]

C>

Dfreqs

Attempts:

3 left

💡 Hint

Common Mistakes

Using the whole freqs array as key instead of single frequency.

Using less than sign instead of greater than.

Swapping keys and values.

The dictionary comprehension maps each positive frequency freqs[i] to its magnitude magnitude[i] where frequency is greater than zero.

Practice

1. Why is frequency analysis important in signal processing?

easy

A. It increases the signal's volume.

B. It helps identify hidden patterns by breaking signals into simple waves.

C. It changes the signal's color.

D. It removes all noise from the signal automatically.

Solution

1. Step 1: Understand the purpose of frequency analysis

   Frequency analysis breaks complex signals into simpler parts called frequencies to reveal hidden patterns.

2. Step 2: Compare options to the purpose

   Only It helps identify hidden patterns by breaking signals into simple waves. correctly states this purpose. Other options describe unrelated or incorrect effects.

3. Final Answer:

   It helps identify hidden patterns by breaking signals into simple waves. -> Option B

4. Quick Check:

   Frequency analysis = reveals hidden patterns [OK]

Hint: Frequency analysis reveals hidden waves in signals [OK]

Common Mistakes:

• Thinking frequency analysis changes signal volume
• Believing it changes signal color
• Assuming it removes noise automatically

2. Which of the following is the correct way to represent a Fourier Transform in Python using numpy?

easy

A. np.fft.fft(signal)

B. np.fft.transform(signal)

C. np.fft.fourier(signal)

D. np.fft.frequency(signal)

Solution

1. Step 1: Recall numpy FFT function name

   The numpy library uses np.fft.fft() to compute the Fourier Transform of a signal.

2. Step 2: Check each option's correctness

   Only np.fft.fft(signal) uses the correct function name. Others are invalid or do not exist in numpy.

3. Final Answer:

   np.fft.fft(signal) -> Option A

4. Quick Check:

   Correct numpy FFT function = np.fft.fft() [OK]

Hint: Remember numpy FFT is np.fft.fft() [OK]

Common Mistakes:

• Using incorrect function names like transform or fourier
• Confusing frequency with fft function
• Misspelling numpy function names

3. Given the Python code:

import numpy as np
signal = np.array([1, 0, -1, 0])
freqs = np.fft.fft(signal)
print(np.round(freqs, 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 FFT of the signal

   The signal [1, 0, -1, 0] represents a sine wave pattern, not a pure cosine wave. Its FFT results in imaginary components at certain frequencies.

2. Step 2: Interpret FFT output

   The FFT output rounded to 2 decimals is [0.+0.j 0.+2.j 0.+0.j 0.-2.j], showing imaginary parts at k=1 and k=3.

3. Final Answer:

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

4. Quick Check:

   FFT output matches imaginary sine components [OK]

Hint: FFT of sine-like signals has imaginary parts [OK]

Common Mistakes:

• Mistaking sine for cosine, expecting real parts
• Confusing magnitude with raw FFT values
• Assuming FFT output is always real

4. The following code tries to compute the frequency components but gives an error:

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

What is the error and how to fix it?

medium

A. Error because np.fft.fft requires integer input only.

B. Error because signal is a list, convert it to numpy array first.

C. Error because np.fft.fft is misspelled.

D. No error; code runs fine.

Solution

1. Step 1: Check input type for np.fft.fft

   np.fft.fft accepts lists or numpy arrays as input and converts lists internally.

2. Step 2: Verify code correctness

   The code runs without error and prints the FFT of the list signal.

3. Final Answer:

   No error; code runs fine. -> Option D

4. Quick Check:

   np.fft.fft accepts lists directly [OK]

Hint: np.fft.fft works with lists or arrays [OK]

Common Mistakes:

• Assuming lists cause errors in FFT
• Thinking FFT input must be integers only
• Believing function name is misspelled

5. You have a machine vibration signal sampled at 1000 Hz. You want to find if a fault frequency of 50 Hz is present. Which step is best to detect this using frequency analysis?

hard

A. Filter out frequencies below 100 Hz only.

B. Increase the signal amplitude and listen to it.

C. Apply Fourier Transform and check magnitude at 50 Hz frequency bin.

D. Use time domain average without frequency analysis.

Solution

1. Step 1: Understand the goal

   We want to detect if 50 Hz frequency exists in the vibration signal.

2. Step 2: Use Fourier Transform to analyze frequencies

   Applying Fourier Transform converts the signal to frequency domain, allowing us to check magnitude at 50 Hz.

3. Step 3: Interpret frequency bin

   By examining the magnitude at the 50 Hz bin, we can confirm presence or absence of the fault frequency.

4. Final Answer:

   Apply Fourier Transform and check magnitude at 50 Hz frequency bin. -> Option C

5. Quick Check:

   Fourier Transform reveals specific frequencies [OK]

Hint: Check frequency magnitude at target frequency after FFT [OK]

Common Mistakes:

• Ignoring frequency domain and using time domain only
• Filtering wrong frequency ranges
• Assuming amplitude increase reveals frequency