makeHomogeneous

Class: coder.CellType
Namespace: coder

Create a homogeneous copy of a cell array type

Syntax

newt = makeHomogeneous(t) t = makeHomogeneous(t)

newt = makeHomogeneous(t) creates a coder.CellType object for a homogeneous cell array newt from the coder.CellType object t.

To create newt, the makeHomogeneous method must determine a size and class that represent all elements of t:

If the elements of t have the same class, but different sizes, the elements of newt are variable size with upper bounds that accommodate the elements of t.
If the elements of t have different classes, for example, char and double, the makeHomogeneous method cannot create a coder.CellType object for a homogeneous cell array.

The classification as homogeneous is permanent. You cannot later create a heterogeneous coder.CellType object from newt.

t = makeHomogeneous(t) creates a homogeneous coder.CellType object from t and replaces t with the new object.

Create a cell array type t whose elements have the same class, but different sizes.

t = coder.typeof({1 [2 3]})

t = 

coder.CellType
   1x2 heterogeneous cell 
      f0: 1x1 double
      f1: 1x2 double

The cell array type is heterogeneous.

Replace t with a cell array type for a homogeneous cell array.

t = makeHomogeneous(t)

t = 

coder.CellType
   1×2 locked homogeneous cell 
      base: 1×:2 double

The new cell array type is homogeneous.

In the display of a coder.CellType object, the terms locked heterogeneous or locked homogeneous indicate that the classification as homogeneous or heterogeneous is permanent. You cannot later change the classification by using the makeHomogeneous or makeHeterogeneous methods.
coder.typeof determines whether the cell array type is homogeneous or heterogeneous. If the cell array elements have the same class and size, coder.typeof returns a homogeneous cell array type. If the elements have different classes, coder.typeof returns a heterogeneous cell array type. For some cell arrays, the classification as homogeneous or heterogeneous is ambiguous. For example, the type for {1 [2 3]} can be a 1x2 heterogeneous type. The first element is double and the second element is 1x2 double. The type can also be a 1x3 homogeneous type in which the elements have class double and size 1x:2. For these ambiguous cases, coder.typeof uses heuristics to classify the type as homogeneous or heterogeneous. If you want a different classification, use the makeHomogeneous or makeHeterogeneous methods.

Introduced in R2015b