Lattice-ladder realization versus direct numerator coefficients

Tutorial goal

Show that lattice-ladder taps can realize the same transfer function as direct numerator coefficients.

Note

New to the terminology? See the lattice DSP concept map and the causality/data-use guide for how online, offline, block, and MIMO examples should be read.

Context

A lattice filter gives a stable recursive denominator. Ladder taps then combine the internal lattice states to realize a numerator. This example is a sanity check that the lattice-ladder representation and a direct numerator representation agree sample-by-sample.

Key idea and equations

The transfer function is still

\[H(z)=\frac{B(z)}{A(z)},\]

but A is controlled by reflection coefficients while B is represented by ladder taps.

How to read the result

The important number is the maximum absolute output difference; it should be close to floating-point roundoff.

Run command

python examples/lattice_ladder_realization.py

Run status

Return code: 0

Captured stdout

reflection: [0.35, -0.2, 0.1]
direct numerator: [0.2, -0.1, 0.05, 0.75]
ladder taps: [0.07164000000000001, 0.06959999999999998, -0.14499999999999996, 0.75]
lattice numerator reconstruction: [0.2, -0.1, 0.04999999999999999, 0.75]
max |direct - lattice|: 8.882e-16

Source code

"""Compare direct-form and synthesis lattice-ladder realizations.

This example starts from SciPy-style direct numerator taps, converts them to
ladder taps for the true synthesis lattice-ladder structure, and verifies that
both realizations produce the same transfer-function behavior.
"""

from __future__ import annotations

import numpy as np

from lattice_dsp import LatticeIIR, LatticeLadderIIR, numerator_to_ladder


def main() -> None:
    rng = np.random.default_rng(0)
    x = rng.normal(size=2048)

    reflection = [0.35, -0.2, 0.1]
    direct_numerator = [0.2, -0.1, 0.05, 0.75]
    ladder_taps = numerator_to_ladder(reflection, direct_numerator)

    direct = LatticeIIR(reflection, direct_numerator)
    lattice = LatticeLadderIIR(reflection, ladder_taps)

    y_direct = direct.process(x)
    y_lattice = lattice.process(x)
    max_abs_err = float(np.max(np.abs(y_direct - y_lattice)))

    print("reflection:", reflection)
    print("direct numerator:", direct_numerator)
    print("ladder taps:", ladder_taps)
    print("lattice numerator reconstruction:", lattice.numerator)
    print(f"max |direct - lattice|: {max_abs_err:.3e}")


if __name__ == "__main__":
    main()