coder.newtype

Create coder.Type object to represent type of an entry-point function input

Syntax

t = coder.newtype(numeric_class,sz,variable_dims)

t = coder.newtype(numeric_class,sz,variable_dims,
Name,Value)

t = coder.newtype('constant',value)

t = coder.newtype('struct',struct_fields,sz,variable_dims)

t = coder.newtype('cell',cells,sz,variable_dims)

t = coder.newtype('embedded.fi',numerictype,sz,variable_dims,
Name,Value)

t = coder.newtype(enum_value,sz,variable_dims)

t = coder.newtype('class_name')

t = coder.newtype('string')

Description

The coder.newtype function is an advanced function that you can use to control the coder.Type object. Consider using coder.typeof instead of coder.newtype. The function coder.typeof creates a type from a MATLAB^® example. By default, t = coder.newtype('class_name') does not assign any properties of the class, class_name to the object t.

Note

You can also create and edit coder.Type objects interactively by using the Coder Type Editor. See Create and Edit Input Types by Using the Coder Type Editor.

t = coder.newtype(numeric_class,sz,variable_dims) creates a coder.Type object representing values of class numeric_class, sizes sz (upper bound), and variable dimensions variable_dims. If sz specifies inf for a dimension, then the size of the dimension is unbounded and the dimension is variable-size. When variable_dims is not specified, the dimensions of the type are fixed except for those that are unbounded. When variable_dims is a scalar, it is applied to type dimensions that are not 1 or 0, which are fixed.

example

t = coder.newtype(numeric_class,sz,variable_dims, Name,Value) creates a coder.Type object by using additional options specified as one or more Name, Value pair arguments.

t = coder.newtype('constant',value) creates a coder.Constant object representing a single value. Use this type to specify a value that must be treated as a constant in the generated code.

example

t = coder.newtype('struct',struct_fields,sz,variable_dims) creates a coder.StructType object for an array of structures that has the same fields as the scalar structure struct_fields. The structure array type has the size specified by sz and variable-size dimensions specified by variable_dims.

example

t = coder.newtype('cell',cells,sz,variable_dims) creates a coder.CellType object for a cell array that has the cells and cell types specified by cells. The cell array type has the size specified by sz and variable-size dimensions specified by variable_dims. You cannot change the number of cells or specify variable-size dimensions for a heterogeneous cell array.

example

t = coder.newtype('embedded.fi',numerictype,sz,variable_dims, Name,Value) creates a coder.FiType object representing a set of fixed-point values that have numerictype and additional options specified by one or more Name, Value pair arguments.

example

t = coder.newtype(enum_value,sz,variable_dims) creates a coder.Type object representing a set of enumeration values of class enum_value.

example

t = coder.newtype('class_name') creates a coder.ClassType object for an object of the class class_name. The new object does not have any properties of the class class_name.

example

t = coder.newtype('string') creates a coder.StringType object for a string scalar. A string scalar contains one piece of text represented as a character vector. To specify the size of the character vector and whether the second dimension is variable-size, set the StringLength property to the required size and set VariableStringLength to true. For example, t.StringLength = 10 and t.VariableStringLength = true specifies that the string scalar is variable-size with an upper bound of 10.

example

Examples

collapse all

Create Type for a Matrix

Create a type for a variable-size matrix of doubles.

t = coder.newtype('double',[2 3 4],[1 1 0])

t = 

coder.PrimitiveType
   :2×:3×4 double
% ':' indicates variable-size dimensions

Create a type for a matrix of doubles, first dimension unbounded, and second dimension with fixed size.

t = coder.newtype('double',[inf,3])

t = 

coder.PrimitiveType
   :inf×3 double

t = coder.newtype('double',[inf,3],[1 0])

%  also returns 
t = 

coder.PrimitiveType
   :inf×3 double
%  ':' indicates variable-size dimensions

Create a type for a matrix of doubles, first dimension unbounded, and second dimension with variable-size that has an upper bound of 3.

t = coder.newtype('double',[inf,3],[0 1])

t = 

coder.PrimitiveType
   :inf×:3 double

%  ':' indicates variable-size dimensions

Create Type for a Structure

Create a type for a structure with a variable-size field.

ta = coder.newtype('int8',[1 1]);
tb = coder.newtype('double',[1 2],[1 1]);
t = coder.newtype('struct',struct('a',ta,'b',tb),[1 1],[1 1])

t = 

coder.StructType
   :1×:1 struct
      a: 1×1 int8
      b: :1×:2 double
% ':' indicates variable-size dimensions

Create Type for a Cell Array

Create a type for a heterogeneous cell array.

ta = coder.newtype('int8',[1 1]);
tb = coder.newtype('double',[1 2],[1 1]);
t = coder.newtype('cell',{ta, tb})

t = 

coder.CellType
   1×2 heterogeneous cell 
      f1: 1×1 int8
      f2: :1×:2 double
% ':' indicates variable-size dimensions

Create a type for a homogeneous cell array.

ta = coder.newtype('int8',[1 1]);
tb = coder.newtype('int8',[1 2],[1 1]);
t = coder.newtype('cell',{ta, tb},[1,1],[1,1])

t = 

coder.CellType
   :1×:1 homogeneous cell 
      base: :1×:2 int8
% ':' indicates variable-size dimensions

Create Type for a Constant

Create a new constant type to use in code generation.

t = coder.newtype('constant',42)

t = 

coder.Constant
       42

Create a `coder.EnumType` Object

Create a coder.EnumType object by using the name of an existing MATLAB enumeration.

1. Define an enumeration MyColors. On the MATLAB path, create a file named MyColors containing:

classdef MyColors < int32
    enumeration
        green(1),
        red(2),
    end
end

2. Create a coder.EnumType object from this enumeration.

t = coder.newtype('MyColors')

t = 

coder.EnumType
   1×1 MyColors

Create a Fixed-Point Type

Create a fixed-point type for use in code generation.

The fixed-point type uses default fimath values.

t = coder.newtype('embedded.fi',numerictype(1, 16, 15),[1 2])

t = 

coder.FiType
   1×2 embedded.fi
             DataTypeMode: Fixed-point: binary point scaling
               Signedness: Signed
               WordLength: 16
           FractionLength: 15

Create a Type for an Object

Create a type for an object to use in code generation.

1. Create this value class:

classdef mySquare
    properties
        side;
    end
    
    methods
        function obj = mySquare(val)
            if nargin > 0
                obj.side = val;
            end
        end
        
        function a = calcarea(obj)
            a = obj.side * obj.side;
        end
        
    end
end

2. Create a type for an object that has the same properties as mySquare.

t = coder.newtype('mySquare');

3. The previous step creates a coder.ClassType type for t, but does not assign any properties of mySquare to it. To assign the properties of mySquare to t, change the type of the property side by using t.Properties.

t.Properties.side = coder.typeof(int8(3))

t = 

coder.ClassType
   1×1 mySquare   
      side: 1×1 int8

Create Type for a String Scalar

Create a type for a string scalar to use in code generation.

1. Create the string scalar type.

t = coder.newtype('string');

2. Specify the size.

t.StringLength = 10;

3. Make the string variable-size.

t.VariableStringLength = true;

4. To make the string variable-size with no upper bound, set StringLength to Inf.

t.StringLength = Inf;

Note

Setting StringLength to Inf implicitly sets VariableStringLength to true.

Input Arguments

collapse all

`numeric_class` — Class of values of type object
numeric (default)

Class of the set of values represented by the type object.

Example: coder.newtype('double',[6,3]);

`struct_fields` — Indicates fields in a new structure type
struct (default)

Scalar structure used to specify the fields in a new structure type.

Example: coder.newtype('struct',struct('a',ta,'b',tb));

Data Types: struct

`cells` — Specify types of cells in a new cell array type
cell array (default)

Cell array of coder.Type objects that specify the types of the cells in a new cell array type.

Example: coder.newtype('cell',{ta,tb});

Data Types: cell

`sz` — Dimension of type object
row vector of integer values

Size vector specifying each dimension of type object. The sz dimension cannot change the number of cells for a heterogeneous cell array.

Example: coder.newtype('int8',[1 2]);

`'class_name'` — Name of the class
character vector | string scalar

Name of the class from which the coder.ClassType is created. Specify as a character vector or string scalar. class_name must be the name of a value class.

Example: coder.newtype('mySquare')

Data Types: char | string

`variable_dims` — Variable- or fixed-dimension
row vector of logical values

The value of variable_dims is true for dimensions for which sz specifies an upper bound of inf; false for all other dimensions.

Logical vector that specifies whether each dimension is variable size (true) or fixed size (false). You cannot specify variable-size dimensions for a heterogeneous cell array.

Example: coder.newtype('char',[1,10],[0,1]);

Data Types: logical

`value` — Value of the constant
constant value (default)

Specifies the actual value of the constant.

Example: coder.newtype('constant',41);

`enum_value` — Enumeration values of class
enum (default)

Enumeration values of a class.

Example: coder.newtype('MyColors');

Name-Value Arguments

Specify optional pairs of arguments as Name1=Value1,...,NameN=ValueN, where Name is the argument name and Value is the corresponding value. Name-value arguments must appear after other arguments, but the order of the pairs does not matter.

Before R2021a, use commas to separate each name and value, and enclose Name in quotes.

Example: t = coder.newtype('double',[10 20],sparse = true)

`complex` — Type representing complex values
`false` (default) | `true`

Set complex to true to create a coder.Type object that can represent complex values. The type must support complex data.

`fimath` — Type representing `fimath` values
`fimath` object with default property settings | `fimath` object

Specify local fimath. If you do not specify fimath, the code generator uses default fimath values.

Use this option only when you create a coder.FiType object.

`sparse` — Type representing sparse data
`false` (default) | `true`

Set sparse to true to create a coder.Type object representing sparse data. The type must support sparse data.

This option is not supported when:

You create a coder.FiType object.
You set the gpu option to true.

`gpu` — Type representing GPU inputs
`false` (default) | `true`

Set gpu to true to create a coder.Type object that can represent the GPU input type. This option requires GPU Coder™.

Output Arguments

collapse all

`t` — New type object
coder.Type object

A new coder.Type object.

Limitations

For sparse matrices, coder.newtype drops upper bounds for variable-size dimensions.
For GPU input types, only bounded numeric and logical base types are supported. Scalar GPU arrays, structures, cell-arrays, classes, enumerated types, character, half-precision and fixed-point data types are not supported.
When using coder.newtype to represent GPU inputs, the memory allocation (malloc) mode property of the GPU code configuration object to 'discrete'.

Tips

The coder.newtype function fixes the size of a singleton dimension unless the variable_dims argument explicitly specifies that the singleton dimension has a variable size.
For example, this code specifies a 1-by-:10 double. The first dimension (the singleton dimension) has a fixed size. The second dimension has a variable size.
```
t = coder.newtype('double',[1 10],1)
```
By contrast, this code specifies a :1-by-:10 double. Both dimensions have a variable size.
```
t = coder.newtype('double',[1 10],[1 1])
```
For a MATLAB Function block, singleton dimensions of input or output signals cannot have a variable size.

Alternatives

coder.typeof

Version History

Introduced in R2011a

coder.newtype

Syntax

Description

Examples

Create Type for a Matrix

Create Type for a Structure

Create Type for a Cell Array

Create Type for a Constant

Create a `coder.EnumType` Object

Create a Fixed-Point Type

Create a Type for an Object

Create Type for a String Scalar

Input Arguments

`numeric_class` — Class of values of type object
numeric (default)

`struct_fields` — Indicates fields in a new structure type
struct (default)

`cells` — Specify types of cells in a new cell array type
cell array (default)

`sz` — Dimension of type object
row vector of integer values

`'class_name'` — Name of the class
character vector | string scalar

`variable_dims` — Variable- or fixed-dimension
row vector of logical values

`value` — Value of the constant
constant value (default)

`enum_value` — Enumeration values of class
enum (default)

Name-Value Arguments

`complex` — Type representing complex values
`false` (default) | `true`

`fimath` — Type representing `fimath` values
`fimath` object with default property settings | `fimath` object

`sparse` — Type representing sparse data
`false` (default) | `true`

`gpu` — Type representing GPU inputs
`false` (default) | `true`

Output Arguments

`t` — New type object
coder.Type object

Limitations

Tips

Alternatives

Version History

See Also

Topics

coder.newtype

Syntax

Description

Examples

Create Type for a Matrix

Create Type for a Structure

Create Type for a Cell Array

Create Type for a Constant

Create a coder.EnumType Object

Create a Fixed-Point Type

Create a Type for an Object

Create Type for a String Scalar

Input Arguments

numeric_class — Class of values of type object numeric (default)

struct_fields — Indicates fields in a new structure type struct (default)

cells — Specify types of cells in a new cell array type cell array (default)

sz — Dimension of type object row vector of integer values

'class_name' — Name of the class character vector | string scalar

variable_dims — Variable- or fixed-dimension row vector of logical values

value — Value of the constant constant value (default)

enum_value — Enumeration values of class enum (default)

Name-Value Arguments

complex — Type representing complex values false (default) | true

fimath — Type representing fimath values fimath object with default property settings | fimath object

sparse — Type representing sparse data false (default) | true

gpu — Type representing GPU inputs false (default) | true

Output Arguments

t — New type object coder.Type object

Limitations

Tips

Alternatives

Version History

See Also

Topics

Create a `coder.EnumType` Object

`numeric_class` — Class of values of type object
numeric (default)

`struct_fields` — Indicates fields in a new structure type
struct (default)

`cells` — Specify types of cells in a new cell array type
cell array (default)

`sz` — Dimension of type object
row vector of integer values

`'class_name'` — Name of the class
character vector | string scalar

`variable_dims` — Variable- or fixed-dimension
row vector of logical values

`value` — Value of the constant
constant value (default)

`enum_value` — Enumeration values of class
enum (default)

`complex` — Type representing complex values
`false` (default) | `true`

`fimath` — Type representing `fimath` values
`fimath` object with default property settings | `fimath` object

`sparse` — Type representing sparse data
`false` (default) | `true`

`gpu` — Type representing GPU inputs
`false` (default) | `true`

`t` — New type object
coder.Type object