Define Variable-Size Data for Code Generation
代码生成,使用变量之前开放rations or returning them as outputs, you must assign them a specific class, size, and complexity. Generally, after the initial assignment, you cannot reassign variable properties. Therefore, after assigning a fixed size to a variable or structure field, attempts to grow the variable or structure field might cause a compilation error. In these cases, you must explicitly define the data as variable-size by using one of these methods.
Method | See |
---|---|
Assign the data from a variable-size matrix constructor such as: |
Use a Matrix Constructor with Nonconstant Dimensions |
Assign multiple, constant sizes to the same variable before using (reading) the variable. | Assign Multiple Sizes to the Same Variable |
Define all instances of a variable to be variable-size. | Define Variable-Size Data Explicitly by Using coder.varsize |
Use a Matrix Constructor with Nonconstant Dimensions
您可以定义一个适应矩阵通过使用一个constructor with nonconstant dimensions. For example:
functions = var_by_assign(u)%#codegeny = ones(3,u); s = numel(y);
If you are not using dynamic memory allocation, you must also add anassert
statement to provide upper bounds for the dimensions. For example:
functions = var_by_assign(u)%#codegenassert (u < 20); y = ones(3,u); s = numel(y);
Assign Multiple Sizes to the Same Variable
Before you use (read) a variable in your code, you can make it variable-size by assigning multiple, constant sizes to it. When the code generator uses static allocation on the stack, it infers the upper bounds from the largest size specified for each dimension. When you assign the same size to a given dimension across all assignments, the code generator assumes that the dimension is fixed at that size. The assignments can specify different shapes and sizes.
When the code generator uses dynamic memory allocation, it does not check for upper bounds. It assumes that the variable-size data is unbounded.
Inferring Upper Bounds from Multiple Definitions with Different Shapes
functions = var_by_multiassign(u)%#codegenif(u > 0) y = ones(3,4,5);elsey = zeros(3,1);ends = numel(y);
When the code generator uses static allocation, it infers thaty
is a matrix with three dimensions:
The first dimension is fixed at size 3
The second dimension is variable-size with an upper bound of 4
The third dimension is variable-size with an upper bound of 5
When the code generator uses dynamic allocation, it analyzes the dimensions ofy
differently:
The first dimension is fixed at size 3.
The second and third dimensions are unbounded.
Define Variable-Size Data Explicitly by Using coder.varsize
To explicitly define variable-size data, use the functioncoder.varsize
. Optionally, you can also specify which dimensions vary along with their upper bounds. For example:
Define
B
as a variable-size 2-dimensional array, where each dimension has an upper bound of 64.coder.varsize('B', [64 64]);
Define
B
as a variable-size array:coder.varsize('B');
When you supply only the first argument,
coder.varsize
assumes that all dimensions ofB
can vary and that the upper bound issize(B)
.
If aMATLAB Functionblock input or output signal is variable-size, in the Property Inspector, you must specify that the signal is variable-size. You must also provide the upper bounds. You do not have to usecoder.varsize
with the corresponding input or output variable inside theMATLAB Functionblock. However, if you specify upper bounds withcoder.varsize
, they must match the upper bounds in the Property Inspector.
Specify Which Dimensions Vary
You can use the functioncoder.varsize
to specify which dimensions vary. For example, the following statement definesB
as an array whose first dimension is fixed at 2, but whose second dimension can grow to a size of 16:
coder.varsize('B',[2, 16],[0 1])
The third argument specifies which dimensions vary. This argument must be a logical vector or a double vector containing only zeros and ones. Dimensions that correspond to zeros orfalse
have fixed size. Dimensions that correspond to ones ortrue
vary in size.coder.varsize
usually treats dimensions of size 1 as fixed. SeeDefine Variable-Size Matrices with Singleton Dimensions.
For an input or output signal, if you specify the upper bounds withcoder.varsize
inside theMATLAB Functionblock, they must match the upper bounds in the Property Inspector.
Allow a Variable to Grow After Defining Fixed Dimensions
Functionvar_by_if
defines matrixY
with fixed 2-by-2 dimensions before the first use (where the statementY = Y + u
reads fromY
). However,coder.varsize
definesY
as a variable-size matrix, allowing it to change size based on decision logic in theelse
clause:
functionY = var_by_if(u)%#codegenif(u > 0) Y = zeros(2,2); coder.varsize('Y');if(u < 10) Y = Y + u;endelseY = zeros(5,5);end
Withoutcoder.varsize
, the code generator infersY
to be a fixed-size, 2-by-2 matrix. It generates a size mismatch error.
Define Variable-Size Matrices with Singleton Dimensions
A singleton dimension is a dimension for whichsize(A,dim)
= 1. Singleton dimensions are fixed in size when:
You specify a dimension with an upper bound of 1 in
coder.varsize
expressions.For example, in this function,
Y
behaves like a vector with one variable-size dimension:functionY = dim_singleton(u)%#codegenY = [1 2]; coder.varsize('Y', [1 10]);if(u > 0) Y = [Y 3];elseY = [Y u];end
You initialize variable-size data with singleton dimensions by using matrix constructor expressions or matrix functions.
For example, in this function,
X
andY
behave like vectors where only their second dimensions are variable-size.function[X,Y] = dim_singleton_vects(u)%#codegenY = ones(1,3); X = [1 4]; coder.varsize('Y','X');if(u > 0) Y = [Y u];elseX = [X u];end
You can override this behavior by usingcoder.varsize
to specify explicitly that singleton dimensions vary. For example:
functionY = dim_singleton_vary(u)%#codegenY = [1 2]; coder.varsize('Y', [1 10], [1 1]);if(u > 0) Y = [Y Y+u];elseY = [Y Y*u];end
In this example, the third argument ofcoder.varsize
is a vector of ones, indicating that each dimension ofY
varies in size.
Define Variable-Size Structure Fields
To define structure fields as variable-size arrays, use a colon (:
) as the index expression. The colon (:
) indicates that all elements of the array are variable-size. For example:
functiony=struct_example()%#codegend = struct('values', zeros(1,0),'color', 0); data = repmat(d, [3 3]); coder.varsize('data(:).values');fori = 1:numel(data) data(i).color = rand-0.5; data(i).values = 1:i;endy = 0;fori = 1:numel(data)ifdata(i).color > 0 y = y + sum(data(i).values);endend
The expressioncoder.varsize('data(:).values')
defines the fieldvalues
inside each element of matrixdata
to be variable-size.
Here are other examples:
coder.varsize('data.A(:).B')
In this example,
data
is a scalar variable that contains matrixA
. Each element of matrixA
contains a variable-size fieldB
.coder.varsize('data(:).A(:).B')
This expression defines field
B
inside each element of matrixA
inside each element of matrixdata
to be variable-size.