Math Function — Control Systems/Base Blocks

Math Function

Control Systems / Base Blocks

Applies one of fifteen mathematical functions to its input, entry by entry. Which function is applied is chosen by the Function parameter, and that choice decides the block's shape as well as its arithmetic: four of the functions take a second input, and two of them transpose the signal.

Ports

• u1 – the signal the function is applied to, of any size [m,n]. For the four two-input functions this is the first operand.
• u2 – present only for Power, Hypotenuse, Remainder and Modulus. Either the SAME size [m,n] as u1, or a scalar [1,1], which is then applied to every entry of u1. Any other size is an error rather than a guess. The port is not added or removed for you: set the input port count to match the function you chose.
• Output – the result y. The SAME size [m,n] as u1 for thirteen of the functions, and [n,m] for Transpose and Hermitian Transpose, which are the only two that reshape a signal.

Parameters

• Function – which function is applied. This selects the arithmetic rather than retuning it, so each option is a separate code path.
  • Exponential (e^u) – y = e^u. This is the default, as in Simulink. Defined for every real input.
  • Natural Logarithm (log(u)) – y = ln(u). Defined for u > 0; zero yields −Inf and a negative entry yields NaN.
  • Power of Two (2^u) – y = 2^u. Defined everywhere.
  • Power of Ten (10^u) – y = 10^u. Defined everywhere.
  • Base 10 Logarithm (log10(u)) – y = log₁₀(u), with the same domain as the natural logarithm.
  • Magnitude Squared (|u|^2) – y = |u|². On the real signals ICore carries this is u², so it computes the same thing as Square; the two are kept apart because they are separate options in Simulink and differ there on a complex signal.
  • Square (u^2) – y = u².
  • Power (u1^u2) – y = u1^u2. Two inputs. A negative base with a fractional exponent has no real value and yields NaN.
  • Complex Conjugate (conj(u)) – y = u̅. On a real signal the conjugate is the signal itself, so this option is the identity. It is offered so that a Simulink model using it crosses without loss.
  • Reciprocal (1/u) – y = 1/u. Zero yields ±Inf.
  • Hypotenuse (sqrt(u1^2+u2^2)) – y = √(u1²+u2²). Two inputs. Defined everywhere.
  • Remainder (rem(u1,u2)) – two inputs. The remainder after division, TRUNCATED toward zero, so its sign follows u1. A zero divisor yields NaN.
  • Modulus (mod(u1,u2)) – two inputs. The remainder after division, FLOORED, so its sign follows u2. This is the one difference from Remainder, and it shows only when the two operands have opposite signs. A zero divisor returns u1 unchanged.
  • Transpose (u') – y = uᵀ. Reshapes: a [m,n] input leaves as [n,m].
  • Hermitian Transpose (u') – the conjugate transpose, which on a real signal is the plain transpose. Reshapes, and is offered for the same round-trip reason Complex Conjugate is.
• 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 function is fixed into the generated arithmetic at export time rather than exposed as a tunable parameter: it selects which code is emitted, so there is nothing left to retune on the generated core.

The seven software targets agree exactly, including out of domain, where they all produce IEEE NaN or ±Inf. MATLAB needs one extra step to get there: its log, log10 and .^ return a complex number where the others return NaN, so the generated MATLAB maps those entries to NaN first and keeps the result real.

The three HDL targets are simulation-only for twelve of the fifteen functions. There is no exponential, logarithm or power in the Q16.16 datapath to call, so the generated cores convert at the port boundary and evaluate in real arithmetic – correct in simulation, but not offered as synthesizable. They also carry neither NaN nor infinity, so out of domain they answer 0 where the software targets answer NaN or ±Inf. Complex Conjugate, Transpose and Hermitian Transpose are the exception: they are pure data movement, stay in the fixed-point datapath, and are synthesizable.

Simulink bridge

Import and export, mapped to simulink/Math Operations/Math Function. "Function" to Operator, one option for one option (exp, log, 2^u, 10^u, log10, magnitude^2, square, pow, conj, reciprocal, hypot, rem, mod, transpose, hermitian), so that round trip is lossless; "Sampling Time (s)" to SampleTime, as on every block.

Neither side carries the port count as a parameter: Simulink moves its own ports when Operator is set, and an imported model brings the port list the operator implies back with it. Two parameters are always written out because this block has no choice to offer behind them – OutputSignalType is real, since ICore signals are real doubles, and AlgorithmMethod is Exact, which pins the reciprocal to a true division rather than Simulink's Newton-Raphson approximation.

Notes

• Algebraic, with no state: the output depends only on the current input.
• Not linear in twelve of the fifteen functions, and the three that are either reshape the signal (Transpose, Hermitian) or do nothing to it (Complex Conjugate), so the block deliberately carries no state space and model reduction reports it as unmergeable.
• Simulink's Square, Reciprocal and Transpose library entries are this same block pre-set to those functions, and import as such.
• Changing Function to or from one of the two-input functions does not add or remove the port for you. The block reports the mismatch when the model is built rather than editing the diagram underneath you.