## Generate Code for Growing Arrays and Cell Arrays with `end + 1`

Indexing

Code generation supports growing either an array or a cell array in your MATLAB^{®} code by using `end + 1`

indexing. To use this
functionality, make sure that the code generation configuration property
`EnableVariableSizing`

or the corresponding setting
**Enable variable-sizing** in the MATLAB
Coder™ app is enabled.

### Grow Array with `(end + 1)`

Indexing

To grow an array `X`

, you can assign a value to ```
X(end +
1)
```

. If you make this assignment in your MATLAB code, the code generator treats the dimension you grow as
variable-size.

For example, you can generate code for this code snippet:

... a = [1 2 3 4 5 6]; a(end + 1) = 7; b = [1 2]; for i = 3:10 b(end + 1) = i; end ...

When you use `(end + 1)`

to grow an array, follow these
restrictions:

Use only

`(end + 1)`

. Do not use`(end + 2)`

,`(end + 3)`

, and so on.Use

`(end + 1)`

with vectors only. For example, the following code is not allowed because`X`

is a matrix, not a vector.... X = [1 2; 3 4]; X(end + 1) = 5; ...

You can grow empty arrays of size

`1x0`

by using`(end + 1)`

. Growing arrays of size`0x1`

is not supported. Growing an array of size`0x0`

is supported only if you create that array by using`[]`

.

#### Growing Variable-Size Column Array That is Initialized as Scalar at Run Time

In MATLAB execution, if you grow a scalar array by using
`(end+1)`

indexing, the array grows along the second
dimension and produces a row vector. For example, define the function
`grow`

:

function z = grow(n, m) n(end+1) = m; z = n; end

Call `grow`

with example inputs:

grow(2,3)

ans = 2 3

By contrast, in code generation, suppose that:

You specify the array to be of variable-size column type (for example,

`:Inf x 1`

) at compile time,*and*Initialize this array as a scalar at run time.

In such situations, the generated code attempts to grow the
scalar along the first dimension and therefore, produces a run-time error. For
example, generate MEX code for `grow`

. Specify the input
`n`

to be a `:Inf x 1`

double array.
Specify the input `m`

to be a double scalar.

codegen grow -args {coder.typeof(0, [Inf 1], [1 0]), 1}

Code generation successful.

Run the generated MEX with the same inputs as before.

grow_mex(2,3)

Attempted to grow a scalar along the first dimension using end+1 indexing. This behavior differs from MATLAB execution which grows a scalar along the second dimension. Error in grow (line 2) n(end+1) = m;

**How to Avoid This Error. **To avoid this error and grow the array along the column dimension in both
generated code and MATLAB execution, rewrite your MATLAB code in *either* of these ways:

Grow the array using the concatenation operator instead of using

`(end+1)`

. For example, rewrite the`grow`

function as:function z = growCat(n, m) n = [n;m]; z = n; end

In your function, create a temporary variable by transposing the variable that you want to grow. Then, grow this temporary variable by using

`(end+1)`

indexing. Finally, take a second transpose of this temporary variable. For example, rewrite the`grow`

function as:function z = growTransposed(n, m) temp = n'; temp(end+1) = m; z = temp'; end

### Grow Cell Array with `{end + 1}`

Indexing

To grow a cell array `X`

, you can use ```
X{end +
1}
```

. For
example:

... X = {1 2}; X{end + 1} = 'a'; ...

When you use `{end + 1}`

to grow a cell array, follow these restrictions:

Use only

`{end + 1}`

. Do not use`{end + 2}`

,`{end + 3}`

, and so on.Use

`{end + 1}`

with vectors only. For example, the following code is not allowed because`X`

is a matrix, not a vector:... X = {1 2; 3 4}; X{end + 1} = 5; ...

Use

`{end + 1}`

only with a variable. In the following code,`{end + 1}`

does not cause`{1 2 3}`

to grow. In this case, the code generator treats`{end + 1}`

as an out-of-bounds index into`X{2}`

.... X = {'a' { 1 2 3 }}; X{2}{end + 1} = 4; ...

When

`{end + 1}`

grows a cell array in a loop, the cell array must be variable-size. Therefore, the cell array must be homogeneous.This code is allowed because

`X`

is homogeneous.... X = {1 2}; for i=1:n X{end + 1} = 3; end ...

This code is not allowed because

`X`

is heterogeneous.... X = {1 'a' 2 'b'}; for i=1:n X{end + 1} = 3; end ...

For a coding pattern that causes a difference in behavior between generated code and MATLAB, see Growing Variable-Size Column Cell Array That is Initialized as Scalar at Run Time.