IIR filter implementation in Signal Processing

Introduction

An IIR filter helps to remove unwanted parts of a signal, like noise, by using past inputs and outputs.

You want to clean audio recordings by reducing background noise.

You need to smooth sensor data in a wearable device.

You want to extract a specific frequency range from a signal.

You want to reduce sudden spikes in temperature readings.

You want to process real-time signals efficiently with less memory.

Syntax

Signal Processing

y[n] = (b0 * x[n]) + (b1 * x[n-1]) + ... - (a1 * y[n-1]) - (a2 * y[n-2]) - ...

x[n] is the current input sample.

y[n] is the current output sample.

Coefficients b are for input, a for output feedback.

Examples

This example uses one past input and one past output to calculate the current output.

Signal Processing

y[n] = 0.5 * x[n] + 0.5 * x[n-1] - 0.3 * y[n-1]

This uses two past inputs and two past outputs for a smoother filter effect.

Signal Processing

y[n] = 0.2 * x[n] + 0.2 * x[n-1] + 0.2 * x[n-2] - 0.4 * y[n-1] - 0.1 * y[n-2]

Sample Program

This code creates a noisy sine wave and applies a simple IIR low-pass filter to reduce noise. The plot shows the original noisy signal and the smoother filtered signal.

Signal Processing

import numpy as np
import matplotlib.pyplot as plt

# Sample input signal: noisy sine wave
fs = 100  # Sampling frequency
f = 5     # Signal frequency
t = np.arange(0, 1, 1/fs)
x = np.sin(2 * np.pi * f * t) + 0.5 * np.random.randn(len(t))

# IIR filter coefficients (simple low-pass)
b = [0.2929, 0.2929]  # feedforward coefficients
a = [-0.4142]         # feedback coefficients

# Initialize output array
y = np.zeros_like(x)

# Apply IIR filter
for n in range(len(x)):
    x_n = x[n]
    x_n_1 = x[n-1] if n-1 >= 0 else 0
    y_n_1 = y[n-1] if n-1 >= 0 else 0
    y[n] = b[0]*x_n + b[1]*x_n_1 - a[0]*y_n_1

# Plot input and filtered output
plt.plot(t, x, label='Noisy Input')
plt.plot(t, y, label='Filtered Output')
plt.legend()
plt.xlabel('Time (seconds)')
plt.title('IIR Filter Example')
plt.show()

Important Notes

IIR filters use feedback, so past outputs affect current output.

Be careful with coefficients to keep the filter stable.

Initial past values are often set to zero at the start.

Summary

IIR filters use past inputs and outputs to process signals.

They are good for real-time filtering with less memory.

Choosing correct coefficients is important for good results.

Practice

1. What does an IIR filter use to calculate its current output?
y[n] = b0*x[n] + b1*x[n-1] + a1*y[n-1]

easy

A. Only past inputs

B. Only current input

C. Only past outputs

D. Both current and past inputs and past outputs

Solution

1. Step 1: Understand the difference equation

   The equation shows output y[n] depends on current input x[n], past input x[n-1], and past output y[n-1].

2. Step 2: Identify used terms in calculation

   Since both inputs (current and past) and past outputs are used, the filter uses all these values.

3. Final Answer:

   Both current and past inputs and past outputs -> Option D

4. Quick Check:

   Uses current input x[n], past input x[n-1], past output y[n-1] = D [OK]

Hint: Look for both x and y terms in the equation [OK]

Common Mistakes:

• Thinking IIR uses only inputs
• Confusing IIR with FIR filters
• Ignoring past output terms

2. Which of the following is the correct Python syntax to implement one step of an IIR filter with coefficients b0, b1, a1 and inputs x and outputs y arrays?

easy

A. y[n] = b0*x[n] + b1*x[n-1] + a1*y[n-1]

B. y[n] == b0*x[n] + b1*x[n-1] + a1*y[n-1]

C. y[n] := b0*x[n] + b1*x[n-1] + a1*y[n-1]

D. y[n] = b0*x[n] + b1*x[n] + a1*y[n]

Solution

1. Step 1: Check assignment operator

   Python uses single equals sign '=' for assignment, so '==' and ':=' are incorrect here.

2. Step 2: Verify correct indexing and coefficients

   y[n] = b0*x[n] + b1*x[n-1] + a1*y[n-1] correctly uses x[n], x[n-1], y[n-1] with proper coefficients. y[n] = b0*x[n] + b1*x[n] + a1*y[n] incorrectly uses x[n] twice and y[n] instead of y[n-1].

3. Final Answer:

   y[n] = b0*x[n] + b1*x[n-1] + a1*y[n-1] -> Option A

4. Quick Check:

   Assignment uses '=' and correct indices = C [OK]

Hint: Remember Python uses '=' for assignment, not '==' or ':=' [OK]

Common Mistakes:

• Using '==' instead of '=' for assignment
• Mixing up indices like y[n] vs y[n-1]
• Using wrong operators like ':='

3. Given the Python code below, what is the output of y after running the loop?

import numpy as np
b0, b1, a1 = 0.5, 0.3, 0.2
x = np.array([1, 2, 3, 4])
y = np.zeros_like(x, dtype=float)
y[0] = b0 * x[0]
for n in range(1, len(x)):
    y[n] = b0*x[n] + b1*x[n-1] + a1*y[n-1]

medium

A. [0.5, 1.3, 2.1, 3.0]

B. [0.5, 1.4, 2.38, 3.376]

C. [0.5, 1.0, 1.5, 2.0]

D. [0.5, 2.0, 3.0, 4.0]

Solution

1. Step 1: Calculate y[0]

   y[0] = 0.5 * 1 = 0.5

2. Step 2: Calculate y[1]

   y[1] = 0.5*2 + 0.3*1 + 0.2*0.5 = 1.0 + 0.3 + 0.1 = 1.4

3. Step 3: Calculate y[2]

   y[2] = 0.5*3 + 0.3*2 + 0.2*1.4 = 1.5 + 0.6 + 0.28 = 2.38

4. Step 4: Calculate y[3]

   y[3] = 0.5*4 + 0.3*3 + 0.2*2.38 = 2.0 + 0.9 + 0.476 = 3.376

5. Final Answer:

   [0.5, 1.4, 2.38, 3.376] -> Option B

6. Quick Check:

   Apply formula stepwise = A [OK]

Hint: Calculate step-by-step using previous y values [OK]

Common Mistakes:

• Ignoring previous output y[n-1]
• Using wrong indices for x or y
• Rounding errors in calculations

4. Identify the error in this IIR filter Python code snippet:

y = [0]*4
b0, b1, a1 = 0.5, 0.3, 0.2
x = [1, 2, 3, 4]
for n in range(1, 4):
    y[n] = b0*x[n] + b1*x[n-1] + a1*y[n]

medium

A. Missing initialization of y[0]

B. Incorrect range in for loop

C. Using y[n] on right side instead of y[n-1]

D. Using list instead of numpy array

Solution

1. Step 1: Analyze the difference equation implementation

   The formula should use previous output y[n-1], but code uses y[n] on right side, causing circular dependency.

2. Step 2: Check other parts

   Range(1,4) is correct for indices 1 to 3.
   y[0] is initialized to 0, so no missing initialization.
   Using list is allowed but less efficient; not an error.

3. Final Answer:

   Using y[n] on right side instead of y[n-1] -> Option C

4. Quick Check:

   Previous output must be y[n-1], not y[n] = A [OK]

Hint: Check if past output uses correct index y[n-1] [OK]

Common Mistakes:

• Using current output y[n] in calculation
• Forgetting to initialize y[0]
• Wrong loop range causing index errors

5. You want to implement a second-order IIR filter with coefficients:
b0=0.2, b1=0.1, b2=0.1, a1=0.3, a2=0.4
Given input signal x = [1, 2, 3, 4, 5], which Python code correctly computes the output y using the difference equation:
y[n] = b0*x[n] + b1*x[n-1] + b2*x[n-2] + a1*y[n-1] + a2*y[n-2]?

hard

A. y = [0]*5
y[0] = b0*x[0]
y[1] = b0*x[1] + b1*x[0] + a1*y[0]
for n in range(2, 5):
y[n] = b0*x[n] + b1*x[n-1] + b2*x[n-2] + a1*y[n-1] + a2*y[n-2]

B. y = [0]*5
for n in range(2, 5):
y[n] = b0*x[n] + b1*x[n-1] + b2*x[n-2] + a1*y[n-1] + a2*y[n-2]

C. y = [0]*5
for n in range(0, 5):
y[n] = b0*x[n] + b1*x[n-1] + b2*x[n-2] + a1*y[n-1] + a2*y[n-2]

D. y = [0]*5
y[0] = b0*x[0]
for n in range(1, 5):
y[n] = b0*x[n] + b1*x[n-1] + b2*x[n-2] + a1*y[n-1] + a2*y[n-2]

Solution

1. Step 1: Handle initial conditions for n=0 and n=1

   For n=0, only x[0] is valid, so y[0] = b0*x[0].
   For n=1, x[1], x[0], y[0] exist, so y[1] = b0*x[1] + b1*x[0] + a1*y[0].

2. Step 2: Loop from n=2 to 4 for full difference equation

   From n=2 onwards, all terms x[n-2], y[n-2] exist.
   y = [0]*5 y[0] = b0*x[0] y[1] = b0*x[1] + b1*x[0] + a1*y[0] for n in range(2, 5): y[n] = b0*x[n] + b1*x[n-1] + b2*x[n-2] + a1*y[n-1] + a2*y[n-2] correctly initializes y[0], y[1] and loops from 2 to 4.

3. Step 3: Check other options

   y = [0]*5 for n in range(2, 5): y[n] = b0*x[n] + b1*x[n-1] + b2*x[n-2] + a1*y[n-1] + a2*y[n-2] misses initial y[0], y[1] initialization.
   y = [0]*5 for n in range(0, 5): y[n] = b0*x[n] + b1*x[n-1] + b2*x[n-2] + a1*y[n-1] + a2*y[n-2] loops from 0 and uses negative indices causing errors.
   y = [0]*5 y[0] = b0*x[0] for n in range(1, 5): y[n] = b0*x[n] + b1*x[n-1] + b2*x[n-2] + a1*y[n-1] + a2*y[n-2] misses y[1] initialization and uses range(1,5) which fails at n=1 for x[n-2].

4. Final Answer:

   Code with y[0] and y[1] explicitly initialized before loop from n=2 -> Option A

5. Quick Check:

   Initialize first two outputs before loop = B [OK]

Hint: Initialize first two outputs before looping from n=2 [OK]

Common Mistakes:

• Not initializing y[0] and y[1] before loop
• Using negative indices without checks
• Looping from 0 causing index errors