Partial Fraction Expansion — Control Systems/Symbolic

Partial Fraction Expansion

Control Systems / Symbolic

Expands a rational expression into partial fractions symbolically and evaluates the result on the input at every sample – MATLAB's partfrac:

f(x) → Σ r / (x − p)^k  +  a polynomial part

The expansion is done once, when the configuration loads, over exact rational arithmetic, including repeated real roots. A pole that cannot be placed exactly – an irreducible quadratic – keeps its quadratic term, which is what MATLAB does too.

The factory setting is (x² + 3x + 5) / ((x−9)(x+7)²), which expands to 113/(256(x−9)) + 143/(256(x+7)) − 33/(16(x+7)²) – a simple root and a repeated one, so the block out of the library is a worked example of both. ⚠ Its poles are at 9 and −7, deliberately far from the origin: a factory default whose pole sits at a round number is one a sample run walks straight into.

Ports

• x – the variables, a vector of n entries (a column [n,1] or a row [1,n]) where n is the number of names in Variables: entry k is the k-th name. A Mux in front builds it from scalar signals; with one variable the scalar signal IS the input.
• y – the expanded expression, the same shape as the expression: [1,1] for a scalar, [r,c] for a matrix literal, which is expanded entry by entry.

Parameters

• Expression – the expression to expand, in MATLAB syntax over the names in Variables: numbers, pi, + - * / ^, parentheses and the functions sin cos tan sec csc cot asin acos atan acot sinh cosh tanh asinh acosh atanh exp log log2 log10 sqrt abs sign heaviside. It is the rational part in the expansion variable that is expanded; anything else is carried along as a coefficient.
• Variables – the names of the input's entries, in order: x, or x a when the coefficients are variables too. Each is a MATLAB identifier, none may repeat, and none may be a function name or pi, e, i, j, Inf, NaN or eps. At most 12.
• Expansion Variable – which of the declared Variables the expansion is taken over, by name. It must be one of them. Every other variable is treated as a constant, exactly as MATLAB's second argument does.
• 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 algebra is done once, at configuration load; what each target carries is the expanded form, printed as one inline expression per entry with its constants folded to 17 significant digits, so a generated core expands nothing. The three HDL targets are simulation-only real arithmetic, quantized to Q16.16 only at the ports: a sum of poles divides across many orders of magnitude, which is not a fixed-point datapath.

Simulink bridge

None (Support::None). partfrac is a Symbolic Math Toolbox function, and that toolbox ships no Simulink library at all, so there is no library path a diagram could name; the bridge reports this block rather than dropping it, and it therefore has no parity testbench. Code export verification covers it across all ten languages. No configuration crosses, including "Sampling Time (s)".

Notes

• ⚠ The result is algebraically EQUAL to the expression, and that is the point. This block does not compute a different number from Symbolic Expression; it computes the same number by different arithmetic. The two disagree only in floating point – and near a pole the expanded form is the better-conditioned one, which is why the residue form is worth having on a wire at all.
• ⚠ A pole is still a pole. Where the denominator vanishes the value is an infinity, in the expanded form exactly as in the original. Expanding does not remove a singularity, it redistributes it.
• An irreducible quadratic keeps its quadratic term rather than being split over complex roots, which is MATLAB's behaviour too: this console's arithmetic is over the rationals.
• abs, sign and heaviside are accepted here, as they are on Symbolic Matrix Inverse: nothing is differentiated. They are carried as opaque coefficients, not expanded.
• Algebraic, with no state: the output depends only on the current input.
• Size limits are on the generated code: 144 entries, 4000 operations per entry.
• No state space: the map is nonlinear in general, so model reduction correctly declines the block.