Documentation

GPU code generation supports the following syntaxes:

The input X must not have variable size. The size must be fixed at code generation time.

GPU code generation for the activations function supports inputs that are defined as half-precision floating point data types. For more information, see half.

The layer argument must be a compile-time constant.

Only the 'OutputAs' and 'MiniBatchSize' name-value pair arguments are supported for code generation. The value of the 'OutputAs' name-value pair must be 'channels'.

All name-value pairs must be compile-time constants.

For code generation, you can load the network by using the syntax net = alexnet or by passing the alexnet function to coder.loadDeepLearningNetwork. For example: net = coder.loadDeepLearningNetwork('alexnet').

For more information, see Load Pretrained Networks for Code Generation.

The syntax alexnet('Weights','none') is not supported for GPU code generation.

Input text must be specified as a character array. Cell arrays are not supported.

When the input is empty, the answer does not match the answer in MATLAB.

BW must be a 2-D binary image. N-D arrays are not supported.

conn must be one of the two-dimensional connectivities (4 or 8) or a 3-by-3 matrix. The 3-D connectivities (6, 18, and 26) are not supported. Matrices of size 3-by-3-by-...-by-3 are not supported.

conn must be a compile-time constant.

The parameter conn must be a compile-time constant.

The parameter options must be a compile-time constant.

The return value A can only be a full matrix, not a sparse matrix.

bwconncomp only supports 2-D inputs.

The conn arguments must be a compile-time constant and the only connectivities supported are 4 or 8. You can also specify connectivity as a 3-by-3 matrix, but it can only be [0 1 0;1 1 1;0 1 0] or ones(3)

The PixelIdxList field in the CC struct return value is not supported.

bwperim supports only 2-D images.

bwperim does not support a no-output-argument syntax.

The connectivity matrix input argument, conn, must be a constant.

When generating code, bwselect supports only these syntaxes:

In addition, the optional fourth input argument, n, must be a compile-time constant.

GPU code generation supports the following syntaxes:

GPU code generation for the classify function is not supported for regression networks and networks with multiple outputs.

GPU code generation for the classify function supports inputs that are defined as half-precision floating point data types. For more information, see half.

The input X must not have variable size. The size must be fixed at code generation time.

GPU code generation supports only vector sequences. The sequence length can be variable sized. The feature dimension must be fixed at code generation time.

Only the 'MiniBatchSize', 'SequenceLength', 'SequencePaddingDirection', and 'SequencePaddingValue' name-value pair arguments are supported for code generation. All name-value pairs must be compile-time constants.

Only the 'longest' and 'shortest' option of the 'SequenceLength' name-value pair is supported for code generation.

If supplied, dim must be a constant.

Code generation does not support sparse matrix inputs for this function.

Single- and double-precision input signal are supported. The precision must be set at compile time.

Timetable input signal is not supported.

Only analytic Morse ('morse') and Morlet ('amor') wavelets are supported.

The following input arguments are not supported: Sampling period (ts), PeriodLimits name-value pair, NumOctave name-value pair, and FilterBank name-value pair.

Scaling coefficient output and filter bank output are not supported.

Plotting is not supported.

Logical inputs are not supported. Cast input to double first.

Code generation does not support sparse matrix inputs for this function.

Logical inputs are not supported. Cast input to double first.

Code generation does not support sparse matrix inputs for this function.

Only the activations, predict, and classify methods are supported.

To create a DAGNetwork object for code generation, see Load Pretrained Networks for Code Generation.

For code generation, you can load the network by using the syntax net = darknet19 or by passing the darknet19 function to coder.loadDeepLearningNetwork. For example: net = coder.loadDeepLearningNetwork('darknet19').

For more information, see Load Pretrained Networks for Code Generation.

The syntax darknet19('Weights','none') is not supported for GPU code generation.

For code generation, you can load the network by using the syntax net = darknet53 or by passing the darknet53 function to coder.loadDeepLearningNetwork. For example: net = coder.loadDeepLearningNetwork('darknet53').

For more information, see Load Pretrained Networks for Code Generation.

The syntax darknet53('Weights','none') is not supported for GPU code generation.

For code generation, you can load the network by using the syntax net = densenet201 or by passing the densenet201 function to coder.loadDeepLearningNetwork. For example: net = coder.loadDeepLearningNetwork('densenet201').

For more information, see Load Pretrained Networks for Code Generation.

The syntax densenet201('Weights','none') is not supported for GPU code generation.

If you supply k, then it must be a real and scalar integer value.

For variable-size inputs that are variable-length vectors (1-by-: or :-by-1), diag:

For variable-size inputs that are not variable-length vectors, diag:

If the input is variable-size (:m-by-:n) and has shape 0-by-0 at run time, then the output is 0-by-1, not 0-by-0. However, if the input is a constant size 0-by-0, then the output is [].

For variable-size inputs that are not variable-length vectors (1-by-: or :-by-1), diag treats the input as a matrix from which to extract a diagonal vector. This behavior occurs even if the input array is a vector at run time. To force diag to build a matrix from variable-size inputs that are not 1-by-: or :-by-1, use:

The input images I1 and I2 must be rectified, same size, and of same data type.

GPU code generation supports the 'UniquenessThreshold' and 'disparityMap' name-value pairs.

For very large inputs, the memory requirements of the algorithm may exceed the GPU device limits. In such cases, consider reducing the input size to proceed with code generation.

The method, direction, and sigma arguments must be compile-time constants.

The 'approxcanny' method is not supported.

Nonprogrammatic syntaxes are not supported. For example, if you do not specify a return value, then edge displays an image. This syntax is not supported with code generation.

typename must be a built-in MATLAB numeric type. Does not invoke the static eye method for other classes. For example, eye(m, n, 'myclass') does not invoke myclass.eye(m,n).

Size arguments must have a fixed size.

If supplied, dim must be a constant.

See Variable-Sizing Restrictions for Code Generation of Toolbox Functions (MATLAB Coder).

If the inputs have nonfinite values (inf or NaN), the results from the generated code may not numerically match MATLAB simulation.

When generating code, the transformationType argument must be a compile-time constant and only the following transformation types are supported: 'nonreflectivesimilarity', 'similarity', 'affine', and 'projective'.

For code generation, you can load the network by using the syntax net = googlenet or by passing the googlenet function to coder.loadDeepLearningNetwork. For example: net = coder.loadDeepLearningNetwork('googlenet').

For more information, see Load Pretrained Networks for Code Generation.

The syntax googlenet('Weights','none') is not supported for GPU code generation.

CUDA compute capability of 5.3 or higher is required for generating and executing code with half-precision data types.

CUDA toolkit version of 10.0 or higher is required for generating and executing code with half-precision data types.

The memory allocation (malloc) mode for generating CUDA code must be set to 'Discrete'.

For more information, see coder.gpuConfig.

Half-precision complex data types are not supported for GPU code generation.

For GPU Code generation, half-precision matrix multiplication can only be performed with real inputs.

In MATLAB, the isobject function returns true with a half-precision input. However, in generated code, this function returns false.

If your target hardware does not have native support for half-precision, then half is used as a storage type, with arithmetic operations performed in single precision.

Some functions use half only as a storage type and the arithmetic is always performed in single-precision, regardless of the target hardware.

Code generation for 32-bit targets is not supported if your MATLAB code contains half-precision data types.

The optional parameters 'Theta' and 'RhoResolution' must be compile-time string constants.

The optional Theta vector must have a bounded size.

Output is complex.

Symmetry type 'symmetric' is not supported.

For limitations related to variable-size data, see Variable-Sizing Restrictions for Code Generation of Toolbox Functions (MATLAB Coder).

Symmetry type 'symmetric' is not supported.

The sz argument must have a fixed size.

The input image I must be 2-D or 3-D.

The structuring element SE must be a compile-time constant.

Supports only up to 3-D inputs.

The optional second input argument, conn, must be a compile-time constant.

The input image I must be 2-D or 3-D.

The structuring element SE must be a compile-time constant.

The interactive syntaxes are not supported, including:

Indexed images are not supported, including the non-interactive syntax X2 = imcrop(X,cmap,rect);

The input image, IM, must be 2-D or 3-D.

The structuring element argument SE must be a compile-time constant.

Packed binary input image (PACKOPT syntax) is not supported.

For 3-D input images with more than three channels, only C/C++ code is generated.

CUDA code is generated only for 1-D or 2-D structuring elements. If the structuring element is 3-D, C/C++ code is generated. Code generation is not supported for structuring elements with more than three dimensions.

For non-flat structuring elements, only C/C++ code is generated.

The optional input arguments, conn and 'holes', must be compile-time constants.

imfill supports up to 3-D inputs only. (No N-D support.)

The interactive syntax to select points, imfill(BW,0,CONN) is not supported.

With the locations input argument, once you select a format at compile time, you cannot change it at run time. However, the number of points in locations can be varied at run time.

When generating code, the input image, A, must be 2-D or 3-D. The value of the input argument, options, must be a compile-time constant.

If you specify a large kernel h, a kernel that contains large values, or specify an image containing large values, you can see different results between MATLAB and generated code using codegen for floating point data types. This happens because of accumulation errors due to different algorithm implementations.

With CUDA toolkit v9.0, a bug in the NVIDIA^® optimization causes numerical mismatch between the results from the generated code and MATLAB. As a workaround, turn off the optimization by passing the following flags to the configuration object (cfg) before generating the code.

cfg.GpuConfig.CompilerFlags = ‘-Xptxas -O0’

NVIDIA is expected to fix this bug in CUDA toolkit v9.1.

imgaussfilt does not support the FilterDomain parameter for code generation. Filtering is always done in the 'spatial' domain in generated code.

When generating code, all character vector input arguments must be compile-time constants.

If the first input is a binary image, then n must be a scalar constant of value 2 at compile time.

Nonprogrammatic syntaxes are not supported. For example, the syntax imhist(I), where imhist displays the histogram, is not supported.

The input image I must be 2-D or 3-D.

The structuring element SE must be a compile-time constant.

When generating code, the optional third input argument, conn, must be a compile-time constant, and can only take the value 4 or 8.

imreconstruct does not support uint64 and int64 data types for code generation.

Supports reading of 8-bit JPEG images only. The input argument filename must be a valid absolute path or relative path.

'Colormap' and 'Dither' Name-Value pair arguments are not supported.

Indexed image is not supported.

Custom interpolation kernel is not supported.

For certain interpolation kernels, there may be a small numerical mismatch between the results in MATLAB and the generated code.

Input images of data type categorical are not supported.

The method and bbox arguments must be compile-time constants.

The image input I must be 2-D or 3-D.

The structuring element SE must be a compile-time constant.

Input images of data type categorical are not supported.

The geometric transformation object input, tform, must be an affine2d or projective2d object and must be constant.

The interpolation method and optional parameter names must be constants.

The spatial referencing information output, RB, is not supported.

For code generation, you can load the network by using the syntax net = inceptionv3 or by passing the inceptionv3 function to coder.loadDeepLearningNetwork. For example: net = coder.loadDeepLearningNetwork('inceptionv3').

For more information, see Load Pretrained Networks for Code Generation.

The syntax inceptionv3('Weights','none') is not supported for GPU code generation.

Xq and Yq must be the same size. Use meshgrid to evaluate on a grid.

For best results, provide X and Y as vectors. The values in these vectors must be strictly monotonic and increasing.

Code generation does not support the 'makima' interpolation method.

For the 'cubic' interpolation method, if the grid does not have uniform spacing, an error results. In this case, use the 'spline' interpolation method.

For best results when you use the 'spline' interpolation method:

The opts structure must be a constant scalar. Code generation does not support arrays of options structures.

Code generation only optimizes these cases:

Other options are equivalent to using mldivide.

Code generation does not support sparse matrix inputs for this function.

If you specify dim, then it must be a constant.

The outtype and nanflag options must be constant character vectors.

Integer types do not support the 'native' output data type option.

For code generation, you can load the network by using the syntax net = mobilenetv2 or by passing the mobilenetv2 function to coder.loadDeepLearningNetwork. For example: net = coder.loadDeepLearningNetwork('mobilenetv2')

For more information, see Load Pretrained Networks for Code Generation.

The syntax mobilenetv2('Weights','none') is not supported for GPU code generation.

If A is a 2-by-2 or larger matrix and B is Inf or -Inf, then A^B returns a matrix of NaN values.

For A^b, if b is a noninteger scalar, then at least one of A or b must be complex.

Code generation does not support sparse matrix inputs for this function.

GPU code generation requires the inputs to be bounded. If the input is of variable dimension, the software generates C code.

When generating code, the padopt argument must be a compile-time constant.

The generated GPU code is not optimized if the domain value that defines the neighborhood for the filtering operation is of size greater than 11x11.

For better performance, consider setting the StackLimitPerThread option in the coder.gpuConfig object to Inf.

Input arrays of data type categorical are not supported.

When generating code, padarray supports only up to 3-D inputs.

The input arguments padval and direction must be compile-time constants.

The supported distance input argument values (Distance) for optimized CUDA code are 'euclidean', 'squaredeuclidean', 'seuclidean', 'cityblock', 'minkowski', 'chebychev', 'cosine', 'correlation', 'hamming', and 'jaccard'.

Distance cannot be a custom distance function.

Distance must be a compile-time constant.

The supported distance input argument values (Distance) for optimized CUDA code are 'euclidean', 'squaredeuclidean', 'seuclidean', 'cityblock', 'minkowski', 'chebychev', 'cosine', 'correlation', 'hamming', and 'jaccard'.

Distance cannot be a custom distance function.

Distance must be a compile-time constant.

Names in name-value pair arguments must be compile-time constants.

The sorted order of tied distances in the generated code can be different from the order in MATLAB due to numerical precision.

GPU code generation for variable input sizes is not optimized. Consider using constant size inputs for an optimized code generation.

GPU code generation supports the 'Color', 'Normal', and 'Intensity' name-value pairs.

GPU code generation supports the findNearestNeighbors, findNeighborsInRadius, findPointsInROI, removeInvalidPoints, and select methods.

For very large inputs, the memory requirements of the algorithm may exceed the GPU device limits. In such cases, consider reducing the input size to proceed with code generation.

When both X and Y are real, but power(X,Y) is complex, simulation produces an error and generated code returns NaN. To get the complex result, make the input value X complex by passing in complex(X). For example, power(complex(X),Y).

When both X and Y are real, but X .^ Y is complex, simulation produces an error and generated code returns NaN. To get the complex result, make the input value X complex by using complex(X). For example, complex(X).^Y.

Code generation does not support sparse matrix inputs for this function.

GPU code generation supports the following syntaxes:

The input X must not have variable size. The size must be fixed at code generation time.

GPU code generation for the predict function supports inputs that are defined as half-precision floating point data types. For more information, see half.

GPU code generation supports only vector sequences. The sequence length can be variable sized. The feature dimension must be fixed at code generation time.

Only the 'MiniBatchSize', 'SequenceLength', 'SequencePaddingDirection', and 'SequencePaddingValue' name-value pair arguments are supported for code generation. All name-value pairs must be compile-time constants.

Only the 'longest' and 'shortest' option of the 'SequenceLength' name-value pair is supported for code generation.

GPU code generation supports the following syntaxes:

GPU code generation for the predictAndUpdateState function is only supported for recurrent neural networks and cuDNN target library.

GPU code generation supports only vector sequences. The sequence length can be variable sized. The feature dimension must be fixed at code generation time.

Only the 'MiniBatchSize', 'SequenceLength', 'SequencePaddingDirection', and 'SequencePaddingValue' name-value pair arguments are supported for code generation. All name-value pairs must be compile-time constants.

Only the 'longest' and 'shortest' option of the 'SequenceLength' name-value pair is supported for code generation.

Size arguments must have a fixed size.

For sparse matrices, the repmat function does not support trailing ones as inputs after the first two dimensions.

If the input is a compile-time empty cell array, then the size arguments must be constants.

Size arguments must have a fixed size.

For sparse matrices, the reshape function does not support trailing ones as inputs after the first two dimensions.

For code generation, you can load the network by using the syntax net = resnet18 or by passing the resnet18 function to coder.loadDeepLearningNetwork. For example: net = coder.loadDeepLearningNetwork('resnet18')

For more information, see Load Pretrained Networks for Code Generation.

The syntax resnet18('Weights','none') is not supported for GPU code generation.

For code generation, you can load the network by using the syntax net = resnet50 or by passing the resnet50 function to coder.loadDeepLearningNetwork. For example: net = coder.loadDeepLearningNetwork('resnet50')

For more information, see Load Pretrained Networks for Code Generation.

The syntax resnet50('Weights','none') is not supported for GPU code generation.

For code generation, you can load the network by using the syntax net = resnet101 or by passing the resnet101 function to coder.loadDeepLearningNetwork. For example: net = coder.loadDeepLearningNetwork('resnet101')

For more information, see Load Pretrained Networks for Code Generation.

The syntax resnet101('Weights','none') is not supported for GPU code generation.

Code generation supports only the syntax Y = round(X).

Code generation does not support char or logical data types for X.

Code generation is only supported for numeric labels.

Code generation is not supported for rotated rectangle bounding box inputs.

Only the activations, classify, predict, predictAndUpdateState, and resetState object functions are supported.

To create a SeriesNetwork object for code generation, see Load Pretrained Networks for Code Generation.

The first input argument must not be a cell array.

If A is complex with all zero imaginary parts, then MATLAB might convert A to real(A) before calling sortrows(A). In this case, MATLAB sorts the rows of A by real(A), but the generated code sorts the rows of A by abs(A). To make the generated code match MATLAB, use sortrows(real(A)) or sortrows(A,'ComparisonMethod','real').

For code generation, you can load the network by using the syntax net = squeezenet or by passing the squeezenet function to coder.loadDeepLearningNetwork. For example: net = coder.loadDeepLearningNetwork('squeezenet').

For more information, see Load Pretrained Networks for Code Generation.

The syntax squeezenet('Weights','none') is not supported for GPU code generation.

Only the detect method of the ssdObjectDetector is supported for code generation.

The bounding box output from code generation may have small numerical differences with the simulation results from MATLAB.

The code generator resizes the input image size to the detect method to that of the input layer size of the network. However, the bounding boxes output generated is with reference to the original input size.

The roi argument to the detect method must be a codegen constant (coder.const()) and a 1x4 vector.

Only the Threshold, SelectStrongest, MinSize, MaxSize, and MiniBatchSize Name-Value pairs are supported. All name-value pair must be compile time constant.

The channel and batch size of the input image must be fixed size.

The labels output is returned as a categorical array.

The 'ConjugateSymmetric' argument is not supported for code generation.

Timetables are not supported for code generation.

The first argument must be a valid size vector. Code generation does not support size vectors for arrays with more than intmax elements.

The generated code treats NaN inputs as out of range and throws a run-time error.

If you specify dim, then it must be a constant.

The outtype and nanflag options must be constant character vectors.

All character vector inputs must be compile-time constants.

The value of 'IsInputLab' (true or false) must be a compile-time constant.

Code generation uses a different SVD implementation than MATLAB uses. Because the singular value decomposition is not unique, left and right singular vectors might differ from those computed by MATLAB.

When the input matrix contains a nonfinite value, the generated code does not issue an error. Instead, the output contains NaN values.

Code generation does not support sparse matrix inputs for this function.

Multiplication of pure imaginary numbers by non-finite numbers might not match MATLAB. The code generator does not specialize multiplication by pure imaginary numbers—it does not eliminate calculations with the zero real part. For example, (Inf + 1i)*1i = (Inf*0 – 1*1) + (Inf*1 + 1*0)i = NaN + Infi.

If you use times with single type and double type operands, the generated code might not produce the same result as MATLAB.

The value of the data type argument must be lowercase.

When you use typecast with inherited input port data types in MATLAB Function blocks, the software can throw a size error. To avoid this error, specify the block input port data types explicitly.

Integer input or result classes must map directly to a C type on the target hardware.

The input must be a variable-length vector or a fixed-size vector.

The output vector always has the same orientation as the input vector.

For code generation, you can load the network by using the syntax net = vgg16 or by passing the vgg16 function to coder.loadDeepLearningNetwork. For example: net = coder.loadDeepLearningNetwork('vgg16')

For more information, see Load Pretrained Networks for Code Generation.

The syntax vgg16('Weights','none') is not supported for GPU code generation.

For code generation, you can load the network by using the syntax net = vgg19 or by passing the vgg19 function to coder.loadDeepLearningNetwork. For example: net = coder.loadDeepLearningNetwork('vgg19')

For more information, see Load Pretrained Networks for Code Generation.

The syntax vgg19('Weights','none') is not supported for GPU code generation.

Supports only 2-D images

Supports only 4 or 8 connectivity

Supports images containing up to 65,535 regions

Output type is always uint16

For code generation, you can load the network by using the syntax net = xception or by passing the xception function to coder.loadDeepLearningNetwork. For example: net = coder.loadDeepLearningNetwork('xception')

For more information, see Load Pretrained Networks for Code Generation.

The syntax xception('Weights','none') is not supported for GPU code generation.

Only the detect method of the yolov2ObjectDetector is supported for code generation.

The roi argument to the detect method must be a codegen constant (coder.const()) and a 1x4 vector.

Only the Threshold, SelectStrongest, MinSize, MaxSize, and MiniBatchSize Name-Value pairs are supported.

The height, width, channel, and batch size of the input image must be fixed size.

The minimum batch size value passed to detect method must be fixed size.

The labels output is returned as a cell array of character vectors, such as {'car','bus'}.