Laplace Transform — Control Systems/Symbolic

Laplace Transform

Control Systems / Symbolic

Takes the Laplace transform of an expression symbolically and evaluates the result on the input at every sample – MATLAB's laplace, or ilaplace when Direction is Inverse:

F(s) = L{f(t)}  ·  f(t) = L⁻¹{F(s)}

The transform is done once, when the configuration loads, from the same table MATLAB uses. What runs per sample is the RESULT. ⚠ This block does not transform a SIGNAL – there is no integral and no quadrature anywhere in the emitted body. It answers F at this s, which is what lets a transfer function derived symbolically be evaluated on a wire.

The factory setting is t²e^−3t, whose transform is 2/(s+3)³ – a worked example out of the library.

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. ⚠ The SOURCE variable's entry is not read by the result – the transform eliminated it. It is still declared, and still an entry, because the expression that goes IN is written over it.
• y – the transform, the same shape as the expression: [1,1] for a scalar, [r,c] for a matrix literal, which is transformed entry by entry as MATLAB's own does.

Parameters

• Expression – the expression to transform, 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. A matrix is written [f1; f2].
• Variables – the names of the input's entries, in order: t s. ⚠ BOTH the source and the target must be here, because the answer is an expression in the target and it is read back against this list. 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.
• Source Variable – the variable the expression is written over (t for a forward transform, s for an inverse one). It must be one of the declared Variables.
• Target Variable – the variable the answer is written over. It must be one of the declared Variables too, and different from the source. MATLAB picks these by a rule when they are omitted; here they are named, because a block cannot depend on what its neighbours happen to be called.
• Direction – Forward for laplace, Inverse for ilaplace.
• 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 transform 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 transforms nothing. 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.

⚠ An INVERSE transform often answers with a variable in the exponent – ilaplace of a simple pole is an exponential, and iztrans's is a power like 2ⁿ⁻¹. A power whose exponent is not a constant is printed as the target's general power (pow, powf, EXPT, $pow), and VHDL's ** is only defined for an INTEGER exponent, so an expression of that shape does not analyze there. A forward transform, whose answer is a rational function, has no such term.

Simulink bridge

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

• ⚠ A term the table cannot do is REFUSED, not carried. MATLAB leaves laplace(g(t), t, s) standing in its answer and so does the engine behind this block; the family's reader then refuses it by name, because an unevaluated laplace is not something ten targets can print. The configuration reports which term it was.
• ⚠ The transform is one-sided, from 0 to infinity, as MATLAB's is. An expression that is meant to be two-sided transforms to something else.
• abs, sign and heaviside are accepted here, as they are on Symbolic Matrix Inverse: nothing is differentiated. They will usually leave the transform unevaluated, and that is the refusal above rather than a silent answer.
• 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.