Symbolic Expression — Control Systems/Symbolic

Symbolic Expression

Control Systems / Symbolic

Evaluates an expression you type, y = f(x₁, …, x_n), on the input at every sample. The expression is written in MATLAB syntax over the names in Variables, which name the entries of the input vector in order, and it may be a scalar or a matrix – [f1; f2; f3] gives a column of three. It is read once, when the configuration loads, by the console's own symbolic engine (the reader behind str2sym), so what runs per sample is plain arithmetic: this is MATLAB's matlabFunction(str2sym(...)) on a wire.

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 expression's value, shaped like the expression: [1,1] for a scalar, [r,c] for an r-by-c matrix literal. The shape follows from the configuration alone.

Parameters

• Expression – the expression, in MATLAB syntax: numbers, the declared variables, pi, + - * / ^ (and their elementwise spellings .* ./ .^, which mean the same on scalars), 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 [a, b; c, d]: commas separate the entries of a row and semicolons separate rows – a space does not separate entries here. Anything else is refused with a reason naming it: an unknown name, a function outside the set (atan2, min, floor and gamma among them), the imaginary unit, a relation, and dirac: the impulse is a distribution with no value at a sample, so no signal carries it. heaviside is 1/2 at 0, as MATLAB's is. e is refused too, because MATLAB's str2sym reads it as a variable and the console's engine as Euler's number; write exp(1).
• 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.
• 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. Each entry is emitted as one inline expression with its constants folded to 17 significant digits; nothing is exposed as a tunable parameter, because the expression is the structure. 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 (IEEE math_real, and the Verilog real math system functions), quantized to Q16.16 only at the ports: a sine, a logarithm or a division of signals is not a fixed-point datapath, so the HDL body is not offered as synthesizable.

Simulink bridge

None (Support::None). Evaluating a symbolic expression is a Symbolic Math Toolbox operation, and that toolbox ships no Simulink library, so there is no block to cross to; the bridge reports this block rather than dropping it, and it has no parity testbench. No configuration of it crosses, including "Sampling Time (s)".

Notes

• Algebraic, with no state: the output depends only on the current input.
• The engine's form is what runs. The engine keeps numbers exact (1e-3*x is x/1000 to it) and prints its own canonical form (x*x*x is x^3); constants are folded to doubles only after it. A rational too large for 64 bits is refused by the engine with its own reason.
• The domain is yours to respect. The expression is evaluated as written, in real arithmetic: log of a negative number, sqrt of a negative number or a division by zero gives NaN or Inf in the simulator and in the exported code alike (MATLAB's own target would go complex instead).
• Size limits are on the generated code: 144 entries, 4000 operations per entry. The calculus blocks of this family – Symbolic Derivative, Gradient, Jacobian, Hessian, Divergence and Curl, Laplacian and Taylor Approximation – take the same two parameters and the same input.
• No state space: the map is nonlinear in general, so model reduction correctly declines the block.