Bilinear Transform — Control Systems/Polynomials

Bilinear Transform

Control Systems / Polynomials

Turns an analog transfer function's coefficients into a digital one's by the bilinear (Tustin) substitution s = K·(z−1)/(z+1), with K = 2·f_s – or K = 2πf_p / tan(πf_p/f_s) when a prewarp frequency is given, which makes the two responses agree exactly at f_p. This is MATLAB's bilinear.

Both polynomials come out L + 1 long, where L is the higher of the two input degrees. Nothing in the generated core substitutes, expands or divides: multiplying through by (z+1)^L makes the whole map a constant matrix fixed by the configuration and the input lengths, so every target emits one multiply-accumulate per output entry.

It transforms a filter, not a sample. Feed the two outputs to Discrete / Discrete Transfer Function to run the result, or take the analog side from Polynomials / Pade Approximant.

Ports

• bs – the analog numerator's coefficients, descending powers of s, as a vector of n + 1 entries. Degree n at most 8.
• as – the analog denominator's coefficients, descending, m + 1 entries. Degree m at most 8.
• bz – the digital numerator, descending powers of z, as a column of L + 1 entries, L = max(n, m).
• az – the digital denominator, descending, the same length.

Parameters

• Sample Rate (Hz) – f_s, the rate the digital filter is designed FOR. Strictly positive. This is not the block's own rate: the block is algebraic and runs whenever it is asked to, while this number is the one the substitution uses. Default 100.
• Prewarp Frequency (Hz) – f_p. Zero (the default) means no prewarping and K = 2f_s; a positive value below f_s/2 bends the frequency axis so the analog and digital responses coincide at exactly that frequency.
• Sampling Time (s) – zero or less inherits the solver's rate; a positive value runs the block at that period.

Code export

All ten targets: Python, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog and PLC Structured Text. The two weight matrices are structural – they follow from the rate, the prewarp and the input lengths – so they are inlined at export time and nothing is exposed as a tunable parameter on the generated core.

The three HDL targets are genuine synthesizable Q16.16: the core carries no substitution and no division, only multiply-accumulate. ⚠ The numerator's precision falls as the sample rate rises, and only in fixed point. bz carries K^n−j−L, so an analog numerator of lower degree than its denominator produces entries of order 1/K or smaller: about 0.05 for a first-over-second-order design at f_s = 4 Hz, and about 0.0015 at 100 Hz – a hundred Q16.16 quanta. The seven software targets are unaffected.

Simulink bridge

None (Support::None). bilinear is a MATLAB function and the Signal Processing Toolbox it comes from ships no Simulink library at all, so there is no library path a diagram could name. Simulink's own discrete blocks are a different thing – they take an already-discretized coefficient set and filter a signal with it – so mapping onto one would be wrong rather than partial. The bridge reports this block instead of dropping it silently, and it therefore has no parity testbench; code export verification still covers it across all ten languages. No configuration of it crosses either, including "Sampling Time (s)", which has no counterpart to be written to.

Notes

• Algebraic, with no state: the output depends only on the current input.
• The scale is K^L and MATLAB's is az[0]. bilinear divides both polynomials by the digital denominator's first entry, making it monic; this divides both by K^L, a configuration-time constant. Same transfer function – both sides carry the same factor. The reason is that az[0] is the analog denominator evaluated at s = K, and that arrives on a port: it can pass through zero, and a core dividing by it would be undefined on those samples in ten languages at once. Divide both outputs by az's first entry, with a Divide block, wherever you know it is safe – that is MATLAB's answer exactly. Measured on bs = [0.3 1.1], as = [1 0.8 2.5], f_s = 100: bilinear reports bz = [0.0015213196389667338, 5.4777466542477171e−05, −0.0014665421724250338] over az = [1, −1.9917833800186742, 0.99203236850295684], and this block's outputs reproduce them to 1e−15 after that one division.
• Degree 8 is the ceiling on each side, and the bound is on the generated FILE: both weight matrices are unrolled in ten languages.
• It designs; it does not filter. Discrete / Discrete Transfer Function and Discrete / Discrete Filter are the blocks that run the result. Those blocks can discretize a continuous set of their own, from configuration, and keep it inside – which is the difference: this one puts the coefficients on a wire, so they can come from another block and change while the model runs.
• No state space: the map changes the signal's height – n + 1 and m + 1 in, L + 1 out twice – which a merged feed-through D cannot do, so model reduction correctly declines it.