Digital modulation (ASK, FSK, PSK) in Signal Processing - Time & Space Complexity

Time Complexity: Digital modulation (ASK, FSK, PSK)

O(n)

Understanding Time Complexity

We want to understand how the time needed to modulate signals grows as the input size increases.

How does the processing time change when we modulate more bits using ASK, FSK, or PSK?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

for bit in input_bits:
    if modulation_type == 'ASK':
        modulated_signal.append(amplitude * bit)
    elif modulation_type == 'FSK':
        modulated_signal.append(frequency_shift(bit))
    elif modulation_type == 'PSK':
        modulated_signal.append(phase_shift(bit))

This code modulates each bit of input using one of three digital modulation methods.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Loop over each bit in the input array.
• How many times: Once for every bit in the input (n times).

How Execution Grows With Input

Each bit requires one modulation operation, so the total work grows directly with the number of bits.

Input Size (n)	Approx. Operations
10	10 modulation steps
100	100 modulation steps
1000	1000 modulation steps

Pattern observation: Doubling the input doubles the work needed.

Final Time Complexity

Time Complexity: O(n)

This means the time to modulate grows in a straight line with the number of bits.

Common Mistake

[X] Wrong: "Modulating more bits takes the same time because each modulation is simple."

[OK] Correct: Even if each step is simple, doing it many times adds up, so total time grows with input size.

Interview Connect

Understanding how processing time grows with input size helps you explain efficiency clearly and shows you can think about real system limits.

Self-Check

"What if we processed bits in parallel instead of one by one? How would the time complexity change?"

Practice

1. Which digital modulation technique changes the amplitude of the carrier wave to represent data bits?

easy

A. Phase Shift Keying (PSK)

B. Amplitude Shift Keying (ASK)

C. Frequency Shift Keying (FSK)

D. Pulse Code Modulation (PCM)

Solution

1. Step 1: Understand modulation types

   ASK changes the amplitude of the carrier wave to represent data bits, while FSK changes frequency and PSK changes phase.

2. Step 2: Match modulation to description

   The question asks for the technique that changes amplitude, which is ASK.

3. Final Answer:

   Amplitude Shift Keying (ASK) -> Option B

4. Quick Check:

   Amplitude change = ASK [OK]

Hint: ASK changes amplitude, FSK frequency, PSK phase [OK]

Common Mistakes:

• Confusing ASK with FSK or PSK
• Choosing PCM which is not a modulation technique
• Mixing phase and amplitude changes

2. Which of the following is the correct Python syntax to generate a Frequency Shift Keying (FSK) signal using numpy arrays for two frequencies f1 and f2?

easy

A. signal = np.sin(2 * np.pi * f1 * t) + np.sin(2 * np.pi * f2 * t)

B. signal = np.cos(2 * np.pi * f1 * t) + np.cos(2 * np.pi * f2 * t)

C. signal = np.sin(2 * np.pi * f1 * t) * np.sin(2 * np.pi * f2 * t)

D. signal = np.sin(2 * np.pi * (f1 if bit == 0 else f2) * t)

Solution

1. Step 1: Understand FSK signal generation

   FSK uses one frequency for bit 0 and another for bit 1, so the signal switches frequency based on the bit.

2. Step 2: Check syntax for conditional frequency

   signal = np.sin(2 * np.pi * (f1 if bit == 0 else f2) * t) uses a conditional expression to select frequency based on bit, which is correct for FSK.

3. Final Answer:

   signal = np.sin(2 * np.pi * (f1 if bit == 0 else f2) * t) -> Option D

4. Quick Check:

   Conditional frequency selection = signal = np.sin(2 * np.pi * (f1 if bit == 0 else f2) * t) [OK]

Hint: FSK switches frequency based on bit using conditional [OK]

Common Mistakes:

• Adding two sine waves instead of switching frequency
• Multiplying sine waves which is incorrect
• Using cosine instead of sine without reason

3. Given the following Python code snippet for Phase Shift Keying (PSK), what will be the output signal array for bits = [0, 1] and phase0 = 0, phase1 = pi?

import numpy as np
t = np.linspace(0, 1, 5)
bits = [0, 1]
phase0 = 0
phase1 = np.pi
signal = np.array([np.cos(2 * np.pi * 1 * t + (phase0 if bit == 0 else phase1)) for bit in bits])
print(signal)

medium

A. [[ 1. 0. -1. 0. 1.]
[-1. 0. 1. 0. -1.]]

B. [[ 0. 0. 0. 0. 0.]
[ 1. 1. 1. 1. 1.]]

C. [[ 1. 0. -1. 0. 1.]
[ 1. 0. -1. 0. 1.]]

D. [[ 1. 1. 1. 1. 1.]
[ 1. 1. 1. 1. 1.]]

Solution

1. Step 1: Calculate cosine values for bit 0

   For bit 0, phase = 0, t = np.linspace(0,1,5) = [0, 0.25, 0.5, 0.75, 1], angles = 2πt = [0, π/2, π, 3π/2, 2π], cos = [1, 0, -1, 0, 1].

2. Step 2: Calculate cosine values for bit 1

   For bit 1, phase = π, angles = 2πt + π, cos(θ + π) = -cos(θ) = [-1, 0, 1, 0, -1].

3. Final Answer:

   [[ 1. 0. -1. 0. 1.] [-1. 0. 1. 0. -1.]] -> Option A

4. Quick Check:

   PSK phase shift: cos(θ + π) = -cos(θ) [OK]

Hint: PSK phase π: cos(θ + π) = -cos(θ) [OK]

Common Mistakes:

• Confusing phase shift effect on cosine
• Misinterpreting array shape or values
• Ignoring phase addition in cosine

4. The following code attempts to generate an ASK signal but produces an error. What is the error and how to fix it?

import numpy as np
bit = 0
t = np.linspace(0, 1, 100)
f = 5
signal = np.sin(2 * np.pi * f * t) if bit == 1 else 0
print(signal)

medium

A. Error: signal is assigned a scalar 0 instead of an array; fix by replacing 0 with np.zeros_like(t)

B. Error: np.sin requires integer input; fix by casting t to int

C. Error: Missing parentheses in np.sin; fix by adding parentheses

D. No error; code runs correctly

Solution

1. Step 1: Identify the error in conditional assignment

   If bit == 1, signal is an array from np.sin, else signal is scalar 0, causing inconsistent types.

2. Step 2: Fix by using array of zeros

   Replace 0 with np.zeros_like(t) to keep signal as an array in both cases.

3. Final Answer:

   Error: signal is assigned a scalar 0 instead of an array; fix by replacing 0 with np.zeros_like(t) -> Option A

4. Quick Check:

   Consistent array types needed = Error: signal is assigned a scalar 0 instead of an array; fix by replacing 0 with np.zeros_like(t) [OK]

Hint: Use np.zeros_like(t) for zero arrays, not scalar 0 [OK]

Common Mistakes:

• Using scalar 0 causing type mismatch
• Casting t to int which is unnecessary
• Ignoring conditional expression structure

5. You want to design a digital communication system that must be robust to amplitude noise but can tolerate frequency variations. Which modulation technique should you choose and why?

hard

A. ASK, because it changes amplitude which is sensitive to noise

B. ASK, because it changes phase which is robust to amplitude noise

C. FSK, because it changes frequency which is less affected by amplitude noise

D. PSK, because it changes phase which is sensitive to frequency noise

Solution

1. Step 1: Analyze noise tolerance requirements

   The system must be robust to amplitude noise, so modulation should not rely on amplitude changes.

2. Step 2: Match modulation to noise tolerance

   FSK changes frequency, which is less affected by amplitude noise, making it suitable. ASK changes amplitude and is sensitive to amplitude noise. PSK changes phase and can be sensitive to frequency noise.

3. Final Answer:

   FSK, because it changes frequency which is less affected by amplitude noise -> Option C

4. Quick Check:

   Amplitude noise robustness = FSK [OK]

Hint: Choose FSK to avoid amplitude noise sensitivity [OK]

Common Mistakes:

• Choosing ASK despite amplitude noise sensitivity
• Confusing phase noise sensitivity with frequency noise
• Misunderstanding modulation noise robustness