Common signal types (sinusoidal, step, impulse, ramp) in Signal Processing

Introduction

Signals are how we represent information changing over time. Knowing common signal types helps us understand and analyze real-world data.

To model sound waves using sinusoidal signals.

To test systems with sudden changes using step signals.

To analyze system responses to very short bursts using impulse signals.

To represent steadily increasing values using ramp signals.

Syntax

Signal Processing

sinusoidal: x(t) = A * sin(2 * pi * f * t + phi)
step: u(t) = 0 if t < 0 else 1
impulse: delta(t) = 0 if t != 0 else very large
ramp: r(t) = t if t >= 0 else 0

sinusoidal signals repeat smoothly like waves.

step signals jump suddenly from 0 to 1 at time zero.

Examples

This code plots a sinusoidal wave with amplitude 1 and frequency 5 Hz.

Signal Processing

import numpy as np
import matplotlib.pyplot as plt

t = np.linspace(-1, 1, 500)
A = 1
f = 5
phi = 0
sinusoid = A * np.sin(2 * np.pi * f * t + phi)

plt.plot(t, sinusoid)
plt.title('Sinusoidal Signal')
plt.show()

This code plots a step signal that jumps from 0 to 1 at time zero.

Signal Processing

import numpy as np
import matplotlib.pyplot as plt

t = np.linspace(-1, 1, 500)
step = np.where(t < 0, 0, 1)

plt.plot(t, step)
plt.title('Step Signal')
plt.show()

This code approximates an impulse signal as a very narrow, tall spike at zero.

Signal Processing

import numpy as np
import matplotlib.pyplot as plt

t = np.linspace(-1, 1, 500)
impulse = np.zeros_like(t)
impulse[np.abs(t) < 0.01] = 50

plt.plot(t, impulse)
plt.title('Impulse Signal Approximation')
plt.show()

This code plots a ramp signal that increases linearly from zero at time zero.

Signal Processing

import numpy as np
import matplotlib.pyplot as plt

t = np.linspace(-1, 1, 500)
ramp = np.where(t < 0, 0, t)

plt.plot(t, ramp)
plt.title('Ramp Signal')
plt.show()

Sample Program

This program creates and plots four common signal types on separate graphs for easy comparison.

Signal Processing

import numpy as np
import matplotlib.pyplot as plt

t = np.linspace(-1, 1, 1000)

# Sinusoidal signal
A = 1
f = 3
phi = 0
sinusoid = A * np.sin(2 * np.pi * f * t + phi)

# Step signal
step = np.where(t < 0, 0, 1)

# Impulse signal approximation
impulse = np.zeros_like(t)
impulse[np.abs(t) < 0.005] = 100

# Ramp signal
ramp = np.where(t < 0, 0, t)

plt.figure(figsize=(10, 8))

plt.subplot(4, 1, 1)
plt.plot(t, sinusoid)
plt.title('Sinusoidal Signal')
plt.grid(True)

plt.subplot(4, 1, 2)
plt.plot(t, step)
plt.title('Step Signal')
plt.grid(True)

plt.subplot(4, 1, 3)
plt.plot(t, impulse)
plt.title('Impulse Signal Approximation')
plt.grid(True)

plt.subplot(4, 1, 4)
plt.plot(t, ramp)
plt.title('Ramp Signal')
plt.grid(True)

plt.tight_layout()
plt.show()

Important Notes

The impulse signal is idealized and cannot be perfectly drawn; we approximate it with a narrow spike.

Step and ramp signals are useful to test how systems react to sudden or gradual changes.

Sinusoidal signals are the building blocks of many complex signals in nature and engineering.

Summary

Common signals include sinusoidal (wave-like), step (sudden jump), impulse (short spike), and ramp (steady increase).

These signals help us understand and test systems in real life.

We can create and visualize these signals easily using simple code.

Practice

1. Which of the following signals represents a sudden jump from zero to one and stays at one afterwards?

easy

A. Sinusoidal signal

B. Step signal

C. Impulse signal

D. Ramp signal

Solution

1. Step 1: Understand the step signal definition

   A step signal jumps suddenly from zero to one and remains at one indefinitely.

2. Step 2: Compare with other signals

   Sinusoidal oscillates, impulse is a short spike, ramp increases steadily.

3. Final Answer:

   Step signal -> Option B

4. Quick Check:

   Step signal = sudden jump and hold [OK]

Hint: Step signal jumps once and stays constant [OK]

Common Mistakes:

• Confusing impulse with step signal
• Thinking ramp is sudden jump
• Mixing sinusoidal oscillation with step

2. Which Python code snippet correctly generates a sinusoidal signal using numpy for time vector t?

easy

A. signal = np.sin(2 * np.pi * f * t)

B. signal = np.step(2 * np.pi * f * t)

C. signal = np.impulse(2 * np.pi * f * t)

D. signal = np.ramp(2 * np.pi * f * t)

Solution

1. Step 1: Recall numpy functions for signals

   NumPy has np.sin() for sinusoidal signals; no step, impulse, or ramp functions exist.

2. Step 2: Verify syntax correctness

   signal = np.sin(2 * np.pi * f * t) uses np.sin() correctly with frequency and time vector.

3. Final Answer:

   signal = np.sin(2 * np.pi * f * t) -> Option A

4. Quick Check:

   Sinusoidal uses np.sin() [OK]

Hint: Sinusoidal signal uses np.sin() function [OK]

Common Mistakes:

• Using non-existent numpy functions like np.step
• Confusing impulse or ramp with sinusoidal
• Incorrect function names or syntax

3. What is the output of the following Python code snippet?

import numpy as np
import matplotlib.pyplot as plt
t = np.linspace(0, 1, 5)
signal = np.heaviside(t - 0.5, 1)
print(signal)

medium

A. [0. 0. 0. 0. 0.]

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

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

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

Solution

1. Step 1: Understand np.heaviside behavior

   np.heaviside(x, 1) returns 0 if x<0, 1 if x>0, and 1 if x=0 (due to second argument).

2. Step 2: Calculate t - 0.5 values and apply heaviside

   t = [0, 0.25, 0.5, 0.75, 1]; t-0.5 = [-0.5, -0.25, 0, 0.25, 0.5]; heaviside gives [0, 0, 1, 1, 1].

3. Final Answer:

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

4. Quick Check:

   Heaviside step at 0.5 = [0,0,1,1,1] [OK]

Hint: Heaviside outputs 0 before step, 1 at and after step [OK]

Common Mistakes:

• Forgetting heaviside returns 1 at zero input
• Miscomputing t vector values
• Confusing output with impulse or ramp

4. The following code is intended to create an impulse signal at t=0 but does not work as expected. What is the error?

import numpy as np
import matplotlib.pyplot as plt
t = np.linspace(-1, 1, 4)
signal = np.zeros_like(t)
signal[t == 0] = 1
print(signal)

medium

A. The assignment 'signal[t == 0] = 1' syntax is invalid.

B. np.zeros_like(t) creates an array of ones, not zeros.

C. The time vector 't' should be integers, not floats.

D. The condition 't == 0' fails due to floating point precision.

Solution

1. Step 1: Understand floating point comparison issue

   Floating point numbers may not exactly equal zero due to precision, so 't == 0' can fail.

2. Step 2: Check the time vector values

   t = [-1. , -0.33333333, 0.33333333, 1. ]; none exactly equal 0, so 't == 0' is False everywhere and assignment does nothing.

3. Final Answer:

   The condition 't == 0' fails due to floating point precision. -> Option D

4. Quick Check:

   Floating point equality check often fails [OK]

Hint: Avoid exact float equality; use tolerance [OK]

Common Mistakes:

• Assuming 't == 0' always works
• Misunderstanding zeros_like function
• Incorrect syntax in assignment

5. You want to create a ramp signal that starts at zero and increases by 2 units every second for 5 seconds. Which Python code correctly generates this ramp signal using numpy?

hard

A. t = np.arange(0, 5, 1)
signal = 2 * t

B. t = np.linspace(0, 5, 5)
signal = np.sin(2 * np.pi * t)

C. t = np.arange(0, 5, 1)
signal = np.heaviside(t, 1)

D. t = np.linspace(0, 5, 5)
signal = np.zeros_like(t)

Solution

1. Step 1: Understand ramp signal definition

   A ramp signal increases steadily; here by 2 units per second means signal = 2 * time.

2. Step 2: Check code correctness

   t = np.arange(0, 5, 1) signal = 2 * t uses np.arange for time steps 0 to 4 and multiplies by 2, correctly creating the ramp.

3. Final Answer:

   t = np.arange(0, 5, 1) signal = 2 * t -> Option A

4. Quick Check:

   Ramp = constant slope * time [OK]

Hint: Ramp = slope times time vector [OK]

Common Mistakes:

• Using sinusoidal or step functions instead of ramp
• Incorrect time vector creation
• Using zeros instead of increasing values