Check Discrete Gradient — Control Systems/Model Verification

Check Discrete Gradient

Control Systems / Model Verification

Verifies that a signal never jumps by more than a given amount from one sample to the next, and publishes the verdict: y = 1 where the entry passes, y = 0 where it fails. The test is |u[k] − u[k−1]| < gradient, taken entry by entry.

Note what that is not: it is a raw difference between samples, not a rate of change. The sampling period does not divide into it, so the same signal checked at a faster rate passes more easily – which is Simulink's behaviour, measured, and not an ICore simplification.

Ports

• Input – the signal u under test, of any size [m,n]. Each entry is tracked independently against its own previous value.
• Output – the verdict y, of the SAME size [m,n]: one 1.0/0.0 flag per entry.

Parameters

• Maximum Gradient – scalar, the largest step the signal may take between consecutive samples. Defaults to 1, as in Simulink. The comparison is strict: a step of exactly this size FAILS.
• Enabled – whether a failing sample is REPORTED. It does not change the output signal: an entry that fails still reads 0 with this off, which is what Simulink's counterpart does.
  • on – a failure is logged once per run, with the block's path and the time it first happened (the default).
  • off – the block computes its verdict silently.
• Stop When Assertion Fails – whether a reported failure also ends the run.
  • on – the run stops at the first failing sample and is marked failed (the default).
  • off – the run continues and the failure is a warning.
  Ignored entirely when Enabled is off.
• Sampling Time (s) – the block is inherently discrete, so this is the period at which it takes its samples. A non-positive value falls back to the model's global sampling time. Because the test is a raw difference, this parameter changes the VERDICT and not merely the update rate: the same signal sampled twice as fast takes half-sized steps and passes more easily.

Notes on the first sample

The first sample of a run always passes: there is no previous value to difference against, so the block seeds its memory from u[0] itself and the first difference is exactly zero. It is deliberately not seeded from zero, which would fail the first sample of any signal that does not start at the origin. Measured against Simulink, which behaves the same way.

Code export

All ten targets: Python, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog and PLC Structured Text. This is the only block in the family with persistent state, so every backend carries the previous sample plus a "primed" flag – the flag is what reproduces the first-sample rule above, and a core that dropped it would disagree with the reference on exactly one sample. The gradient is baked in as an export-time constant rather than exposed as a tunable parameter.

Simulink bridge

Import and export, mapped to simulink/Model Verification/Check Discrete Gradient. "Maximum Gradient" to gradient, "Enabled" to enabled and "Stop When Assertion Fails" to stopWhenAssertionFail, all as plain pass-through values, so the round trip is lossless. The block always sets Simulink's export to on: ICore's block always has its verdict output, whereas Simulink's grows one only when that box is ticked. The Simulink counterpart has no SampleTime parameter, so "Sampling Time (s)" does not cross – and on this block that is worth knowing, because the rate changes the verdict. Set the rate on the Simulink side by the surrounding model.

Notes

• Stateful, and the state is one previous sample per entry.
• Discrete only: the block declares itself discrete, so a model running a continuous solver still steps it once per sample rather than pushing it through Runge-Kutta, where "the previous sample" would be meaningless.
• Not linear, and so deliberately carries no state space – model reduction reports it as unmergeable rather than absorbing a comparison.