Signal addition and multiplication in Signal Processing - Step-by-Step Execution

Concept Flow - Signal addition and multiplication

Start with two signals x(t) and y(t)

↓

Align signals in time domain

↓

Add signals pointwise

↓

Result: z_add(t) = x(t) + y(t)

↓

Result: z_mul(t) = x(t) * y(t)

We start with two signals, align them in time, then add or multiply their values at each time point to get new signals.

Execution Sample

Signal Processing

import numpy as np
import matplotlib.pyplot as plt

t = np.linspace(0, 1, 5)
x = np.array([1, 2, 3, 4, 5])
y = np.array([5, 4, 3, 2, 1])

z_add = x + y
z_mul = x * y

This code creates two simple signals and computes their addition and multiplication pointwise.

Execution Table

Step	t (time)	x(t)	y(t)	x(t)+y(t)	x(t)*y(t)
1	0.00	1	5	6	5
2	0.25	2	4	6	8
3	0.50	3	3	6	9
4	0.75	4	2	6	8
5	1.00	5	1	6	5
6	-	-	-	-	-

💡 All time points processed; addition and multiplication completed pointwise.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5	Final
t	[0.00, 0.25, 0.50, 0.75, 1.00]	[0.00, 0.25, 0.50, 0.75, 1.00]	[0.00, 0.25, 0.50, 0.75, 1.00]	[0.00, 0.25, 0.50, 0.75, 1.00]	[0.00, 0.25, 0.50, 0.75, 1.00]	[0.00, 0.25, 0.50, 0.75, 1.00]	[0.00, 0.25, 0.50, 0.75, 1.00]
x	[1, 2, 3, 4, 5]	[1, 2, 3, 4, 5]	[1, 2, 3, 4, 5]	[1, 2, 3, 4, 5]	[1, 2, 3, 4, 5]	[1, 2, 3, 4, 5]	[1, 2, 3, 4, 5]
y	[5, 4, 3, 2, 1]	[5, 4, 3, 2, 1]	[5, 4, 3, 2, 1]	[5, 4, 3, 2, 1]	[5, 4, 3, 2, 1]	[5, 4, 3, 2, 1]	[5, 4, 3, 2, 1]
z_add	[]	[6]	[6, 6]	[6, 6, 6]	[6, 6, 6, 6]	[6, 6, 6, 6, 6]	[6, 6, 6, 6, 6]
z_mul	[]	[5]	[5, 8]	[5, 8, 9]	[5, 8, 9, 8]	[5, 8, 9, 8, 5]	[5, 8, 9, 8, 5]

Key Moments - 2 Insights

Why do the addition and multiplication results have the same length as the original signals?

Because addition and multiplication happen point by point for each time value, so the output signal length matches the input signals, as shown in execution_table rows 1 to 5.

What happens if the two signals have different lengths or time points?

They must be aligned or resampled to the same time points before addition or multiplication; otherwise, pointwise operations won't work correctly. This example assumes aligned signals.

Visual Quiz - 3 Questions

Look at the execution_table at step 3. What is the value of x(t)*y(t)?

A 6

B 3

C 9

D 8

💡 Hint

Check the 'x(t)*y(t)' column in row 3 of the execution_table.

At which step does the addition result first become 6?

A All steps

B Step 1

C Step 3

D Step 2

💡 Hint

Look at the 'x(t)+y(t)' column for all steps in the execution_table.

If y(t) was changed to [1, 1, 1, 1, 1], how would the addition result at step 5 change?

A It would be 6

B It would be 5

C It would be 10

D It would be 1

💡 Hint

Addition is pointwise: new z_add at step 5 = x(1.00) + y(1.00) = 5 + 1.

Concept Snapshot

Signal Addition and Multiplication:
- Two signals x(t), y(t) must align in time.
- Addition: z_add(t) = x(t) + y(t) (pointwise sum).
- Multiplication: z_mul(t) = x(t) * y(t) (pointwise product).
- Output signals have same length as inputs.
- Used in combining or modulating signals in processing.

Full Transcript

This visual execution shows how two signals are combined by adding and multiplying their values at each time point. We start with two arrays representing signals over time. For each time step, we add the values from both signals to get a new signal, and multiply the values to get another new signal. The execution table lists each time point, the original signal values, and the results of addition and multiplication. Variables remain constant except the output signals which build up step by step. Key points include that signals must be aligned in time and that output signals keep the same length as inputs. The quiz questions check understanding of values at specific steps and effects of changing inputs. This method is fundamental in signal processing for combining or modulating signals.

Practice

1. What happens when you add two signals of the same length point by point?

easy

A. The signals are concatenated end to end.

B. You get a new signal where each value is the product of the corresponding values.

C. You get a new signal where each value is the sum of the corresponding values.

D. The signals are subtracted from each other point by point.

Solution

1. Step 1: Understand signal addition

   Signal addition means adding each value of one signal to the corresponding value of the other signal.

2. Step 2: Apply point-by-point addition

   For signals of the same length, each position's values are summed to form the new signal.

3. Final Answer:

   You get a new signal where each value is the sum of the corresponding values. -> Option C

4. Quick Check:

   Signal addition = sum of values [OK]

Hint: Addition means sum values at each point [OK]

Common Mistakes:

• Confusing addition with multiplication
• Thinking signals concatenate instead of adding
• Assuming subtraction instead of addition

2. Which of the following is the correct Python syntax to multiply two signals stored as lists a and b element-wise?

easy

A. result = a + b

B. result = [a[i] * b[i] for i in range(len(a))]

C. result = multiply(a, b)

D. result = a * b

Solution

1. Step 1: Understand element-wise multiplication

   We multiply each element of list a by the corresponding element of list b.

2. Step 2: Use list comprehension with index

   The syntax [a[i] * b[i] for i in range(len(a))] correctly multiplies elements point by point.

3. Final Answer:

   result = [a[i] * b[i] for i in range(len(a))] -> Option B

4. Quick Check:

   Element-wise multiply = list comprehension [OK]

Hint: Use list comprehension with index for element-wise multiply [OK]

Common Mistakes:

• Using a * b which repeats list instead of multiply
• Using undefined function multiply
• Using addition instead of multiplication

3. Given two signals a = [1, 3, 5] and b = [2, 4, 6], what is the result of their element-wise addition?

medium

A. [3, 7, 11]

B. [2, 7, 11]

C. [2, 4, 6]

D. [1, 3, 5, 2, 4, 6]

Solution

1. Step 1: Add corresponding elements of signals

   Calculate 1+2=3, 3+4=7, 5+6=11 for each position.

2. Step 2: Form the new signal list

   The resulting list is [3, 7, 11].

3. Final Answer:

   [3, 7, 11] -> Option A

4. Quick Check:

   Sum each pair = [3, 7, 11] [OK]

Hint: Add each pair of values in order [OK]

Common Mistakes:

• Adding all values together instead of point-wise
• Confusing addition with multiplication
• Concatenating lists instead of adding

4. Consider the code below that tries to multiply two signals element-wise:

signal1 = [1, 2, 3]
signal2 = [4, 5]
result = [signal1[i] * signal2[i] for i in range(len(signal1))]

What is the main problem with this code?

medium

A. The signals have different lengths causing an index error.

B. The multiplication operator is incorrect.

C. The range should be based on signal2 length.

D. List comprehension syntax is invalid.

Solution

1. Step 1: Check signal lengths

   signal1 has length 3, signal2 has length 2, so they differ.

2. Step 2: Identify index error cause

   Loop runs 3 times, but signal2[2] does not exist, causing an error.

3. Final Answer:

   The signals have different lengths causing an index error. -> Option A

4. Quick Check:

   Different lengths cause index error [OK]

Hint: Check signal lengths before element-wise operations [OK]

Common Mistakes:

• Ignoring length mismatch
• Blaming operator instead of index range
• Assuming list comprehension syntax is wrong

5. You have two signals representing sensor readings:
temp = [20, 22, 21, 23] and humidity = [0.5, 0.6, 0.55, 0.65].
You want to create a new signal that represents the heat index by multiplying temperature and humidity point by point.
What is the correct Python code to do this?

hard

A. heat_index = [temp[i] + humidity[i] for i in range(len(temp))]

B. heat_index = temp * humidity

C. heat_index = multiply(temp, humidity)

D. heat_index = [temp[i] * humidity[i] for i in range(len(temp))]

Solution

1. Step 1: Confirm signals have same length

   Both temp and humidity have length 4, so element-wise operations are valid.

2. Step 2: Use list comprehension for multiplication

   Multiply each temperature by corresponding humidity using [temp[i] * humidity[i] for i in range(len(temp))].

3. Final Answer:

   heat_index = [temp[i] * humidity[i] for i in range(len(temp))] -> Option D

4. Quick Check:

   Element-wise multiply with list comprehension [OK]

Hint: Multiply matching elements with list comprehension [OK]

Common Mistakes:

• Using temp * humidity which repeats list
• Adding instead of multiplying signals
• Using undefined function multiply