Chebyshev Filter Element-Value Tables

Circuit topology

The elements are numbered from the input side as $g_1, g_2, g_3, \ldots, g_n$.

• Odd-numbered elements ($g_1, g_3, g_5, \ldots$): series inductor (L) or shunt capacitor (C)
• Even-numbered elements ($g_2, g_4, g_6, \ldots$): shunt capacitor (C) or series inductor (L)
• $g_0$: source resistance (normalized value = 1)
• $g_{n+1}$: load resistance

Scaling

Frequency scaling

Change the cutoff frequency from $\omega_c = 1$ to an arbitrary $\omega_c'$:

Impedance scaling

Change the load resistance from $R_L = 1$ Ω to an arbitrary $R_L'$:

Combined scaling

Normalized element-value tables

Worked example

Design example: 5th order, 1 dB ripple, $f_c = 10$ MHz, $R_L = 50$ Ω

Read the element values for 1 dB ripple and $n=5$ from the table:

• $g_1 = 2.1349$
• $g_2 = 1.0911$
• $g_3 = 3.0009$
• $g_4 = 1.0911$
• $g_5 = 2.1349$

Scaling computation ($\omega_c = 2\pi \times 10^7$, $R_L = 50$ Ω):

Computing element values in Python

import numpy as np

def chebyshev_lc_elements(n, rp_db):
    """
    Compute the normalized LC element values of a Chebyshev Type I filter.

    Parameters:
        n: filter order
        rp_db: passband ripple [dB]

    Returns:
        g: list of normalized element values [g1, g2, ..., gn, g_{n+1}]
    """
    epsilon = np.sqrt(10**(rp_db/10) - 1)
    eta = (1/n) * np.arcsinh(1/epsilon)

    g = np.zeros(n + 2)
    g[0] = 1.0  # source resistance

    # g1
    g[1] = 2 * np.sin(np.pi / (2*n)) / np.sinh(eta)

    # g2 ... gn
    for k in range(2, n + 1):
        a_k = np.sin((2*k - 1) * np.pi / (2*n))
        b_k = np.sinh(eta)**2 + np.sin(k * np.pi / n)**2
        g[k] = 4 * a_k * np.sin((2*k - 3) * np.pi / (2*n)) / (g[k-1] * b_k)

    # g_{n+1} (load resistance)
    if n % 2 == 1:
        g[n + 1] = 1.0
    else:
        g[n + 1] = 1 / np.tanh(eta / 2)**2

    return g

def scale_elements(g, fc_hz, RL_ohm):
    """
    Scale the normalized element values to actual element values.

    Parameters:
        g: normalized element values
        fc_hz: cutoff frequency [Hz]
        RL_ohm: load resistance [ohm]

    Returns:
        L, C: list of inductances [H] and capacitances [F]
    """
    omega_c = 2 * np.pi * fc_hz
    n = len(g) - 2

    elements = []
    for k in range(1, n + 1):
        if k % 2 == 1:  # series inductor
            L = g[k] * RL_ohm / omega_c
            elements.append(('L', L))
        else:  # shunt capacitor
            C = g[k] / (RL_ohm * omega_c)
            elements.append(('C', C))

    return elements

# Example usage
n = 5
rp_db = 1.0
fc = 10e6  # 10 MHz
RL = 50  # 50 ohm

g = chebyshev_lc_elements(n, rp_db)
print(f"Order-{n} Chebyshev Type I ({rp_db} dB ripple)")
print("Normalized element values:")
for i, val in enumerate(g):
    print(f"  g{i} = {val:.4f}")

print(f"\nAfter scaling (fc={fc/1e6} MHz, RL={RL} ohm):")
elements = scale_elements(g, fc, RL)
for i, (typ, val) in enumerate(elements):
    if typ == 'L':
        print(f"  {typ}{i+1} = {val*1e6:.3f} uH")
    else:
        print(f"  {typ}{i+1} = {val*1e12:.1f} pF")

Frequently asked questions

References

• A. I. Zverev, Handbook of Filter Synthesis, Wiley, 1967.
• G. L. Matthaei, L. Young, and E. M. T. Jones, Microwave Filters, Impedance-Matching Networks, and Coupling Structures, Artech House, 1980.
• A. B. Williams and F. J. Taylor, Electronic Filter Design Handbook, 4th ed., McGraw-Hill, 2006.

Related pages

• Chebyshev Filter overview
• Circuit: analog circuit implementation
• Design: order determination and procedure