Design of Chebyshev Filters

Design specification

Designing a Chebyshev Type I low-pass filter requires the following four parameters:

• $\omega_p$: passband edge frequency (cutoff frequency)
• $\omega_s$: stopband edge frequency
• $R_p$: passband ripple [dB] (maximum attenuation within the passband)
• $A_s$: stopband attenuation [dB] (minimum attenuation within the stopband)

Order-determination formula

Order formula for Chebyshev Type I

The minimum order $n$ that meets a given specification can be computed from the following formula:

Comparison with Butterworth

For reference, the order formula for a Butterworth filter is:

In the Chebyshev formula the $\log$ is replaced by $\cosh^{-1}$. Since $\cosh^{-1}(x) \approx \log(2x)$ the numerators are nearly equal, but the denominator changes from $\log(\omega_s/\omega_p)$ to $\cosh^{-1}(\omega_s/\omega_p)$, so Chebyshev meets the same specification at a lower order (the exact reduction depends on the specification).

Numerical example

Specification: $R_p = 1$ dB, $A_s = 40$ dB, $\omega_s/\omega_p = 2$

Therefore $n = 5$ is required. For the same specification a Butterworth filter would need $n = 8$, so Chebyshev achieves it at a lower order.

Design procedure

Design example

Let us design a normalized Chebyshev Type I low-pass filter with a passband ripple of 1 dB and order $n = 6$.

Computing the parameters

Pole locations

(Left-half-plane poles only. $m = 3, 4, 5$ are conjugate poles and are omitted.)

Coefficients of the second-order sections

Python implementation

Design with SciPy

import numpy as np
from scipy.signal import cheby1, cheby1ord, freqs, tf2zpk

# Specification
Rp = 1.0    # passband ripple [dB]
As = 40.0   # stopband attenuation [dB]
wp = 1.0    # passband edge frequency [rad/s]
ws = 2.0    # stopband edge frequency [rad/s]

# Order determination
n, Wn = cheby1ord(wp, ws, Rp, As, analog=True)
print(f"Required order: {n}")
print(f"Cutoff frequency: {Wn:.4f} rad/s")

# Filter design
b, a = cheby1(n, Rp, Wn, btype='low', analog=True)
print(f"\nNumerator coefficients b: {b}")
print(f"Denominator coefficients a: {a}")

# Zero-pole-gain form
z, p, k = tf2zpk(b, a)
print(f"\nPoles:")
for i, pole in enumerate(p):
    print(f"  p{i}: {pole:.4f}, |p|={np.abs(pole):.4f}, Q={np.abs(pole)/(-2*pole.real):.2f}")

Converting poles to second-order sections

from scipy.signal import zpk2sos

# Convert to second-order-section form
sos = zpk2sos(z, p, k)

print("Second-order sections (sos):")
print("  [b0, b1, b2, a0, a1, a2]")
for i, section in enumerate(sos):
    print(f"  Section {i+1}: {section}")

# Convert to standard-form parameters
print("\nStandard-form parameters:")
for i, section in enumerate(sos):
    b0, b1, b2, a0, a1, a2 = section
    omega0 = np.sqrt(a2/a0)
    Q = omega0 / (a1/a0)
    print(f"  Section {i+1}: ω₀ = {omega0:.4f}, Q = {Q:.4f}")

Plotting the frequency response

import matplotlib.pyplot as plt

# Frequency response
w = np.logspace(-1, 1, 500)
w, H = freqs(b, a, w)

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

# Magnitude response
ax1.semilogx(w, 20*np.log10(np.abs(H)))
ax1.axhline(-Rp, color='r', linestyle='--', label=f'Passband ripple ({-Rp} dB)')
ax1.axhline(-As, color='g', linestyle='--', label=f'Stopband attenuation ({-As} dB)')
ax1.axvline(wp, color='b', linestyle=':', alpha=0.5)
ax1.axvline(ws, color='b', linestyle=':', alpha=0.5)
ax1.set_ylabel('Magnitude [dB]')
ax1.set_ylim(-60, 5)
ax1.legend()
ax1.grid(True)

# Phase response
ax2.semilogx(w, np.unwrap(np.angle(H)) * 180/np.pi)
ax2.set_xlabel('Frequency [rad/s]')
ax2.set_ylabel('Phase [degrees]')
ax2.grid(True)

plt.tight_layout()
plt.show()

Component-value calculation (for Sallen-Key)

def sallen_key_components(omega0, Q, R):
    """
    Compute the component values of a Sallen-Key circuit (R1=R2=R)

    Parameters:
        omega0: natural angular frequency [rad/s]
        Q: Q factor
        R: resistance [Ω]

    Returns:
        C1, C2: capacitor values [F]
    """
    C2 = 1 / (2 * Q * omega0 * R)
    C1 = 2 * Q / (omega0 * R)
    return C1, C2

# Design example: 1 kHz cutoff, R = 10 kΩ
fc = 1000  # Hz
R = 10000  # Ω
omega_scale = 2 * np.pi * fc

print(f"Cutoff frequency: {fc} Hz")
print(f"Resistance: {R/1000} kΩ")
print()

for i, section in enumerate(sos):
    b0, b1, b2, a0, a1, a2 = section
    omega0_norm = np.sqrt(a2/a0)
    Q = omega0_norm / (a1/a0)
    omega0_actual = omega0_norm * omega_scale

    C1, C2 = sallen_key_components(omega0_actual, Q, R)

    print(f"Section {i+1}:")
    print(f"  ω₀ = {omega0_actual:.1f} rad/s ({omega0_actual/2/np.pi:.1f} Hz)")
    print(f"  Q = {Q:.3f}")
    print(f"  C₁ = {C1*1e9:.2f} nF")
    print(f"  C₂ = {C2*1e9:.2f} nF")
    print()

Designing a Type II filter

Designing a Chebyshev Type II (inverse Chebyshev) filter follows a similar procedure, but the parameters you specify are different.

Order-determination formula (Type II)

The Chebyshev order formula is common to Type I and Type II and involves both the passband ripple $R_p$ and the stopband attenuation $A_s$ (identical to Eq.\eqref{eq:order}):

Because the Type II passband is monotonic (maximally flat), $R_p$ is given as the allowed deviation at the passband edge. The Python example below uses 3 dB for the passband specification.

Python implementation (Type II)

from scipy.signal import cheby2, cheby2ord

# Specification
As = 40.0   # stopband attenuation [dB]
wp = 1.0    # passband edge frequency [rad/s]
ws = 2.0    # stopband edge frequency [rad/s]

# Order determination
n, Wn = cheby2ord(wp, ws, 3, As, analog=True)  # 3 dB is the passband
print(f"Required order: {n}")

# Filter design
b, a = cheby2(n, As, Wn, btype='low', analog=True)

# Frequency response
w = np.logspace(-1, 1, 500)
w, H = freqs(b, a, w)

plt.figure(figsize=(10, 4))
plt.semilogx(w, 20*np.log10(np.abs(H)))
plt.axhline(-As, color='r', linestyle='--', label=f'Stopband ({-As} dB)')
plt.xlabel('Frequency [rad/s]')
plt.ylabel('Magnitude [dB]')
plt.title('Chebyshev Type II Filter')
plt.legend()
plt.grid(True)
plt.ylim(-60, 5)
plt.show()

Frequency transformations

Transformations from a normalized low-pass filter to other filter types:

Key parameters for band-pass / band-stop design

When designing a band-pass filter (BPF) or a band-stop filter (BEF / notch), it is important to understand the following parameters.

Center frequency and bandwidth

Center frequency $f_0$ (or $\omega_0$)

The frequency at the center of the passband (BPF) or the stopband (BEF). A BPF has its maximum gain at this frequency; a BEF has its maximum attenuation there.

Bandwidth $B$ (or $\Delta\omega$)

The width of the passband for a BPF, or of the stopband for a BEF. It is defined as the difference between the upper frequency $f_H$ and the lower frequency $f_L$ at the ripple level. \begin{equation} B = f_H - f_L \end{equation}

Geometric-mean center frequency

In filter theory the center frequency is often defined as the geometric mean of the upper and lower frequencies:

This means that on a logarithmic frequency axis $f_0$ sits exactly halfway between $f_L$ and $f_H$. Note that it differs from the arithmetic mean $(f_L + f_H)/2$.

Fractional bandwidth and Q factor

The fractional bandwidth, which is the bandwidth normalized by the center frequency, and its reciprocal the Q factor, are important measures of how "narrow" a BPF/BEF is.

Relationship between LP → BP transformation and order

Applying the LP → BP transformation to an $n$th-order low-pass prototype yields a band-pass filter of order $2n$. This is because the transformation $s \to (s^2 + \omega_0^2)/(Bs)$ splits each pole into two poles.

• 3rd-order LPF → 6th-order BPF (3 conjugate complex-pole pairs)
• 4th-order LPF → 8th-order BPF (4 conjugate complex-pole pairs)

Design notes for narrowband BPFs

A high-Q (narrowband) BPF becomes harder to implement.

• Component sensitivity: the higher the Q, the more sensitive the response is to component variation
• Increase in pole Q: the Q of each second-order section after the transformation is close to the Q of the original LPF multiplied by the Q of the BPF
• Practical limit: for active filters, $Q \approx 30$ is about the practical upper bound; beyond that, consider crystal filters or SAW filters

Designing various filters in Python

# Designing various filters in SciPy
from scipy.signal import cheby1

n = 4
rp = 1.0

# Low-pass
b_lp, a_lp = cheby1(n, rp, 1000, btype='low', analog=True)

# High-pass
b_hp, a_hp = cheby1(n, rp, 1000, btype='high', analog=True)

# Band-pass (center 1000 rad/s, bandwidth 200 rad/s)
# Note: in SciPy you specify the lower and upper frequencies
b_bp, a_bp = cheby1(n, rp, [900, 1100], btype='band', analog=True)

# Band-stop
b_bs, a_bs = cheby1(n, rp, [900, 1100], btype='stop', analog=True)

# Example of computing Q and bandwidth
f_L, f_H = 900, 1100
f_0 = (f_L * f_H) ** 0.5  # geometric-mean center frequency
B = f_H - f_L             # bandwidth
Q = f_0 / B               # Q factor
print(f"Center frequency: {f_0:.1f} rad/s")
print(f"Bandwidth: {B} rad/s")
print(f"Q factor: {Q:.2f}")

Frequently asked questions

Related topics

• Chebyshev filter overview
• Theory (Type I): Chebyshev polynomials and pole placement
• Circuit article: analog circuit implementation
• Component-value tables: normalized LC ladder coefficients