Interpolate Matrix X — Control Systems/Gain Scheduling

Interpolate Matrix(x)

Control Systems / Gain Scheduling

Blends a stored stack of matrices along one axis and answers a single matrix: Y = M[lo] + f·(M[hi] − M[lo]), where f is the fraction across an interval and the two slice indices are lo = clamp(floor(k), 0, P−1) and hi = clamp(floor(k)+1, 0, P−1) for a stack of P matrices. It is the primitive a gain-scheduled controller is built from – the schedule holds one matrix per operating point and this block reads it at the operating point you are at.

Pair it with a Prelookup on the scheduling variable: that block turns a value into exactly the (k, f) pair this one consumes, and several schedules sharing one scheduling variable can then search it once and read it many times.

Ports

• x_k – the interval index k, counted from zero, as a scalar. It is truncated, not rounded, and the two slice indices it selects are clamped separately into [0, P−1]. So the axis has three kinds of region: below zero the first matrix is answered flatly, between two indices the pair either side of k is blended, and at or past the last index the last matrix is answered flatly. In both flat regions the fraction cannot change the answer.
• x_f – the fraction f across the interval, as a scalar. It is not held in [0,1]: inside the stack a value outside it extrapolates along the line through the two matrices, which is what a Prelookup set to linear extrapolation produces.
• Output – the blended matrix Y, of the shape of ONE matrix of the stack: Matrix Rows tall and as wide as the Matrix Table. Its size comes from the configuration and not from the inputs, so it is known before the model runs.

Parameters

• Matrix Table – the stack, with the matrices stacked vertically: P·R rows by C columns for P matrices of R×C. A matrix config cannot hold a three-dimensional array, so this is the one spelling available; the count P is derived from the height and never stated. From a MATLAB array M of size [R C P] the config is reshape(permute(M,[1 3 2]), R*P, C).
• Matrix Rows – R, how tall one matrix of the stack is. A whole-number scalar of at least 1; it is what cuts the table into slices, and the table's height must be a whole multiple of it. Defaults to 2.
• 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 stack is resolved at export time into the constants of a decision chain – one branch per interval, each carrying that interval's matrix and its difference to the next – and inlined rather than exposed as a tunable parameter. That is not a preference: the number of matrices decides how many branches the generated code has, so it cannot be retuned after export. The emitted body grows as P·R·C.

The three HDL targets are not simulation-only: every branch is one multiply and one add on constants known at export time, so no divider is emitted. Two caveats, both about range rather than about the block: a signal is carried in Q16.16 there, so a matrix entry outside ±32767 cannot be represented; and the index and fraction arrive already quantized to about 1.5×10⁻⁵, which can move an index that sits exactly on a whole number to the interval below.

Simulink bridge

None (Support::None). Simulink's counterpart is aerolibschedule/Interpolate Matrix(x) in the Aerospace Blockset and it computes the same thing – the measurements this block is written from were taken off it – but its one parameter, matrix, is a three-dimensional array, and neither MATLAB's matrix literal syntax nor an ICore matrix config has a three-dimensional form. So the table cannot cross in either direction: an exported model would carry the ports and the wiring and no schedule at all, which is worse than a block the bridge reports. It is reported rather than dropped silently, and it therefore has no parity testbench; code export verification still covers it across all ten languages.

The Simulink block defines no SampleTime parameter either – measured, its only parameter is the array – so nothing about the rate would have crossed had the table done so.

Notes

• Algebraic, with no state: the output depends only on the current inputs.
• The index truncates, it does not round, and that was measured rather than assumed: k = 1.5 answers exactly what k = 1 answers. Rounding agrees with this on every whole-number index and disagrees on every fractional one.
• Both slice indices are clamped separately, so the upper one is not always lo + 1. Below the table both collapse onto the first matrix and the answer is flat, the mirror of what happens above it – measured, k = −0.5 with f = 0.5 answers the first matrix and not halfway to the second. In either flat region the blend collapses and no multiply is emitted at all.
• The fraction is not clamped. Outside [0,1] it is let through and extrapolates along the line through the two matrices – but only where there are two: in a flat region there is nothing to extrapolate along.
• Not linear – selecting between stored matrices is a step function of the index – so the block deliberately carries no state space and model reduction reports it as unmergeable. That holds even when what it is selecting between IS a set of state-space matrices.
• The inputs are scalars. One index and one fraction select ONE matrix out of the stack; a per-entry index would have to answer a stack rather than a matrix, which is a different block. For a table of VALUES read entry by entry, use Lookup Tables / Interpolation Using Prelookup.
• For two or three scheduling variables, use Interpolate Matrix(x,y) or Interpolate Matrix(x,y,z), which blend the same stack bilinearly and trilinearly.