Interpolate Matrix XYZ — Control Systems/Gain Scheduling

Interpolate Matrix XYZ (x,y,z)

Control Systems / Gain Scheduling

Blends a stored three-dimensional grid of matrices and answers a single matrix: the trilinear blend of the eight matrices around the position (k_x, f_x, k_y, f_y, k_z, f_z), each corner weighted by the product of its three per-axis weights – 1−f on the low side of an axis and f on the high side. It is the three-scheduling-variable form of Interpolate Matrix(x).

Pair it with one Prelookup per scheduling variable: each turns a value into the (k, f) pair one axis of this block consumes.

It is registered as Interpolate Matrix XYZ; the Aerospace Blockset spells the same block Interpolate Matrix(x,y,z), and the title above carries both so either name finds it.

Ports

• x_k – the interval index on the x axis, counted from zero, as a scalar. Truncated, not rounded, and the two slice indices it selects are clamped separately into [0, P_x−1]: below zero and at or past the last index the blend goes flat along x.
• x_f – the fraction across that interval, as a scalar. Not held in [0,1]: inside the grid a value outside it extrapolates.
• y_k – the interval index on the y axis, same rules, over [0, P_y−1].
• y_f – the fraction across that interval, same rules.
• z_k – the interval index on the z axis, same rules, over [0, P_z−1]. Every axis clamps on its own, so the blend can be flat along one or two axes while still interpolating along the rest.
• z_f – the fraction across that interval, same rules.
• Output – the blended matrix Y, of the shape of ONE matrix of the grid: Matrix Rows tall and as wide as the Matrix Table. Its size comes from the configuration and not from the inputs.

Parameters

• Matrix Table – the grid, with the matrices stacked vertically, x varying fastest and z slowest: the matrix at (i_x, i_y, i_z) occupies row block i_x + P_x·i_y + P_xP_y·i_z, so the table is P_xP_yP_z·R rows by C columns. A matrix config cannot hold a five-dimensional array, so this is the one spelling available. From a MATLAB array M of size [R C Px Py Pz] the config is reshape(permute(M,[1 3 4 5 2]), R*Px*Py*Pz, C), whose column-major walk over (row, i_x, i_y, i_z) is exactly that order.
• Matrix Rows – R, how tall one matrix of the grid is. A whole-number scalar of at least 1; the table's height must be a whole multiple of it. Defaults to 2.
• X Breakpoint Count – P_x, how many matrices the grid holds along x. A whole-number scalar of at least 1. Defaults to 2.
• Y Breakpoint Count – P_y, the same along y. The product of the two must divide the number of slices the table holds; P_z is derived from what is left and is never stated. 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 grid is resolved at export time into the constants of a decision chain – one branch per triple of regions, each carrying its eight corners folded into a nested blend – and inlined rather than exposed as a tunable parameter. It cannot be otherwise: the grid's shape decides how many branches the generated code has.

This is the block whose exported body gets large, and it is the one thing to plan for. Each axis contributes one branch per interval plus one for each of its two flat regions, so the emitted body grows as (P_x+1)·(P_y+1)·(P_z+1)·R·C: a 5×5×5 grid of 3×3 matrices is about 1900 branches per language, and a 10×10×10 grid of 4×4 is over 21000. A schedule that is comfortable in the simulator can still be a very large generated core. Prefer fewer breakpoints on the axes that matter least, or split the schedule across two blocks of fewer axes.

The three HDL targets are not simulation-only: each branch is seven multiplies and seven adds on constants known at export time, and no divider is emitted. The Q16.16 caveats are the one-axis block's – a matrix entry outside ±32767 cannot be represented, and an index arriving exactly on a whole number can be moved to the interval below by the port's own quantization.

Simulink bridge

None (Support::None). Simulink's counterpart is aerolibschedule/Interpolate Matrix(x,y,z) in the Aerospace Blockset and it computes the same trilinear blend – the measurements this block is written from, including which trailing dimension is which axis, were taken off it – but its one parameter, matrix, is a five-dimensional array, and neither MATLAB's matrix literal syntax nor an ICore matrix config has a five-dimensional form. So the grid cannot cross in either direction, and an exported model would carry the ports, the wiring and no schedule at all. 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.

Notes

• Algebraic, with no state: the output depends only on the current inputs.
• The third dimension of the array is x, the fourth is y and the fifth is z, measured rather than inferred. A permutation of the three is exactly right on the diagonal of a cubic grid and wrong elsewhere – and right everywhere on any grid whose axes have equal breakpoint counts, which is the shape a first test is most likely to have.
• Each index truncates, its two slice indices clamp separately, and no fraction is clamped. Same rules as the one-axis block, applied per axis and independently – so the blend can be flat along one or two axes and still interpolating along the rest. Where an axis is flat, no multiply is emitted for it at all.
• Not linear – selecting between stored matrices is a step function of the indices – so the block carries no state space and model reduction reports it as unmergeable.
• All six inputs are scalars. One index and one fraction per axis select ONE matrix out of the grid.
• For one or two scheduling variables, use Interpolate Matrix(x) or Interpolate Matrix(x,y) – and prefer them where they suffice, for the export size above.