Algebraic Constraint — Control Systems/Base Blocks

Algebraic Constraint

Control Systems / Base Blocks

Searches for the signal z that makes the residual you feed back into it come out right: wire the block's output into an expression and the expression back into its input, and it moves z until f(z) = 0 (or f(z) = z, if you pick the fixed-point form). It is how you state an implicit equation in a diagram, rather than solving it by hand first.

It searches by integral action on the residual, one step per sample: dz/dt = −K·f for the zero form and dz/dt = K·(f − z) for the fixed-point form. The loop settles exactly where the residual is satisfied, and it settles there because that is the only value at which z stops moving.

Ports

• f(z) – the residual, of any size [m,n]. It is what the block drives to zero (or towards z), and the block does not care how it was computed.
• z – the trial value, the SAME size [m,n]. Every entry is solved independently, so an [m,n] residual is m×n separate constraints, not one vector equation.

Parameters

• Constraint – which relation to enforce.
  • f(z) = 0 – drive the residual to zero. This is the usual form, and the default.
  • f(z) = z – drive the input to equal the output, i.e. find a fixed point of whatever the loop computes.
• Initial Guess – where the search starts, as the size of the signal. A good guess reaches the answer sooner and, on a residual with more than one root, decides which root it reaches.
• Solver Gain – K, how hard the block pushes. It must be a strictly positive scalar. Larger converges faster and, past a point, oscillates or diverges; the loop is stable while K·df/dz is positive and not too large, so a residual that decreases with z needs the sign put right in the expression rather than in K. Defaults to 1.
• Sampling Time (s) – the block is discrete by nature, so this is its iteration period: zero or less falls back to the model's global sampling time, and a positive value runs one relaxation step every that many seconds.

Code export

All ten targets: Python, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog and PLC Structured Text.

The exported core carries the discretization of the relaxation for the model's discretization method, and the initial guess as the seed of its persistent state, so a generated core searches exactly as the simulation did. That also means Solver Gain and Initial Guess are baked in at export time rather than exposed as tunable parameters: the gain has already been folded into the discretized coefficients, and re-tuning it on the deployed core would mean re-deriving the discretization there.

The three HDL targets carry the state in Q16.16 fixed point and are fully synthesizable. The quantum, about 1.5×10^-5, is the floor on how finely the fixed-point core can resolve a root; the seven software targets resolve it to double precision. All three round each step to the nearest quantum rather than truncating it, which matters here more than it does in most blocks: in the f(z) = 0 form the search is a pure accumulation, so it never forgets a rounding bias, and a core that truncated would creep away from the root by roughly half a quantum per step for as long as it ran.

Simulink bridge

Neither direction. Simulink's simulink/Math Operations/Algebraic Constraint is not the same mechanism: it hands the loop to a nonlinear algebraic solver that re-evaluates f(z) several times within one time step and returns a z satisfying the constraint to a tolerance before the step ends. An ICore feedback loop advances once per sample by construction – there is nothing that could re-enter the loop mid-step – so this block converges across samples instead. The two agree on where they settle and disagree on every step before that, which makes them the same intent and not the same block, so the bridge reports it rather than translating it. Simulink's Solver and Tolerance parameters describe that in-step solver and have no counterpart; Solver Gain is this block's own and describes the relaxation. Note that Simulink's block, like this one, has no SampleTime parameter.

Notes

• Stateful: one state per entry of the signal, the current trial value, seeded with the Initial Guess.
• Discrete by nature – one relaxation step per sample – so the block runs the same recursion whatever solver the model uses, and the exported core matches the simulation step for step rather than to a tolerance.
• Linear in the residual, so the block carries a continuous state space and model reduction can use it. That describes the relaxation, which is the block's actual dynamics; it says nothing about the loop the block is wired into, which is as nonlinear as the expression you wrote.
• Feedback loops in ICore carry one sample of delay per loop. That is what makes this block an iteration rather than a solve, and it is also why a loop containing it should be certified by code-export verification rather than compared step by step against Simulink.