Phase Spectrum and Group Delay: Theory and Python Implementation

Introduction

When performing spectral analysis with the Fast Fourier Transform (FFT), the result is commonly displayed as a magnitude spectrum showing how much power each frequency component carries. However, the Fourier transform output is complex-valued, and alongside the magnitude it encodes a phase spectrum that is equally important yet frequently overlooked.

Why does phase matter in practice?

Consider applying a Butterworth filter to a speech or biomedical signal. Even when the magnitude response is nearly ideal, the filtered waveform can exhibit visible distortion — transients spread out, sharp edges become blurred, and the temporal relationships between frequency components are altered. This distortion arises entirely from the filter’s nonlinear phase response: different frequency components are delayed by different amounts as they pass through the filter. The quantity that captures this frequency-dependent delay is the group delay.

This article provides a systematic treatment of phase spectrum and group delay: their mathematical definitions, the physical interpretation of group delay as signal travel time, the linear phase property of FIR filters, the nonlinear phase distortion inherent to IIR filters, and the use of all-pass filters for phase equalization — all illustrated with Python implementations using scipy.signal.

Phase Spectrum: Definition and Properties

Complex Frequency Response and Phase

The frequency response of a discrete-time linear filter evaluated on the unit circle is:

where \(\omega \in [0, \pi]\) is the normalized angular frequency (\(\omega = \pi\) corresponds to the Nyquist frequency), and:

• \(|H(e^{j\omega})|\) — magnitude response: the gain applied to each frequency component
• \(\phi(\omega) = \angle H(e^{j\omega})\) — phase response: the phase shift imparted to each frequency component

The phase response is computed as:

Wrapped vs. Unwrapped Phase

Because \(\arctan\) has range \((-\pi, \pi]\) , the directly computed phase is wrapped: it exhibits artificial \(\pm\pi\) discontinuities even when the true underlying phase varies continuously. For instance, a continuously decreasing phase may appear as \(-3.10 \to -3.14 \to 3.12 \to 3.10\) , with a \(2\pi\) jump at the boundary.

The unwrapped phase removes these discontinuities by adding the appropriate integer multiples of \(2\pi\) :

In Python, np.unwrap() performs this operation automatically. Unwrapped phase is essential for meaningful group delay computation, since numerical differentiation of the wrapped phase produces large spurious spikes at each \(2\pi\) discontinuity.

Linear Phase and Nonlinear Phase

The most significant distinction in filter phase behavior is between linear phase and nonlinear phase.

A filter has linear phase if:

where \(\tau_0\) is a constant called the phase delay. In this case, every frequency component is shifted by a phase proportional to its frequency — which is mathematically equivalent to a pure time delay of \(\tau_0\) samples. The output waveform is an exact replica of the input, shifted in time.

A filter has nonlinear phase when \(\phi(\omega)\) deviates from a straight line. In this case, the delay experienced by each frequency component differs, and a waveform composed of multiple frequencies will emerge distorted.

Group Delay: Definition and Physical Interpretation

Mathematical Definition

The group delay is defined as the negative derivative of the phase response with respect to angular frequency:

Group delay has units of samples (or seconds when multiplied by the sampling period \(T_s = 1/f_s\) ). When \(\tau_g(\omega) = \tau_0\) (constant), the filter has linear phase. When \(\tau_g(\omega)\) varies with \(\omega\) , the filter has nonlinear phase and introduces group delay distortion.

Substituting the linear phase condition \(\phi(\omega) = -\omega \tau_0\) into equation \((5)\) confirms:

Physical Interpretation: Envelope Delay

The physical meaning of group delay becomes clear by examining a narrowband signal — a slowly modulated carrier:

where \(a(t)\) is the slowly varying envelope and \(\omega_0\) is the carrier frequency. After passing through a filter \(H\) , the output is approximately:

The envelope \(a(t)\) is delayed by the group delay \(\tau_g(\omega_0)\) , while the carrier is phase-shifted by \(\phi(\omega_0)\) . Thus, the group delay quantifies how many samples (or seconds) a signal packet centered at frequency \(\omega_0\) is delayed by the filter.

If group delay is frequency-independent (linear phase), all signal packets arrive at the output simultaneously and the waveform is preserved. If group delay varies with frequency (group delay distortion), different frequency bands arrive at different times, causing the output waveform to be stretched, smeared, or distorted relative to the input.

Consequences of Group Delay Distortion

Group delay distortion causes problems in many practical applications:

• Waveform distortion: A square wave contains harmonics at odd multiples of the fundamental. If high harmonics are delayed more than the fundamental (or vice versa), the reconstructed waveform loses its sharp edges.
• Biomedical signal processing: In ECG analysis, the shape of the QRS complex is diagnostically significant. Phase distortion can alter the morphology of these transient waveforms, potentially affecting automated detection algorithms.
• Audio systems: Group delay variations across the audio band cause audible coloration — transients lose crispness, and the perceived spatial localization of sounds may shift.
• Digital communications: In bandlimited channels, frequency-dependent group delay causes inter-symbol interference (ISI), spreading each transmitted symbol into adjacent time slots.
• Feedback control: In closed-loop systems, group delay constitutes a frequency-dependent phase lag that erodes phase margin and can destabilize the loop.

Linear Phase FIR Filters

Why Symmetric Coefficients Guarantee Linear Phase

An \(N\) -tap FIR filter with impulse response \(h[n]\) has transfer function:

If the coefficients satisfy the even symmetry condition:

then the frequency response can be factored as:

where \(A(\omega)\) is a real-valued amplitude function. This factorization shows that the phase response is:

In the passband where \(A(\omega) > 0\) , the phase is exactly linear: \(\phi(\omega) = -\frac{N-1}{2}\omega\) . The group delay is therefore constant:

A key insight is that the group delay equals half the filter length minus one. A 65-tap FIR filter introduces a fixed delay of 32 samples at all frequencies within the passband — a pure time shift, with no waveform distortion.

The Four Types of Linear Phase FIR Filters

Linear phase FIR filters are classified into four types based on coefficient symmetry and filter length parity:

Type I is the most commonly used for general-purpose filtering. scipy.signal.firwin produces Type I or II filters depending on whether the specified number of taps is odd or even.

Zero-Phase Filtering for Offline Processing

The constant group delay of a linear phase FIR filter is \(\frac{N-1}{2}\) samples — a non-zero delay. In offline processing where causality is not required, this delay can be eliminated entirely using forward-backward filtering:

1. Filter the signal in the forward direction to obtain \(y_1[n]\)
2. Reverse \(y_1[n]\)
3. Filter again in the forward direction, then reverse again

The net result has zero phase shift and a squared magnitude response:

scipy.signal.filtfilt implements this procedure. It doubles the effective filter order and cannot be used for real-time (causal) processing, but it completely eliminates phase distortion.

Nonlinear Phase in IIR Filters

Why IIR Filters Cannot Achieve Linear Phase

An IIR filter with rational transfer function:

has poles located inside the unit circle. The phase response of \(H(e^{j\omega})\) can be decomposed as a sum of contributions from each zero and pole:

where \(z_k\) and \(p_k\) are the zeros and poles respectively. Since the poles are located asymmetrically relative to the unit circle (they are inside it, with no mirror-image poles outside), the phase response is generally a nonlinear function of \(\omega\) . This is a fundamental property of stable IIR filters — it cannot be circumvented by choice of filter coefficients.

Group Delay Comparison of Classical IIR Filters

The following table summarizes the group delay characteristics of classical IIR filter designs:

The Bessel filter is designed with the explicit objective of maximizing the flatness of group delay in the passband (Maximally Flat Group Delay criterion). It achieves the best time-domain waveform fidelity among IIR filters, at the cost of a very gradual transition between passband and stopband.

The Fundamental Trade-off

The relationship between magnitude sharpness and group delay flatness represents a fundamental trade-off in IIR filter design:

• Sharper amplitude transition → more poles clustered near the unit circle in the transition region → larger group delay variation
• Flatter group delay → poles more evenly distributed → gentler amplitude roll-off

When both sharp magnitude cutoff and flat group delay are required simultaneously, the only general solution is to use an IIR filter for amplitude shaping followed by an all-pass filter for phase equalization.

All-Pass Filters for Phase Equalization

Definition and Transfer Function

An all-pass filter (APF) has unit magnitude response at all frequencies:

while its phase response — and therefore its group delay — can be freely shaped by choice of pole/zero locations. The first-order all-pass filter transfer function is:

This filter has a zero at \(z = 1/a\) (outside the unit circle) and a pole at \(z = a\) (inside the unit circle), placed in a mirror-image relationship with respect to the unit circle. This mirror-image placement ensures that the magnitude response is identically 1 for all \(\omega\) .

For a complex pole at \(z = re^{j\theta}\) (\(r < 1\) ), the all-pass filter and its complex conjugate are combined into a second-order real-coefficient all-pass filter:

The practical second-order implementation with real coefficients is:

Phase and Group Delay of the First-Order All-Pass Filter

For the first-order all-pass filter with real coefficient \(a\) (\(0 < a < 1\) ), the phase response is:

The group delay is:

This is always positive (the all-pass filter only adds delay, never advances the signal), and exhibits a peak near \(\omega = 0\) . For the second-order filter, the peak is located near \(\omega = \theta\) (the angle of the pole), and its height is controlled by \(r\) (the pole radius). A value of \(r\) close to 1 produces a sharp, tall peak; a smaller \(r\) gives a broad, low peak.

Group Delay Equalization Strategy

Phase equalization using all-pass filters follows this procedure:

1. Measure the group delay \(\tau_g^{\text{target}}(\omega)\) of the IIR filter to be equalized using scipy.signal.group_delay.
2. Identify the frequency regions where \(\tau_g^{\text{target}}(\omega)\) is smallest relative to the maximum — these are the regions where additional delay needs to be added.
3. Design all-pass sections (choosing \(r\) and \(\theta\) for each second-order section) to add delay in these regions, bringing the total group delay closer to a flat response.
4. Cascade the all-pass sections after the original IIR filter.

Since \(|H_{AP}| = 1\) , the amplitude response of the original filter is preserved exactly. The equalization is imperfect in general (particularly at the passband edge), but significant improvement is achievable with a few all-pass sections.

Python Implementation

Setup: Library Imports

import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import butter, sosfilt, freqz, firwin, group_delay, lfilter, iirfilter
from scipy.signal import cheby1, ellip, bessel

Phase Response: Wrapped vs. Unwrapped

# --- Filter design ---
fs = 1000          # sampling frequency [Hz]
fc = 100           # cutoff frequency [Hz]
N_iir = 8          # IIR filter order
N_fir = 64         # FIR filter tap count

# Butterworth IIR filter (ba form)
b_iir, a_iir = butter(N_iir, fc, fs=fs, output='ba')

# Linear-phase FIR filter (Hamming window)
b_fir = firwin(N_fir, fc, fs=fs, window='hamming')
a_fir = np.array([1.0])

# --- Frequency response ---
worN = 4096
w, H_iir = freqz(b_iir, a_iir, worN=worN, fs=fs)
_, H_fir = freqz(b_fir, a_fir, worN=worN, fs=fs)

# --- Phase computation ---
phase_iir_wrapped = np.angle(H_iir)          # wrapped phase
phase_iir = np.unwrap(np.angle(H_iir))       # unwrapped phase
phase_fir = np.unwrap(np.angle(H_fir))       # FIR (linear phase)

# --- Plot ---
fig, axes = plt.subplots(3, 1, figsize=(10, 10))

# Magnitude
axes[0].plot(w, 20 * np.log10(np.abs(H_iir) + 1e-12),
             label=f'IIR Butterworth N={N_iir}')
axes[0].plot(w, 20 * np.log10(np.abs(H_fir) + 1e-12),
             label=f'FIR Hamming {N_fir} taps', linestyle='--')
axes[0].set_xlabel('Frequency [Hz]')
axes[0].set_ylabel('Magnitude [dB]')
axes[0].set_title('Magnitude Response')
axes[0].set_xlim(0, fs / 2)
axes[0].set_ylim(-80, 5)
axes[0].axvline(fc, color='gray', linestyle=':', alpha=0.5, label='Cutoff')
axes[0].legend()
axes[0].grid(True, alpha=0.3)

# Wrapped vs unwrapped phase (IIR)
axes[1].plot(w, np.degrees(phase_iir_wrapped),
             label='IIR (wrapped)', color='orange')
axes[1].plot(w, np.degrees(phase_iir),
             label='IIR (unwrapped)', color='blue')
axes[1].set_xlabel('Frequency [Hz]')
axes[1].set_ylabel('Phase [degrees]')
axes[1].set_title('Phase Response: Wrapped vs Unwrapped (IIR Butterworth)')
axes[1].set_xlim(0, fs / 2)
axes[1].legend()
axes[1].grid(True, alpha=0.3)

# IIR vs FIR phase
axes[2].plot(w, np.degrees(phase_iir),
             label=f'IIR Butterworth N={N_iir} (nonlinear)')
axes[2].plot(w, np.degrees(phase_fir),
             label=f'FIR Hamming {N_fir} taps (linear)', linestyle='--')
axes[2].set_xlabel('Frequency [Hz]')
axes[2].set_ylabel('Phase [degrees]')
axes[2].set_title('Phase Response: IIR vs FIR')
axes[2].set_xlim(0, fs / 2)
axes[2].legend()
axes[2].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

Group Delay Calculation and Comparison

# --- Group delay via scipy.signal.group_delay ---
worN = 4096
w_gd, gd_iir = group_delay((b_iir, a_iir), w=worN, fs=fs)
w_gd, gd_fir = group_delay((b_fir, a_fir), w=worN, fs=fs)

# --- Finite difference approximation (for illustration) ---
w_arr, H_iir_arr = freqz(b_iir, a_iir, worN=worN * 2, fs=fs)
omega_arr = w_arr * 2 * np.pi / fs   # Hz → rad/sample
phase_arr = np.unwrap(np.angle(H_iir_arr))

# τ_g(ω) ≈ −Δφ/Δω
gd_diff = -np.diff(phase_arr) / np.diff(omega_arr)
w_diff = (w_arr[:-1] + w_arr[1:]) / 2   # midpoints

# --- Plot ---
fig, axes = plt.subplots(2, 1, figsize=(10, 8))

axes[0].plot(w_gd, gd_iir,
             label=f'IIR Butterworth N={N_iir}', color='blue')
axes[0].plot(w_gd, gd_fir,
             label=f'FIR Hamming {N_fir} taps (constant = {(N_fir-1)/2:.1f} samples)',
             linestyle='--', color='red')
axes[0].axhline((N_fir - 1) / 2, color='red', linestyle=':', alpha=0.5)
axes[0].set_xlabel('Frequency [Hz]')
axes[0].set_ylabel('Group Delay [samples]')
axes[0].set_title('Group Delay: IIR vs FIR')
axes[0].set_xlim(0, fs / 2)
axes[0].set_ylim(-5, 50)
axes[0].legend()
axes[0].grid(True, alpha=0.3)

axes[1].plot(w_diff, gd_diff,
             label='IIR (finite difference)', color='purple', alpha=0.7)
axes[1].plot(w_gd, gd_iir,
             label='IIR (scipy.signal.group_delay)', color='blue', linestyle='--')
axes[1].set_xlabel('Frequency [Hz]')
axes[1].set_ylabel('Group Delay [samples]')
axes[1].set_title('Group Delay: Finite Difference vs scipy.signal.group_delay')
axes[1].set_xlim(0, fs / 2)
axes[1].set_ylim(-5, 50)
axes[1].legend()
axes[1].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

The FIR filter maintains a constant group delay of exactly \((N-1)/2 = 31.5\) samples across all frequencies, while the Butterworth IIR filter shows a pronounced group delay peak near the cutoff frequency, dropping back to a lower value in the deep stopband.

Waveform Distortion Due to Phase Nonlinearity

# --- Test signal: sum of harmonics ---
fs = 1000
t = np.arange(0, 0.5, 1/fs)

# Multicomponent signal (10, 30, 50, 70, 90 Hz)
freqs_sig = [10, 30, 50, 70, 90]
x = sum(np.sin(2 * np.pi * f * t) / f for f in freqs_sig)

# --- Filtering ---
fc_test = 200   # high cutoff — all components pass through

# IIR Butterworth (nonlinear phase)
b_iir_t, a_iir_t = butter(6, fc_test, fs=fs, output='ba')
y_iir = lfilter(b_iir_t, a_iir_t, x)

# FIR linear-phase filter
b_fir_t = firwin(101, fc_test, fs=fs, window='hamming')
y_fir = lfilter(b_fir_t, [1.0], x)

# Compensate FIR group delay shift
fir_delay = 50   # (101 - 1) / 2 = 50 samples
y_fir_aligned = np.concatenate([y_fir[fir_delay:], np.zeros(fir_delay)])

# --- Plot ---
fig, axes = plt.subplots(3, 1, figsize=(12, 8), sharex=True)

axes[0].plot(t, x, 'k', linewidth=1.5)
axes[0].set_title('Original Signal (10 + 30 + 50 + 70 + 90 Hz)')
axes[0].set_ylabel('Amplitude')
axes[0].grid(True, alpha=0.3)

axes[1].plot(t, y_iir, color='blue')
axes[1].plot(t, x, 'k--', alpha=0.3, linewidth=1, label='Original')
axes[1].set_title('After IIR Butterworth (nonlinear phase — waveform distorted)')
axes[1].set_ylabel('Amplitude')
axes[1].legend()
axes[1].grid(True, alpha=0.3)

axes[2].plot(t, y_fir_aligned, color='red')
axes[2].plot(t, x, 'k--', alpha=0.3, linewidth=1, label='Original')
axes[2].set_title('After FIR linear-phase (delay-corrected — shape preserved)')
axes[2].set_xlabel('Time [s]')
axes[2].set_ylabel('Amplitude')
axes[2].legend()
axes[2].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

All-Pass Filter Design and Phase Equalization

def allpass_filter_2nd(r, theta):
    """
    Compute second-order all-pass filter coefficients.

    Transfer function:
        H_AP(z) = (r^2 - 2r*cos(θ)*z^{-1} + z^{-2})
                / (1 - 2r*cos(θ)*z^{-1} + r^2*z^{-2})

    Parameters
    ----------
    r : float
        Pole radius (0 < r < 1). Larger r → sharper group delay peak.
    theta : float
        Pole angle in radians. Controls peak frequency location.

    Returns
    -------
    b, a : ndarray
        Numerator and denominator coefficients (b = numerator, a = denominator).
    """
    c = 2 * r * np.cos(theta)
    r2 = r ** 2
    b = np.array([r2, -c, 1.0])
    a = np.array([1.0, -c, r2])
    return b, a


# --- All-pass filter characterization ---
worN = 4096
fig, axes = plt.subplots(3, 1, figsize=(10, 10))

r_values = [0.5, 0.7, 0.9]
theta_ap = np.pi / 4   # peak group delay near ω = π/4

for r in r_values:
    b_ap, a_ap = allpass_filter_2nd(r, theta_ap)
    w_ap, H_ap = freqz(b_ap, a_ap, worN=worN, fs=fs)
    w_gd_ap, gd_ap = group_delay((b_ap, a_ap), w=worN, fs=fs)

    axes[0].plot(w_ap, 20 * np.log10(np.abs(H_ap) + 1e-12), label=f'r={r}')
    axes[1].plot(w_ap, np.degrees(np.unwrap(np.angle(H_ap))), label=f'r={r}')
    axes[2].plot(w_gd_ap, gd_ap, label=f'r={r}')

axes[0].set_title('All-Pass Filter: Magnitude Response (must be 0 dB)')
axes[0].set_xlabel('Frequency [Hz]')
axes[0].set_ylabel('Magnitude [dB]')
axes[0].set_ylim(-3, 3)
axes[0].legend()
axes[0].grid(True, alpha=0.3)

axes[1].set_title('All-Pass Filter: Phase Response')
axes[1].set_xlabel('Frequency [Hz]')
axes[1].set_ylabel('Phase [degrees]')
axes[1].legend()
axes[1].grid(True, alpha=0.3)

axes[2].set_title('All-Pass Filter: Controllable Group Delay Peak')
axes[2].set_xlabel('Frequency [Hz]')
axes[2].set_ylabel('Group Delay [samples]')
axes[2].set_ylim(0, 30)
axes[2].legend()
axes[2].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# --- Phase equalization: Butterworth + all-pass filter ---
fs = 1000
fc = 100
N_butter = 6

b_butter, a_butter = butter(N_butter, fc, fs=fs, output='ba')
w_hz, gd_butter = group_delay((b_butter, a_butter), w=4096, fs=fs)

# Design all-pass sections to flatten the group delay
r_ap = 0.65
theta_ap1 = 2 * np.pi * (fc * 0.9) / fs   # near cutoff
theta_ap2 = 2 * np.pi * (fc * 0.7) / fs   # slightly below cutoff

b_ap1, a_ap1 = allpass_filter_2nd(r_ap, theta_ap1)
b_ap2, a_ap2 = allpass_filter_2nd(r_ap, theta_ap2)

# Cascade: convolve coefficients
b_total = np.convolve(np.convolve(b_butter, b_ap1), b_ap2)
a_total = np.convolve(np.convolve(a_butter, a_ap1), a_ap2)

w_hz, gd_total = group_delay((b_total, a_total), w=4096, fs=fs)
w_hz, gd_ap1 = group_delay((b_ap1, a_ap1), w=4096, fs=fs)
w_hz, gd_ap2 = group_delay((b_ap2, a_ap2), w=4096, fs=fs)

fig, axes = plt.subplots(2, 1, figsize=(10, 8))

# Magnitude response (all-pass sections should not affect amplitude)
w_hz_mag, H_butter = freqz(b_butter, a_butter, worN=4096, fs=fs)
_, H_total = freqz(b_total, a_total, worN=4096, fs=fs)
axes[0].plot(w_hz_mag,
             20 * np.log10(np.abs(H_butter) + 1e-12),
             label='Butterworth only', color='blue')
axes[0].plot(w_hz_mag,
             20 * np.log10(np.abs(H_total) + 1e-12),
             label='Butterworth + APF (equalized)', color='red', linestyle='--')
axes[0].set_xlabel('Frequency [Hz]')
axes[0].set_ylabel('Magnitude [dB]')
axes[0].set_title('Magnitude Response: All-Pass Equalization Preserves Amplitude')
axes[0].set_xlim(0, fs / 2)
axes[0].set_ylim(-80, 5)
axes[0].legend()
axes[0].grid(True, alpha=0.3)

# Group delay comparison
axes[1].plot(w_hz, gd_butter,
             label=f'Butterworth N={N_butter}', color='blue')
axes[1].plot(w_hz, gd_ap1 + gd_ap2,
             label='APF contribution (ap1 + ap2)', color='green', linestyle='--')
axes[1].plot(w_hz, gd_total,
             label='Butterworth + APF (equalized)', color='red', linewidth=2)
axes[1].set_xlabel('Frequency [Hz]')
axes[1].set_ylabel('Group Delay [samples]')
axes[1].set_title('Group Delay Equalization with All-Pass Filter')
axes[1].set_xlim(0, fc * 2)
axes[1].set_ylim(0, 30)
axes[1].axvline(fc, color='gray', linestyle=':', alpha=0.5, label='Cutoff')
axes[1].legend()
axes[1].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

The equalized system (Butterworth + all-pass) shows a flatter group delay profile near the cutoff frequency, while the magnitude response remains unchanged — demonstrating the principle that amplitude and phase shaping can be decoupled using all-pass filters.

IIR Filter Group Delay Comparison

fs = 1000
fc = 100
N = 6

filters = {
    'Butterworth': butter(N, fc, fs=fs, output='ba'),
    'Chebyshev I (1 dB)': cheby1(N, 1, fc, fs=fs, output='ba'),
    'Elliptic (1 dB, 60 dB)': ellip(N, 1, 60, fc, fs=fs, output='ba'),
    'Bessel': bessel(N, fc, norm='mag', fs=fs, output='ba'),
}

fig, axes = plt.subplots(2, 1, figsize=(10, 8))

for name, (b, a) in filters.items():
    w_hz, H = freqz(b, a, worN=4096, fs=fs)
    w_gd, gd = group_delay((b, a), w=4096, fs=fs)
    axes[0].plot(w_hz, 20 * np.log10(np.abs(H) + 1e-12), label=name)
    axes[1].plot(w_gd, gd, label=name)

axes[0].set_xlabel('Frequency [Hz]')
axes[0].set_ylabel('Magnitude [dB]')
axes[0].set_title(f'Magnitude Response: IIR Filter Comparison (N={N}, fc={fc} Hz)')
axes[0].set_xlim(0, 300)
axes[0].set_ylim(-80, 5)
axes[0].axvline(fc, color='gray', linestyle=':', alpha=0.5)
axes[0].legend()
axes[0].grid(True, alpha=0.3)

axes[1].set_xlabel('Frequency [Hz]')
axes[1].set_ylabel('Group Delay [samples]')
axes[1].set_title('Group Delay: IIR Filter Comparison')
axes[1].set_xlim(0, 300)
axes[1].set_ylim(0, 50)
axes[1].axvline(fc, color='gray', linestyle=':', alpha=0.5)
axes[1].legend()
axes[1].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

The Bessel filter exhibits the flattest group delay across the passband, confirming its Maximally Flat Group Delay property. The elliptic filter achieves the steepest magnitude roll-off but at the cost of the largest group delay distortion — illustrating the fundamental sharpness-versus-phase-linearity trade-off.

Summary

Practical Filter Selection Guide

Related Articles

• Fast Fourier Transform (FFT): Theory and Python Implementation - The foundation of phase spectrum analysis.
• FIR and IIR Filter Comparison - Foundational comparison of FIR and IIR filter properties.
• Butterworth Filter Design: Theory and Python Implementation - Canonical example of IIR nonlinear phase behavior.
• Chebyshev Filter Design and Python Implementation - Sharper transition at the cost of greater group delay distortion.
• Elliptic Filter Design and Python Implementation - Minimum-order design with maximum group delay distortion.
• Bessel Filter Design and Python Implementation - Maximum-flat group delay IIR filter.
• Short-Time Fourier Transform (STFT): Theory and Python Implementation - Time-frequency analysis that captures phase evolution over time.
• Hilbert Transform and Instantaneous Frequency Analysis - Instantaneous phase and frequency, closely related to group delay concepts.

References

• Oppenheim, A. V., & Schafer, R. W. (2009). Discrete-Time Signal Processing (3rd ed.). Prentice Hall.
• Proakis, J. G., & Manolakis, D. G. (2006). Digital Signal Processing: Principles, Algorithms, and Applications (4th ed.). Pearson.
• Zölzer, U. (2011). DAFX: Digital Audio Effects (2nd ed.). Wiley.
• Smith, J. O. (2007). Introduction to Digital Filters with Audio Applications. W3K Publishing. https://ccrma.stanford.edu/~jos/filters/
• SciPy scipy.signal.group_delay documentation
• SciPy scipy.signal.freqz documentation