MATLAB® Coder User's Guide

• Publisher: MathWorks
• Year: 2022
• Tongue: English
• Leaves: 1476
• Category: Library

✦ Table of Contents

About MATLAB Coder
MATLAB Coder Product Description
Product Overview
When to Use MATLAB Coder
Code Generation for Embedded Software Applications
Code Generation for Fixed-Point Algorithms
Design Considerations for C/C++ Code Generation
When to Generate Code from MATLAB Algorithms
When Not to Generate Code from MATLAB Algorithms
Which Code Generation Feature to Use
Prerequisites for C/C++ Code Generation from MATLAB
MATLAB Code Design Considerations for Code Generation
See Also
Differences Between Generated Code and MATLAB Code
Functions that have Multiple Possible Outputs
Writing to ans Variable
Logical Short-Circuiting
Loop Index Overflow
Indexing for Loops by Using Single Precision Operands
Index of an Unentered for Loop
Character Size
Order of Evaluation in Expressions
Name Resolution While Constructing Function Handles
Termination Behavior
Size of Variable-Size N-D Arrays
Size of Empty Arrays
Size of Empty Array That Results from Deleting Elements of an Array
Binary Element-Wise Operations with Single and Double Operands
Floating-Point Numerical Results
NaN and Infinity
Negative Zero
Code Generation Target
MATLAB Class Property Initialization
MATLAB Classes in Nested Property Assignments That Have Set Methods
MATLAB Handle Class Destructors
Variable-Size Data
Complex Numbers
Converting Strings with Consecutive Unary Operators to double
Display Function
Potential Differences Reporting
Addressing Potential Differences Messages
Disabling and Enabling Potential Differences Reporting for MATLAB Coder
Disabling and Enabling Potential Differences Reporting for Fixed-Point Designer
Potential Differences Messages
Automatic Dimension Incompatibility
mtimes No Dynamic Scalar Expansion
Matrix-Matrix Indexing
Vector-Vector Indexing
Loop Index Overflow
MATLAB Language Features Supported for C/C++ Code Generation
MATLAB Features That Code Generation Supports
MATLAB Language Features That Code Generation Does Not Support
Functions, Classes, and System Objects Supported for Code Generation
Functions and Objects Supported for C/C++ Code Generation
Defining MATLAB Variables for C/C++ Code Generation
Variables Definition for Code Generation
Best Practices for Defining Variables for C/C++ Code Generation
Define Variables By Assignment Before Using Them
Use Caution When Reassigning Variables
Use Type Cast Operators in Variable Definitions
Define Matrices Before Assigning Indexed Variables
Index Arrays by Using Constant Value Vectors
Eliminate Redundant Copies of Variables in Generated Code
When Redundant Copies Occur
How to Eliminate Redundant Copies by Defining Uninitialized Variables
Defining Uninitialized Variables
Reassignment of Variable Properties
Reuse the Same Variable with Different Properties
When You Can Reuse the Same Variable with Different Properties
When You Cannot Reuse Variables
Limitations of Variable Reuse
Supported Variable Types
Edit and Represent Coder Type Objects and Properties
Object Properties
Legacy Representation of Coder Type Objects
Defining Data for Code Generation
Data Definition Considerations for Code Generation
Code Generation for Complex Data
Restrictions When Defining Complex Variables
Code Generation for Complex Data with Zero-Valued Imaginary Parts
Results of Expressions That Have Complex Operands
Results of Complex Multiplication with Nonfinite Values
Encoding of Characters in Code Generation
Array Size Restrictions for Code Generation
Code Generation for Constants in Structures and Arrays
Code Generation for Strings
Limitations
Differences Between Generated Code and MATLAB Code
Define String Scalar Inputs
Define String Scalar Types at the Command Line
Define String Scalar Inputs in the MATLAB Coder App
Code Generation for Sparse Matrices
Sparse Data Types in Generated Code
Input Definition
Code Generation Guidelines
Code Generation Limitations
Specify Array Layout in Functions and Classes
Specify Array Layout in a Function
Query Array Layout of a Function
Specify Array Layout in a Class
Code Design for Row-Major Array Layout
Understand Potential Inefficiencies Caused by Array Layout
Linear Indexing Uses Column-Major Array Layout
Code Generation for Variable-Size Data
Code Generation for Variable-Size Arrays
Memory Allocation for Variable-Size Arrays
Enabling and Disabling Support for Variable-Size Arrays
Variable-Size Arrays in a Code Generation Report
Control Memory Allocation for Variable-Size Arrays
Provide Upper Bounds for Variable-Size Arrays
Disable Dynamic Memory Allocation
Configure Code Generator to Use Dynamic Memory Allocation for Arrays Bigger Than a Threshold
Specify Upper Bounds for Variable-Size Arrays
Specify Upper Bounds for Variable-Size Inputs
Specify Upper Bounds for Local Variables
Define Variable-Size Data for Code Generation
Use a Matrix Constructor with Nonconstant Dimensions
Assign Multiple Sizes to the Same Variable
Define Variable-Size Data Explicitly by Using coder.varsize
Diagnose and Fix Variable-Size Data Errors
Diagnosing and Fixing Size Mismatch Errors
Diagnosing and Fixing Errors in Detecting Upper Bounds
Incompatibilities with MATLAB in Variable-Size Support for Code Generation
Incompatibility with MATLAB for Scalar Expansion
Incompatibility with MATLAB in Determining Size of Variable-Size N-D Arrays
Incompatibility with MATLAB in Determining Size of Empty Arrays
Incompatibility with MATLAB in Determining Class of Empty Arrays
Incompatibility with MATLAB in Matrix-Matrix Indexing
Incompatibility with MATLAB in Vector-Vector Indexing
Incompatibility with MATLAB in Matrix Indexing Operations for Code Generation
Incompatibility with MATLAB in Concatenating Variable-Size Matrices
Differences When Curly-Brace Indexing of Variable-Size Cell Array Inside Concatenation Returns No Elements
Variable-Sizing Restrictions for Code Generation of Toolbox Functions
Common Restrictions
Toolbox Functions with Restrictions for Variable-Size Data
Generate Code With Implicit Expansion Enabled
Output Size
Additional Code Generation
Performance Variation
Optimize Implicit Expansion in Generated Code
Disable Implicit Expansion in Specified Function by Using coder.noImplicitExpansionInFunction
Disable Implicit Expansion for Specific Binary Operation by Using coder.sameSizeBinaryOp
Disable Implicit Expansion in your Project
Representation of Arrays in Generated Code
Customize Interface Generation
Control Memory Allocation for Fixed-Size Arrays
Enable Dynamic Memory Allocation for All Fixed-Size Arrays
Enable Dynamic Memory Allocation for Arrays Bigger Than a Threshold
Resolve Error: Size Mismatches
Issue
Possible Solutions
Code Generation for MATLAB Structures
Structure Definition for Code Generation
Structure Operations Allowed for Code Generation
Define Scalar Structures for Code Generation
Restrictions When Defining Scalar Structures by Assignment
Adding Fields in Consistent Order on Each Control Flow Path
Restriction on Adding New Fields After First Use
Define Arrays of Structures for Code Generation
Ensuring Consistency of Fields
Using repmat to Define an Array of Structures with Consistent Field Properties
Defining an Array of Structures by Using struct
Defining an Array of Structures Using Concatenation
Index Substructures and Fields
Assign Values to Structures and Fields
Code Generation for Categorical Arrays
Code Generation for Categorical Arrays
Define Categorical Arrays for Code Generation
Allowed Operations on Categorical Arrays
MATLAB Toolbox Functions That Support Categorical Arrays
Define Categorical Array Inputs
Define Categorical Array Inputs at the Command Line
Define Categorical Array Inputs in the MATLAB Coder App
Representation of Categorical Arrays
Categorical Array Limitations for Code Generation
Code Generation for Cell Arrays
Code Generation for Cell Arrays
Homogeneous vs. Heterogeneous Cell Arrays
Controlling Whether a Cell Array Is Homogeneous or Heterogeneous
Naming the Structure Type That Represents a Heterogeneous Cell Array in the Generated Code
Cell Arrays in Reports
Control Whether a Cell Array Is Variable-Size
Define Cell Array Inputs
Cell Array Limitations for Code Generation
Cell Array Element Assignment
Variable-Size Cell Arrays
Definition of Variable-Size Cell Array by Using cell
Cell Array Indexing
Growing a Cell Array by Using {end + 1}
Cell Array Contents
Passing Cell Arrays to External C/C++ Functions
Code Generation for Datetime Arrays
Code Generation for Datetime Arrays
Define Datetime Arrays for Code Generation
Allowed Operations on Datetime Arrays
MATLAB Toolbox Functions That Support Datetime Arrays
Define Datetime Array Inputs
Define Datetime Array Inputs at the Command Line
Define Datetime Array Inputs in the MATLAB Coder App
Representation of Datetime Arrays
Datetime Array Limitations for Code Generation
Code Generation for Duration Arrays
Code Generation for Duration Arrays
Define Duration Arrays for Code Generation
Allowed Operations on Duration Arrays
MATLAB Toolbox Functions That Support Duration Arrays
Define Duration Array Inputs
Define Duration Array Inputs at the Command Line
Define Duration Array Inputs in the MATLAB Coder App
Representation of Duration Arrays
Duration Array Limitations for Code Generation
Code Generation for Tables
Code Generation for Tables
Define Tables for Code Generation
Allowed Operations on Tables
MATLAB Toolbox Functions That Support Tables
Define Table Inputs
Define Table Inputs at the Command Line
Define Table Inputs in the MATLAB Coder App
Representation of Tables
Table Limitations for Code Generation
Creating Tables Limitations
Modifying Tables Limitations
Using Table Functions Limitations
Code Generation for Timetables
Code Generation for Timetables
Define Timetables for Code Generation
Allowed Operations on Timetables
MATLAB Toolbox Functions That Support Timetables
Define Timetable Inputs
Define Timetable Inputs at the Command Line
Define Timetable Inputs in the MATLAB Coder App
Representation of Timetables
Timetable Limitations for Code Generation
Creating Timetables Limitations
Modifying Timetables Limitations
Using Timetable Functions Limitations
Code Generation for Enumerated Data
Code Generation for Enumerations
Define Enumerations for Code Generation
Allowed Operations on Enumerations
MATLAB Toolbox Functions That Support Enumerations
Customize Enumerated Types in Generated Code
Specify a Default Enumeration Value
Specify a Header File
Include Class Name Prefix in Generated Enumerated Type Value Names
Generate C++11 Code Containing Ordinary C Enumeration
Code Generation for MATLAB Classes
MATLAB Classes Definition for Code Generation
Language Limitations
Code Generation Features Not Compatible with Classes
Defining Class Properties for Code Generation
Inheritance from Built-In MATLAB Classes Not Supported
Classes That Support Code Generation
Generate Code for MATLAB Value Classes
Generate Code for MATLAB Handle Classes and System Objects
Code Generation for Handle Class Destructors
Guidelines and Restrictions
Behavioral Differences of Objects in Generated Code and in MATLAB
Class Does Not Have Property
Solution
Passing By Reference Not Supported for Some Properties
Handle Object Limitations for Code Generation
A Variable Outside a Loop Cannot Refer to a Handle Object Allocated Inside a Loop
A Handle Object That a Persistent Variable Refers To Must Be a Singleton Object
References to Handle Objects Can Appear Undefined
System Objects in MATLAB Code Generation
Usage Rules and Limitations for System Objects for Generating Code
System Objects in codegen
System Objects in the MATLAB Function Block
System Objects in the MATLAB System Block
System Objects and MATLAB Compiler Software
Specify Objects as Inputs at the Command Line
Consistency Between coder.ClassType Object and Class Definition File
Limitations for Using Objects as Entry-Point Function Inputs
Specify Objects as Inputs in the MATLAB Coder App
Automatically Define an Object Input Type
Provide an Example
Consistency Between the Type Definition and Class Definition File
Limitations for Using Objects as Entry-Point Function Inputs
Work Around Language Limitation: Code Generation Does Not Support Object Arrays
Issue
Possible Solutions
Generating C++ Classes
Generate C++ Classes for MATLAB Classes
Example: Generate Code for a Handle Class That Has Private and Public Members
Additional Usage Notes and Limitations
Code Generation for Function Handles
Function Handle Limitations for Code Generation
Code Generation for Deep Learning Arrays
Code Generation for dlarray
Define dlarray for Code Generation
dlarray Object Functions with Code Generation Support
Deep Learning Toolbox Functions with dlarray Code Generation Support
MATLAB Functions with dlarray Code Generation Support
dlarray Limitations for Code Generation
Recommended Usage
Limitations
Defining Functions for Code Generation
Code Generation for Variable Length Argument Lists
Generate Code for arguments Block That Validates Input Arguments
Supported Features
Input Type Specification and arguments blocks
Specify Number of Entry-Point Function Input or Output Arguments to Generate
Control Number of Input Arguments
Control the Number of Output Arguments
Code Generation for Anonymous Functions
Anonymous Function Limitations for Code Generation
Code Generation for Nested Functions
Nested Function Limitations for Code Generation
Calling Functions for Code Generation
Resolution of Function Calls for Code Generation
Key Points About Resolving Function Calls
Compile Path Search Order
When to Use the Code Generation Path
Resolution of File Types on Code Generation Path
Compilation Directive %#codegen
Use MATLAB Engine to Execute a Function Call in Generated Code
When To Declare a Function as Extrinsic
Use the coder.extrinsic Construct
Call MATLAB Functions Using feval
Working with mxArrays
Restrictions on Using Extrinsic Functions
Code Generation for Recursive Functions
Compile-Time Recursion
Run-Time Recursion
Disallow Recursion
Disable Run-Time Recursion
Recursive Function Limitations for Code Generation
Force Code Generator to Use Run-Time Recursion
Treat the Input to the Recursive Function as a Nonconstant
Make the Input to the Recursive Function Variable-Size
Assign Output Variable Before the Recursive Call
Avoid Duplicate Functions in Generated Code
Issue
Cause
Solution
Fixed-Point Conversion
Detect Unexecuted and Constant-Folded Code
What Is Unexecuted Code?
Detect Unexecuted Code
Fix Unexecuted Code
Convert MATLAB Code to Fixed-Point C Code
Propose Fixed-Point Data Types Based on Simulation Ranges
Propose Fixed-Point Data Types Based on Derived Ranges
Specify Type Proposal Options
Detect Overflows
Replace the exp Function with a Lookup Table
Replace a Custom Function with a Lookup Table
Enable Plotting Using the Simulation Data Inspector
Visualize Differences Between Floating-Point and Fixed-Point Results
View and Modify Variable Information
View Variable Information
Modify Variable Information
Revert Changes
Promote Sim Min and Sim Max Values
Automated Fixed-Point Conversion
Automated Fixed-Point Conversion Capabilities
Code Coverage
Proposing Data Types
Locking Proposed Data Types
Viewing Functions
Viewing Variables
Log Data for Histogram
Function Replacements
Validating Types
Testing Numerics
Detecting Overflows
Convert Fixed-Point Conversion Project to MATLAB Scripts
Generated Fixed-Point Code
Location of Generated Fixed-Point Files
Minimizing fi-casts to Improve Code Readability
Avoiding Overflows in the Generated Fixed-Point Code
Controlling Bit Growth
Avoiding Loss of Range or Precision
Handling Non-Constant mpower Exponents
Fixed-Point Code for MATLAB Classes
Automated Conversion Support for MATLAB Classes
Unsupported Constructs
Coding Style Best Practices
Automated Fixed-Point Conversion Best Practices
Create a Test File
Prepare Your Algorithm for Code Acceleration or Code Generation
Check for Fixed-Point Support for Functions Used in Your Algorithm
Manage Data Types and Control Bit Growth
Convert to Fixed Point
Use the Histogram to Fine-Tune Data Type Settings
Optimize Your Algorithm
Avoid Explicit Double and Single Casts
Replacing Functions Using Lookup Table Approximations
MATLAB Language Features Supported for Automated Fixed-Point Conversion
MATLAB Language Features Supported for Automated Fixed-Point Conversion
MATLAB Language Features Not Supported for Automated Fixed-Point Conversion
Inspecting Data Using the Simulation Data Inspector
What Is the Simulation Data Inspector?
Import Logged Data
Export Logged Data
Group Signals
Run Options
Create Report
Comparison Options
Enabling Plotting Using the Simulation Data Inspector
Save and Load Simulation Data Inspector Sessions
Custom Plot Functions
Data Type Issues in Generated Code
Enable the Highlight Option in the MATLAB Coder App
Enable the Highlight Option at the Command Line
Stowaway Doubles
Stowaway Singles
Expensive Fixed-Point Operations
Automated Fixed-Point Conversion Using Programmatic Workflow
Convert MATLAB Code to Fixed-Point C Code
Propose Fixed-Point Data Types Based on Simulation Ranges
Propose Fixed-Point Data Types Based on Derived Ranges
Detect Overflows
Replace the exp Function with a Lookup Table
Replace a Custom Function with a Lookup Table
Enable Plotting Using the Simulation Data Inspector
Visualize Differences Between Floating-Point and Fixed-Point Results
Single-Precision Conversion
Generate Single-Precision C Code at the Command Line
Prerequisites
Create a Folder and Copy Relevant Files
Determine the Type of the Input Argument
Generate and Run Single-Precision MEX to Verify Numerical Behavior
Generate Single-Precision C Code
View the Generated Single-Precision C Code
View Potential Data Type Issues
Generate Single-Precision C Code Using the MATLAB Coder App
Prerequisites
Create a Folder and Copy Relevant Files
Open the MATLAB Coder App
Select the Source Files
Enable Single-Precision Conversion
Define Input Types
Check for Run-Time Issues
Generate Single-Precision C Code
View the Generated C Code
View Potential Data Type Issues
Generate Single-Precision MATLAB Code
Prerequisites
Create a Folder and Copy Relevant Files
Set Up the Single-Precision Configuration Object
Generate Single-Precision MATLAB Code
View the Type Proposal Report
View Generated Single-Precision MATLAB Code
View Potential Data Type Issues
Compare the Double-Precision and Single-Precision Variables
Optionally Generate Single-Precision C Code
Choose a Single-Precision Conversion Workflow
Single-Precision Conversion Best Practices
Use Integers for Index Variables
Limit Use of assert Statements
Initialize MATLAB Class Properties in Constructor
Provide a Test File That Calls Your MATLAB Function
Prepare Your Code for Code Generation
Verify Double-Precision Code Before Single-Precision Conversion
Best Practices for Generation of Single-Precision C/C++ Code
Best Practices for Generation of Single-Precision MATLAB Code
Warnings from Conversion to Single-Precision C/C++ Code
Function Uses Double-Precision in the C89/C90 Standard
Built-In Function Is Implemented in Double-Precision
Built-In Function Returns Double-Precision
Combining Integers and Double-Precision Numbers
MATLAB Language Features Supported for Single-Precision Conversion
MATLAB Language Features Supported for Single-Precision Conversion
MATLAB Language Features Not Supported for Single-Precision Conversion
Setting Up a MATLAB Coder Project
Set Up a MATLAB Coder Project
Create a Project
Open an Existing Project
Specify Properties of Entry-Point Function Inputs Using the App
Why Specify Input Properties?
Specify an Input Definition Using the App
Automatically Define Input Types by Using the App
Make Dimensions Variable-Size When They Meet Size Threshold
Define Input Parameter by Example by Using the App
Define an Input Parameter by Example
Specify Input Parameters by Example
Specify a String Scalar Input Parameter by Example
Specify a Structure Type Input Parameter by Example
Specify a Cell Array Type Input Parameter by Example
Specify an Enumerated Type Input Parameter by Example
Specify an Object Input Type Parameter by Example
Specify a Fixed-Point Input Parameter by Example
Specify an Input from an Entry-Point Function Output Type
Define or Edit Input Parameter Type by Using the App
Define or Edit an Input Parameter Type
Specify a String Scalar Input Parameter
Specify an Enumerated Type Input Parameter
Specify a Fixed-Point Input Parameter
Specify a Structure Input Parameter
Specify a Cell Array Input Parameter
Define Constant Input Parameters Using the App
Define Inputs Programmatically in the MATLAB File
Add Global Variables by Using the App
Specify Global Variable Type and Initial Value Using the App
Why Specify a Type Definition for Global Variables?
Specify a Global Variable Type
Define a Global Variable by Example
Define or Edit Global Variable Type
Define Global Variable Initial Value
Define Global Variable Constant Value
Remove Global Variables
Undo and Redo Changes to Type Definitions in the App
Code Generation Readiness Screening in the MATLAB Coder App
Slow Operations in MATLAB Coder App
Unable to Open a MATLAB Coder Project
Preparing MATLAB Code for C/C++ Code Generation
Workflow for Preparing MATLAB Code for Code Generation
See Also
Fixing Errors Detected at Design Time
See Also
Using the Code Analyzer
Check Code with the Code Analyzer
Check Code by Using the Code Generation Readiness Tool
Run Code Generation Readiness Tool at the Command Line
Run Code Generation Readiness Tool from the Current Folder Browser
Run the Code Generation Readiness Tool Using the MATLAB Coder App
Code Generation Readiness Tool
Issues Tab
Files Tab
Unable to Determine Code Generation Readiness
Generate MEX Functions by Using the MATLAB Coder App
Workflow for Generating MEX Functions Using the MATLAB Coder App
Generate a MEX Function Using the MATLAB Coder App
Configure Project Settings
Build a MATLAB Coder Project
See Also
Generate MEX Functions at the Command Line
Command-line Workflow for Generating MEX Functions
Generate a MEX Function at the Command Line
Fix Errors Detected at Code Generation Time
See Also
Running and Debugging MEX Functions
Debug MEX Functions
Debug MEX Functions by Using a C/C++ Debugger
Debugging Strategies
Collect and View Line Execution Counts for Your MATLAB Code
Resolve Error: Function Is Not Supported for Code Generation
Issue
Possible Solutions
Debug Generated C/C++ Code
Testing MEX Functions in MATLAB
Why Test MEX Functions in MATLAB?
Workflow for Testing MEX Functions in MATLAB
See Also
Running MEX Functions
Debug MEX Functions
Debug MEX Functions by Using a C/C++ Debugger
Check for Run-Time Issues by Using the App
Collect MATLAB Line Execution Counts
Disable JIT Compilation for Parallel Loops
Verify MEX Functions in the MATLAB Coder App
Verify MEX Functions at the Command Line
Debug Run-Time Errors
Viewing Errors in the Run-Time Stack
Handling Run-Time Errors
Using MEX Functions That MATLAB Coder Generates
Generating C/C++ Code from MATLAB Code
Code Generation Workflow
See Also
Generating Standalone C/C++ Executables from MATLAB Code
Generate a C Executable Using the MATLAB Coder App
Generate a C Executable at the Command Line
Specifying main Functions for C/C++ Executables
Specify main Functions
Configure Build Settings
Specify Build Type
Specify a Language for Code Generation
Specify Output File Name
Specify Output File Locations
Parameter Specification Methods
Specify Build Configuration Parameters
Specify Configuration Parameters in Command-Line Workflow Interactively
Create and Modify Configuration Objects by Using the Dialog Box
Additional Functionalities in the Dialog Box
Specify Data Types Used in Generated Code
Specify Data Type Using the MATLAB Coder App
Specify Data Type at the Command Line
Use Generated Initialize and Terminate Functions
Initialize Function
Terminate Function
Change the Language Standard
Convert codegen Command to Equivalent MATLAB Coder Project
Example: Convert a Complete codegen Command to a Project File
Example: Convert an Incomplete codegen Command to a Template Project File
Limitations
Share Build Configuration Settings
Export Settings
Import Settings
Convert MATLAB Coder Project to MATLAB Script
Convert a Project Using the MATLAB Coder App
Convert a Project Using the Command-Line Interface
Run the Script
Special Cases That Generate Additional MAT-File
Preserve Variable Names in Generated Code
Reserved Keywords
C Reserved Keywords
C++ Reserved Keywords
Keywords Reserved for Code Generation
Reserved Prefixes
MATLAB Coder Code Replacement Library Keywords
Specify Properties of Entry-Point Function Inputs
Why You Must Specify Input Properties
Properties to Specify
Rules for Specifying Properties of Primary Inputs
Methods for Defining Properties of Primary Inputs
Define Input Properties by Example at the Command Line
Specify Constant Inputs at the Command Line
Specify Variable-Size Inputs at the Command Line
Input Type Specification and arguments blocks
Specify Cell Array Inputs at the Command Line
Specify Cell Array Inputs by Example
Specify the Type of the Cell Array Input
Make a Homogeneous Copy of a Type
Make a Heterogeneous Copy of a Type
Specify Variable-Size Cell Array Inputs
Specify Type Name for Heterogeneous Cell Array Inputs
Specify Constant Cell Array Inputs
Constant Input Checking in MEX Functions
Control Whether a MEX Function Checks the Value of a Constant Input
Define Input Properties Programmatically in the MATLAB File
How to Use assert with MATLAB Coder
Rules for Using assert Function
Specifying General Properties of Primary Inputs
Specifying Properties of Primary Fixed-Point Inputs
Specifying Properties of Cell Arrays
Specifying Class and Size of Scalar Structure
Specifying Class and Size of Structure Array
Create and Edit Input Types by Using the Coder Type Editor
Open the Coder Type Editor
Common Editor Actions
Type Browser Pane
Type Properties Pane
MATLAB Code Pane
Speed Up Compilation by Generating Only Code
Disable Creation of the Code Generation Report
Paths and File Infrastructure Setup
Compile Path Search Order
Specify Folders to Search for Custom Code
Naming Conventions
Generate Code for Multiple Entry-Point Functions
Generating Code for Multiple Entry-Point Functions
Call a Single Entry-Point Function from a MEX Function
Generate Code for More Than One Entry-Point Function Using the MATLAB Coder App
Generate One MEX Function for Multiple Signatures
Generate Multisignature MEX Function for a Single Entry-Point Function
Generate Multisignature MEX Function for Multiple Entry-Point Functions
Pass an Entry-Point Function Output as an Input
Pass an Entry-Point Function Output as an Input to Another Entry-Point Function
Use coder.OutputType to Facilitate Code Componentization
Generate Code for Global Data
Workflow
Declare Global Variables
Define Global Data
Synchronizing Global Data with MATLAB
Define Constant Global Data
Global Data Limitations for Generated Code
Specify Global Cell Arrays at the Command Line
Generate Code for Enumerations
Generate Code for Variable-Size Data
Disable Support for Variable-Size Data
Control Dynamic Memory Allocation
Generating Code for MATLAB Functions with Variable-Size Data
Generate Code for a MATLAB Function That Expands a Vector in a Loop
How MATLAB Coder Partitions Generated Code
Partitioning Generated Files
How to Select the File Partitioning Method
Partitioning Generated Files with One C/C++ File Per MATLAB File
Generated Files and Locations
File Partitioning and Inlining
Requirements for Signed Integer Representation
Build Process Customization
RTW.BuildInfo Methods
coder.updateBuildInfo Function
coder.ExternalDependency Class
Post-Code-Generation Command
Run-time Stack Overflow
Compiler and Linker Errors
Failure to Specify a Main Function
Failure to Specify External Code Files
Errors Caused by External Code
Pass Structure Arguments by Reference or by Value in Generated Code
Name the C Structure Type to Use With a Global Structure Variable
Generate Code for an LED Control Function That Uses Enumerated Types
Generate Code That Uses N-Dimensional Indexing
Improve Readability with N-Dimensional Indexing and Row-Major Layout
Column-Major Layout and N-Dimensional Indexing
Other Code Generation Considerations
Install OpenMP Library on macOS Platform
Generate Code to Detect Edges on Images
C Code Generation for a MATLAB Kalman Filtering Algorithm
Generate Code to Optimize Portfolio by Using Black Litterman Approach
Generate Code for Persistent Variables
Generate Code for Structure Arrays
Add Custom Toolchains to MATLAB® Coder™ Build Process
Generate Code for Sobel Edge Detection That Uses Half-Precision Data Type
Half Precision in MATLAB
Half Precision Code Generation Support
Generate Native Half-Precision C Code Using MATLAB Coder
Generate Native Half-Precision C Code for ARM® Cortex®-A with GCC Compiler
Generate Native Half-Precision C Code for ARM Cortex-A with Armclang Compiler
Register ARM Target Hardware with Custom Language Implementation
What is Half Precision?
Half Precision Applications
Benefits of Using Half Precision in Embedded Applications
Half Precision in MATLAB
Half Precision in Simulink
Code Generation with Half Precision
Build Process Support for File and Folder Names
Filenames with Spaces
Folder Names with Spaces
Troubleshooting Errors When Folder Names Have Spaces
Folder Names with Special Characters
Very Long Folder Paths
Generate Code That Reads Data from a File
Verify Generated C/C++ Code
Tracing Generated C/C++ Code to MATLAB Source Code
Generate Traceability Tags
Format of Traceability Tags
Location of Comments in Generated Code
Traceability Tag Limitations
Code Generation Reports
Report Generation
Report Location
Errors and Warnings
Files and Functions
MATLAB Source
MATLAB Variables
Tracing Code
Code Insights
Additional Reports
Report Limitations
Access Code Generation Report Information Programmatically
Create Report Information Object
Example: Create Report Information Object for Successful Code Generation
Example: Create Report Information Object for Successful Code Generation That Checks Out Toolbox Licenses
Example: Create Report Information Object for Failed Code Generation
Inspect Code Manually
Transferring Code Configuration Objects to a New MATLAB Session
Generate Standalone C/C++ Code That Detects and Reports Run-Time Errors
Generated C Code vs. Generated C++ Code
Example: Compare Generated C and C++ Code That Include Run-Time Checks
Limitations
Example: Generate Standalone C Code That Detects and Reports Run-Time Errors
Testing Code Generated from MATLAB Code
Unit Test Generated Code with MATLAB Coder
Unit Test External C Code with MATLAB Coder
Calculate Number of Lines of Code by Using Report Information Object
Code Replacement for MATLAB Code
What Is Code Replacement?
Code Replacement Libraries
Code Replacement Terminology
Code Replacement Limitations
Choose a Code Replacement Library
About Choosing a Code Replacement Library
Explore Available Code Replacement Libraries
Explore Code Replacement Library Contents
Replace Code Generated from MATLAB Code
Generate SIMD Code for MATLAB Functions
MATLAB Functions That Support SIMD Code
Generate SIMD Code Versus Plain C Code
Limitations
Custom Toolchain Registration
Custom Toolchain Registration
What Is a Custom Toolchain?
What Is a Factory Toolchain?
What is a Toolchain Definition?
Key Terms
Typical Workflow
About coder.make.ToolchainInfo
Create and Edit Toolchain Definition File
Toolchain Definition File with Commentary
Steps Involved in Writing a Toolchain Definition File
Write a Function That Creates a ToolchainInfo Object
Setup
Macros
C Compiler
C++ Compiler
Linker
Archiver
Builder
Build Configurations
Create and Validate ToolchainInfo Object
Register the Custom Toolchain
Use the Custom Toolchain
Troubleshooting Custom Toolchain Validation
Build Tool Command Path Incorrect
Build Tool Not in System Path
Tool Path Does Not Exist
Path Incompatible with Builder or Build Tool
Unsupported Platform
Toolchain is Not installed
Project or Configuration Is Using the Template Makefile
Prevent Circular Data Dependencies with One-Pass or Single-Pass Linkers
Build 32-bit DLL on 64-bit Windows® Platform Using MSVC Toolchain
Deploying Generated Code
C Compiler Considerations for Signed Integer Overflows
Use C Arrays in the Generated Function Interfaces
Implementation of Arrays in the Generated C/C++ Code
The emxArray Dynamic Data Structure Definition
Utility Functions for Interacting with emxArray Data
Examples
Use Dynamically Allocated C++ Arrays in Generated Function Interfaces
Using the coder::array Class Template
Examples
Change Interface Generation
Use a Dynamic Library in a Microsoft Visual Studio Project
Incorporate Generated Code Using an Example Main Function
Workflow for Using an Example Main Function
Control Example Main Generation Using the MATLAB Coder App
Control Example Main Generation Using the Command-Line Interface
Use an Example C Main in an Application
Prerequisites
Create a Folder and Copy Relevant Files
Run the Sobel Filter on the Image
Generate and Test a MEX Function
Generate an Example Main Function for sobel.m
Copy the Example Main Files
Modify the Generated Example Main Function
Generate the Sobel Filter Application
Run the Sobel Filter Application
Display the Resulting Image
Package Code for Other Development Environments
When to Package Code
Package Generated Code Using the MATLAB Coder App
Package Generated Code at the Command Line
Specify packNGo Options
Structure of Generated Example C/C++ Main Function
Contents of the File main.c or main.cpp
Contents of the File main.h
Troubleshoot Failures in Deployed Code
Using Dynamic Memory Allocation for an Atoms Simulation
Register New Hardware Devices
Specify Hardware Implementation for New Device
Specify Hardware Implementation That Persists Over MATLAB Sessions
Create Hardware Implementation by Modifying Existing Implementation
Create Hardware Implementation by Reusing Existing Implementation
Validate Hardware Device Data
Export Hardware Device Data
Create Alternative Identifier for Target Object
Upgrade Data Definitions for Hardware Devices
Configure CMake Build Process
Specify CMake Toolchain Definition
Available CMake Toolchain Definitions
Create Custom CMake Toolchain Definition
Deploy Generated C Code to External Hardware: Raspberry Pi Examples
Prerequisites
Hardware Implementation Parameters
Hello World Example
Spring Mass Damper System Example
Deploy Generated Code
Main Function
Generated Function Interfaces
Executable Applications
Static and Dynamic Libraries
Generated File Structure
Code Verification
Custom Hardware Considerations
Other Deployment Strategies
Approaches for Building Code Generated from MATLAB Code
Accelerating MATLAB Algorithms
Workflow for Accelerating MATLAB Algorithms
See Also
Best Practices for Using MEX Functions to Accelerate MATLAB Algorithms
Accelerate Code That Dominates Execution Time
Include Loops Inside MEX Function
Avoid Generating MEX Functions from Unsupported Functions
Avoid Generating MEX Functions if Built-In MATLAB Functions Dominate Run Time
Minimize MEX Function Calls
Accelerate MATLAB Algorithms
Modifying MATLAB Code for Acceleration
How to Modify Your MATLAB Code for Acceleration
Profile MEX Functions by Using MATLAB Profiler
MEX Profile Generation
Example
Effect of Folding Expressions on MEX Code Coverage
Control Run-Time Checks
Types of Run-Time Checks
When to Disable Run-Time Checks
How to Disable Run-Time Checks
Algorithm Acceleration Using Parallel for-Loops (parfor)
Parallel for-Loops (parfor) in Generated Code
How parfor-Loops Improve Execution Speed
When to Use parfor-Loops
When Not to Use parfor-Loops
parfor-Loop Syntax
parfor Restrictions
Control Compilation of parfor-Loops
When to Disable parfor
Reduction Assignments in parfor-Loops
What are Reduction Assignments?
Multiple Reductions in a parfor-Loop
Classification of Variables in parfor-Loops
Overview
Sliced Variables
Broadcast Variables
Reduction Variables
Temporary Variables
Accelerate MATLAB Algorithms That Use Parallel for-Loops (parfor)
Specify Maximum Number of Threads in parfor-Loops
Troubleshooting parfor-Loops
Global or Persistent Declarations in parfor-Loop
Compiler Does Not Support OpenMP
Generate MEX Code to Accelerate Simulation of Bouncing Balls
Generate MEX Code to Calculate Geodesics in Curved Space-Time
Generate Accelerated MEX Code for Reverberation Using MATLAB Classes
Using PARFOR to Speed Up an Image Contrast Enhancement Algorithm
Use Generated Code to Accelerate an Application Deployed with MATLAB Compiler
External Code Integration
Call Custom C/C++ Code from the Generated Code
Call C Code
Return Multiple Values from a C Function
Pass Data by Reference
Integrate External Code that Uses Custom Data Types
Integrate External Code that Uses Pointers, Structures, and Arrays
Configure Build for External C/C++ Code
Provide External Files for Code Generation
Configure Build from Within a Function
Configure Build by Using the Configuration Object
Configure Build by Using the MATLAB Coder App
Develop Interface for External C/C++ Code
Create a class from coder.ExternalDependency
Best Practices for Using coder.ExternalDependency
Mapping MATLAB Types to Types in Generated Code
Complex Types
Structure Types
Fixed-Point Types
Character Vectors
Multiword Types
Generate Code to Read a Text File
Generate C/C++ Strings from MATLAB Strings and Character Row Vectors
Add New Line to Strings in Generated Code
Limitations
Generate Efficient and Reusable Code
Optimization Strategies
Modularize MATLAB Code
Avoid Data Copies of Function Inputs in Generated Code
Inline Code
Control Inlining to Fine-Tune Performance and Readability of Generated Code
Control Inlining of a Specific MATLAB Function
Control Inlining by Using Code Generation Settings
Interaction Between Different Inlining Controls
Example: Control Inlining at the Boundary Between Your Functions and MathWorks® Functions
Fold Function Calls into Constants
Control Stack Space Usage
Stack Allocation and Performance
Allocate Heap Space from Command Line
Allocate Heap Space Using the MATLAB Coder App
Dynamic Memory Allocation and Performance
When Dynamic Memory Allocation Occurs
Minimize Dynamic Memory Allocation
Provide Maximum Size for Variable-Size Arrays
Disable Dynamic Memory Allocation During Code Generation
Set Dynamic Memory Allocation Threshold
Set Dynamic Memory Allocation Threshold Using the MATLAB Coder App
Set Dynamic Memory Allocation Threshold at the Command Line
Optimize Dynamic Array Access
Disable Cache Dynamic Array Data Pointer Property
Compare Generated C Code
Excluding Unused Paths from Generated Code
Prevent Code Generation for Unused Execution Paths
Prevent Code Generation When Local Variable Controls Flow
Prevent Code Generation When Input Variable Controls Flow
Generate Code with Parallel for-Loops (parfor)
Minimize Redundant Operations in Loops
Unroll for-Loops and parfor-Loops
Force for-Loop Unrolling by Using coder.unroll
Set Loop Unrolling Threshold for All for-Loops and parfor-Loops in the MATLAB Code
Disable Support for Integer Overflow or Nonfinites
Disable Support for Integer Overflow
Disable Support for Nonfinite Numbers
Integrate External/Custom Code
MATLAB Coder Optimizations in Generated Code
Constant Folding
Loop Fusion
Successive Matrix Operations Combined
Unreachable Code Elimination
memcpy Calls
memset Calls
Use coder.const with Extrinsic Function Calls
Reduce Code Generation Time by Using coder.const with feval
Force Constant-Folding by Using coder.const with feval
memcpy Optimization
memset Optimization
Reuse Large Arrays and Structures
LAPACK Calls in Generated Code
Speed Up Linear Algebra in Generated Standalone Code by Using LAPACK Calls
Specify LAPACK Library
Write LAPACK Callback Class
Generate LAPACK Calls by Specifying a LAPACK Callback Class
Locate LAPACK Library in Execution Environment
BLAS Calls in Generated Code
Speed Up Matrix Operations in Generated Standalone Code by Using BLAS Calls
Specify BLAS Library
Write BLAS Callback Class
Generate BLAS Calls by Specifying a BLAS Callback Class
Locate BLAS Library in Execution Environment
Usage Notes and Limitations for OpenBLAS Library
Speed Up Fast Fourier Transforms in Generated Standalone Code by Using FFTW Library Calls
FFTW Planning Considerations
Install FFTW Library
Write an FFT Callback Class
Generate FFTW Library Calls by Specifying an FFT Library Callback Class
Synchronize Multithreaded Access to FFTW Planning in Generated Standalone Code
Prerequisites
Create a MATLAB Function
Write Supporting C Code
Write an FFT Library Callback Class
Generate a Dynamically Linked Library
Specify Configuration Parameters in the MATLAB Coder App
Speed Up MEX Generation by Using JIT Compilation
Specify Use of JIT Compilation in the MATLAB Coder App
Specify Use of JIT Compilation at the Command Line
JIT Compilation Incompatibilities
Automatically Parallelize for Loops in Generated Code
Parallelize for Loops by Using MATLAB Coder App
Parallelize for Loops at Command Line
Inspect Generated Code and Code Insights
Disable Automatic Parallelization of a for Loop
Parallelize Implicit for Loops
Parallelize for Loops Performing Reduction Operations
Usage Notes and Limitations
Specify Maximum Number of Threads to Run Parallel for-Loops in the Generated Code
Specify Number of Threads by Using MATLAB Coder App
Specify Number of Threads at the Command Line
Create Custom Hardware Processor
Optimize Generated Code for Fast Fourier Transform Functions
Intel Target Support
ARM Target Support
MEX Target Support
Generating Reentrant C Code from MATLAB Code
Generate Reentrant C Code from MATLAB Code
About This Tutorial
Copying Files Locally
About the Example
Providing a C main Function
Configuring Build Parameters
Generating the C Code
Viewing the Generated C Code
Running the Code
Key Points to Remember
Learn More
Reentrant Code
Specify Generation of Reentrant Code
Specify Generation of Reentrant Code Using the MATLAB Coder App
Specify Generation of Reentrant Code Using the Command-Line Interface
API for Generated Reusable Code
Call Reentrant Code in a Single-Threaded Environment
Call Reentrant Code in a Multithreaded Environment
Multithreaded Examples
Call Reentrant Code with No Persistent or Global Data (UNIX Only)
Provide a Main Function
Generate Reentrant C Code
Examine the Generated Code
Run the Code
Call Reentrant Code — Multithreaded with Persistent Data (Windows Only)
MATLAB Code for This Example
Provide a Main Function
Generate Reentrant C Code
Examine the Generated Code
Run the Code
Call Reentrant Code — Multithreaded with Persistent Data (UNIX Only)
MATLAB Code for This Example
Provide a Main Function
Generate Reentrant C Code
Examine the Generated Code
Run the Code
Troubleshooting Code Generation Problems
JIT MEX Incompatibility Warning
Issue
Cause
Solution
JIT Compilation Does Not Support OpenMP
Issue
Cause
Solution
Output Variable Must Be Assigned Before Run-Time Recursive Call
Issue
Cause
Solution
Compile-Time Recursion Limit Reached
Issue
Cause
Solutions
Force Run-Time Recursion
Increase the Compile-Time Recursion Limit
Unable to Determine That Every Element of Cell Array Is Assigned
Issue
Cause
Solution
Nonconstant Index into varargin or varargout in a for-Loop
Issue
Cause
Solution
Unknown Output Type for coder.ceval
Issue
Cause
Solution
MEX Generated on macOS Platform Stays Loaded in Memory
Issue
Cause
Solution
Resolve Error: Code Generator Failed to Produce C++ Destructor for MATLAB Class
Issue
Possible Solutions
Row-Major Array Layout
Row-Major and Column-Major Array Layouts
Array Storage in Computer Memory
Conversions Between Different Array Layouts
Generate Code That Uses Row-Major Array Layout
Specify Row-Major Layout
Array Layout and Algorithmic Efficiency
Row-Major Layout for N-Dimensional Arrays
Specify Array Layout in External Function Calls
Deep Learning with MATLAB Coder
Prerequisites for Deep Learning with MATLAB Coder
MathWorks Products
Third-Party Hardware and Software
Environment Variables
Workflow for Deep Learning Code Generation with MATLAB Coder
Networks and Layers Supported for Code Generation
Supported Pretrained Networks
Supported Layers
Supported Classes
int8 Code Generation
Analyze Network for Code Generation
Check dlnetwork for Code Generation Compatibility
Analyze Classification Network for Code Generation Compatibility
Load Pretrained Networks for Code Generation
Load a Network by Using coder.loadDeepLearningNetwork
Specify a Network Object for Code Generation
Specify a dlnetwork Object for Code Generation
Generate Generic C/C++ Code for Deep Learning Networks
Requirements
Code Generation by Using codegen
Code Generation by Using the MATLAB Coder App
Code Generation for Deep Learning Networks with MKL-DNN
Requirements
Code Generation by Using codegen
Code Generation by Using the MATLAB Coder App
Code Generation for Deep Learning Networks with ARM Compute Library
Requirements
Code Generation by Using codegen
Code Generation by Using the MATLAB Coder App
Cross-Compile Deep Learning Code That Uses ARM Compute Library
Prerequisites
Generate and Deploy Deep Learning Code
Generate int8 Code for Deep Learning Networks
ARM Cortex-A Processors
ARM Cortex-M Processors
Update Network Parameters After Code Generation
Create an Entry-Point Function
Create a Network
Code Generation by Using codegen
Run the Generated MEX
Update Network with Different Learnable Parameters
Run the Generated MEX with Updated Learnables
Limitations
Deep Learning Code Generation on Intel Targets for Different Batch Sizes
Deep Learning Prediction with ARM Compute Using codegen
Code Generation for Deep Learning on ARM Targets
Generate C++ Code for Object Detection Using YOLO v2 and Intel MKL-DNN
Code Generation and Deployment of MobileNet-v2 Network to Raspberry Pi
Code Generation for Semantic Segmentation Application on Intel CPUs That Uses U-Net
Code Generation for Semantic Segmentation Application on ARM Neon Targets That Uses U-Net
Code Generation for LSTM Network on Raspberry Pi
Code Generation for LSTM Network That Uses Intel MKL-DNN
Code Generation for Convolutional LSTM Network That Uses Intel MKL-DNN
Cross Compile Deep Learning Code for ARM Neon Targets
Generate INT8 Code for Deep Learning Network on Raspberry Pi
Generate INT8 Code for Deep Learning Network on Cortex-M Target
Generate Generic C/C++ Code for Sequence-to-Sequence Regression That Uses Deep Learning
Generate Digit Images Using Variational Autoencoder on Intel CPUs
Post-Code-Generation Update of Deep Learning Network Parameters
Generate Code for LSTM Network and Deploy on Cortex-M Target
Prune Filters in a Detection Network Using Taylor Scores
Generating Code for C++
C++ Code Generation
Generate C++ Code
C++ Language Features Supported in Generated Code
Additional Differences Between Generated C Code and C++ Code
Generate C++ Code with Class Interface
Generate C++ Code with a Class Interface
Globals and Persistents in a Generated C++ Class
Put Multiple Entry-Point Functions in the Same Class
Organize Generated C++ Code into Namespaces
Settings That Control Namespace Structure
Example: Generate C++ Code with Namespaces
Integrate Multiple Generated C++ Code Projects
Generate C++ Classes for MATLAB Classes That Model Simple and Damped Oscillators
Simulation Data Inspector
View Data in the Simulation Data Inspector
View Logged Data
Import Data from the Workspace or a File
View Complex Data
View String Data
View Frame-Based Data
View Event-Based Data
Import Data from a CSV File into the Simulation Data Inspector
Basic File Format
Multiple Time Vectors
Signal Metadata
Import Data from a CSV File
Microsoft Excel Import, Export, and Logging Format
Basic File Format
Multiple Time Vectors
Signal Metadata
User-Defined Data Types
Complex, Multidimensional, and Bus Signals
Function-Call Signals
Simulation Parameters
Multiple Runs
Configure the Simulation Data Inspector
Logged Data Size and Location
Archive Behavior and Run Limit
Incoming Run Names and Location
Signal Metadata to Display
Signal Selection on the Inspect Pane
How Signals Are Aligned for Comparison
Colors Used to Display Comparison Results
Signal Grouping
Data to Stream from Parallel Simulations
Options for Saving and Loading Session Files
Signal Display Units
How the Simulation Data Inspector Compares Data
Signal Alignment
Synchronization
Interpolation
Tolerance Specification
Limitations
Save and Share Simulation Data Inspector Data and Views
Save and Load Simulation Data Inspector Sessions
Share Simulation Data Inspector Views
Share Simulation Data Inspector Plots
Create Simulation Data Inspector Report
Export Data to the Workspace or a File
Export Video Signal to an MP4 File
Inspect and Compare Data Programmatically
Create a Run and View the Data
Compare Two Signals in the Same Run
Compare Runs with Global Tolerance
Analyze Simulation Data Using Signal Tolerances
Limit the Size of Logged Data
Limit the Number of Runs Retained in the Simulation Data Inspector Archive
Specify a Minimum Disk Space Requirement or Maximum Size for Logged Data
View Data Only During Simulation
Reduce the Number of Data Points Logged from Simulation