Trigonometric Function — Control Systems/Base Blocks

Trigonometric Function

Control Systems / Base Blocks

Applies one of thirteen trigonometric or hyperbolic functions to its input, entry by entry. Which function is applied is chosen by the Function parameter, and one of them – the four-quadrant arctangent – takes a second input. Angles are in radians throughout.

Ports

• u1 – the signal the function is applied to, of any size [m,n]. For Four-Quadrant Arctangent this is the numerator (the "y" operand).
• u2 – present only for Four-Quadrant Arctangent, where it is the denominator (the "x" operand). 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 every one of the thirteen. This block never reshapes a signal.

Parameters

• Function – which function is applied. This selects the arithmetic rather than retuning it, so each option is a separate code path.
  • Sine (sin(u)) – y = sin(u), u in radians. This is the default, as in Simulink. Defined for every real input.
  • Cosine (cos(u)) – y = cos(u). Defined everywhere.
  • Tangent (tan(u)) – y = tan(u). Defined everywhere a double can represent, but unbounded near odd multiples of π/2, where a small change in the input makes a large change in the output.
  • Arcsine (asin(u)) – y = asin(u) in [−π/2, π/2]. Domain [−1, 1]; outside it the result is NaN.
  • Arccosine (acos(u)) – y = acos(u) in [0, π]. Domain [−1, 1]; outside it the result is NaN.
  • Arctangent (atan(u)) – y = atan(u) in (−π/2, π/2). Defined everywhere.
  • Four-Quadrant Arctangent (atan2(u1,u2)) – two inputs. y = atan2(u₁, u₂) in (−π, π], the angle of the point (u₂, u₁), using the signs of BOTH operands to place the quadrant. Defined everywhere, including u₂ = 0; at the origin it is 0.
  • Hyperbolic Sine (sinh(u)) – y = sinh(u). Defined everywhere.
  • Hyperbolic Cosine (cosh(u)) – y = cosh(u). Defined everywhere, and never less than 1.
  • Hyperbolic Tangent (tanh(u)) – y = tanh(u) in (−1, 1). Defined everywhere.
  • Hyperbolic Arcsine (asinh(u)) – y = asinh(u). Defined everywhere.
  • Hyperbolic Arccosine (acosh(u)) – y = acosh(u). Domain 1, +∞); below 1 the result is NaN.
  • Hyperbolic Arctangent (atanh(u)) – y = atanh(u). Domain (−1, 1); at ±1 the result is ±Inf and beyond them NaN.
• 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 asin, acos, acosh and atanh return a complex number outside their domains, so the generated MATLAB maps those entries to NaN first and keeps the result real. Two targets lack the inverse hyperbolics entirely – Java and PLC Structured Text – and build them from logarithms; the other five call the library function, which is more accurate near zero than the logarithmic form.

The three HDL targets are simulation-only for all thirteen. There is no sine 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 carry neither NaN nor infinity, so out of domain they answer 0 where the software targets answer NaN or ±Inf.

Simulink bridge

Import and export, mapped to simulink/Math Operations/Trigonometric Function. "Function" to Operator, one option for one option (sin, cos, tan, asin, acos, atan, atan2, sinh, cosh, tanh, asinh, acosh, atanh), so that round trip is lossless for the thirteen this block offers; "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. Three parameters are always written out because this block has no choice to offer behind them – ApproximationMethod is None, which pins the result to the exact library function rather than Simulink's CORDIC or lookup approximation; OutputSignalType is real, since ICore signals are real doubles; and AngleUnit is radian.

Two of Simulink's fifteen operators are not offered. sincos produces TWO outputs, and every operator here has one – use two blocks sharing an input. cos + jsin produces a COMPLEX output, and ICore signals are real doubles. A Simulink model using either is reported on import rather than silently mapped to something else.

Notes

• Algebraic, with no state: the output depends only on the current input.
• Not linear in any of the thirteen, so the block deliberately carries no state space and model reduction reports it as unmergeable.
• Angles are in radians. Simulink's AngleUnit also offers revolutions; this block does not, and always writes radian. Scale with a Gain of 2π to work in revolutions.
• Changing Function to or from Four-Quadrant Arctangent does not add or remove the second port for you. The block reports the mismatch when the model is built rather than editing the diagram underneath you.
• Hyperbolic Cosine and Hyperbolic Sine grow exponentially: an input beyond about 710 overflows a double to ±Inf in every target.