Diagnose and Fix Variable-Size Data Errors

Diagnosing and Fixing Size Mismatch Errors

Issue: Assigning Variable-Size Matrices to Fixed-Size Matrices

You cannot assign variable-size matrices to fixed-size matrices in generated code. Consider this example:

function Y = example_mismatch1(n) %#codegen
assert(n < 10);
B = ones(n,n);
A = magic(3);
A(1) = mean(A(:));
if (n == 3)
    A = B;
end
Y = A;

Compiling this function produces this error:

??? Dimension 1 is fixed on the left-hand side 
but varies on the right ...

There are several ways to fix this error:

• Allow matrix A to grow by adding the coder.varsize construct:

  function Y = example_mismatch1_fix1(n) %#codegen
  coder.varsize('A');
  assert(n < 10);
  B = ones(n,n);
  A = magic(3);
  A(1) = mean(A(:));
  if (n == 3)
      A = B;
  end
  Y = A;

• Explicitly restrict the size of matrix B to 3-by-3 by modifying the assert statement:

  function Y = example_mismatch1_fix2(n) %#codegen
  coder.varsize('A');
  assert(n == 3)
  B = ones(n,n);
  A = magic(3);
  A(1) = mean(A(:));
  if (n == 3)
      A = B;
  end
  Y = A;

• Use explicit indexing to make B the same size as A:

  function Y = example_mismatch1_fix3(n) %#codegen
  assert(n < 10);
  B = ones(n,n);
  A = magic(3);
  A(1) = mean(A(:));
  if (n == 3)
      A = B(1:3, 1:3);
  end
  Y = A;

Issue: Empty Matrix Reshaped to Match Variable-Size Specification

If you assign an empty matrix [] to variable-size data, MATLAB^® might silently reshape the data in generated code to match a coder.varsize specification. For example:

function Y = test(u) %#codegen
Y = [];
coder.varsize('Y', [1 10]);
if u < 0
    Y = [Y u];
end

In this example, coder.varsize defines Y as a column vector of up to 10 elements, so its first dimension is fixed at size 1. The statement Y = [] designates the first dimension of Y as 0, creating a mismatch. The right hand side of the assignment is an empty matrix and the left hand side is a variable-size vector. In this case, MATLAB reshapes the empty matrix Y = [] in generated code to Y = zeros(1,0) so it matches the coder.varsize specification.

Issue: Assigning Implicitly Expanded Outputs to Fixed-Size Variable

If you assign the implicitly expanded output of a binary operation or function to a variable of different size, the code generator might produce an error. For example:

function out = test(n) %#codegen
x = ones(n,1);
if mod(n,2) == 1
	y = ones(n,n);
	x = y + x;
end 
out = out + x(2);
end

In this example, x is an unbounded vector. Due to implicit expansion, the plus operation on x and y results in an unbounded matrix (Inf-by-Inf). Assigning an unbounded matrix to x, which is an unbounded vector, results in an error.

If you want to use the implicitly expanded output, assign the output to a new variable with the same size as the output.

If you want x to retain its size and not apply implicit expansion in the generated code, use coder.sameSizeBinaryOp (MATLAB Coder) to apply the operation. You can also call coder.noImplicitExpansionInFunction (MATLAB Coder) in your function body to disable implicit expansion in the code generated for that function.

Implicit expansion automatically expands the operands to apply binary operations on arrays of compatible sizes. See Generate Code With Implicit Expansion Enabled (MATLAB Coder), Optimize Implicit Expansion in Generated Code (MATLAB Coder), and Compatible Array Sizes for Basic Operations.

Diagnosing and Fixing Errors in Detecting Upper Bounds

Issue: Using Nonconstant Dimensions in a Matrix Constructor

If you enable dynamic memory allocation, you can define variable-size data by assigning a variable to a matrix with nonconstant dimensions. For example:

function y = dims_vary(u) %#codegen
if (u > 0)
    y = ones(3,u);
else
    y = zeros(3,1);
end

By default, dynamic memory allocation is enabled for variable-size arrays whose size is greater than or equal to a configurable threshold. See Generate Code for Variable-Size Data (MATLAB Coder).

If you disable dynamic memory allocation, code generation for this function errors. If you do not want to use dynamic memory allocation, you can define a variable-size array with a fixed upper bound by using an assert statement. For example:

function y = dims_vary_fix(u) %#codegen
assert (u < 20);
if (u > 0)
    y = ones(3,u);
else
    y = zeros(3,1);
end