Documentation

coder.newtype

Package: coder

Create a coder.Type object

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

Note

coder.newtype is an advanced function that you can use to control the coder.Type object. Consider using coder.typeof instead. coder.typeof creates a type from a MATLAB® example.

t = coder.newtype(numeric_class, sz, variable_dims) creates a coder.Type object representing values of class numeric_class with (upper bound) sizes sz 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 dimensions of the type that are not 1 or 0, which are fixed.

t = coder.newtype(numeric_class, sz, variable_dims, Name, Value) creates a coder.Type object with additional options specified by 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.

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.

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.

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

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

t = coder.newtype(class_name) creates a coder.ClassType object for an object of the class class_name.

t = coder.newtype('string') creates a type 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, create a type for the character vector and assign it to the Value property of the string scalar type. For example, t.Properties.Value = coder.newtype('char',[1 10], [0 1]) specifies that the character vector inside the string scalar is variable-size with an upper bound of 10.

Input Arguments

numeric_class

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

struct_fields

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

cells

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

sz

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

Default: [1 1]

class_name

Name of class from which to create the coder.ClassType, specified as a character vector or string scalar. class_name must be the name of a value class.

variable_dims

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.

Default: true for dimensions for which sz specifies an upper bound of inf; false for all other dimensions.

Name-Value Pair Arguments

Specify optional comma-separated pairs of Name,Value arguments. Name is the argument name and Value is the corresponding value. Name must appear inside single quotes (' '). You can specify several name and value pair arguments in any order as Name1,Value1,...,NameN,ValueN.

'complex'

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

Default: false

'fimath'

Specify local fimath. If fimath is not specified, uses default fimath values.

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

'sparse'

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

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

Default: false

Output Arguments

t

New coder.Type object.

Examples

Create a type for use in code generation.

t=coder.newtype('double',[2 3 4],[1 1 0])
% Returns double :2x:3x4
% ':' indicates variable-size dimensions

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

coder.newtype('double',[inf,3]) 
%   returns double:inf x 3

coder.newtype('double', [inf, 3], [1 0]) 
%   also returns double :inf x3
%   ':' indicates variable-size dimensions

Create a type for a matrix of doubles, first dimension unbounded, second dimension with variable size with an upper bound of 3

coder.newtype('double', [inf,3],[0 1]) 
%  returns double :inf x :3
%  ':' indicates variable-size dimensions

Create a structure type to use in code generation.

ta = coder.newtype('int8',[1 1]);
tb = coder.newtype('double',[1 2],[1 1]);
coder.newtype('struct',struct('a',ta,'b',tb))
% returns struct 1x1
%            a: int8 1x1
%            b: double :1x:2
% ':' indicates variable-size dimensions

Create a cell array to use in code generation.

ta = coder.newtype('int8',[1 1]);
tb = coder.newtype('double',[1 2],[1 1]);
coder.newtype('cell',{ta, tb})
% returns 1x2 heterogeneous cell
%            f0: 1x1 int8
%            f1: :1x:2 double
% ':' indicates variable-size dimensions

Create a new constant type to use in code generation.

k = coder.newtype('constant', 42);
% Returns
% k = 
%
% coder.Constant
%       42

Create a coder.EnumType object 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');

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 = 
% Returns
% coder.FiType
%   1x2 embedded.fi 
%     DataTypeMode: Fixed-point: binary point scaling
%     Signedness: Signed
%     WordLength: 16
%     FractionLength: 15

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)
            end
        end
        if nargin > 0
            obj.side = val;
        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. Change the type of the property side.

    t.Properties.side = coder.typeof(int8(3))
    t = 
    
    coder.ClassType
       1×1 mySquare   
          side: 1×1 int8

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

  1. Create the string scalar type.

    t = coder.newtype('string');

  2. Specify the size.

    t.Properties.Value = coder.newtype('char',[1, 10])
    t = 
    
    coder.ClassType
       1×1 string -> redirected to -> coder.internal.string   
          Value: 1×10 char

  3. Make the string variable-size with an upper bound of 10.

    t.Properties.Value = coder.newtype('char',[1, 10], [0, 1])

  4. Make the string variable-size with no uppper bound.

    t.Properties.Value = coder.newtype('char',[1, inf])

Alternatives

coder.typeof

Introduced in R2011a

Was this topic helpful?