mlinearize

Static method of mss.

Approximate a nonlinear Simulink model by an explicit MTI (mss) model, sampled on a sparse grid.

Source: src/model/@mss/mlinearize.m

Overview

mlinearize computes an explicit multilinear time-invariant state-space (mss) approximation of a nonlinear Simulink model over a prescribed operating domain.

The nonlinear model is assumed to be of the form

$$\begin{aligned} \delta x &= f(x,u), \\ y &= g(x,u), \end{aligned}$$

where $x \in \mathbb{R}^{n_x}$ denotes the state vector, $u \in \mathbb{R}^{n_u}$ the input vector, and $y \in \mathbb{R}^{n_y}$ the output vector of Simulink model. The function returns an mss object

$$\begin{aligned} \delta x &= \big<\mathsf{F}|\mathbf{M}(x,u) \big>, \\ y &= \big<\mathsf{G}|\mathbf{M}(x,u) \big>, \end{aligned}$$

where the state evolution $\delta x$ is valid for both continuous-time $\dot x$ or discrete-time $x_{k+1}$ of the original Simulink model.

The approximation is constructed over a bounded operating region specified by lower and upper bounds for the states, inputs, and outputs.

$$\text{low\_bnd} = \left[ x_1^{\mathrm{l}},\ldots,x_{n_x}^{\mathrm{l}}, u_1^{\mathrm{l}},\ldots,u_{n_u}^{\mathrm{l}}, y_1^{\mathrm{l}},\ldots,y_{n_y}^{\mathrm{l}} \right],$$

$$\text{up\_bnd} = \left[ x_1^{\mathrm{u}},\ldots,x_{n_x}^{\mathrm{u}}, u_1^{\mathrm{u}},\ldots,u_{n_u}^{\mathrm{u}}, y_1^{\mathrm{u}},\ldots,y_{n_y}^{\mathrm{u}} \right],$$

where the state variables must follow the ordering used internally by Simulink (reported by mlinearize after execution).

The function computes the coefficients of the tensors $\mathsf{F}$ and $\mathsf{G}$ following the method described in [1]. f For continuous-time models, this requires sampling and numerically integrating the model equations over a grid of operating points over the specified domain. For discrete-time models, only the former is needed.

The grid is constructed using sparse-grid interpolation [2], which is also used to efficiently perform the numerical integrations. The interpolation level, denoted by $\mu$ controls both the number of grid points and the integration accuracy. The number of interpolation points grows polynomially with $\mu$ as

$$\mathcal{O}\!\left((n_x+n_u)^{\mu}\right),$$

where $n_x$ is the number of states and $n_u$ is the number of inputs.

Only monomials whose multilinear order is less than or equal to the specified max_order are retained. The retained monomials define the structure of the resulting multilinear model, as illustrated below.

Monomial ordering and switching behavior

Let

$$\mathbf{z} = [z_1, z_2, \dots, z_n]^{\top},$$

be a vector of variables $z_{i}$. The multilinear monomial basis

$$\mathbf{m}(\mathbf{z}) = \bigotimes_{i=1}^{n} \begin{bmatrix} 1 \\ z_i \end{bmatrix}$$

contains $2^n$ monomials, with $n \in \mathbb{N}$, and $\otimes$ is the Kronecker product. Each $m_k(\mathbf{z})$ its $k$-th entry, i.e. one monomial.

Consider ordering the monomials generated by the recursive construction

$$\begin{aligned} \mathbf{m}^{(0)} &= [1], \\ \mathbf{m}^{(1)} &= [1, \ z_{1}], \\ \mathbf{m}^{(2)} &= [1, \ z_{1}, \ z_{2}, \ z_{1} z_{2}], \\ &\vdots \\ \mathbf{m}^{(i)} &= [\mathbf{m}^{(i-1)}, \ \mathbf{m}^{(i-1)}z_i], \quad i = 1, \dots, n, \end{aligned}$$

This ordering induces a structured pattern in the exponent vectors of the monomials, i.e. a vector with the order of each element in $\mathbf{m}^{(i)}$.

Let $\mathbf{U} \in \{0,1\}^{n \times 2^n}$ be the exponent matrix, where the $k$-th column $\mathbf{U}(:,k)$ corresponds to the exponent vector of the monomial at position $k$.

For example with $n=3$, the monomial ordering is

$$\mathbf{m}^{(3)} = [1,\; z_1,\; z_2,\; z_1 z_2,\; z_3,\; z_1 z_3,\; z_2 z_3,\; z_1 z_2 z_3],$$

so that $m_1 = 1$, $m_4 = z_1 z_2$ and $m_8 = z_1 z_2 z_3$, and the exponent matrix is

$$\mathbf{U} = \begin{bmatrix} 0 & 1 & 0 & 1 & 0 & 1 & 0 & 1 \\ 0 & 0 & 1 & 1 & 0 & 0 & 1 & 1 \\ 0 & 0 & 0 & 0 & 1 & 1 & 1 & 1 \end{bmatrix} \begin{matrix} \ \to z_{1} \\ \ \to z_{2} \\ \ \to z_{3} \end{matrix}$$

Here, $z_1$ switches every $2^0=1$ monomial, $z_2$ every $2^1=2$ monomials, and $z_3$ every $2^2=4$ monomials.

For variable $z_i$, its exponent switches every $2^{i-1}$ monomials. The exponent matrix is computed as

$$\mathbf{U}(i,k) = \left\lfloor \frac{k-1}{2^{i-1}} \right\rfloor \bmod 2, \qquad i = 1,\dots,n,\; k = 1,\dots,2^n.$$

Equivalently, variable $z_i$ is present in blocks of length $2^{i-1}$, alternating between absence and presence as $k$ increases.

Reduced set and maximum order

The multilinear order of a monomial is the number of variables it contains, which in this encoding is simply the column sum of the exponent matrix,

$$\deg(k) = \sum_{i=1}^{n} \mathbf{U}(i,k) = \left\lVert \mathbf{U}(:,k) \right\rVert_1 .$$

The argument max_order $=p$ keeps only the monomials up to that order,

$$\mathcal{K}(p) = \left\{\, k \in \{1,\dots,2^n\} \;:\; \deg(k) \le p \,\right\}, \qquad \bigl\lvert \mathcal{K}(p) \bigr\rvert = \sum_{j=0}^{p} \binom{n}{j}.$$

which leads to the reduced exponent matrix

$$\mathbf{U}_{\text{red}} = \mathbf{U}\!\left(:,\mathcal{K}(p)\right) \in \{0,1\}^{\,n \times \bigl\lvert \mathcal{K}(p) \bigr\rvert}.$$

This is exactly the structure matrix $S$ of the returned mss object.

Choosing $p \ge n$ retains the full basis of $2^n$ monomials (values above $n$ are capped to $n$ with a warning), so max_order trades approximation quality against model size.

Retained monomials whose coefficients all turn out to be zero are dropped afterwards by trivialReduction, so the rank of the returned model is usually smaller still.

The variables of the basis

In mlinearize the variables of the basis are the states and inputs together,

$$\mathbf{z} = \left[x_1,\dots,x_{n_x},\,u_1,\dots,u_{n_u}\right]^{\top}, \qquad n = n_x + n_u,$$

so $\mathbf{m}(\mathbf{z})$ is the $\mathbf{m}(x,u)$ of the model above, and the exponent matrix $\mathbf{U}$ has one row per state and per input, in that order.

The sparse grid lives on $[-1,1]^{n}$, so each variable is first mapped onto that cube by the affine scaling built from the operating bounds,

$$\tilde{z}_i = a_i z_i + b_i, \qquad a_i = \frac{2}{z_i^{\text{u}} - z_i^{\text{l}}}, \qquad b_i = -\,\frac{z_i^{\text{u}} + z_i^{\text{l}}}{z_i^{\text{u}} - z_i^{\text{l}}}.$$

which is why the bounds may not be degenerate: $z_i^{\text{u}} = z_i^{\text{l}}$ makes $a_i$ singular. The outputs are scaled the same way, from their own bounds.

The computation of the coefficients in $\mathsf{F}$ and $\mathsf{G}$ is done on the scaled variables $\tilde{\mathbf{z}}$, and the coefficients are mapped back to physical units as the last step.

Requirements

Simulink

• Continuous/discrete hybrid models are not supported. The model must be either entirely continuous-time or entirely discrete-time. Mixed models containing both continuous and discrete dynamics cannot be multilinearized.

• Simscape models are not supported. Only models constructed from standard Simulink blocks are compatible with mlinearize.

• Accelerator and Rapid Accelerator simulation modes are not supported. The multilinearization procedure repeatedly modifies model parameters and performs a large number of simulations. Therefore, the Simulink model must be executed in Normal simulation mode.

External libraries

The function requires the Sparse Grids MATLAB Kit, which builds the sparse grid it samples on.

The kit is not part of the MTI-Toolbox. It is a separate package by L. Tamellini, F. Nobile and C. Piazzola, licensed BSD-2-Clause, and it is redistributed unmodified inside the toolbox — release 23.05 (“Robert”), under externalTools/sparse-grids-matlab-kit/, with its own LICENSE.txt beside it. An installed toolbox puts it on the MATLAB path, so mlinearize works with no download and no network. Running from a source checkout instead, add it to the path yourself.

It is bundled rather than fetched on your behalf, so nothing is installed silently and the capability does not depend on an external hosting link staying alive. It can still be deleted from an installed tree, which is why environmentChecker probes for it rather than assuming it.

The kit’s authors ask to be cited: the package webpage, https://sites.google.com/view/sparse-grids-kit/home, together with reference [2] below. Please do both if you publish work that used mlinearize.

Input arguments

Output arguments

Syntax

msys = mss.mlinearize(model,low_bnd,up_bnd,level,max_order)
msys = mss.mlinearize(model,low_bnd,up_bnd,level,max_order,tolerance)

References

1. Kruppa, K., Pangalos, G., and Lichtenberg, G. Multilinear approximation of nonlinear state-space models. IFAC Proceedings Volumes, 47(3):9474–9479, 2014.

2. Piazzola, C., and Tamellini, L. The Sparse Grids Matlab kit — a Matlab implementation of sparse grids for high-dimensional function approximation and uncertainty quantification. 2023. Package webpage: https://sites.google.com/view/sparse-grids-kit/home (check it for the most up-to-date citation data).

See Also

• mss

MyToolbox Documentation | Generated automatically by CI/CD pipeline