Taylor Approximation — Control Systems/Symbolic

Taylor Approximation

Control Systems / Symbolic

Replaces the expression by its Taylor polynomial about a point and evaluates that at every sample: y = Σ_k<N f^(k)(a)·(x−a)^k/k!. This is MATLAB's taylor(f, x, a, 'Order', N), and Order is MATLAB's 'Order': a truncation order, so the polynomial keeps the powers below it – the default 6 keeps up to (x−a)⁵.

The derivatives are taken symbolically and the coefficients evaluated at the expansion point, once, when the configuration loads; what runs per sample is a polynomial in (x−a), emitted in Horner form. That is what makes this block worth having on a target with no transcendental library: a sine, a logarithm or an exponential becomes a handful of multiplies and adds.

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.
• y – the polynomial's value at x, [1,1].

Parameters

• Expression – the expression, 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. A matrix is written [f1; f2], with semicolons between rows and commas between the entries of a row. abs, sign and heaviside are refused here, unlike on Symbolic Expression: see Notes.
• Variables – the names of the input's entries, in order, separated by spaces or commas: x y z. 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 Point – the a the polynomial is written about, a finite scalar. Every derivative of the expression must be finite there.
• Order – MATLAB's 'Order', a whole number from 1 to 16: the polynomial keeps the powers below it, so Order 6 keeps (x−a)⁰ through (x−a)⁵.
• 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 calculus is done once, at configuration load; what each target carries is the RESULT, printed as one inline expression per entry with its constants folded to 17 significant digits, so a generated core differentiates nothing and has no parameter to tune. Where a target lacks a function it gets the identity – Java has no inverse hyperbolic functions and PLC Structured Text no hyperbolic functions at all, so those are written through log, exp and sqrt. The three HDL targets are simulation-only real arithmetic, quantized to Q16.16 only at the ports: a derivative of a transcendental expression is not a fixed-point datapath. Taylor's polynomial is the one case where the HDL body holds no transcendental call at all -- it is a Horner nest of multiplies and adds -- and it is still carried in real rather than Q16.16, because the coefficients of a high-order term are far below one quantum.

Simulink bridge

None (Support::None). taylor 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

• One variable. The expansion is in a single variable, so Variables names exactly one and the input is [1,1].
• The polynomial is only good near the point. Away from a it departs from the expression it came from; the block evaluates the polynomial, and does not warn.
• The coefficients are baked in, not tunable. Changing the expansion point or the order re-derives them and changes the exported code.
• abs, sign and heaviside are refused in the expression. The symbolic engine answers diff(abs(x)) only under an assumption that x is real – console state a block may not depend on – and the derivative of sign or heaviside is an impulse no sample can carry. Symbolic Expression accepts all three, because it differentiates nothing.
• Algebraic, with no state: the output depends only on the current input.
• The calculus is the console's own symbolic engine's (the engine behind diff and jacobian on the command line), over exact rational arithmetic; constants are folded to doubles only after it.
• Size limits are on the generated code: 144 entries, 4000 operations per entry. An expression whose derivatives grow past that is refused with that reason rather than truncated.
• No state space: the map is nonlinear in general, so model reduction correctly declines the block.