Fourier Transform — Control Systems/Symbolic

Fourier Transform

Control Systems / Symbolic

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

F(w) = ∫ f(t)·e^−i·w·t dt  ·  f(t) = (1/2π)·∫ F(w)·e^i·w·t dw, both over the whole line.

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

⚠ The answer is complex, so the output is a complex signal. The factory setting is heaviside(t)·e^−2t, whose transform is 1/(2 + i·w): real part 2/(w²+4), imaginary part −w/(w²+4).

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 (cplx) – the transform, a complex signal 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. Like every complex signal it travels as [r,2c] numbers, each entry's real part beside its imaginary part; a Complex to Real-Imag block takes the parts apart.

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]. The imaginary unit cannot be typed: the input is real, and only the answer is complex.
• Variables – the names of the input's entries, in order: t w. ⚠ 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, w 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 fourier, Inverse for ifourier.
• 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, and its answer is split into a real and an imaginary part there too; what each target carries is those two parts, printed as two inline expressions per entry with their constants folded to 17 significant digits, so a generated core transforms nothing and needs no complex arithmetic. 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.

Simulink bridge

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

• ⚠ An answer holding an impulse is REFUSED. fourier(1) is 2π·dirac(w), and an impulse has no value at a sample, so dirac is refused by name wherever it appears. A constant, a polynomial, and cos or sin without a decaying envelope all answer one; multiply by a decaying envelope (exp(-t^2), heaviside(t)*exp(-t)) and they transform.
• ⚠ A term the table cannot do is REFUSED, not carried. MATLAB leaves fourier(g(t), t, w) standing in its answer and so does the engine behind this block; the family's reader then refuses it by name, because an unevaluated fourier is not something ten targets can print.
• The parts are taken with every variable real, which is what a signal is. An answer whose parts cannot be separated that way – a complex value to a power that is not a whole number – is refused with the reason.
• An answer may be singular at a point: fourier(sign(t)) is −2i/w, infinite at w = 0, as MATLAB's is.
• Algebraic, with no state: the output depends only on the current input.
• Size limits are on the generated code: 144 entries (each complex entry counts twice), 4000 operations per entry.
• No state space: the map is nonlinear in general, so model reduction correctly declines the block.