Functions and Objects Supported for C/C++ Code Generation

You can generate efficient C/C++ code for a subset of MATLAB® built-in functions and toolbox functions and System objects that you call from MATLAB code. These functions and System objects are listed in the following tables.

Note

For more information on code generation for fixed-point algorithms, refer to Code Acceleration and Code Generation from MATLAB.

MATLAB

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

-

Subtraction

&

Find logical AND

**

Matrix multiplication

.**

Multiplication

./

Right array division

.\

Left array division

.^*

Element-wise power

/*

Solve systems of linear equations xA = B for x

\*

Solve systems of linear equations Ax = B for x

^*

Matrix power

|

Find logical OR

~

Find logical NOT

~=*

Determine inequality

+

Addition

<

Determine less than

<=

Determine less than or equal to

==*

Determine equality

>

Determine greater than

>=

Determine greater than or equal to

abs

Absolute value and complex magnitude

accumarray*

Construct array with accumulation

acos*

Inverse cosine in radians

acosd

Inverse cosine in degrees

acosh*

Inverse hyperbolic cosine

acot

Inverse cotangent in radians

acotd

Inverse cotangent in degrees

acoth

Inverse hyperbolic cotangent

acsc

Inverse cosecant in radians

acscd

Inverse cosecant in degrees

acsch

Inverse hyperbolic cosecant

airy*

Airy Functions

all*

Determine if all array elements are nonzero or true

angle

Phase angle

any*

Determine if any array elements are nonzero

array2table*

Convert homogeneous array to table

arrayfun*

Apply function to each element of array

asec

Inverse secant in radians

asecd

Inverse secant in degrees

asech

Inverse hyperbolic secant

asin*

Inverse sine in radians

asind

Inverse sine in degrees

asinh

Inverse hyperbolic sine

assert*

Throw error if condition false

atan

Inverse tangent in radians

atan2

Four-quadrant inverse tangent

atan2d

Four-quadrant inverse tangent in degrees

atand

Inverse tangent in degrees

atanh*

Inverse hyperbolic tangent

bandwidth*

Lower and upper matrix bandwidth

besseli*

Modified Bessel function of first kind

besselj*

Bessel function of first kind

beta

Beta function

betainc*

Incomplete beta function

betaincinv*

Beta inverse cumulative distribution function

betaln

Logarithm of beta function

bin2dec*

Convert text representation of binary number to decimal number

bitand

Bit-wise AND

bitcmp

Bit-wise complement

bitget

Get bit at specified position

bitor

Bit-wise OR

bitset

Set bit at specific location

bitshift

Shift bits specified number of places

bitxor

Bit-wise XOR

blanks

Create character array of blanks

blkdiag

Block diagonal matrix

bounds

Smallest and largest elements

break

Terminate execution of for or while loop

bsxfun*

Apply element-wise operation to two arrays with implicit expansion enabled

builtin

Execute built-in function from overloaded method

cart2pol

Transform Cartesian coordinates to polar or cylindrical

cart2sph

Transform Cartesian coordinates to spherical

cast*

Convert variable to different data type

cat*

Concatenate arrays

categorical*

Array that contains values assigned to categories

categories

Categories of categorical array

ceil*

Round toward positive infinity

cell*

Cell array

cellstr*

Convert to cell array of character vectors

char*

Character array

chol*

Cholesky factorization

cholupdate*

Rank 1 update to Cholesky factorization

circshift

Shift array circularly

class

Class of object

colon*

Vector creation, array subscripting, and for-loop iteration

compan

Companion matrix

complex

Create complex array

computer*

Information about computer on which MATLAB is running

cond

Condition number for inversion

conj

Complex conjugate

contains*

Determine if pattern is in strings

continue

Pass control to next iteration of for or while loop

conv*

Convolution and polynomial multiplication

conv2

2-D convolution

convertCharsToStrings*

Convert character arrays to string arrays, leaving other arrays unaltered

convertStringsToChars

Convert string arrays to character arrays, leaving other arrays unaltered

convn

N-D convolution

corrcoef*

Correlation coefficients

cos

Cosine of argument in radians

cosd

Cosine of argument in degrees

cosh

Hyperbolic cosine

cospi

Compute cos(X*pi) accurately

cot

Cotangent of angle in radians

cotd*

Cotangent of argument in degrees

coth

Hyperbolic cotangent

count*

Count occurrences of pattern in strings

cov*

Covariance

cplxpair

Sort complex numbers into complex conjugate pairs

cross*

Cross product

csc

Cosecant of input angle in radians

cscd*

Cosecant of argument in degrees

csch

Hyperbolic cosecant

ctranspose

Complex conjugate transpose

cummax

Cumulative maximum

cummin

Cumulative minimum

cumprod*

Cumulative product

cumsum*

Cumulative sum

cumtrapz

Cumulative trapezoidal numerical integration

datevec*

Convert date and time to vector of components

days

Duration in days

deal

Distribute inputs to outputs

deblank*

Remove trailing whitespace from ends of strings

dec2base

Convert decimal number to character array representing base-N number

dec2bin*

Convert decimal number to character array representing binary number

dec2hex*

Convert decimal number to character array representing hexadecimal number

deconv*

Deconvolution and polynomial division

deg2rad

Convert angle from degrees to radians

del2

Discrete Laplacian

det*

Matrix determinant

detrend*

Remove polynomial trend

diag*

Create diagonal matrix or get diagonal elements of matrix

diff*

Differences and approximate derivatives

discretize*

Group data into bins or categories

dot*

Dot product

double*

Double-precision arrays

duration*

Lengths of time in fixed-length units

eig*

Eigenvalues and eigenvectors

ellipke

Complete elliptic integrals of first and second kind

end

Terminate block of code, or indicate last array index

endsWith*

Determine if strings end with pattern

enumeration

Class enumeration members and names

eps

Floating-point relative accuracy

erase*

Delete substrings within strings

eraseBetween*

Delete substrings between start and end points

erf*

Error function

erfc*

Complementary error function

erfcinv*

Inverse complementary error function

erfcx*

Scaled complementary error function

erfinv*

Inverse error function

error*

Throw error and display message

exp

Exponential

expint

Exponential integral

expm*

Matrix exponential

expm1

Compute exp(x)-1 accurately for small values of x

extractAfter*

Extract substrings after specified positions

extractBefore*

Extract substrings before specified positions

eye*

Identity matrix

factor*

Prime factors

factorial

Factorial of input

false*

Logical 0 (false)

fclose

Close one or all open files

feof

Test for end of file

feval*

Evaluate function

fft*

Fast Fourier transform

fft2*

2-D fast Fourier transform

fftn*

N-D fast Fourier transform

fftshift

Shift zero-frequency component to center of spectrum

fftw*

Define method for determining FFT algorithm

fgetl*

Read line from file, removing newline characters

fgets*

Read line from file, keeping newline characters

fieldnames*

Field names of structure, or public fields of Java® or Microsoft® COM object

fileread*

Read contents of file as text

fillmissing*

Fill missing values

filloutliers*

Detect and replace outliers in data

filter*

1-D digital filter

filter2

2-D digital filter

find*

Find indices and values of nonzero elements

fix*

Round toward zero

flintmax

Largest consecutive integer in floating-point format

flip*

Flip order of elements

flipdim*

(Not recommended) Flip array along specified dimension

fliplr*

Flip array left to right

flipud*

Flip array up to down

floor*

Round toward negative infinity

fminbnd*

Find minimum of single-variable function on fixed interval

fminsearch*

Find minimum of unconstrained multivariable function using derivative-free method

fopen*

Open file, or obtain information about open files

for*

for loop to repeat specified number of times

fprintf*

Write data to text file

fread*

Read data from binary file

freqspace

Frequency spacing for frequency response

frewind

Move file position indicator to beginning of open file

fseek*

Move to specified position in file

ftell*

Current position

full

Convert sparse matrix to full storage

func2str*

Construct character vector from function handle

fwrite*

Write data to binary file

fzero*

Root of nonlinear function

gamma

Gamma function

gammainc*

Incomplete gamma function

gammaincinv*

Inverse incomplete gamma function

gammaln

Logarithm of gamma function

gcd

Greatest common divisor

getNumInputs*

Number of inputs required to call the System object™

getNumOutputs*

Number of outputs from calling the System object

gradient

Numerical gradient

hadamard*

Hadamard matrix

hankel

Hankel matrix

hasFrame

Determine if video frame is available to read

height

Number of table rows

hex2dec*

Convert text representation of hexadecimal number to decimal number

hex2num*

Convert IEEE® hexadecimal format to double-precision number

hilb

Hilbert matrix

hist*

Histogram plot (not recommended; use histogram)

histc*

Histogram bin counts (not recommended; use histcounts)

histcounts*

Histogram bin counts

histcounts2*

Bivariate histogram bin counts

hms*

Hour, minute, and second numbers of datetime or duration

horzcat

Concatenate arrays horizontally

hours

Duration in hours

hsv2rgb

Convert HSV colors to RGB

hypot

Square root of sum of squares (hypotenuse)

idivide*

Integer division with rounding option

if, elseif, else

Execute statements if condition is true

ifft*

Inverse fast Fourier transform

ifft2*

2-D inverse fast Fourier transform

ifftn*

Multidimensional inverse fast Fourier transform

ifftshift

Inverse zero-frequency shift

im2double

Convert image to double precision

imag

Imaginary part of complex number

imread*

Read image from graphics file

imresize*

Resize image

ind2rgb

Convert indexed image to RGB image

ind2sub*

Convert linear indices to subscripts

Inf*

Create array of all Inf values

inpolygon*

Points located inside or on edge of polygonal region

insertAfter*

Insert strings after specified substrings

insertBefore*

Insert strings before specified substrings

int16

16-bit signed integer arrays

int2str*

Convert integers to characters

int32

32-bit signed integer arrays

int64

64-bit signed integer arrays

int8

8-bit signed integer arrays

interp1*

1-D data interpolation (table lookup)

interp1q*

Quick 1-D linear interpolation

interp2*

Interpolation for 2-D gridded data in meshgrid format

interp3*

Interpolation for 3-D gridded data in meshgrid format

interpn*

Interpolation for 1-D, 2-D, 3-D, and N-D gridded data in ndgrid format

intersect*

Set intersection of two arrays

intmax

Largest value of specific integer type

intmin

Smallest value of specified integer type

inv*

Matrix inverse

invhilb

Inverse of Hilbert matrix

ipermute*

Inverse permute array dimensions

isa

Determine if input has specified data type

isbanded*

Determine if matrix is within specific bandwidth

iscalendarduration

Determine if input is calendar duration array

iscategory

Test for categorical array categories

iscell

Determine if input is cell array

iscellstr

Determine if input is cell array of character vectors

ischar

Determine if input is character array

iscolumn

Determine whether input is column vector

isdatetime

Determine if input is datetime array

isdiag*

Determine if matrix is diagonal

isDone*

End-of-data status

isduration

Determine if input is duration array

isempty

Determine whether array is empty

isenum

Determine if variable is enumeration

isequal

Determine array equality

isequaln

Determine array equality, treating NaN values as equal

isfield*

Determine if input is structure array field

isfinite

Determine which array elements are finite

isfloat

Determine if input is floating-point array

ishermitian*

Determine if matrix is Hermitian or skew-Hermitian

isinf

Determine which array elements are infinite

isinteger

Determine whether input is integer array

isletter*

Determine which characters are letters

islocalmax*

Find local maxima

islocalmin*

Find local minima

isLocked*

Determine if System object is in use

islogical

Determine if input is logical array

ismac*

Determine if version is for macOS platform

ismatrix

Determine whether input is matrix

ismember*

Array elements that are members of set array

ismethod

Determine if method of object

ismissing*

Find missing values

isnan

Determine which array elements are NaN

isnumeric

Determine whether input is numeric array

isobject

Determine if input is MATLAB object

isordinal

Determine whether input is ordinal categorical array

isoutlier*

Find outliers in data

ispc*

Determine if version is for Windows® (PC) platform

isprime*

Determine which array elements are prime

isprotected

Determine whether categories of categorical array are protected

isreal

Determine whether array is real

isrow

Determine whether input is row vector

isscalar

Determine whether input is scalar

issorted*

Determine if array is sorted

issortedrows*

Determine if matrix or table rows are sorted

isspace*

Determine which characters are space characters

issparse

Determine whether input is sparse

isstring

Determine if input is string array

isstrprop*

Determine which characters in input strings are of specified category

isstruct

Determine if input is structure array

issymmetric*

Determine if matrix is symmetric or skew-symmetric

istril*

Determine if matrix is lower triangular

istriu*

Determine if matrix is upper triangular

isundefined

Find undefined elements in categorical array

isunix*

Determine if version is for Linux® or Mac platforms

isvector

Determine whether input is vector

kron*

Kronecker tensor product

lcm

Least common multiple

length

Length of largest array dimension

linsolve*

Solve linear system of equations

linspace

Generate linearly spaced vector

load*

Load variables from file into workspace

log*

Natural logarithm

log10

Common logarithm (base 10)

log1p

Compute log(1+x) accurately for small values of x

log2

Base 2 logarithm and floating-point number dissection

logical

Convert numeric values to logicals

logspace

Generate logarithmically spaced vector

lower*

Convert strings to lowercase

lscov*

Least-squares solution in presence of known covariance

lsqnonneg*

Solve nonnegative linear least-squares problem

lu*

LU matrix factorization

magic*

Magic square

matchpairs*

Solve linear assignment problem

max*

Maximum elements of an array

maxk*

Find k largest elements of array

mean*

Average or mean value of array

median*

Median value of array

meshgrid

2-D and 3-D grids

mfilename

File name of currently running code

milliseconds

Duration in milliseconds

min*

Minimum elements of an array

mink*

Find k smallest elements of array

minutes

Duration in minutes

mkpp*

Make piecewise polynomial

mod*

Remainder after division (modulo operation)

mode*

Most frequent values in array

movmad*

Moving median absolute deviation

movmax*

Moving maximum

movmean*

Moving mean

movmedian*

Moving median

movmin*

Moving minimum

movprod*

Moving product

movstd*

Moving standard deviation

movsum*

Moving sum

movvar*

Moving variance

mustBeFinite

Validate that value is finite or issue error

mustBeGreaterThan

Validate that value is greater than another value or issue error

mustBeGreaterThanOrEqual

Validate that value is greater than or equal to another value or issue error

mustBeInteger

Validate that value is integer or issue error

mustBeLessThan

Validate that value is less than another value or issue error

mustBeLessThanOrEqual

Validate that value is less than or equal to another value or issue error

mustBeMember

Validate that value is member of specified set

mustBeNegative

Validate that value is negative or issue error

mustBeNonempty

Validate that value is nonempty or issue error

mustBeNonNan

Validate that value is nonNaN

mustBeNonnegative

Validate that value is nonnegative or issue error

mustBeNonpositive

Validate that value is nonpositive or issue error

mustBeNonsparse

Validate that value is nonsparse or issue error

mustBeNonzero

Validate that value is nonzero or issue error

mustBeNumeric

Validate that value is numeric or issue error

mustBeNumericOrLogical

Validate that value is numeric or logical or issue error

mustBePositive

Validate that value is positive or issue error

mustBeReal

Validate that value is real or issue error

NaN*

Create array of all NaN values

nargin*

Number of function input arguments

narginchk

Validate number of input arguments

nargout*

Number of function output arguments

nargoutchk

Validate number of output arguments

nchoosek*

Binomial coefficient or all combinations

ndgrid

Rectangular grid in N-D space

ndims

Number of array dimensions

newline

Create newline character

nextpow2

Exponent of next higher power of 2

nnz

Number of nonzero matrix elements

nonzeros

Nonzero matrix elements

norm*

Vector and matrix norms

normalize*

Normalize data

normest*

2-norm estimate

nthroot

Real nth root of real numbers

null*

Null space of matrix

num2hex

Convert single- and double-precision numbers to IEEE hexadecimal format

num2str*

Convert numbers to character array

numel

Number of array elements

nzmax

Amount of storage allocated for nonzero matrix elements

ode23*

Solve nonstiff differential equations — low order method

ode45*

Solve nonstiff differential equations — medium order method

odeget*

Extract ODE option values

odeset*

Create or modify options structure for ODE and PDE solvers

ones*

Create array of all ones

optimget*

Optimization options values

optimset*

Create or modify optimization options structure

orth*

Orthonormal basis for range of matrix

parfor*

Parallel for loop

pascal

Pascal matrix

pause*

Stop MATLAB execution temporarily

pchip*

Piecewise Cubic Hermite Interpolating Polynomial (PCHIP)

permute*

Permute array dimensions

persistent*

Define persistent variable

pi

Ratio of circle's circumference to its diameter

pinv*

Moore-Penrose pseudoinverse

planerot*

Givens plane rotation

pol2cart

Transform polar or cylindrical coordinates to Cartesian

poly*

Polynomial with specified roots or characteristic polynomial

polyarea

Area of polygon

polyder*

Polynomial differentiation

polyeig*

Polynomial eigenvalue problem

polyfit*

Polynomial curve fitting

polyint

Polynomial integration

polyval

Polynomial evaluation

polyvalm

Matrix polynomial evaluation

ppval*

Evaluate piecewise polynomial

primes*

Prime numbers less than or equal to input value

prod*

Product of array elements

psi*

Psi (polygamma) function

qr*

Orthogonal-triangular decomposition

qrupdate*

Rank 1 update to QR factorization

quad2d*

Numerically evaluate double integral — tiled method

quadgk

Numerically evaluate integral — Gauss-Kronrod quadrature

rad2deg

Convert angle from radians to degrees

rand*

Uniformly distributed random numbers

randi*

Uniformly distributed pseudorandom integers

randn*

Normally distributed random numbers

randperm

Random permutation of integers

rank*

Rank of matrix

rat*

Rational fraction approximation

rcond*

Reciprocal condition number

read*

Read one or more video frames

read

Read data from remote host over TCP/IP

readFrame*

Read next video frame

real

Real part of complex number

reallog

Natural logarithm for nonnegative real arrays

realmax

Largest positive floating-point number

realmin

Smallest normalized floating-point number

realpow

Array power for real-only output

realsqrt

Square root for nonnegative real arrays

rectint

Rectangle intersection area

release*

Release resources and allow changes to System object property values and input characteristics

rem*

Remainder after division

repelem*

Repeat copies of array elements

replace*

Find and replace one or more substrings

replaceBetween*

Replace substrings between start and end points

repmat*

Repeat copies of array

rescale

Scale range of array elements

reset*

Reset internal states of System object

reshape*

Reshape array

return

Return control to invoking script or function

reverse*

Reverse order of characters in strings

rgb2gray*

Convert RGB image or colormap to grayscale

rgb2hsv

Convert RGB colors to HSV

rmmissing*

Remove missing entries

rmoutliers*

Detect and remove outliers in data

rng*

Control random number generation

roots*

Polynomial roots

rosser

Classic symmetric eigenvalue test problem

rot90*

Rotate array 90 degrees

round*

Round to nearest decimal or integer

rsf2csf*

Convert real Schur form to complex Schur form

schur*

Schur decomposition

sec

Secant of angle in radians

secd*

Secant of argument in degrees

sech

Hyperbolic secant

seconds

Duration in seconds

setdiff*

Set difference of two arrays

setxor*

Set exclusive OR of two arrays

shiftdim*

Shift array dimensions

sign

Sign function (signum function)

sin

Sine of argument in radians

sind

Sine of argument in degrees

single

Single-precision arrays

sinh

Hyperbolic sine

sinpi

Compute sin(X*pi) accurately

size

Array size

sort*

Sort array elements

sortrows*

Sort rows of matrix or table

spalloc

Allocate space for sparse matrix

sparse*

Create sparse matrix

spdiags

Extract nonzero diagonals and create sparse band and diagonal matrices

speye

Sparse identity matrix

spfun

Apply function to nonzero sparse matrix elements

sph2cart

Transform spherical coordinates to Cartesian

spline*

Cubic spline data interpolation

spones

Replace nonzero sparse matrix elements with ones

sprintf*

Format data into string or character vector

sqrt*

Square root

sqrtm*

Matrix square root

squeeze*

Remove dimensions of length 1

standardizeMissing*

Insert standard missing values

startsWith*

Determine if strings start with pattern

std*

Standard deviation

step*

Run System object algorithm

str2double*

Convert strings to double precision values

str2func*

Construct function handle from character vector

strcmp*

Compare strings

strcmpi*

Compare strings (case insensitive)

strfind*

Find strings within other strings

string*

String array

strip*

Remove leading and trailing characters from stringS

strjoin*

Join strings in array

strjust*

Justify strings

strlength

Lengths of strings

strncmp*

Compare first n characters of strings (case sensitive)

strncmpi*

Compare first n characters of strings (case insensitive)

strrep*

Find and replace substrings

strtok*

Selected parts of strings

strtrim*

Remove leading and trailing whitespace from strings

struct*

Structure array

struct2cell*

Convert structure to cell array

structfun*

Apply function to each field of scalar structure

sub2ind*

Convert subscripts to linear indices

subspace*

Angle between two subspaces

sum*

Sum of array elements

svd*

Singular value decomposition

swapbytes*

Swap byte ordering

switch, case, otherwise*

Execute one of several groups of statements

table*

Table array with named variables that can contain different types

table2array*

Convert table to homogeneous array

table2cell

Convert table to cell array

tan

Tangent of argument in radians

tand*

Tangent of argument in degrees

tanh

Hyperbolic tangent

tcpclient

Create TCP/IP client object to communicate over TCP/IP

tic*

Start stopwatch timer

toc*

Read elapsed time from stopwatch

toeplitz

Toeplitz matrix

trace*

Sum of diagonal elements

transpose

Transpose vector or matrix

trapz*

Trapezoidal numerical integration

tril*

Lower triangular part of matrix

triu*

Upper triangular part of matrix

true*

Logical 1 (true)

typecast*

Convert data types without changing underlying data

uint16

16-bit unsigned integer arrays

uint32

32-bit unsigned integer arrays

uint64

64-bit unsigned integer arrays

uint8

8-bit unsigned integer arrays

uminus

Unary minus

union*

Set union of two arrays

unique*

Unique values in array

unmkpp*

Extract piecewise polynomial details

unwrap*

Shift phase angles

uplus

Unary plus

upper*

Convert strings to uppercase

validateattributes*

Check validity of array

validatestring*

Check validity of text

vander

Vandermonde matrix

var*

Variance

varargin*

Variable-length input argument list

varargout*

Variable-length output argument list

vecnorm*

Vector-wise norm

vertcat

Concatenate arrays vertically

VideoReader*

Create object to read video files

while

while loop to repeat when condition is true

width

Number of table variables

wilkinson*

Wilkinson's eigenvalue test matrix

write

Write data to remote host over TCP/IP

xcorr*

Cross-correlation

xcov

Cross-covariance

xor

Find logical exclusive-OR

years

Duration in years

zeros*

Create array of all zeros

5G Toolbox

C and C++ code generation for the following functions requires the 5G Toolbox™ software.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

getPathFilters

Get path filter impulse response for link-level MIMO fading channel

getTransportBlock

Get transport block from UL-SCH or DL-SCH encoder

info

Get characteristic information about link-level MIMO fading channel

nrBCH

Broadcast channel (BCH) encoding

nrBCHDecode*

Broadcast channel (BCH) decoding

nrCarrierConfig

Carrier configuration parameters

nrCDLChannel*

Send signal through CDL channel model

nrChannelEstimate

Practical channel estimation

nrCodeBlockDesegmentLDPC

LDPC code block desegmentation and CRC decoding

nrCodeBlockSegmentLDPC

LDPC code block segmentation and CRC attachment

nrCRCDecode

Decode and remove cyclic redundancy check (CRC)

nrCRCEncode

Calculate and append cyclic redundancy check (CRC)

nrCSIRS

Generate CSI-RS symbols

nrCSIRSConfig

CSI-RS configuration parameters

nrCSIRSIndices

Generate CSI-RS resource element indices

nrDCIDecode*

Decode downlink control information (DCI)

nrDCIEncode

Encode downlink control information (DCI)

nrDLSCH*

Apply DL-SCH encoder processing chain

nrDLSCHDecoder*

Apply DL-SCH decoder processing chain

nrDLSCHInfo

Get downlink shared channel (DL-SCH) information

nrEqualizeMMSE

Minimum mean-squared error (MMSE) equalization

nrExtractResources*

Extract resource elements from resource array

nrLayerDemap

Layer demapping onto scrambled and modulated codewords

nrLayerMap

Layer mapping of modulated and scrambled codewords

nrLDPCDecode*

Low-density parity-check (LDPC) decoding

nrLDPCEncode

Low-density parity-check (LDPC) encoding

nrLowPAPRS*

Generate low peak-to-average power ratio (low-PAPR) sequence

nrPBCH*

Generate PBCH modulation symbols

nrPBCHDecode

Decode PBCH modulation symbols

nrPBCHDMRS*

Generate PBCH DM-RS symbols

nrPBCHDMRSIndices*

Generate PBCH DM-RS resource element indices

nrPBCHIndices*

Generate PBCH resource element indices

nrPBCHPRBS*

Generate PBCH scrambling sequence

nrPDCCH*

Generate PDCCH modulation symbols

nrPDCCHDecode

Decode PDCCH modulation symbols

nrPDCCHPRBS*

Generate PDCCH scrambling sequence

nrPDSCH*

Generate PDSCH modulation symbols

nrPDSCHDecode

Decode PDSCH modulation symbols

nrPDSCHPRBS*

Generate PDSCH scrambling sequence

nrPerfectChannelEstimate

Perfect channel estimation

nrPerfectTimingEstimate

Perfect timing estimation

nrPolarDecode*

Polar decoding

nrPolarEncode

Polar encoding

nrPRBS*

Generate PRBS

nrPSS*

Generate PSS symbols

nrPSSIndices*

Generate PSS resource element indices

nrPUCCH0*

Generate PUCCH format 0 modulation symbols

nrPUCCH1*

Generate PUCCH format 1 modulation symbols

nrPUCCH2*

Generate PUCCH format 2 modulation symbols

nrPUCCH3*

Generate PUCCH format 3 modulation symbols

nrPUCCH4*

Generate PUCCH format 4 modulation symbols

nrPUCCHHoppingInfo

Get PUCCH hopping information

nrPUCCHPRBS*

Generate PUCCH scrambling sequence

nrPUSCH*

Generate PUSCH modulation symbols

nrPUSCHCodebook

Generate PUSCH precoding matrix

nrPUSCHDecode

Decode PUSCH modulation symbols

nrPUSCHDescramble

Perform PUSCH descrambling

nrPUSCHPRBS*

Generate PUSCH scrambling sequence

nrPUSCHScramble

Perform PUSCH scrambling

nrRateMatchLDPC

Low-density parity-check (LDPC) rate matching

nrRateMatchPolar

Polar rate matching

nrRateRecoverLDPC

Low-density parity-check (LDPC) rate recovery

nrRateRecoverPolar

Polar rate recovering

nrSSS*

Generate SSS symbols

nrSSSIndices*

Generate SSS resource element indices

nrSymbolDemodulate*

Demodulate and convert symbols to bits

nrSymbolModulate*

Generate modulated symbols

nrTDLChannel*

Send signal through TDL channel model

nrTimingEstimate

Practical timing estimation

nrTransformDeprecode

Recover transform deprecoded symbols

nrTransformPrecode

Generate transform precoded symbols

nrUCIDecode*

Decode uplink control information (UCI)

nrUCIEncode

Encode uplink control information (UCI)

nrULSCH*

Apply UL-SCH encoder processing chain

nrULSCHDecoder*

Apply UL-SCH decoder processing chain

nrULSCHInfo

Get uplink shared channel (UL-SCH) information

resetSoftBuffer

Reset soft buffer for HARQ process in UL-SCH or DL-SCH decoder

setTransportBlock

Load transport block into UL-SCH or DL-SCH encoder

Aerospace Toolbox

C and C++ code generation for the following Aerospace Toolbox quaternion functions requires the Aerospace Toolbox software.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

quatconj*

Calculate conjugate of quaternion

quatdivide*

Divide quaternion by another quaternion

quatinv*

Calculate inverse of quaternion

quatmod*

Calculate modulus of quaternion

quatmultiply*

Calculate product of two quaternions

quatnorm*

Calculate norm of quaternion

quatnormalize*

Normalize quaternion

Audio Toolbox

C and C++ code generation for the following functions and System objects requires the Audio Toolbox™ software.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

audioDeviceReader*

Record from sound card

audioDeviceWriter*

Play to sound card

audioOscillator*

Generate sine, square, and sawtooth waveforms

audioPlayerRecorder*

Simultaneously play and record using an audio device

audioPlugin

Base class for audio plugins

audioPluginGridLayout

Specify layout for audio plugin UI

audioPluginInterface

Specify audio plugin interface

audioPluginParameter

Specify audio plugin parameters

audioPluginSource

Base class for audio source plugins

audioTimeScaler*

Apply time scaling to streaming audio

bark2hz

Convert from Bark scale to hertz

cepstralFeatureExtractor*

Extract cepstral features from audio segment

compressor*

Dynamic range compressor

crossoverFilter*

Audio crossover filter

designAuditoryFilterBank

Design auditory filter bank

designParamEQ

Design parametric equalizer

designShelvingEQ

Design shelving equalizer

designVarSlopeFilter

Design variable slope lowpass or highpass IIR filter

dsp.ArrayPlot*

Display vectors or arrays

dsp.AudioFileReader*

Stream from audio file

dsp.AudioFileWriter*

Stream to audio file

dsp.SpectrumAnalyzer*

Display frequency spectrum of time-domain signals

dsp.TimeScope*

Time domain signal display and measurement

erb2hz

Convert from equivalent rectangular bandwidth (ERB) scale to hertz

expander*

Dynamic range expander

gammatoneFilterBank*

Gammatone filter bank

graphicEQ*

Standards-based graphic equalizer

gtcc

Extract gammatone cepstral coefficients, log-energy, delta, and delta-delta

harmonicRatio

Harmonic ratio

hz2bark

Convert from hertz to Bark scale

hz2erb

Convert from hertz to equivalent rectangular bandwidth (ERB) scale

hz2mel

Convert from hertz to mel scale

imdct

Inverse modified discrete cosine transform

integratedLoudness

Measure integrated loudness and loudness range

interpolateHRTF

3-D head-related transfer function (HRTF) interpolation

kbdwin

Kaiser-Bessel-derived window

limiter*

Dynamic range limiter

loudnessMeter*

Standard-compliant loudness measurements

mdct

Modified discrete cosine transform

mel2hz

Convert from mel scale to hertz

melSpectrogram

Mel spectrogram

mfcc

Extract mfcc, log energy, delta, and delta-delta of audio signal

multibandParametricEQ*

Multiband parametric equalizer

noiseGate*

Dynamic range gate

octaveFilter*

Octave-band and fractional octave-band filter

octaveFilterBank*

Octave and fractional-octave filter bank

pinknoise

Generate pink noise

pitch

Estimate fundamental frequency of audio signal

reverberator*

Add reverberation to audio signal

shiftPitch

Shift audio pitch

spectralCentroid

Spectral centroid for audio signals and auditory spectrograms

spectralCrest

Spectral crest for audio signals and auditory spectrograms

spectralDecrease

Spectral decrease for audio signals and auditory spectrograms

spectralEntropy

Spectral entropy for audio signals and auditory spectrograms

spectralFlatness

Spectral flatness for audio signals and auditory spectrograms

spectralFlux

Spectral flux for audio signals and auditory spectrograms

spectralKurtosis

Spectral kurtosis for audio signals and auditory spectrograms

spectralRolloffPoint

Spectral rolloff point for audio signals and auditory spectrograms

spectralSkewness

Spectral skewness for audio signals and auditory spectrograms

spectralSlope

Spectral slope for audio signals and auditory spectrograms

spectralSpread

Spectral spread for audio signals and auditory spectrograms

splMeter*

Measure sound pressure level of audio signal

stretchAudio

Time-stretch audio

voiceActivityDetector*

Detect presence of speech in audio signal

wavetableSynthesizer*

Generate periodic signal from single-cycle waveforms

weightingFilter*

Frequency-weighted filter

Automated Driving Toolbox

C and C++ code generation for the following functions and System objects requires the Automated Driving Toolbox™ software.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

acfObjectDetector*

Detect objects using aggregate channel features

acfObjectDetectorMonoCamera*

Detect objects in monocular camera using aggregate channel features

birdsEyeView

Create bird's-eye view using inverse perspective mapping

cameas

Measurement function for constant-acceleration motion

cameasjac

Jacobian of measurement function for constant-acceleration motion

cameraParameters*

Object for storing camera parameters

checkFree

Check vehicle costmap for collision-free poses or points

checkOccupied

Check vehicle costmap for occupied poses or points

checkPathValidity

Check validity of planned vehicle path

clone

Create duplicate tracking filter

constacc

Constant-acceleration motion model

constaccjac

Jacobian for constant-acceleration motion

constturn

Constant turn-rate motion model

constturnjac

Jacobian for constant turn-rate motion

constvel

Constant velocity state update

constveljac

Jacobian for constant-velocity motion

correct

Correct state and state estimation error covariance using tracking filter

correctjpda*

Correct state and state estimation error covariance using tracking filter and JPDA

ctmeas

Measurement function for constant turn-rate motion

ctmeasjac

Jacobian of measurement function for constant turn-rate motion

cvmeas

Measurement function for constant velocity motion

cvmeasjac

Jacobian of measurement function for constant velocity motion

distance

Distances between current and predicted measurements of tracking filter

driving.DubinsPathSegment*

Dubins path segment

driving.Path

Planned vehicle path

driving.ReedsSheppPathSegment*

Reeds-Shepp path segment

findNearestNeighbors*

Find nearest neighbors of a point in point cloud

findNeighborsInRadius*

Find neighbors within a radius of a point in the point cloud

findPointsInROI

Find points within a region of interest in the point cloud

getCosts

Get cost value of cells in vehicle costmap

getTrackPositions

Returns updated track positions and position covariance matrix

getTrackVelocities

Obtain updated track velocities and velocity covariance matrix

imageToVehicle

Convert bird's-eye-view image coordinates to vehicle coordinates

inflationCollisionChecker*

Collision-checking configuration for costmap based on inflation

initcaekf

Create constant-acceleration extended Kalman filter from detection report

initcakf

Create constant-acceleration linear Kalman filter from detection report

initcaukf

Create constant-acceleration unscented Kalman filter from detection report

initctekf

Create constant turn-rate extended Kalman filter from detection report

initctukf

Create constant turn-rate unscented Kalman filter from detection report

initcvekf

Create constant-velocity extended Kalman filter from detection report

initcvkf

Create constant-velocity linear Kalman filter from detection report

initcvukf

Create constant-velocity unscented Kalman filter from detection report

initialize

Initialize state and covariance of tracking filter

insertMarker*

Insert markers in image or video

insertObjectAnnotation*

Annotate truecolor or grayscale image or video stream

insertShape*

Insert shapes in image or video

insertText*

Insert text in image or video

interpolate

Interpolate poses along planned vehicle path

lateralControllerStanley

Compute steering angle command for path following by using Stanley method

likelihood

Likelihood of measurement from tracking filter

monoCamera

Configure monocular camera sensor

multiObjectTracker*

Track objects using GNN assignment

objectDetection

Report for single object detection

pathPlannerRRT*

Configure RRT* path planner

pcdenoise*

Remove noise from 3-D point cloud

pcdownsample*

Downsample a 3-D point cloud

pcfitplane*

Fit plane to 3-D point cloud

pcmerge*

Merge two 3-D point clouds

pcnormals*

Estimate normals for point cloud

pcregistercpd*

Register two point clouds using CPD algorithm

pcregisterndt*

Register two point clouds using NDT algorithm

pcsegdist*

Segment point cloud into clusters based on Euclidean distance

pctransform*

Transform 3-D point cloud

plan*

Plan vehicle path using RRT* path planner

pointCloud

Object for storing 3-D point cloud

predict

Predict state and state estimation error covariance of tracking filter

predict (trackingKF)

Predict state and state estimation error covariance of linear Kalman filter

radarDetectionGenerator*

Generate radar detections for driving scenario

removeInvalidPoints

Remove invalid points from point cloud

residual

Measurement residual and residual noise from tracking filter

segmentLaneMarkerRidge

Detect lanes in a grayscale intensity image

segmentLidarData*

Segment organized 3-D range data into clusters

select

Select points in point cloud

setCosts

Set cost value of cells in vehicle costmap

smoothPathSpline

Smooth vehicle path using cubic spline interpolation

trackingEKF

Extended Kalman filter for object tracking

trackingKF*

Linear Kalman filter for object tracking

trackingUKF

Unscented Kalman filter for object tracking

transformImage

Transform image to bird's-eye view

undistortImage*

Correct image for lens distortion

vehicleCostmap*

Costmap representing planning space around vehicle

vehicleDimensions*

Store vehicle dimensions

vehicleToImage

Convert vehicle coordinates to bird's-eye-view image coordinates

vision.CascadeObjectDetector*

Detect objects using the Viola-Jones algorithm

vision.DeployableVideoPlayer*

Display video

vision.PeopleDetector*

Detect upright people using HOG features

visionDetectionGenerator*

Generate vision detections for driving scenario

Communications Toolbox

C and C++ code generation for the following functions and System objects requires the Communications Toolbox™ software.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

algdeintrlv

Restore ordering of symbols using algebraically derived permutation table

algintrlv

Reorder symbols using algebraically derived permutation table

alignsignals

Align two signals by delaying earliest signal

apskdemod

Amplitude phase shift keying (APSK) demodulation

apskmod

Amplitude phase shift keying (APSK) modulation

awgn*

Add white Gaussian noise to signal

bchgenpoly*

Generator polynomial of BCH code

bi2de

Convert binary vectors to decimal numbers

bin2gray

Convert positive integers into corresponding Gray-encoded integers

bleATTPDU

Generate BLE ATT PDU

bleATTPDUConfig

Create configuration object for BLE ATT PDU

bleATTPDUDecode

Decode BLE ATT PDU

bleChannelSelection*

Select BLE channel index

bleGAPDataBlock

Generate BLE GAP data block

bleGAPDataBlockConfig

Create configuration object for BLE GAP data block

bleGAPDataBlockDecode

Decode BLE GAP data block

bleIdealReceiver

Ideal receiver for BLE PHY waveform

bleL2CAPFrame

Generate BLE L2CAP frame

bleL2CAPFrameConfig

Create configuration object for BLE L2CAP frame

bleL2CAPFrameDecode

Decode BLE L2CAP frame

bleLLAdvertisingChannelPDU

Generate BLE LL advertising channel PDU

bleLLAdvertisingChannelPDUDecode

Decode BLE LL advertising channel PDU

bleLLControlPDUConfig

Create configuration object for BLE LL control PDU payload configuration

bleLLDataChannelPDU*

Generate BLE LL data channel PDU

bleLLDataChannelPDUConfig

Create configuration object for BLE LL data channel PDU

bleLLDataChannelPDUDecode*

Decode BLE LL data channel PDU

bleWaveformGenerator

Waveform generator for BLE PHY

bsc*

Binary symmetric channel

comm.ACPR*

Adjacent Channel Power Ratio measurements

comm.AGC*

Adaptively adjust gain for constant signal-level output

comm.AlgebraicDeinterleaver*

(To be removed) Deinterleave input symbols using algebraically derived permutation vector

comm.AlgebraicInterleaver*

(To be removed) Permute input symbols using algebraically derived permutation vector

comm.APPDecoder*

Decode convolutional code using the a posteriori probability method

comm.AWGNChannel*

Add white Gaussian noise to input signal

comm.BarkerCode*

Generate bipolar Barker code

comm.BasebandFileReader*

Read baseband signals from file

comm.BasebandFileWriter*

Write baseband signals to file

comm.BCHDecoder*

Decode data using BCH decoder

comm.BCHEncoder*

Encode data using BCH encoder

comm.BinarySymmetricChannel*

(To be removed) Introduce binary errors

comm.BlockDeinterleaver*

(To be removed) Deinterleave input symbols using permutation vector

comm.BlockInterleaver*

(To be removed) Permute input symbols using permutation vector

comm.BPSKDemodulator*

Demodulate using BPSK method

comm.BPSKModulator*

Modulate using BPSK method

comm.CarrierSynchronizer*

Compensate for carrier frequency offset

comm.CCDF*

Measure complementary cumulative distribution function

comm.CoarseFrequencyCompensator*

Compensate for frequency offset for PAM, PSK, or QAM

comm.ConstellationDiagram*

Display constellation diagram for input signals

comm.ConvolutionalDeinterleaver*

Restore ordering of symbols using shift registers

comm.ConvolutionalEncoder*

Convolutionally encode binary data

comm.ConvolutionalInterleaver*

Permute input symbols using shift registers with same property values

comm.CPFSKDemodulator*

Demodulate using CPFSK method and Viterbi algorithm

comm.CPFSKModulator*

Modulate using CPFSK method

comm.CPMCarrierPhaseSynchronizer*

(To be removed) Recover carrier phase of baseband CPM signal

comm.CPMDemodulator*

Demodulate using CPM method and Viterbi algorithm

comm.CPMModulator*

Modulate using CPM method

comm.CRCDetector*

Detect errors in input data using CRC

comm.CRCGenerator*

Generate CRC code bits and append to input data

comm.DBPSKDemodulator*

Demodulate using DBPSK method

comm.DBPSKModulator*

Modulate using DBPSK method

comm.DecisionFeedbackEqualizer

Equalize modulated signals using decision feedback filtering

comm.Descrambler*

Descramble input signal

comm.DifferentialDecoder*

Decode binary signal using differential decoding

comm.DifferentialEncoder*

Encode binary signal using differential coding

comm.DiscreteTimeVCO*

Generate variable frequency sinusoid

comm.DPD*

Digital predistorter

comm.DPDCoefficientEstimator*

Estimate memory-polynomial coefficients for digital predistortion

comm.DPSKDemodulator*

Demodulate using M-ary DPSK method

comm.DPSKModulator*

Modulate using M-ary DPSK method

comm.DQPSKDemodulator*

Demodulate using DQPSK method

comm.DQPSKModulator*

Modulate using DQPSK method

comm.ErrorRate*

Compute bit or symbol error rate of input data

comm.EVM*

Measure error vector magnitude

comm.EyeDiagram*

Display eye diagram of time-domain signals

comm.FMBroadcastDemodulator*

Demodulate broadcast FM signal

comm.FMBroadcastModulator*

Modulate broadcast FM signal

comm.FMDemodulator*

Demodulate using FM method

comm.FMModulator*

Modulate using FM method

comm.FSKDemodulator*

Demodulate using M-ary FSK method

comm.FSKModulator*

Modulate using M-ary FSK method

comm.GeneralQAMDemodulator*

Demodulate using arbitrary QAM constellation

comm.GeneralQAMModulator*

Modulate using arbitrary QAM constellation

comm.GeneralQAMTCMDemodulator*

Demodulate convolutionally encoded data mapped to arbitrary QAM constellation

comm.GeneralQAMTCMModulator*

Convolutionally encode binary data and map using arbitrary QAM constellation

comm.GMSKDemodulator*

Demodulate using GMSK method and the Viterbi algorithm

comm.GMSKModulator*

Modulate using GMSK method

comm.GMSKTimingSynchronizer*

Recover symbol timing phase using fourth-order nonlinearity method

comm.GoldSequence*

Generate Gold sequence

comm.HadamardCode*

Generate Hadamard code

comm.HDLCRCDetector*

Detect errors in input data using CRC

comm.HDLCRCGenerator*

Generate CRC code bits and append to input data

comm.HDLRSDecoder*

Decode message using Reed-Solomon decoder

comm.HDLRSEncoder*

Encode message using Reed-Solomon encoder

comm.HelicalDeinterleaver*

Restore ordering of symbols using helical array

comm.HelicalInterleaver*

Permute input symbols using helical array

comm.IntegrateAndDumpFilter*

Integrate discrete-time signal with periodic resets

comm.IQImbalanceCompensator*

Compensate for I/Q imbalance

comm.KasamiSequence*

Generate Kasami sequence

comm.LDPCDecoder*

Decode binary low-density parity-check code

comm.LDPCEncoder*

Encode binary low-density parity-check code

comm.LinearEqualizer

Equalize modulated signals using linear filtering

comm.LTEMIMOChannel*

(To be removed) Filter input signal through LTE MIMO multipath fading channel

comm.MatrixDeinterleaver*

(To be removed) Deinterleave input symbols using permutation matrix

comm.MatrixHelicalScanDeinterleaver*

(To be removed) Deinterleave input symbols by filling a matrix along diagonals

comm.MatrixHelicalScanInterleaver*

(To be removed) Permute input symbols by selecting matrix elements along diagonals

comm.MatrixInterleaver*

(To be removed) Permute input symbols using permutation matrix

comm.MemorylessNonlinearity*

Apply memoryless nonlinearity to input signal

comm.MER*

Measure modulation error ratio

comm.MIMOChannel*

Filter input signal through MIMO multipath fading channel

comm.MLSEEqualizer*

Equalize using maximum likelihood sequence estimation

comm.MSKDemodulator*

Demodulate using MSK method and the Viterbi algorithm

comm.MSKModulator*

Modulate using MSK method

comm.MSKTimingSynchronizer*

Recover symbol timing phase using fourth-order nonlinearity method

comm.MultiplexedDeinterleaver*

Deinterleave input symbols using set of shift registers with specified delays

comm.MultiplexedInterleaver*

Permute input symbols using set of shift registers with specified delays

comm.OFDMDemodulator*

Demodulate using OFDM method

comm.OFDMModulator*

Modulate using OFDM method

comm.OQPSKDemodulator*

Demodulation using OQPSK method

comm.OQPSKModulator*

Modulation using OQPSK method

comm.OSTBCCombiner*

Combine inputs using orthogonal space-time block code

comm.OSTBCEncoder*

Encode input using orthogonal space-time block code

comm.PAMDemodulator*

(Not recommended) Demodulate using M-ary PAM method

comm.PAMModulator*

(Not recommended) Modulate using M-ary PAM method

comm.PhaseFrequencyOffset*

Apply phase and frequency offsets to input signal

comm.PhaseNoise*

Apply phase noise to baseband signal

comm.PNSequence*

Generate a pseudo-noise (PN) sequence

comm.PreambleDetector*

Detect preamble in data

comm.PSKCoarseFrequencyEstimator*

(To be removed) Estimate frequency offset for PSK signal

comm.PSKDemodulator*

Demodulate using M-ary PSK method

comm.PSKModulator*

Modulate using M-ary PSK method

comm.PSKTCMDemodulator*

Demodulate convolutionally encoded data mapped to M-ary PSK signal constellation

comm.PSKTCMModulator*

Convolutionally encode binary data and map using M-ary PSK signal constellation

comm.QAMCoarseFrequencyEstimator*

(To be removed) Estimate frequency offset for QAM signal

comm.QPSKDemodulator*

Demodulate using QPSK method

comm.QPSKModulator*

Modulate using QPSK method

comm.RaisedCosineReceiveFilter*

Apply pulse shaping by decimating signal using raised cosine filter

comm.RaisedCosineTransmitFilter*

Apply pulse shaping by interpolating signal using raised cosine filter

comm.RayleighChannel*

Filter input signal through a Rayleigh multipath fading channel

comm.RBDSWaveformGenerator*

Generate RDS/RBDS waveform

comm.RectangularQAMDemodulator*

(To be removed) Demodulate using rectangular QAM signal constellation

comm.RectangularQAMModulator*

(To be removed) Modulate using rectangular QAM signal constellation

comm.RectangularQAMTCMDemodulator*

Demodulate convolutionally encoded data mapped to rectangular QAM signal constellation

comm.RectangularQAMTCMModulator*

Convolutionally encode binary data and map using rectangular QAM signal constellation

comm.RicianChannel*

Filter input signal through a Rician fading channel

comm.RSDecoder*

Decode data using Reed-Solomon decoder

comm.RSEncoder*

Encode data using Reed-Solomon encoder

comm.Scrambler*

Scramble input signal

comm.SphereDecoder*

Decode input using sphere decoder

comm.SymbolSynchronizer*

Correct symbol timing clock skew

comm.ThermalNoise*

Add thermal noise to signal

comm.TurboDecoder*

Decode input signal using parallel concatenated decoding scheme

comm.TurboEncoder*

Encode input signal using parallel concatenated encoding scheme

comm.ViterbiDecoder*

Decode convolutionally encoded data using Viterbi algorithm

comm.WalshCode*

Generate Walsh code from orthogonal set of codes

convenc

Convolutionally encode binary data

de2bi

Convert decimal numbers to binary vectors

deintrlv

Restore ordering of symbols

doppler*

Construct Doppler spectrum structure

dpskdemod

Differential phase shift keying demodulation

dpskmod

Differential phase shift keying modulation

dsp.ArrayPlot*

Display vectors or arrays

dsp.DCBlocker*

Block DC component (offset) from input signal

dsp.SpectrumAnalyzer*

Display frequency spectrum of time-domain signals

dsp.TimeScope*

Time domain signal display and measurement

dvbs2ldpc*

Low-density parity-check codes from DVB-S.2 standard

dvbsapskdemod

DVB-S2/S2X/SH standard-specific amplitude phase shift keying (APSK) demodulation

dvbsapskmod

DVB-S2/S2X/SH standard-specific amplitude phase shift keying (APSK) modulation

finddelay

Estimate delay(s) between signals

fogpl*

RF signal attenuation due to fog and clouds

fspl*

Free space path loss

gaspl*

RF signal attenuation due to atmospheric gases

genqamdemod

General quadrature amplitude demodulation

genqammod

General quadrature amplitude modulation

gray2bin

Convert Gray-encoded positive integers to corresponding Gray-decoded integers

gsmCheckTimeMask*

Inspect GSM burst against time mask

gsmDownlinkConfig*

Create GSM downlink TDMA frame configuration object

gsmFrame

Create GSM waveform

gsmInfo

View GSM waveform information

gsmUplinkConfig*

Create GSM uplink TDMA frame configuration object

helscandeintrlv

Restore ordering of symbols in helical pattern

helscanintrlv

Reorder symbols in helical pattern

intrlv

Reorder sequence of symbols

iqcoef2imbal

Convert compensator coefficient to amplitude and phase imbalance

iqimbal

Apply I/Q imbalance to input signal

iqimbal2coef

Convert I/Q imbalance to compensator coefficient

istrellis

True for valid trellis structure

matdeintrlv

Restore ordering of symbols by filling matrix by columns and emptying it by rows

matintrlv

Reorder symbols by filling matrix by rows and emptying it by columns

mil188qamdemod

MIL-STD-188-110 B/C standard-specific quadrature amplitude demodulation

mil188qammod

MIL-STD-188-110 B/C standard-specific quadrature amplitude modulation (QAM)

oct2dec

Convert octal to decimal numbers

ofdmdemod

Demodulate time-domain signal using orthogonal frequency division multiplexing (OFDM)

ofdmmod

Modulate frequency-domain signal using orthogonal frequency division multiplexing (OFDM)

pamdemod

Pulse amplitude demodulation

pammod

Pulse amplitude modulation

poly2trellis*

Convert convolutional code polynomials to trellis description

qamdemod

Quadrature amplitude demodulation

qammod

Quadrature amplitude modulation

rainpl*

RF signal attenuation due to rainfall

randi*

Uniformly distributed pseudorandom integers

rangeangle*

Range and angle calculation

rcosdesign*

Raised cosine FIR pulse-shaping filter design

rsgenpoly*

Generator polynomial of Reed-Solomon code

rsgenpolycoeffs*

Generator polynomial coefficients of Reed-Solomon code

tpcdec*

Turbo product code (TPC) decoder

tpcenc*

Turbo product code (TPC) encoder

vitdec

Convolutionally decode binary data using Viterbi algorithm

wgn*

Generate white Gaussian noise samples

zadoffChuSeq

Generate root Zadoff-Chu sequence

Computer Vision Toolbox

C and C++ code generation for the following functions and System objects requires the Computer Vision Toolbox™ software.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

acfObjectDetector*

Detect objects using aggregate channel features

affine2d*

2-D affine geometric transformation

affine3d*

3-D affine geometric transformation

assignDetectionsToTracks

Assign detections to tracks for multiobject tracking

bbox2points

Convert rectangle to corner points list

bboxOverlapRatio

Compute bounding box overlap ratio

binaryFeatures

Object for storing binary feature vectors

BRISKPoints*

Object for storing BRISK interest points

cameraMatrix*

Camera projection matrix

cameraParameters*

Object for storing camera parameters

cameraPose*

Compute relative rotation and translation between camera poses

cameraPoseToExtrinsics

Convert camera pose to extrinsics

cornerPoints*

Object for storing corner points

detect*

Detect objects using ACF object detector

detectBRISKFeatures*

Detect BRISK features and return BRISKPoints object

detectCheckerboardPoints*

Detect checkerboard pattern in image

detectFASTFeatures*

Detect corners using FAST algorithm and return cornerPoints object

detectHarrisFeatures*

Detect corners using Harris–Stephens algorithm and return cornerPoints object

detectKAZEFeatures*

Detect KAZE features

detectMinEigenFeatures*

Detect corners using minimum eigenvalue algorithm and return cornerPoints object

detectMSERFeatures*

Detect MSER features and return MSERRegions object

detectORBFeatures

Detect and store ORB keypoints

detectSURFFeatures*

Detect SURF features and return SURFPoints object

disparity*

(Not recommended) Disparity map between stereo images

disparityBM

Compute disparity map using block matching

disparitySGM

Compute disparity map through semi-global matching

epipolarLine

Compute epipolar lines for stereo images

estimateEssentialMatrix*

Estimate essential matrix from corresponding points in a pair of images

estimateFlow

Estimate optical flow

estimateFundamentalMatrix*

Estimate fundamental matrix from corresponding points in stereo images

estimateGeometricTransform*

Estimate geometric transform from matching point pairs

estimateUncalibratedRectification

Uncalibrated stereo rectification

estimateWorldCameraPose*

Estimate camera pose from 3-D to 2-D point correspondences

extractFeatures*

Extract interest point descriptors

extractHOGFeatures

Extract histogram of oriented gradients (HOG) features

extractLBPFeatures*

Extract local binary pattern (LBP) features

extrinsics*

Compute location of calibrated camera

extrinsicsToCameraPose

Convert extrinsics to camera pose

findNearestNeighbors*

Find nearest neighbors of a point in point cloud

findNeighborsInRadius*

Find neighbors within a radius of a point in the point cloud

findPointsInROI

Find points within a region of interest in the point cloud

generateCheckerboardPoints

Generate checkerboard corner locations

imcrop*

Crop image

imresize*

Resize image

imwarp*

Apply geometric transformation to image

insertMarker*

Insert markers in image or video

insertObjectAnnotation*

Annotate truecolor or grayscale image or video stream

insertShape*

Insert shapes in image or video

insertText*

Insert text in image or video

isEpipoleInImage

Determine whether image contains epipole

KAZEPoints*

Object for storing KAZE interest points

lineToBorderPoints

Intersection points of lines in image and image border

matchFeatures*

Find matching features

MSERRegions*

Object for storing MSER regions

ocr*

Recognize text using optical character recognition

ocrText*

Object for storing OCR results

opticalFlow

Object for storing optical flow matrices

opticalFlowFarneback

Object for estimating optical flow using Farneback method

opticalFlowHS

Object for estimating optical flow using Horn-Schunck method

opticalFlowLK

Object for estimating optical flow using Lucas-Kanade method

opticalFlowLKDoG

Object for estimating optical flow using Lucas-Kanade derivative of Gaussian method

ORBPoints*

Object for storing ORB keypoints

pcdenoise*

Remove noise from 3-D point cloud

pcdownsample*

Downsample a 3-D point cloud

pcfitcylinder*

Fit cylinder to 3-D point cloud

pcfitplane*

Fit plane to 3-D point cloud

pcfitsphere*

Fit sphere to 3-D point cloud

pcmerge*

Merge two 3-D point clouds

pcnormals*

Estimate normals for point cloud

pcregistercpd*

Register two point clouds using CPD algorithm

pcregisterndt*

Register two point clouds using NDT algorithm

pcsegdist*

Segment point cloud into clusters based on Euclidean distance

pctransform*

Transform 3-D point cloud

pointCloud

Object for storing 3-D point cloud

projective2d*

2-D projective geometric transformation

reconstructScene*

Reconstruct 3-D scene from disparity map

rectifyStereoImages*

Rectify a pair of stereo images

relativeCameraPose*

Compute relative rotation and translation between camera poses

removeInvalidPoints

Remove invalid points from point cloud

reset

Reset the internal state of the optical flow estimation object

rotationMatrixToVector

Convert 3-D rotation matrix to rotation vector

rotationVectorToMatrix

Convert 3-D rotation vector to rotation matrix

segmentLidarData*

Segment organized 3-D range data into clusters

select

Select points in point cloud

selectStrongestBbox

Select strongest bounding boxes from overlapping clusters

selectStrongestBboxMulticlass*

Select strongest multiclass bounding boxes from overlapping clusters

stereoAnaglyph

Create red-cyan anaglyph from stereo pair of images

stereoParameters*

Object for storing stereo camera system parameters

SURFPoints*

Object for storing SURF interest points

triangulate*

3-D locations of undistorted matching points in stereo images

undistortImage*

Correct image for lens distortion

vision.AlphaBlender*

Combine images, overlay images, or highlight selected pixels

vision.BlobAnalysis*

Properties of connected regions

vision.CascadeObjectDetector*

Detect objects using the Viola-Jones algorithm

vision.ChromaResampler*

Downsample or upsample chrominance components of images

vision.Deinterlacer*

Remove motion artifacts by deinterlacing input video signal

vision.DeployableVideoPlayer*

Display video

vision.ForegroundDetector*

Foreground detection using Gaussian mixture models

vision.GammaCorrector*

Apply or remove gamma correction from images or video streams

vision.HistogramBasedTracker*

Histogram-based object tracking

vision.KalmanFilter*

Correction of measurement, state, and state estimation error covariance

vision.LocalMaximaFinder*

Find local maxima in matrices

vision.Maximum*

Find maximum values in input or sequence of inputs

vision.Mean*

Find mean values in input or sequence of inputs

vision.Median*

Find median values in input or sequence of inputs

vision.Minimum*

Find minimum values in input or sequence of inputs

vision.PeopleDetector*

Detect upright people using HOG features

vision.PointTracker*

Track points in video using Kanade-Lucas-Tomasi (KLT) algorithm

vision.StandardDeviation*

Find standard deviation values in input or sequence of inputs

vision.TemplateMatcher*

Locate template in image

vision.Variance*

Find variance values in input or sequence of inputs

vision.VideoFileReader*

Read video frames and audio samples from video file

vision.VideoFileWriter*

Write video frames and audio samples to video file

Control System Toolbox

C and C++ code generation for the following functions requires the Control System Toolbox™ software.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

extendedKalmanFilter*

Create extended Kalman filter object for online state estimation

particleFilter*

Particle filter object for online state estimation

unscentedKalmanFilter*

Create unscented Kalman filter object for online state estimation

Deep Learning Toolbox

C and C++ code generation for the following functions requires the Deep Learning Toolbox™ software.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

activations*

Compute deep learning network layer activations

alexnet*

Pretrained AlexNet convolutional neural network

DAGNetwork*

Directed acyclic graph (DAG) network for deep learning

genFunction*

Generate MATLAB function for simulating shallow neural network

googlenet*

Pretrained GoogLeNet convolutional neural network

inceptionv3*

Pretrained Inception-v3 convolutional neural network

predict*

Predict responses using a trained deep learning neural network

resnet101*

Pretrained ResNet-101 convolutional neural network

resnet50*

Pretrained ResNet-50 convolutional neural network

SeriesNetwork*

Series network for deep learning

squeezenet*

Pretrained SqueezeNet convolutional neural network

vgg16*

Pretrained VGG-16 convolutional neural network

vgg19*

Pretrained VGG-19 convolutional neural network

You can use genFunction in the Deep Learning Toolbox to generate a standalone MATLAB function for a trained neural network. You can generate C/C++ code from this standalone MATLAB function. To generate Simulink® blocks, use the gensim function. See Deploy Shallow Neural Network Functions (Deep Learning Toolbox).

DSP System Toolbox

C code generation for the following functions and System objects requires the DSP System Toolbox™ license. Many DSP System Toolbox functions require constant inputs for code generation. To specify a constant input for fiaccel, use coder.Constant. For more information, see Specify Constant Inputs at the Command Line.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

audioDeviceWriter*

Play to sound card

ca2tf*

Convert coupled allpass filter to transfer function form

cl2tf*

Convert coupled allpass lattice to transfer function form

designMultirateFIR*

Multirate FIR filter design

dsp.AdaptiveLatticeFilter*

Adaptive lattice filter

dsp.AffineProjectionFilter*

Compute output, error and coefficients using affine projection (AP) Algorithm

dsp.AllpassFilter*

Single section or cascaded allpass filter

dsp.AllpoleFilter*

IIR Filter with no zeros

dsp.AnalyticSignal*

Analytic signals of discrete-time inputs

dsp.ArrayPlot*

Display vectors or arrays

dsp.ArrayVectorAdder*

Add array to vector along specified dimension

dsp.ArrayVectorDivider*

Divide array by vector along specified dimension

dsp.ArrayVectorMultiplier*

Multiply array by vector along specified dimension

dsp.ArrayVectorSubtractor*

Subtract vector from array along specified dimension

dsp.AsyncBuffer*

FIFO buffer

dsp.AudioFileReader*

Stream from audio file

dsp.AudioFileWriter*

Stream to audio file

dsp.Autocorrelator*

Autocorrelation sequence

dsp.BinaryFileReader*

Read data from binary file

dsp.BinaryFileWriter*

Write data to binary files

dsp.BiquadFilter*

IIR filter using biquadratic structures

dsp.BlockLMSFilter*

Compute output, error, and weights using block LMS adaptive algorithm

dsp.BurgAREstimator*

(To be removed) Estimate of autoregressive (AR) model parameters using Burg method

dsp.BurgSpectrumEstimator*

(To be removed) Parametric spectral estimate using Burg method

dsp.CepstralToLPC*

(To be removed) Convert cepstral coefficients to linear prediction coefficients

dsp.Channelizer*

Polyphase FFT analysis filter bank

dsp.ChannelSynthesizer*

Polyphase FFT synthesis filter bank

dsp.CICCompensationDecimator*

Compensate for CIC decimation filter using FIR decimator

dsp.CICCompensationInterpolator*

Compensate for CIC interpolation filter using FIR interpolator

dsp.CICDecimator*

Decimate signal using cascaded integrator-comb (CIC) filter

dsp.CICInterpolator*

Interpolate signal using cascaded integrator-comb filter

dsp.ColoredNoise*

Generate colored noise signal

dsp.ComplexBandpassDecimator*

Extract a frequency subband using a one-sided (complex) bandpass decimator

dsp.Convolver*

Convolution of two signals

dsp.Counter*

Count up or down through specified range of numbers

dsp.Crosscorrelator*

Cross-correlation of two inputs

dsp.CrossSpectrumEstimator*

Estimate cross-spectral density

dsp.CumulativeProduct*

Cumulative product of channel, column, or row elements

dsp.CumulativeSum*

Cumulative sum of channel, column, or row elements

dsp.DCBlocker*

Block DC component (offset) from input signal

dsp.DCT*

(To be removed) Discrete cosine transform (DCT)

dsp.Delay*

Delay input signal by fixed samples

dsp.DelayLine*

Rebuffer sequence of inputs with one-sample shift

dsp.Differentiator*

Direct form FIR fullband differentiator filter

dsp.DigitalDownConverter*

Translate digital signal from intermediate frequency (IF) band to baseband and decimate it

dsp.DigitalUpConverter*

Interpolate digital signal and translate it from baseband to IF band

dsp.FarrowRateConverter*

Polynomial sample rate converter with arbitrary conversion factor

dsp.FastTransversalFilter*

Fast transversal least-squares FIR adaptive filter

dsp.FFT*

Discrete Fourier transform

dsp.FilterCascade*

Create cascade of filter System objects

dsp.FilteredXLMSFilter*

Filtered XLMS filter

dsp.FIRDecimator*

Polyphase FIR decimator

dsp.FIRFilter*

Static or time-varying FIR filter

dsp.FIRHalfbandDecimator*

Halfband decimator

dsp.FIRHalfbandInterpolator*

Halfband interpolator

dsp.FIRInterpolator*

Polyphase FIR interpolator

dsp.FIRRateConverter*

Sample rate converter

dsp.FrequencyDomainAdaptiveFilter*

Compute output, error, and coefficients using frequency-domain FIR adaptive filter

dsp.FrequencyDomainFIRFilter*

Filter input signal in frequency domain

dsp.HampelFilter*

Filter outliers using Hampel identifier

dsp.HighpassFilter*

FIR or IIR highpass filter

dsp.Histogram*

(To be removed) Histogram of input or sequence of inputs

dsp.IDCT*

(To be removed) Inverse discrete cosine transform (IDCT)

dsp.IFFT*

Inverse discrete Fourier transform (IDFT)

dsp.IIRFilter*

Infinite impulse response (IIR) filter

dsp.IIRHalfbandDecimator*

Decimate by factor of two using polyphase IIR

dsp.IIRHalfbandInterpolator*

Interpolate by a factor of two using polyphase IIR

dsp.Interpolator*

Linear or polyphase FIR interpolation

dsp.ISTFT*

Inverse short-time FFT

dsp.KalmanFilter*

Estimate system measurements and states using Kalman filter

dsp.LDLFactor*

Factor square Hermitian positive definite matrices into components

dsp.LevinsonSolver*

Solve linear system of equations using Levinson-Durbin recursion

dsp.LMSFilter*

Compute output, error, and weights of LMS adaptive filter

dsp.LowerTriangularSolver*

Solve lower-triangular matrix equation

dsp.LowpassFilter*

FIR or IIR lowpass filter

dsp.LPCToAutocorrelation*

(To be removed) Convert linear prediction coefficients to autocorrelation coefficients

dsp.LPCToCepstral*

(To be removed) Convert linear prediction coefficients to cepstral coefficients

dsp.LPCToLSF*

(To be removed) Convert linear prediction coefficients to line spectral frequencies

dsp.LPCToLSP*

(To be removed) Convert linear prediction coefficients to line spectral pairs

dsp.LPCToRC*

(To be removed) Convert linear prediction coefficients to reflection coefficients

dsp.LSFToLPC*

(To be removed) Convert line spectral frequencies to linear prediction coefficients

dsp.LSPToLPC*

(To be removed) Convert line spectral pairs to linear prediction coefficients

dsp.LUFactor*

Factor square matrix into lower and upper triangular matrices

dsp.Maximum*

(To be removed) Find maximum value of input or sequence of inputs

dsp.Mean*

(To be removed) Find mean value of input or sequence of inputs

dsp.Median*

(To be removed) Median value of input

dsp.MedianFilter*

Median filter

dsp.Minimum*

(To be removed) Find minimum values of input or sequence of inputs

dsp.MovingAverage*

Moving average

dsp.MovingMaximum*

Moving maximum

dsp.MovingMinimum*

Moving minimum

dsp.MovingRMS*

Moving root mean square

dsp.MovingStandardDeviation*

Moving standard deviation

dsp.MovingVariance*

Moving variance

dsp.NCO*

Generate real or complex sinusoidal signals

dsp.Normalizer*

(To be removed) Vector normalization along specified dimension

dsp.PeakFinder*

(To be removed) Identify peak values in input signal

dsp.PeakToPeak*

Peak-to-peak value

dsp.PeakToRMS*

Peak-to-root-mean-square value of vector

dsp.PhaseExtractor*

Extract the unwrapped phase of a complex input

dsp.PhaseUnwrapper*

Unwrap signal phase

dsp.RCToAutocorrelation*

(To be removed) Convert reflection coefficients to autocorrelation coefficients

dsp.RCToLPC*

(To be removed) Convert reflection coefficients to linear prediction coefficients

dsp.RLSFilter*

Compute output, error and coefficients using recursive least squares (RLS) algorithm

dsp.RMS*

(To be removed) Root mean square of vector elements

dsp.SampleRateConverter*

Multistage sample rate converter

dsp.ScalarQuantizerDecoder*

Convert each index value into quantized output value

dsp.ScalarQuantizerEncoder*

Associate input value with index value of quantization region

dsp.SignalSource*

Import variable from workspace

dsp.SineWave*

Generate discrete sine wave

dsp.SpectrumAnalyzer*

Display frequency spectrum of time-domain signals

dsp.SpectrumEstimator*

Estimate power spectrum or power density spectrum

dsp.StandardDeviation*

(To be removed) Standard deviation of input or sequence of inputs

dsp.StateLevels*

State-level estimation for bilevel rectangular waveform

dsp.STFT

Short-time FFT

dsp.SubbandAnalysisFilter*

Decompose signal into high-frequency and low-frequency subbands

dsp.SubbandSynthesisFilter*

Reconstruct signal from high-frequency and low-frequency subbands

dsp.TimeScope*

Time domain signal display and measurement

dsp.TransferFunctionEstimator*

Estimate transfer function

dsp.UDPReceiver*

Receive UDP packets from the network

dsp.UDPSender*

Send UDP packets to network

dsp.UpperTriangularSolver*

Solve upper-triangular matrix equation

dsp.VariableBandwidthFIRFilter*

Variable bandwidth FIR filter

dsp.VariableBandwidthIIRFilter*

Variable bandwidth IIR filter

dsp.VariableFractionalDelay*

Delay input by time-varying fractional number of sample periods

dsp.VariableIntegerDelay*

Delay input by time-varying integer number of sample periods

dsp.Variance*

(To be removed) Variance of input or sequence of inputs

dsp.VectorQuantizerDecoder*

Vector quantizer codeword for given index value

dsp.VectorQuantizerEncoder*

Vector quantization encoding

dsp.Window*

Apply window to input signal

dsp.ZeroCrossingDetector*

Detect zero crossings

dsp.ZoomFFT *

High-resolution FFT of a portion of a spectrum

firceqrip*

Constrained equiripple FIR filter

fireqint*

Equiripple FIR interpolators

firgr*

Parks-McClellan FIR filter

firhalfband*

Halfband FIR filter design

firlpnorm*

Least P-norm optimal FIR filter

firminphase*

Minimum-phase FIR spectral factor

firnyquist*

Lowpass Nyquist (Lth-band) FIR filter

firpr2chfb*

Two-channel FIR filter bank for perfect reconstruction

ifir*

Interpolated FIR filter design

iircomb*

IIR comb notch or peak filter

iirgrpdelay*

Optimal IIR filter with prescribed group-delay

iirlpnorm*

Least P-norm optimal IIR filter

iirlpnormc*

Constrained least Pth-norm optimal IIR filter

iirnotch*

Second-order IIR notch filter

iirpeak*

Second-order IIR peak or resonator filter

tf2ca*

Transfer function to coupled allpass

tf2cl*

Transfer function to coupled allpass lattice

Fixed-Point Designer

The following general limitations apply to the use of Fixed-Point Designer™ functions in generated code, with fiaccel:

  • fipref and quantizer objects are not supported.

  • Word lengths greater than 128 bits are not supported.

  • You cannot change the fimath or numerictype of a given fi variable after that variable has been created.

  • The boolean value of the DataTypeMode and DataType properties are not supported.

  • For all SumMode property settings other than FullPrecision, the CastBeforeSum property must be set to true.

  • You can use parallel for (parfor) loops in code compiled with fiaccel, but those loops are treated like regular for loops.

  • When you compile code containing fi objects with nontrivial slope and bias scaling, you may see different results in generated code than you achieve by running the same code in MATLAB.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

abs

Absolute value of fi object

accumneg

Subtract two fi objects or values

accumpos

Add two fi objects or values

add*

Add two objects using fimath object

atan2

Four-quadrant inverse tangent of fixed-point values

bitand*

Bitwise AND of two fi objects

bitandreduce

Reduce consecutive slice of bits to one bit by performing bitwise AND operation

bitcmp

Bitwise complement of fi object

bitconcat

Concatenate bits of fi objects

bitget

Get bits at certain positions

bitor*

Bitwise OR of two fi objects

bitorreduce

Reduce consecutive slice of bits to one bit by performing bitwise OR operation

bitreplicate

Replicate and concatenate bits of fi object

bitrol

Bitwise rotate left

bitror

Bitwise rotate right

bitset

Set bits at certain positions

bitshift

Shift bits specified number of places

bitsliceget

Get consecutive slice of bits

bitsll*

Bit shift left logical

bitsra*

Bit shift right arithmetic

bitsrl*

Bit shift right logical

bitxor*

Bitwise exclusive OR of two fi objects

bitxorreduce

Reduce consecutive slice of bits to one bit by performing bitwise exclusive OR operation

ceil

Round toward positive infinity

complex

Construct complex fi object from real and imaginary parts

conj

Complex conjugate of fi object

conv*

Convolution and polynomial multiplication of fi objects

convergent

Round toward nearest integer with ties rounding to nearest even integer

cordicabs*

CORDIC-based absolute value

cordicangle*

CORDIC-based phase angle

cordicatan2*

CORDIC-based four quadrant inverse tangent

cordiccart2pol*

CORDIC-based approximation of Cartesian-to-polar conversion

cordiccexp*

CORDIC-based approximation of complex exponential

cordiccos*

CORDIC-based approximation of cosine

cordicpol2cart*

CORDIC-based approximation of polar-to-Cartesian conversion

cordicrotate*

Rotate input using CORDIC-based approximation

cordicsin*

CORDIC-based approximation of sine

cordicsincos*

CORDIC-based approximation of sine and cosine

cordicsqrt*

CORDIC-based approximation of square root

cos

Cosine of fi object

ctranspose

Complex conjugate transpose of fi object

divide*

Divide two fi objects

double*

Double-precision floating-point real-world value of fi object

eps*

Quantized relative accuracy for fi or quantizer objects

eq*

Determine whether real-world values of two fi objects are equal

fi*

Construct fixed-point numeric object

filter*

One-dimensional digital filter of fi objects

fimath*

Set fixed-point math settings

fix

Round toward zero

fixed.Quantizer

Quantize fixed-point numbers

floor

Round toward negative infinity

for

Execute statements specified number of times

ge*

Determine whether real-world value of one fi object is greater than or equal to another

get*

Property values of object

getlsb

Least significant bit

getmsb

Most significant bit

gt*

Determine whether real-world value of one fi object is greater than another

horzcat

Horizontally concatenate multiple fi objects

int16

Convert fi object to signed 16-bit integer

int32

Convert fi object to signed 32-bit integer

int64

Convert fi object to signed 64-bit integer

int8

Convert fi object to signed 8-bit integer

isequal

Determine whether real-world values of two fi objects are equal, or determine whether properties of two fimath, numerictype, or quantizer objects are equal

isfi*

Determine whether variable is fi object

isfimath

Determine whether variable is fimath object

isfimathlocal

Determine whether fi object has local fimath

isnumerictype

Determine whether input is numerictype object

issigned

Determine whether fi object is signed

le*

Determine whether real-world value of fi object is less than or equal to another

lowerbound

Lower bound of range of fi object

lsb*

Scaling of least significant bit of fi object, or value of least significant bit of quantizer object

lt*

Determine whether real-world value of one fi object is less than another

max

Largest element in array of fi objects

mean

Average or mean value of fixed-point array

median

Median value of fixed-point array

min

Smallest element in array of fi objects

minus*

Matrix difference between fi objects

mpower*

Fixed-point matrix power (^)

mpy*

Multiply two objects using fimath object

mrdivide

Right-matrix division

mtimes*

Matrix product of fi objects

ne*

Determine whether real-world values of two fi objects are not equal

nearest

Round toward nearest integer with ties rounding toward positive infinity

numel

Number of data elements in fi array

numerictype*

Construct numerictype object

plus*

Matrix sum of fi objects

pow2

Efficient fixed-point multiplication by 2K

power*

Fixed-point element-wise power

qr

Orthogonal-triangular decomposition

quantize

Quantize fixed-point numbers

range

Numerical range of fi or quantizer object

rdivide

Right-array division

realmax

Largest positive fixed-point value or quantized number

realmin

Smallest positive normalized fixed-point value or quantized number

reinterpretcast

Convert fixed-point data types without changing underlying data

removefimath

Remove fimath object from fi object

rescale

Change scaling of fi object

round

Round fi object toward nearest integer or round input data using quantizer object

setfimath

Attach fimath object to fi object

sfi*

Construct signed fixed-point numeric object

sign

Perform signum function on array

sin

Sine of fixed-point values

single*

Single-precision floating-point real-world value of fi object

sort*

Sort elements of real-valued fi object in ascending or descending order

sqrt*

Square root of fi object

storedInteger

Stored integer value of fi object

storedIntegerToDouble

Convert stored integer value of fi object to built-in double value

sub*

Subtract two objects using fimath object

subsasgn

Subscripted assignment

subsref

Subscripted reference

sum*

Sum of array elements

times*

Element-by-element multiplication of fi objects

ufi*

Construct unsigned fixed-point numeric object

uint16

Convert fi object to unsigned 16-bit integer

uint32

Stored integer value of fi object as built-in uint32

uint64

Convert fi object to unsigned 64-bit integer

uint8

Convert fi object to unsigned 8-bit integer

uminus

Negate elements of fi object array

upperbound

Upper bound of range of fi object

vertcat

Vertically concatenate multiple fi objects

Fuzzy Logic Toolbox

C and C++ code generation for the following functions requires the Fuzzy Logic Toolbox™ software.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

dsigmf

Difference between two sigmoidal membership functions

evalfis*

Evaluate fuzzy inference system

evalfisOptions*

Option set for evalfis function

gauss2mf

Gaussian combination membership function

gaussmf

Gaussian membership function

gbellmf

Generalized bell-shaped membership function

getFISCodeGenerationData*

Create homogeneous fuzzy inference system structure

pimf

Pi-shaped membership function

psigmf

Product of two sigmoidal membership functions

sigmf

Sigmoidal membership function

smf

S-shaped membership function

trapmf

Trapezoidal membership function

trimf

Triangular membership function

zmf

Z-shaped membership function

Image Acquisition Toolbox

C and C++ code generation for the following functions requires the Image Acquisition Toolbox™ software.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

imaq.VideoDevice*

Acquire one frame at a time from video device

Image Processing Toolbox

The following table lists the Image Processing Toolbox™ functions that have been enabled for code generation. You must have the MATLAB Coder™ software installed to generate C code from MATLAB for these functions.

Image Processing Toolbox provides three types of code generation support:

  • Functions that generate C code.

  • Functions that generate C code that depends on a platform-specific shared library (.dll, .so, or .dylib). Use of a shared library preserves performance optimizations in these functions, but this limits the target platforms for which you can generate code. For more information, see Code Generation for Image Processing (Image Processing Toolbox).

  • Functions that generate C code or C code that depends on a shared library, depending on which target platform you specify in MATLAB Coder. If you specify the generic MATLAB Host Computer target platform, these functions generate C code that depends on a shared library. If you specify any other target platform, these functions generate C code.

In generated code, each supported toolbox function has the same name, arguments, and functionality as its Image Processing Toolbox counterpart. However, some functions have limitations. The following table includes information about code generation limitations that might exist for each function. In the following table, all the functions generate C code. The table identifies those functions that generate C code that depends on a shared library, and those functions that can do both, depending on which target platform you choose.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

adaptthresh*

Adaptive image threshold using local first-order statistics

affine2d*

2-D affine geometric transformation

affine3d*

3-D affine geometric transformation

boundarymask*

Find region boundaries of segmentation

bwareaopen*

Remove small objects from binary image

bwboundaries*

Trace region boundaries in binary image

bwconncomp*

Find connected components in binary image

bwdist*

Distance transform of binary image

bweuler*

Euler number of binary image

bwlabel*

Label connected components in 2-D binary image

bwlookup*

Nonlinear filtering using lookup tables

bwmorph*

Morphological operations on binary images

bwpack*

Pack binary image

bwperim*

Find perimeter of objects in binary image

bwselect*

Select objects in binary image

bwtraceboundary*

Trace object in binary image

bwunpack*

Unpack binary image

conndef*

Create connectivity array

demosaic*

Convert Bayer pattern encoded image to truecolor image

edge*

Find edges in intensity image

fft2*

2-D fast Fourier transform

fftshift

Shift zero-frequency component to center of spectrum

fitgeotrans*

Fit geometric transformation to control point pairs

freqspace

Frequency spacing for frequency response

fspecial*

Create predefined 2-D filter

fspecial3*

Create predefined 3-D filter

getrangefromclass*

Default display range of image based on its class

grayconnected*

Select contiguous image region with similar gray values

histeq*

Enhance contrast using histogram equalization

hough*

Hough transform

houghlines*

Extract line segments based on Hough transform

houghpeaks*

Identify peaks in Hough transform

hsv2rgb

Convert HSV colors to RGB

ifft2*

2-D inverse fast Fourier transform

ifftshift

Inverse zero-frequency shift

im2double

Convert image to double precision

im2int16*

Convert image to 16-bit signed integers

im2single*

Convert image to single precision

im2uint16*

Convert image to 16-bit unsigned integers

im2uint8*

Convert image to 8-bit unsigned integers

imabsdiff*

Absolute difference of two images

imadjust*

Adjust image intensity values or colormap

imbinarize*

Binarize 2-D grayscale image or 3-D volume by thresholding

imbothat*

Bottom-hat filtering

imboxfilt*

2-D box filtering of images

imclearborder*

Suppress light structures connected to image border

imclose*

Morphologically close image

imcomplement*

Complement image

imcrop*

Crop image

imdilate*

Dilate image

imerode*

Erode image

imextendedmax*

Extended-maxima transform

imextendedmin*

Extended-minima transform

imfill*

Fill image regions and holes

imfilter*

N-D filtering of multidimensional images

imfindcircles*

Find circles using circular Hough transform

imgaborfilt*

Apply Gabor filter or set of filters to 2-D image

imgaussfilt*

2-D Gaussian filtering of images

imgradient3*

Find gradient magnitude and direction of 3-D image

imgradientxyz*

Find directional gradients of 3-D image

imhist*

Histogram of image data

imhmax*

H-maxima transform

imhmin*

H-minima transform

imlincomb*

Linear combination of images

immse*

Mean-squared error

imopen*

Morphologically open image

imoverlay*

Burn binary mask into 2-D image

impyramid*

Image pyramid reduction and expansion

imquantize*

Quantize image using specified quantization levels and output values

imread*

Read image from graphics file

imreconstruct*

Morphological reconstruction

imref2d*

Reference 2-D image to world coordinates

imref3d*

Reference 3-D image to world coordinates

imregcorr

Estimate geometric transformation that aligns two 2-D images using phase correlation

imregionalmax*

Regional maxima

imregionalmin*

Regional minima

imresize*

Resize image

imrotate*

Rotate image

imsplit

Split multichannel image into its individual channels

imtophat*

Top-hat filtering

imtranslate*

Translate image

imwarp*

Apply geometric transformation to image

ind2rgb

Convert indexed image to RGB image

inpaintCoherent*

Restore specific image regions using coherence transport based image inpainting

integralBoxFilter*

2-D box filtering of integral images

integralImage

Calculate 2-D integral image

intlut*

Convert integer values using lookup table

iptcheckconn*

Check validity of connectivity argument

iptcheckmap*

Check validity of colormap

lab2rgb*

Convert CIE 1976 L*a*b* to RGB

label2idx*

Convert label matrix to cell array of linear indices

label2rgb*

Convert label matrix into RGB image

mean2*

Average or mean of matrix elements

medfilt2*

2-D median filtering

multithresh*

Multilevel image thresholds using Otsu's method

offsetstrel*

Morphological offset structuring element

ordfilt2*

2-D order-statistic filtering

otsuthresh*

Global histogram threshold using Otsu's method

padarray*

Pad array

projective2d*

2-D projective geometric transformation

psnr*

Peak Signal-to-Noise Ratio (PSNR)

regionprops*

Measure properties of image regions

rgb2gray*

Convert RGB image or colormap to grayscale

rgb2hsv

Convert RGB colors to HSV

rgb2lab*

Convert RGB to CIE 1976 L*a*b*

rgb2lightness*

Convert RGB color values to lightness values

rgb2ycbcr*

Convert RGB color values to YCbCr color space

strel*

Morphological structuring element

stretchlim*

Find limits to contrast stretch image

superpixels*

2-D superpixel oversegmentation of images

watershed*

Watershed transform

ycbcr2rgb*

Convert YCbCr color values to RGB color space

MATLAB Compiler

C and C++ code generation for the following functions requires the MATLAB Compiler™ software.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

isdeployed*

Determine whether code is running in deployed or MATLAB mode

ismcc*

Test if code is running during compilation process (using mcc)

Model Predictive Control Toolbox

C and C++ code generation for the following function requires the Model Predictive Control Toolbox™.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

mpcqpsolver*

Solve a quadratic programming problem using the KWIK algorithm

Navigation Toolbox

C and C++ code generation for the following functions requires the Navigation Toolbox™ software.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

accelparams

Accelerometer sensor parameters

addRelativePose*

Add relative pose to pose graph

addScan*

Add scan to lidar SLAM map

ahrs10filter

Height and orientation from MARG and altimeter readings

ahrsfilter*

Orientation from accelerometer, gyroscope, and magnetometer readings

altimeterSensor*

Altimeter simulation model

angdiff

Difference between two angles

axang2quat

Convert axis-angle rotation to quaternion

axang2rotm

Convert axis-angle rotation to rotation matrix

axang2tform

Convert axis-angle rotation to homogeneous transformation

binaryOccupancyMap

Create occupancy grid with binary values

cart2frenet

Convert Cartesian states to Frenet states

cart2hom

Convert Cartesian coordinates to homogeneous coordinates

classUnderlying

Class of parts within quaternion

compact

Convert quaternion array to N-by-4 matrix

complementaryFilter

Orientation estimation from a complementary filter

conj

Complex conjugate of quaternion

connect

Connect poses for given connection type

controllerPurePursuit

Create controller to follow set of waypoints

controllerVFH

Avoid obstacles using vector field histogram

copy*

Copy lidar SLAM object

ctranspose, '

Complex conjugate transpose of quaternion array

dist

Angular distance in radians

dubinsConnection

Dubins path connection type

dubinsPathSegment

Dubins path segment connecting two poses

ecompass

Orientation from magnetometer and accelerometer readings

edgeConstraints*

Edge constraints in pose graph

edges*

Edges in pose graph

eul2quat

Convert Euler angles to quaternion

eul2rotm

Convert Euler angles to rotation matrix

eul2tform

Convert Euler angles to homogeneous transformation

euler

Convert quaternion to Euler angles (radians)

eulerd

Convert quaternion to Euler angles (degrees)

exp

Exponential of quaternion array

findEdgeID*

Find edge ID of edge

frenet2cart

Convert Frenet states to Cartesian states

gpsSensor*

GPS receiver simulation model

gyroparams

Gyroscope sensor parameters

hom2cart

Convert homogeneous coordinates to Cartesian coordinates

imufilter*

Orientation from accelerometer and gyroscope readings

imuSensor*

IMU simulation model

insfilter

Create inertial navigation filter

insfilterAsync

Estimate pose from asynchronous MARG and GPS data

insfilterErrorState

Estimate pose from IMU, GPS, and monocular visual odometry (MVO) data

insfilterMARG

Estimate pose from MARG and GPS data

insfilterNonholonomic

Estimate pose with nonholonomic constraints

interpolate

Interpolate poses along path segment

kinematicTrajectory*

Rate-driven trajectory generator

ldivide, .\

Element-wise quaternion left division

lidarScan

Create object for storing 2-D lidar scan

lidarSLAM*

Perform localization and mapping using lidar scans

log

Natural logarithm of quaternion array

magparams

Magnetometer sensor parameters

matchScans*

Estimate pose between two laser scans

matchScansGrid

Estimate pose between two lidar scans using grid-based search

meanrot

Quaternion mean rotation

minus, -

Quaternion subtraction

mtimes, *

Quaternion multiplication

nav.StateSpace

Create state space for path planning

nav.StateValidator*

Create state validator for path planning

nodes*

Poses of nodes in pose graph

norm

Quaternion norm

normalize

Quaternion normalization

occupancyMap

Create occupancy map with probabilistic values

odometryMotionModel

Create an odometry motion model

ones

Create quaternion array with real parts set to one and imaginary parts set to zero

optimizePoseGraph*

Optimize nodes in pose graph

parts

Extract quaternion parts

plan

Plan optimal trajectory

poseGraph*

Create 2-D pose graph

poseGraph3D*

Create 3-D pose graph

power, .^

Element-wise quaternion power

prod

Product of a quaternion array

quat2axang

Convert quaternion to axis-angle rotation

quat2eul

Convert quaternion to Euler angles

quat2rotm

Convert quaternion to rotation matrix

quat2tform

Convert quaternion to homogeneous transformation

quaternion

Create a quaternion array

randrot

Uniformly distributed random rotations

rdivide, ./

Element-wise quaternion right division

reedsSheppConnection

Reeds-Shepp path connection type

reedsSheppPathSegment

Reeds-Shepp path segment connecting two poses

removeEdges*

Remove loop closure edges from graph

removeLoopClosures*

Remove loop closures from pose graph

rotateframe

Quaternion frame rotation

rotatepoint

Quaternion point rotation

rotm2axang

Convert rotation matrix to axis-angle rotation

rotm2eul

Convert rotation matrix to Euler angles

rotm2quat

Convert rotation matrix to quaternion

rotm2tform

Convert rotation matrix to homogeneous transformation

rotmat

Convert quaternion to rotation matrix

rotvec

Convert quaternion to rotation vector (radians)

rotvecd

Convert quaternion to rotation vector (degrees)

scansAndPoses*

Extract scans and corresponding poses

slerp

Spherical linear interpolation

stateEstimatorPF

Create particle filter state estimator

stateSpaceDubins

State space for Dubins vehicles

stateSpaceReedsShepp

State space for Reeds-Shepp vehicles

stateSpaceSE2

SE(2) state space

tform2axang

Convert homogeneous transformation to axis-angle rotation

tform2eul

Extract Euler angles from homogeneous transformation

tform2quat

Extract quaternion from homogeneous transformation

tform2rotm

Extract rotation matrix from homogeneous transformation

tform2trvec

Extract translation vector from homogeneous transformation

times, .*

Element-wise quaternion multiplication

trajectoryOptimalFrenet*

Find optimal trajectory for reference path

transformScan

Transform laser scan based on relative pose

transpose, .'

Transpose a quaternion array

trvec2tform

Convert translation vector to homogeneous transformation

uminus, -

Quaternion unary minus

validatorOccupancyMap*

State validator based on 2-D grid map

waypointTrajectory*

Waypoint trajectory generator

zeros

Create quaternion array with all parts set to zero

Optimization Toolbox

C and C++ code generation for the following functions and System objects requires the Optimization Toolbox™.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

fminbnd*

Find minimum of single-variable function on fixed interval

fmincon*

Find minimum of constrained nonlinear multivariable function

fminsearch*

Find minimum of unconstrained multivariable function using derivative-free method

fzero*

Root of nonlinear function

lsqnonneg*

Solve nonnegative linear least-squares problem

mldivide, \*

Solve systems of linear equations Ax = B for x

optimget*

Optimization options values

optimset*

Create or edit optimization options structure

Phased Array System Toolbox

C and C++ code generation for the following functions and System objects requires the Phased Array System Toolbox™ software.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

aictest*

Dimension of signal subspace

albersheim*

Required SNR using Albersheim's equation

ambgfun*

Ambiguity and crossambiguity function

aperture2gain*

Convert effective aperture to gain

az2broadside*

Convert azimuth and elevation angle to broadside angle

azel2phitheta*

Convert angles from azimuth/elevation form to phi/theta form

azel2phithetapat*

Convert radiation pattern from azimuth-elevation to phi-theta coordinates

azel2uv*

Convert azimuth/elevation angles to u/v coordinates

azel2uvpat*

Convert radiation pattern from azimuth/elevation form to u/v form

azelaxes*

Spherical basis vectors in 3-by-3 matrix form

azelcut2pat

Create 3-D response pattern from azimuth and elevation cuts

backscatterBicyclist

Backscatter radar signals from bicyclist

backscatterPedestrian

Backscatter radar signals from pedestrian

beat2range*

Convert beat frequency to range

billingsleyicm*

Billingsley's intrinsic clutter motion (ICM) model

broadside2az*

Convert broadside angle to azimuth angle

bw2range*

Convert bandwidth to range resolution

cart2sphvec*

Convert vector from Cartesian components to spherical representation

cbfweights*

Conventional beamformer weights

circpol2pol*

Convert circular component representation of field to linear component representation

clone

Create identical object

clone

Copy of alpha-beta tracking filter

clusterDBSCAN

Data clustering

correct

Correct the state and state estimation error covariance

dechirp*

Perform dechirp operation on FMCW signal

delayseq*

Delay or advance sequence

depressionang*

Depression angle of surface target

diagbfweights*

Diagonalize MIMO channel

discoverClusters*

Find cluster hierarchy in data

distance

Distances between measurements and predicted measurements

dop2speed*

Convert Doppler shift to speed

dopsteeringvec*

Doppler steering vector

effearthradius*

Effective earth radius

espritdoa*

Direction of arrival using TLS ESPRIT

estimateEpsilon*

Estimate neighborhood clustering threshold

fogpl*

RF signal attenuation due to fog and clouds

fspl*

Free space path loss

gain2aperture*

Convert gain to effective aperture

gaspl*

RF signal attenuation due to atmospheric gases

gccphat*

Generalized cross-correlation

getMonopulseEstimator

Create monopulse estimator from monopulse feed

getNumScatterers

Number of scatterers on bicyclist

global2localcoord*

Convert global to local coordinates

grazingang*

Grazing angle of surface target

horizonrange*

Horizon range

lcmvweights*

Narrowband linearly constrained minimum variance (LCMV) beamformer weights

likelihood

Likelihood of measurement

local2globalcoord*

Convert local to global coordinates

mdltest*

Dimension of signal subspace

move

Position, velocity, and orientation of moving bicyclist

move

Position and velocity of walking pedestrian

musicdoa*

Estimate arrival directions of signals using MUSIC

mvdrweights*

Minimum variance distortionless response (MVDR) beamformer weights

noisepow*

Receiver noise power

npwgnthresh*

Detection SNR threshold for signal in white Gaussian noise

ompdecomp

Decomposition using orthogonal matching pursuit

omphybweights

Hybrid beamforming weights using orthogonal matching pursuit

pambgfun*

Periodic ambiguity function

phased.ADPCACanceller*

Adaptive DPCA (ADPCA) pulse canceller

phased.AlphaBetaFilter

Alpha-beta filter for object tracking

phased.AngleDopplerResponse*

Angle-Doppler response

phased.ArrayGain*

Sensor array gain

phased.ArrayResponse*

Sensor array response

phased.BackscatterRadarTarget*

Backscatter radar target

phased.BackscatterSonarTarget*

Sonar target backscatter

phased.BarrageJammer*

Barrage jammer

phased.BeamscanEstimator*

Beamscan spatial spectrum estimator for ULA

phased.BeamscanEstimator2D*

2-D beamscan spatial spectrum estimator

phased.BeamspaceESPRITEstimator*

Beamspace ESPRIT direction of arrival (DOA) estimator for ULA

phased.CFARDetector*

Constant false alarm rate (CFAR) detector

phased.CFARDetector2D*

Two-dimensional CFAR detector

phased.Collector*

Narrowband signal collector

phased.ConformalArray*

Conformal array

phased.ConstantGammaClutter*

Constant gamma clutter simulation

phased.CosineAntennaElement*

Cosine antenna element

phased.CrossedDipoleAntennaElement*

Crossed-dipole antenna element

phased.CustomAntennaElement*

Custom antenna element

phased.CustomMicrophoneElement*

Custom microphone

phased.DopplerEstimator*

Doppler estimation

phased.DPCACanceller*

Displaced phase center array (DPCA) pulse canceller

phased.ElementDelay*

Sensor array element delay estimator

phased.ESPRITEstimator*

ESPRIT direction of arrival (DOA) estimator for ULA

phased.FMCWWaveform*

FMCW waveform

phased.FreeSpace*

Free space environment

phased.FrostBeamformer*

Frost beamformer

phased.GCCEstimator*

Wideband direction of arrival estimation

phased.GSCBeamformer*

Generalized sidelobe canceler beamformer

phased.HeterogeneousConformalArray*

Heterogeneous conformal array

phased.HeterogeneousULA*

Heterogeneous uniform linear array

phased.HeterogeneousURA*

Heterogeneous uniform rectangular array

phased.IsoSpeedUnderwaterPaths*

Isospeed multipath sonar channel

phased.IsotropicAntennaElement*

Isotropic antenna element

phased.IsotropicHydrophone*

Isotropic hydrophone

phased.IsotropicProjector*

Isotropic projector

phased.LCMVBeamformer*

Narrowband LCMV beamformer

phased.LinearFMWaveform*

Linear FM pulse waveform

phased.LOSChannel*

Narrowband LOS propagation channel

phased.MatchedFilter*

Matched filter

phased.MFSKWaveform*

MFSK waveform

phased.MonopulseEstimator*

Amplitude monopulse direction finding

phased.MonopulseFeed*

Creates sum and difference channels

phased.MultipathChannel*

Propagate signals in multipath channel

phased.MUSICEstimator*

Estimate direction of arrival using narrowband MUSIC algorithm for ULA

phased.MUSICEstimator2D*

Estimate 2D direction of arrival using narrowband MUSIC algorithm

phased.MVDRBeamformer*

Narrowband minimum-variance distortionless-response beamformer

phased.MVDREstimator*

MVDR (Capon) spatial spectrum estimator for ULA

phased.MVDREstimator2D*

2-D MVDR (Capon) spatial spectrum estimator

phased.OmnidirectionalMicrophoneElement*

Omnidirectional microphone

phased.PartitionedArray*

Phased array partitioned into subarrays

phased.PhaseCodedWaveform*

Phase-coded pulse waveform

phased.PhaseShiftBeamformer*

Narrowband phase shift beamformer

phased.Platform*

Model platform motion

phased.PulseCompressionLibrary*

Create a library of pulse compression specifications

phased.PulseWaveformLibrary*

Create a library of pulse waveforms

phased.RadarTarget*

Radar target

phased.Radiator*

Narrowband signal radiator

phased.RangeAngleResponse*

Range-angle response

phased.RangeDopplerResponse*

Range-Doppler response

phased.RangeEstimator*

Range estimation

phased.RangeResponse*

Range response

phased.ReceiverPreamp*

Receiver preamp

phased.RectangularWaveform*

Rectangular pulse waveform

phased.ReplicatedSubarray*

Phased array formed by replicated subarrays

phased.RootMUSICEstimator*

Root MUSIC direction of arrival (DOA) estimator for ULA and UCA

phased.RootWSFEstimator*

Root WSF direction of arrival (DOA) estimator for ULA

phased.ScatteringMIMOChannel*

Scattering MIMO channel

phased.ShortDipoleAntennaElement*

Short-dipole antenna element

phased.STAPSMIBeamformer*

Sample matrix inversion (SMI) beamformer

phased.SteeringVector*

Sensor array steering vector

phased.SteppedFMWaveform*

Stepped FM pulse waveform

phased.StretchProcessor*

Stretch processor for linear FM waveform

phased.SubbandMVDRBeamformer*

Wideband minimum-variance distortionless-response beamformer

phased.SubbandPhaseShiftBeamformer*

Subband phase shift beamformer

phased.SumDifferenceMonopulseTracker*

Sum and difference monopulse for ULA

phased.SumDifferenceMonopulseTracker2D*

Sum and difference monopulse for URA

phased.TimeDelayBeamformer*

Time delay beamformer

phased.TimeDelayLCMVBeamformer*

Time delay LCMV beamformer

phased.TimeVaryingGain*

Time varying gain control

phased.Transmitter*

Transmitter

phased.TwoRayChannel*

Two-ray propagation channel

phased.UCA*

Uniform circular array

phased.ULA*

Uniform linear array

phased.UnderwaterRadiatedNoise*

Radiate acoustic noise from underwater or surface sound source

phased.URA*

Uniform rectangular array

phased.WidebandBackscatterRadarTarget*

Backscatter wideband signal from radar target

phased.WidebandCollector*

Wideband signal collector

phased.WidebandFreeSpace*

Wideband freespace propagation

phased.WidebandLOSChannel*

Wideband LOS propagation channel

phased.WidebandRadiator*

Wideband signal radiator

phased.WidebandTwoRayChannel*

Wideband two-ray propagation channel

phitheta2azel*

Convert angles from phi/theta form to azimuth/elevation form

phitheta2azelpat*

Convert radiation pattern from phi/theta form to azimuth/elevation form

phitheta2uv*

Convert phi/theta angles to u/v coordinates

phitheta2uvpat*

Convert radiation pattern from phi/theta form to u/v form

physconst*

Physical constants

pilotcalib*

Array calibration using pilot sources

pol2circpol*

Convert linear component representation of field to circular component representation

polellip*

Parameters of ellipse traced out by tip of a polarized field vector

polloss*

Polarization loss

polratio*

Ratio of vertical to horizontal linear polarization components of a field

polsignature*

Copolarization and cross-polarization signatures

predict

Predict the state and state estimation error covariance

pulsint*

Pulse integration

radareqpow*

Peak power estimate from radar equation

radareqrng*

Maximum theoretical range estimate

radareqsnr*

SNR estimate from radar equation

radarvcd*

Vertical coverage diagram

radialspeed*

Relative radial speed

rainpl*

RF signal attenuation due to rainfall

range2beat*

Convert range to beat frequency

range2bw*

Convert range resolution to required bandwidth

range2time*

Convert propagation distance to propagation time

range2tl*

Compute underwater sound transmission loss from range

rangeangle*

Range and angle calculation

rcscylinder

Radar cross section of cylinder

rcsdisc

Radar cross section of flat circular plate

rcstruncone

Radar cross section of truncated cone

rdcoupling*

Range Doppler coupling

reflect

Reflected signal from walking pedestrian

reflect

Reflected signal from moving bicyclist

release

Release resources and allow changes to object property values and input characteristics

reset

Reset object state and property values

rocpfa*

Receiver operating characteristic curves by false-alarm probability

rocsnr*

Receiver operating characteristic curves by SNR

rootmusicdoa*

Direction of arrival using Root MUSIC

rotpat

Rotate radiation pattern

rotx*

Rotation matrix for rotations around x-axis

roty*

Rotation matrix for rotations around y-axis

rotz*

Rotation matrix for rotations around z-axis

scatteringchanmtx*

Scattering channel matrix

sensorcov*

Sensor spatial covariance matrix

sensorsig*

Simulate received signal at sensor array

shnidman*

Required SNR using Shnidman's equation

sonareqsl*

Compute source level using the sonar equation

sonareqsnr*

Compute SNR using the sonar equation

sonareqtl*

Compute transmission loss using the sonar equation

speed2dop*

Convert speed to Doppler shift

sph2cartvec*

Convert vector from spherical basis components to Cartesian components

spsmooth*

Spatial smoothing

steervec*

Steering vector

stokes*

Stokes parameters of polarized field

stretchfreq2rng*

Convert frequency offset to range

surfacegamma*

Gamma value for different terrains

surfclutterrcs*

Surface clutter radar cross section (RCS)

systemp*

Receiver system-noise temperature

taylortaperc*

Taylor nbar taper for arrays

time2range*

Convert propagation time to propagation distance

tl2range*

Compute range from underwater transmission loss

unigrid*

Uniform grid

uv2azel*

Convert u/v coordinates to azimuth/elevation angles

uv2azelpat*

Convert radiation pattern from u/v form to azimuth/elevation form

uv2phitheta*

Convert u/v coordinates to phi/theta angles

uv2phithetapat*

Convert radiation pattern from u/v form to phi/theta form

val2ind*

Uniform grid index

waterfill*

Waterfill MIMO power distribution

Robotics System Toolbox

C and C++ code generation for the following functions requires the Robotics System Toolbox™ software.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

ackermannKinematics

Create car-like steering vehicle model

angdiff

Difference between two angles

axang2quat

Convert axis-angle rotation to quaternion

axang2rotm

Convert axis-angle rotation to rotation matrix

axang2tform

Convert axis-angle rotation to homogeneous transformation

bicycleKinematics

Create bicycle vehicle model

binaryOccupancyMap

Create occupancy grid with binary values

bsplinepolytraj

Generate polynomial trajectories using B-splines

cart2hom

Convert Cartesian coordinates to homogeneous coordinates

classUnderlying

Class of parts within quaternion

compact

Convert quaternion array to N-by-4 matrix

conj

Complex conjugate of quaternion

constraintAiming

Create aiming constraint for pointing at a target location

constraintCartesianBounds

Create constraint to keep body origin inside Cartesian bounds

constraintJointBounds

Create constraint on joint positions of robot model

constraintOrientationTarget

Create constraint on relative orientation of body

constraintPoseTarget

Create constraint on relative pose of body

constraintPositionTarget

Create constraint on relative position of body

control

Control commands for UAV

controllerPurePursuit

Create controller to follow set of waypoints

ctranspose, '

Complex conjugate transpose of quaternion array

cubicpolytraj

Generate third-order polynomial trajectories

derivative

Time derivative of UAV states

differentialDriveKinematics

Create differential-drive vehicle model

dist

Angular distance in radians

environment

Environmental inputs for UAV

eul2quat

Convert Euler angles to quaternion

eul2rotm

Convert Euler angles to rotation matrix

eul2tform

Convert Euler angles to homogeneous transformation

euler

Convert quaternion to Euler angles (radians)

eulerd

Convert quaternion to Euler angles (degrees)

exp

Exponential of quaternion array

fixedwing

Guidance model for fixed-wing UAVs

generalizedInverseKinematics*

Create multiconstraint inverse kinematics solver

hom2cart

Convert homogeneous coordinates to Cartesian coordinates

inverseKinematics*

Create inverse kinematic solver

jointSpaceMotionModel

Model rigid body tree motion given joint-space inputs

ldivide, .\

Element-wise quaternion left division

lidarScan

Create object for storing 2-D lidar scan

log

Natural logarithm of quaternion array

meanrot

Quaternion mean rotation

minus, -

Quaternion subtraction

mobileRobotPRM*

Create probabilistic roadmap path planner

mtimes, *

Quaternion multiplication

multirotor

Guidance model for multirotor UAVs

norm

Quaternion norm

normalize

Quaternion normalization

ones

Create quaternion array with real parts set to one and imaginary parts set to zero

parts

Extract quaternion parts

power, .^

Element-wise quaternion power

prod

Product of a quaternion array

quat2axang

Convert quaternion to axis-angle rotation

quat2eul

Convert quaternion to Euler angles

quat2rotm

Convert quaternion to rotation matrix

quat2tform

Convert quaternion to homogeneous transformation

quaternion

Create a quaternion array

quinticpolytraj

Generate fifth-order trajectories

randrot

Uniformly distributed random rotations

rdivide, ./

Element-wise quaternion right division

rigidBody

Create a rigid body

rigidBodyJoint

Create a joint

rigidBodyTree*

Create tree-structured robot

rotateframe

Quaternion frame rotation

rotatepoint

Quaternion point rotation

rotm2axang

Convert rotation matrix to axis-angle rotation

rotm2eul

Convert rotation matrix to Euler angles

rotm2quat

Convert rotation matrix to quaternion

rotm2tform

Convert rotation matrix to homogeneous transformation

rotmat

Convert quaternion to rotation matrix

rottraj

Generate trajectories between orientation rotation matrices

rotvec

Convert quaternion to rotation vector (radians)

rotvecd

Convert quaternion to rotation vector (degrees)

slerp

Spherical linear interpolation

state

UAV state vector

stateEstimatorPF

Create particle filter state estimator

taskSpaceMotionModel

Model rigid body tree motion given task-space reference inputs

tform2axang

Convert homogeneous transformation to axis-angle rotation

tform2eul

Extract Euler angles from homogeneous transformation

tform2quat

Extract quaternion from homogeneous transformation

tform2rotm

Extract rotation matrix from homogeneous transformation

tform2trvec

Extract translation vector from homogeneous transformation

times, .*

Element-wise quaternion multiplication

transformScan

Transform laser scan based on relative pose

transformtraj

Generate trajectories between two transformations

transpose, .'

Transpose a quaternion array

trapveltraj

Generate trajectories with trapezoidal velocity profiles

trvec2tform

Convert translation vector to homogeneous transformation

uavOrbitFollower

Orbit location of interest using a UAV

uavWaypointFollower

Follow waypoints for UAV

uminus, -

Quaternion unary minus

unicycleKinematics

Create unicycle vehicle model

zeros

Create quaternion array with all parts set to zero

Sensor Fusion and Tracking Toolbox

C and C++ code generation for the following functions requires the Sensor Fusion and Tracking Toolbox™ software.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

accelparams

Accelerometer sensor parameters

ahrs10filter

Height and orientation from MARG and altimeter readings

ahrsfilter*

Orientation from accelerometer, gyroscope, and magnetometer readings

altimeterSensor*

Altimeter simulation model

append

Append two phd filter objects

assignauction

Assignment using auction global nearest neighbor

assignjv

Jonker-Volgenant global nearest neighbor assignment algorithm

assignkbest

Assignment using k-best global nearest neighbor

assignkbestsd

K-best S-D solution that minimizes total cost of assignment

assignmunkres

Munkres global nearest neighbor assignment algorithm

assignsd

S-D assignment using Lagrangian relaxation

assignTOMHT

Track-oriented multi-hypotheses tracking assignment

AsyncMARGGPSFuser

Estimate pose from asynchronous MARG and GPS data

cameas

Measurement function for constant-acceleration motion

cameasjac

Jacobian of measurement function for constant-acceleration motion

checkConfirmation

Check if track should be confirmed

checkDeletion

Check if track should be deleted

classUnderlying

Class of parts within quaternion

clone

Create duplicate tracking filter

clone

Create duplicate phd filter object

clone

Create copy of track logic

clusterTrackBranches*

Cluster track-oriented multi-hypothesis history

compact

Convert quaternion array to N-by-4 matrix

compatibleTrackBranches*

Formulate global hypotheses from clusters

complementaryFilter

Orientation estimation from a complementary filter

conj

Complex conjugate of quaternion

constacc

Constant-acceleration motion model

constaccjac

Jacobian for constant-acceleration motion

constturn

Constant turn-rate motion model

constturnjac

Jacobian for constant turn-rate motion

constvel

Constant velocity state update

constveljac

Jacobian for constant-velocity motion

constvelmsc

Constant velocity (CV) motion model in MSC frame

constvelmscjac

Jacobian of constant velocity (CV) motion model in MSC frame

correct

Correct states using direct state measurements

correct

Correct states using direct state measurements

correct

Correct phd filter with detections

correct

Correct states using direct state measurements

correct

Correct state and state estimation error covariance using tracking filter

correct

Correct states using direct state measurements

correct

Correct states using direct state measurements

correctjpda*

Correct state and state estimation error covariance using tracking filter and JPDA

correctUndetected

Correct phd filter with no detection hypothesis

ctmeas

Measurement function for constant turn-rate motion

ctmeasjac

Jacobian of measurement function for constant turn-rate motion

ctranspose, '

Complex conjugate transpose of quaternion array

ctrect

Constant turn-rate rectangular target motion model

ctrectcorners

Corner measurements of constant turn-rate rectangular target

ctrectjac

Jacobian of constant turn-rate rectangular target motion model

ctrectmeas

Constant turn-rate rectangular target measurement model

ctrectmeasjac

Jacobian of constant turn-rate rectangular target measurement model

cvmeas

Measurement function for constant velocity motion

cvmeasjac

Jacobian of measurement function for constant velocity motion

cvmeasmsc

Measurement based on constant velocity (CV) model in MSC frame

cvmeasmscjac

Jacobian of measurement using constant velocity (CV) model in MSC frame

dist

Angular distance in radians

distance

Distances between current and predicted measurements of tracking filter

ecompass

Orientation from magnetometer and accelerometer readings

emissionsInBody

Transform emissions to body frame of platform

ErrorStateIMUGPSFuser

Estimate pose from IMU, GPS, and monocular visual odometry (MVO) data

euler

Convert quaternion to Euler angles (radians)

eulerd

Convert quaternion to Euler angles (degrees)

exp

Exponential of quaternion array

extractState

Extract target state estimates from the phd filter

fuseaccel

Correct states using accelerometer data

fusealtimeter

Correct states using altimeter data

fusecovint

Covariance fusion using covariance intersection

fusecovunion

Covariance fusion using covariance union

fusegps

Correct states using GPS data

fusegps

Correct states using GPS data

fusegps

Correct states using GPS data

fusegps

Correct states using GPS data

fusegyro

Correct states using gyroscope data

fusemag

Correct states using magnetometer data

fusemag

Correct states using magnetometer data

fusemag

Correct states using magnetometer data

fusemvo

Correct states using monocular visual odometry

fuserSourceConfiguration

Configuration of source used with track fuser

fusexcov

Covariance fusion using cross-covariance

getTrackPositions

Returns updated track positions and position covariance matrix

getTrackVelocities

Obtain updated track velocities and velocity covariance matrix

ggiwphd*

Gamma Gaussian Inverse Wishart (GGIW) PHD filter

gmphd*

Gaussian mixture (GM) PHD filter

gpsSensor*

GPS receiver simulation model

gyroparams

Gyroscope sensor parameters

hit

Update track logic with subsequent hit

imufilter*

Orientation from accelerometer and gyroscope readings

imuSensor*

IMU simulation model

init

Initialize track logic with first hit

initapekf

Constant velocity angle-parameterized EKF initialization

initcaabf

Create constant acceleration alpha-beta tracking filter from detection report

initcackf

Create constant acceleration tracking cubature Kalman filter from detection report

initcaekf

Create constant-acceleration extended Kalman filter from detection report

initcaggiwphd

Create constant acceleration ggiwphd filter

initcagmphd

Create constant acceleration gmphd filter

initcakf

Create constant-acceleration linear Kalman filter from detection report

initcapf

Create constant acceleration tracking particle filter from detection report

initcaukf

Create constant-acceleration unscented Kalman filter from detection report

initctckf

Create constant turn rate tracking cubature Kalman filter from detection report

initctekf

Create constant turn-rate extended Kalman filter from detection report

initctggiwphd

Create constant turn-rate ggiwphd filter

initctgmphd

Create constant turn-rate gmphd filter

initctpf

Create constant turn rate tracking particle filter from detection report

initctrectgmphd

Create constant turn-rate rectangular target gmphd filter

initctukf

Create constant turn-rate unscented Kalman filter from detection report

initcvabf

Create constant velocity tracking alpha-beta filter from detection report

initcvckf

Create constant velocity tracking cubature Kalman filter from detection report

initcvekf

Create constant-velocity extended Kalman filter from detection report

initcvggiwphd

Create constant velocity ggiwphd filter

initcvgmphd

Create constant velocity gmphd filter

initcvkf

Create constant-velocity linear Kalman filter from detection report

initcvmscekf

Constant velocity trackingMSCEKF initialization

initcvpf

Create constant velocity tracking particle filter from detection report

initcvukf

Create constant-velocity unscented Kalman filter from detection report

initekfimm

Initialize trackingIMM object

initialize

Initialize state and covariance of tracking filter

initrpekf

Constant velocity range-parameterized EKF initialization

insfilter

Create inertial navigation filter

insfilterMARG

Estimate pose from MARG and GPS data

insfilterNonholonomic

Estimate pose with nonholonomic constraints

insSensor*

Inertial navigation and GPS simulation model

irSensor*

Generate infrared detections for tracking scenario

irSignature

Infrared platform signature

irSignature.value

Infrared intensity at specified angle and frequency

jpadEvents*

Feasible joint events for trackerJPDA

kinematicTrajectory*

Rate-driven trajectory generator

labeledDensity

Keep components with a given label ID

ldivide, .\

Element-wise quaternion left division

likelihood

Log-likelihood of association between detection cells and components in the density

likelihood

Likelihood of measurement from tracking filter

log

Natural logarithm of quaternion array

magparams

Magnetometer sensor parameters

meanrot

Quaternion mean rotation

merge

Merge components in the density of phd filter

mergeScores

Update track score by track merging

minus, -

Quaternion subtraction

miss

Update track logic with miss

monostaticRadarSensor*

Generate radar detections for tracking scenario

mtimes, *

Quaternion multiplication

norm

Quaternion norm

normalize

Quaternion normalization

objectDetection

Report for single object detection

objectTrack*

Single object track report

ones

Create quaternion array with real parts set to one and imaginary parts set to zero

output

Get current state of track logic

partitionDetections*

Partition detections based on Mahalanobis distance

parts

Extract quaternion parts

pose

Current orientation and position estimate

pose

Current orientation and position estimate

pose

Current orientation and position estimate

pose

Current orientation and position estimate

pose

Current position, orientation, and velocity estimate

power, .^

Element-wise quaternion power

predict

Predict probability hypothesis density of phd filter

predict

Update states using accelerometer and gyroscope data

predict

Update states using accelerometer and gyroscope data

predict

Predict state and state estimation error covariance of tracking filter

predict

Update states using accelerometer and gyroscope data

predict

Update states using accelerometer and gyroscope data

predict

Update states based on motion model

predict (trackingKF)

Predict state and state estimation error covariance of linear Kalman filter

prod

Product of a quaternion array

prune

Prune the filter by removing selected components

pruneTrackBranches

Prune track branches with low likelihood

quaternion

Create a quaternion array

radarChannel

Free space propagation and reflection of radar signals

radarEmission

Emitted radar signal structure

radarEmitter*

Radar signals and interferences generator

radarSensor*

Generate detections from radar emissions

randrot

Uniformly distributed random rotations

rcsSignature

Radar cross-section pattern

rcsSignature.value

Radar cross-section at specified angle and frequency

rdivide, ./

Element-wise quaternion right division

reset

Reset state of track logic

reset

Reset internal states

reset

Reset internal states

reset

Reset internal states

reset

Reset internal states

reset

Reset internal states

residual

Measurement residual and residual noise from tracking filter

rotateframe

Quaternion frame rotation

rotatepoint

Quaternion point rotation

rotmat

Convert quaternion to rotation matrix

rotvec

Convert quaternion to rotation vector (radians)

rotvecd

Convert quaternion to rotation vector (degrees)

scale

Scale weights of components in the density

slerp

Spherical linear interpolation

sonarEmission

Emitted sonar signal structure

sonarEmitter*

Acoustic signals and interferences generator

sonarSensor*

Generate detections from sonar emissions

stateinfo

Display state vector information

stateinfo

Display state vector information

stateinfo

Display state vector information

stateinfo

Display state vector information

stateinfo

Display state vector information

staticDetectionFuser*

Static fusion of synchronous sensor detections

switchimm

Model conversion function for trackingIMM object

sync

Synchronize scores of trackScoreLogic objects

times, .*

Element-wise quaternion multiplication

toStruct

Convert objectTrack object to struct

trackerGNN*

Multi-sensor, multi-object tracker using GNN assignment

trackerJPDA*

Joint probabilistic data association tracker

trackerPHD*

Multi-sensor, multi-object PHD tracker

trackerTOMHT*

Multi-hypothesis, multi-sensor, multi-object tracker

trackFuser*

Single-hypothesis track-to-track fuser

trackHistoryLogic

Confirm and delete tracks based on recent track history

trackingABF

Alpha-beta filter for object tracking

trackingCKF

Cubature Kalman filter for object tracking

trackingEKF

Extended Kalman filter for object tracking

trackingGSF

Gaussian-sum filter for object tracking

trackingIMM

Interacting multiple model (IMM) filter for object tracking

trackingKF*

Linear Kalman filter for object tracking

trackingPF

Particle filter for object tracking

trackingSensorConfiguration

Represent sensor configuration for tracking

trackingUKF

Unscented Kalman filter for object tracking

trackOSPAMetric

Optimal subpattern assignment (OSPA) metric

trackScoreLogic

Confirm and delete tracks based on track score

transpose, .'

Transpose a quaternion array

triangulateLOS

Triangulate multiple line-of-sight detections

tsSignature

Target strength pattern

tsSignature.value

Target strength at specified angle and frequency

uminus, -

Quaternion unary minus

underwaterChannel

Propagated and reflected sonar signals

waypointTrajectory*

Waypoint trajectory generator

zeros

Create quaternion array with all parts set to zero

SerDes Toolbox

C and C++ code generation for the following functions requires the SerDes Toolbox™ software.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

serdes.AGC*

Automatically adjusts gain to maintain output waveform amplitude

serdes.CDR*

Performs clock data recovery function

serdes.ChannelLoss*

Create simple lossy transmission line model

serdes.CTLE*

Continuous time linear equalizer (CTLE) or peaking filter

serdes.DFECDR*

Decision feedback equalizer (DFE) with clock and data recovery (CDR)

serdes.FFE*

Models a feed-forward equalizer

serdes.PassThrough*

Propagates baseband signal without modification

serdes.SaturatingAmplifier*

Models a saturating amplifier

serdes.VGA*

Models a variable gain amplifier

Signal Processing Toolbox

C and C++ code generation for the following functions requires the Signal Processing Toolbox™ software. These functions do not support variable-size inputs, you must define the size and type of the function inputs. For more information, see Specifying Inputs in Code Generation from MATLAB (Signal Processing Toolbox).

Note

Many Signal Processing Toolbox functions require constant inputs in generated code. To specify a constant input for codegen, use coder.Constant.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

abs

Absolute value and complex magnitude

alignsignals

Align two signals by delaying earliest signal

angle

Phase angle

barthannwin

Modified Bartlett-Hann window

bartlett

Bartlett window

besselap*

Bessel analog lowpass filter prototype

bitrevorder

Permute data into bit-reversed order

blackman

Blackman window

blackmanharris

Minimum four-term Blackman-Harris window

bohmanwin

Bohman window

buttap

Butterworth filter prototype

butter*

Butterworth filter design

buttord*

Butterworth filter order and cutoff frequency

cconv

Modulo-n circular convolution

cfirpm*

Complex and nonlinear-phase equiripple FIR filter design

cheb1ap*

Chebyshev Type I analog lowpass filter prototype

cheb1ord*

Chebyshev Type I filter order

cheb2ap*

Chebyshev Type II analog lowpass filter prototype

cheb2ord*

Chebyshev Type II filter order

chebwin

Chebyshev window

cheby1*

Chebyshev Type I filter design

cheby2*

Chebyshev Type II filter design

chirp

Swept-frequency cosine

conv*

Convolution and polynomial multiplication

conv2

2-D convolution

convmtx

Convolution matrix

corrcoef*

Correlation coefficients

corrmtx

Data matrix for autocorrelation matrix estimation

cov*

Covariance

cpsd

Cross power spectral density

cummax

Cumulative maximum

cummin

Cumulative minimum

czt*

Chirp Z-transform

db2pow

Convert decibels to power

dct*

Discrete cosine transform

deconv*

Deconvolution and polynomial division

detrend*

Remove polynomial trend

dftmtx

Discrete Fourier transform matrix

diric

Dirichlet or periodic sinc function

downsample

Decrease sample rate by integer factor

dpss*

Discrete prolate spheroidal (Slepian) sequences

ellip*

Elliptic filter design

ellipap*

Elliptic analog lowpass filter prototype

ellipord*

Minimum order for elliptic filters

emd

Empirical mode decomposition

envelope*

Signal envelope

envspectrum

Envelope spectrum for machinery diagnosis

eqtflength

Equalize lengths of transfer function's numerator and denominator

fft*

Fast Fourier transform

fft2*

2-D fast Fourier transform

fftfilt*

FFT-based FIR filtering using overlap-add method

fftshift

Shift zero-frequency component to center of spectrum

fillmissing*

Fill missing values

filloutliers*

Detect and replace outliers in data

filter*

1-D digital filter

filter2

2-D digital filter

filtfilt*

Zero-phase digital filtering

filtord

Filter order

finddelay

Estimate delay(s) between signals

findpeaks

Find local maxima

fir1

Window-based FIR filter design

fir2*

Frequency sampling-based FIR filter design

fircls*

Constrained-least-squares FIR multiband filter design

fircls1*

Constrained-least-squares linear-phase FIR lowpass and highpass filter design

firls

Least-squares linear-phase FIR filter design

firpm*

Parks-McClellan optimal FIR filter design

firpmord*

Parks-McClellan optimal FIR filter order estimation

flattopwin

Flat top weighted window

freqspace

Frequency spacing for frequency response

freqz*

Frequency response of digital filter

fsst*

Fourier synchrosqueezed transform

gauspuls

Gaussian-modulated sinusoidal RF pulse

gausswin

Gaussian window

gmonopuls

Gaussian monopulse

goertzel*

Discrete Fourier transform with second-order Goertzel algorithm

hamming

Hamming window

hann

Hann (Hanning) window

hilbert

Discrete-time analytic signal using Hilbert transform

idct*

Inverse discrete cosine transform

ifft*

Inverse fast Fourier transform

ifft2*

2-D inverse fast Fourier transform

ifsst

Inverse Fourier synchrosqueezed transform

interp1*

1-D data interpolation (table lookup)

intfilt*

Interpolation FIR filter design

iscola

Determine whether window-overlap combination is COLA compliant

isoutlier*

Find outliers in data

istft*

Inverse short-time Fourier transform

kaiser

Kaiser window

kaiserord

Kaiser window FIR filter design estimation parameters

levinson*

Levinson-Durbin recursion

lsf2poly

Convert line spectral frequencies to prediction filter coefficients

max*

Maximum elements of an array

maxflat*

Generalized digital Butterworth filter design

mean*

Average or mean value of array

median*

Median value of array

min*

Minimum elements of an array

movmad*

Moving median absolute deviation

movmedian*

Moving median

mscohere

Magnitude-squared coherence

nuttallwin

Nuttall-defined minimum 4-term Blackman-Harris window

parzenwin

Parzen (de la Vallée Poussin) window

pchip*

Piecewise Cubic Hermite Interpolating Polynomial (PCHIP)

peak2peak

Maximum-to-minimum difference

peak2rms

Peak-magnitude-to-RMS ratio

periodogram

Periodogram power spectral density estimate

plomb

Lomb-Scargle periodogram

poly2ac*

Convert prediction filter polynomial to autocorrelation sequence

poly2lsf*

Convert prediction filter coefficients to line spectral frequencies

poly2rc*

Convert prediction filter polynomial to reflection coefficients

pow2db

Convert power to decibels

pulstran*

Pulse train

pwelch

Welch's power spectral density estimate

rainflow

Rainflow counts for fatigue analysis

randn*

Normally distributed random numbers

rc2ac*

Convert reflection coefficients to autocorrelation sequence

rc2poly*

Convert reflection coefficients to prediction filter polynomial

rceps

Real cepstrum and minimum phase reconstruction

rcosdesign*

Raised cosine FIR pulse-shaping filter design

rectpuls

Sampled aperiodic rectangle

rectwin

Rectangular window

resample*

Resample uniform or nonuniform data to new fixed rate

rlevinson*

Reverse Levinson-Durbin recursion

rms

Root-mean-square level

sawtooth

Sawtooth or triangle wave

sgolay

Savitzky-Golay filter design

sgolayfilt

Savitzky-Golay filtering

sin

Sine of argument in radians

sinc

Sinc function

sos2tf

Convert digital filter second-order section data to transfer function form

sosfilt

Second-order (biquadratic) IIR digital filtering

spline*

Cubic spline data interpolation

square

Square wave

std*

Standard deviation

stft

Short-time Fourier transform

taylorwin

Taylor window

tf2ss

Convert transfer function filter parameters to state-space form

tfridge*

Time-frequency ridges

triang

Triangular window

tripuls

Sampled aperiodic triangle

tsa

Time-synchronous signal average

tukeywin

Tukey (tapered cosine) window

unwrap*

Shift phase angles

upfirdn*

Upsample, apply FIR filter, and downsample

upsample

Increase sample rate by integer factor

var*

Variance

wvd*

Wigner-Ville distribution and smoothed pseudo Wigner-Ville distribution

xcorr*

Cross-correlation

xcorr2

2-D cross-correlation

xcov

Cross-covariance

xwvd*

Cross Wigner-Ville distribution and cross smoothed pseudo Wigner-Ville distribution

yulewalk*

Recursive digital filter design

zp2tf

Convert zero-pole-gain filter parameters to transfer function form

Statistics and Machine Learning Toolbox

C and C++ code generation for the following functions requires the Statistics and Machine Learning Toolbox™ software.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

betacdf

Beta cumulative distribution function

BetaDistribution*

Beta probability distribution object

betafit

Beta parameter estimates

betainv

Beta inverse cumulative distribution function

betalike

Beta negative log-likelihood

betapdf

Beta probability density function

betarnd*

Beta random numbers

betastat

Beta mean and variance

binocdf

Binomial cumulative distribution function

binoinv

Binomial inverse cumulative distribution function

binopdf

Binomial probability density function

binornd*

Random numbers from binomial distribution

binostat

Binomial mean and variance

categorical*

Array that contains values assigned to categories

cdf*

Cumulative distribution function

chi2cdf

Chi-square cumulative distribution function

chi2inv

Chi-square inverse cumulative distribution function

chi2pdf

Chi-square probability density function

chi2rnd*

Chi-square random numbers

chi2stat

Chi-square mean and variance

ClassificationBaggedEnsemble*

Classification ensemble grown by resampling

ClassificationDiscriminant*

Discriminant analysis classification

ClassificationECOC*

Multiclass model for support vector machines (SVMs) and other classifiers

ClassificationEnsemble*

Ensemble classifier

ClassificationKNN*

k-nearest neighbor classification

ClassificationLinear*

Linear model for binary classification of high-dimensional data

ClassificationNaiveBayes*

Naive Bayes classification

ClassificationSVM*

Support vector machine (SVM) for one-class and binary classification

ClassificationTree*

Binary decision tree for classification

CompactClassificationDiscriminant*

Compact discriminant analysis class

CompactClassificationECOC*

Compact multiclass model for support vector machines (SVMs) and other classifiers

CompactClassificationEnsemble*

Compact classification ensemble class

CompactClassificationNaiveBayes*

Compact naive Bayes classifier

CompactClassificationSVM*

Compact support vector machine (SVM) for one-class and binary classification

CompactClassificationTree*

Compact classification tree

CompactGeneralizedLinearModel*

Compact generalized linear regression model class

CompactLinearModel*

Compact linear regression model

CompactRegressionEnsemble*

Compact regression ensemble class

CompactRegressionGP*

Compact Gaussian process regression model class

CompactRegressionSVM*

Compact support vector machine regression model

CompactRegressionTree*

Compact regression tree

coxphfit*

Cox proportional hazards regression

ecdf*

Empirical cumulative distribution function

evcdf

Extreme value cumulative distribution function

evfit

Extreme value parameter estimates

evinv

Extreme value inverse cumulative distribution function

evpdf

Extreme value probability density function

evrnd*

Extreme value random numbers

evstat

Extreme value mean and variance

ExhaustiveSearcher*

Create exhaustive nearest neighbor searcher

expcdf

Exponential cumulative distribution function

expfit

Exponential parameter estimates

expinv

Exponential inverse cumulative distribution function

ExponentialDistribution*

Exponential probability distribution object

exppdf

Exponential probability density function

exprnd*

Exponential random numbers

expstat

Exponential mean and variance

ExtremeValueDistribution*

Extreme value probability distribution object

fcdf

F cumulative distribution function

finv

F inverse cumulative distribution function

fitdist*

Fit probability distribution object to data

fpdf

F probability density function

frnd*

F random numbers

fstat

F mean and variance

gamcdf

Gamma cumulative distribution function

gaminv

Gamma inverse cumulative distribution function

gampdf

Gamma probability density function

gamrnd*

Gamma random numbers

gamstat

Gamma mean and variance

GeneralizedLinearModel*

Generalized linear regression model class

GeneralizedParetoDistribution*

Normal probability distribution object

geocdf

Geometric cumulative distribution function

geoinv

Geometric inverse cumulative distribution function

geomean*

Geometric mean

geopdf

Geometric probability density function

geornd*

Geometric random numbers

geostat

Geometric mean and variance

gevcdf

Generalized extreme value cumulative distribution function

gevinv

Generalized extreme value inverse cumulative distribution function

gevpdf

Generalized extreme value probability density function

gevrnd*

Generalized extreme value random numbers

gevstat

Generalized extreme value mean and variance

glmval*

Generalized linear model values

gpcdf

Generalized Pareto cumulative distribution function

gpinv

Generalized Pareto inverse cumulative distribution function

gppdf

Generalized Pareto probability density function

gprnd*

Generalized Pareto random numbers

gpstat

Generalized Pareto mean and variance

grp2idx*

Create index vector from grouping variable

harmmean*

Harmonic mean

hygecdf

Hypergeometric cumulative distribution function

hygeinv

Hypergeometric inverse cumulative distribution function

hygepdf

Hypergeometric probability density function

hygernd*

Hypergeometric random numbers

hygestat

Hypergeometric mean and variance

icdf*

Inverse cumulative distribution function

iqr*

Interquartile range

KDTreeSearcher*

Create Kd-tree nearest neighbor searcher

kmeans*

k-means clustering

knnsearch*

Find k-nearest neighbors using input data

knnsearch*

Find k-nearest neighbors using searcher object

ksdensity*

Kernel smoothing function estimate for univariate and bivariate data

kurtosis*

Kurtosis

LinearModel*

Linear regression model

loadCompactModel

(To be removed) Reconstruct model object from saved model for code generation

loadLearnerForCoder*

Reconstruct model object from saved model for code generation

logncdf

Lognormal cumulative distribution function

lognfit

Lognormal parameter estimates

logninv

Lognormal inverse cumulative distribution function

LognormalDistribution*

Lognormal probability distribution object

lognpdf

Lognormal probability density function

lognrnd*

Lognormal random numbers

lognstat

Lognormal mean and variance

mad*

Mean or median absolute deviation

mean*

Mean of probability distribution

median*

Median of probability distribution

mnpdf

Multinomial probability density function

moment*

Central moment

mvksdensity*

Kernel smoothing function estimate for multivariate data

nancov*

Covariance ignoring NaN values

nanmax*

Maximum, ignoring NaN values

nanmean*

Mean, ignoring NaN values

nanmedian*

Median, ignoring NaN values

nanmin*

Minimum, ignoring NaN values

nanstd*

Standard deviation, ignoring NaN values

nansum*

Sum, ignoring NaN values

nanvar*

Variance, ignoring NaN values

nbincdf

Negative binomial cumulative distribution function

nbininv

Negative binomial inverse cumulative distribution function

nbinpdf

Negative binomial probability density function

nbinrnd*

Negative binomial random numbers

nbinstat

Negative binomial mean and variance

ncfcdf

Noncentral F cumulative distribution function

ncfinv

Noncentral F inverse cumulative distribution function

ncfpdf

Noncentral F probability density function

ncfrnd*

Noncentral F random numbers

ncfstat

Noncentral F mean and variance

nctcdf

Noncentral t cumulative distribution function

nctinv

Noncentral t inverse cumulative distribution function

nctpdf

Noncentral t probability density function

nctrnd*

Noncentral t random numbers

nctstat

Noncentral t mean and variance

ncx2cdf

Noncentral chi-square cumulative distribution function

ncx2rnd*

Noncentral chi-square random numbers

ncx2stat

Noncentral chi-square mean and variance

normcdf

Normal cumulative distribution function

normfit

Normal parameter estimates

norminv

Normal inverse cumulative distribution function

normpdf

Normal probability density function

normrnd*

Normal random numbers

normstat

Normal mean and variance

pca*

Principal component analysis of raw data

pdf*

Probability density function

pdist*

Pairwise distance between pairs of observations

pdist2*

Pairwise distance between two sets of observations

pearsrnd*

Pearson system random numbers

poisscdf

Poisson cumulative distribution function

poissinv

Poisson inverse cumulative distribution function

poisspdf

Poisson probability density function

poissrnd*

Random numbers from Poisson distribution

poisstat

Poisson mean and variance

prctile*

Percentiles of a data set

predict*

Predict responses of linear regression model

predict*

Classify observations using multiclass error-correcting output codes (ECOC) model

predict*

Classify observations using support vector machine (SVM) classifier

predict*

Predict labels using discriminant analysis classification model

predict*

Predict response of Gaussian process regression model

predict*

Predict labels using classification tree

predict*

Predict labels for linear classification models

predict*

Predict labels using k-nearest neighbor classification model

predict*

Predict response of linear regression model

predict*

Predict response of generalized linear regression model

predict*

Predict responses using ensemble of regression models

predict*

Predict labels using naive Bayes classification model

predict*

Predict responses using regression tree

predict*

Classify observations using ensemble of classification models

predict*

Predict responses using support vector machine regression model

quantile*

Quantiles of a data set

randg

Gamma random numbers with unit scale

random*

Random numbers

random*

Simulate responses with random noise for linear regression model

random*

Simulate responses for generalized linear regression model

randsample*

Random sample

rangesearch*

Find all neighbors within specified distance using searcher object

rangesearch*

Find all neighbors within specified distance using input data

raylcdf

Rayleigh cumulative distribution function

raylinv

Rayleigh inverse cumulative distribution function

raylpdf

Rayleigh probability density function

raylrnd*

Rayleigh random numbers

raylstat

Rayleigh mean and variance

RegressionBaggedEnsemble*

Regression ensemble grown by resampling

RegressionEnsemble*

Ensemble regression

RegressionGP*

Gaussian process regression model class

RegressionLinear*

Linear regression model for high-dimensional data

RegressionSVM*

Support vector machine regression model

RegressionTree*

Regression tree

skewness*

Skewness

squareform*

Format distance matrix

std*

Standard deviation of probability distribution

table*

Table array with named variables that can contain different types

tcdf

Student's t cumulative distribution function

tinv

Student's t inverse cumulative distribution function

tpdf

Student's t probability density function

trnd*

Student's t random numbers

truncate*

Truncate probability distribution object

tstat

Student's t mean and variance

unidcdf

Discrete uniform cumulative distribution function

unidinv

Discrete uniform inverse cumulative distribution function

unidpdf

Discrete uniform probability density function

unidrnd

Random numbers from discrete uniform distribution

unidstat

Discrete uniform mean and variance

unifcdf

Continuous uniform cumulative distribution function

unifinv

Continuous uniform inverse cumulative distribution function

unifpdf

Continuous uniform probability density function

unifrnd*

Continuous uniform random numbers

unifstat

Continuous uniform mean and variance

update*

Update model parameters for code generation

var*

Variance of probability distribution

wblcdf

Weibull cumulative distribution function

wblfit

Weibull parameter estimates

wblinv

Weibull inverse cumulative distribution function

wblpdf

Weibull probability density function

wblrnd*

Weibull random numbers

wblstat

Weibull mean and variance

WeibullDistribution*

Weibull probability distribution object

zscore*

Standardized z-scores

System Identification Toolbox

C and C++ code generation for the following functions and System objects requires the System Identification Toolbox™ software.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

extendedKalmanFilter*

Create extended Kalman filter object for online state estimation

particleFilter*

Particle filter object for online state estimation

recursiveAR*

Create System object for online parameter estimation of AR model

recursiveARMA*

Create System object for online parameter estimation of ARMA model

recursiveARMAX*

Create System object for online parameter estimation of ARMAX model

recursiveARX*

Create System object for online parameter estimation of ARX model

recursiveBJ*

Create System object for online parameter estimation of Box-Jenkins polynomial model

recursiveLS*

Create System object for online parameter estimation using recursive least squares algorithm

recursiveOE*

Create System object for online parameter estimation of Output-Error polynomial model

unscentedKalmanFilter*

Create unscented Kalman filter object for online state estimation

Wavelet Toolbox

C and C++ code generation for the following functions requires the Wavelet Toolbox™ software.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

appcoef*

1-D approximation coefficients

appcoef2*

2-D approximation coefficients

cwtfilterbank*

Continuous wavelet transform filter bank

cwtfreqbounds*

CWT maximum and minimum frequency or period

ddencmp*

Default values for denoising or compression

detcoef

1-D detail coefficients

detcoef2

2-D detail coefficients

dwt

Single-level 1-D discrete wavelet transform

dwt2

Single-level discrete 2-D wavelet transform

dyadup*

Dyadic upsampling

emd

Empirical mode decomposition

filterbank

Shearlet system filters

framebounds

Shearlet system frame bounds

idwt

Single-level inverse discrete 1-D wavelet transform

idwt2*

Single-level inverse discrete 2-D wavelet transform

imodwpt

Inverse maximal overlap discrete wavelet packet transform

imodwt

Inverse maximal overlap discrete wavelet transform

isheart2

Inverse shearlet transform

mdwtdec*

Multisignal 1-D wavelet decomposition

mdwtrec*

Multisignal 1-D wavelet reconstruction

meyeraux

Meyer wavelet auxiliary function

modwpt

Maximal overlap discrete wavelet packet transform

modwptdetails

Maximal overlap discrete wavelet packet transform details

modwt

Maximal overlap discrete wavelet transform

modwtmra

Multiresolution analysis based on MODWT

numshears

Number of shearlets

qmf

Scaling and Wavelet Filter

shearletSystem

Bandlimited shearlet system

sheart2

Shearlet transform

thselect

Threshold selection for denoising

wavedec*

1-D wavelet decomposition

wavedec2*

2-D wavelet decomposition

waverec*

1-D wavelet reconstruction

waverec2*

2-D wavelet reconstruction

wden*

Automatic 1-D denoising

wdencmp*

Denoising or compression

wextend*

Extend vector or matrix

wnoisest

Estimate noise of 1-D wavelet coefficients

wthcoef

1-D wavelet coefficient thresholding

wthcoef2

Wavelet coefficient thresholding 2-D

wthresh

Soft or hard thresholding

wvd*

Wigner-Ville distribution and smoothed pseudo Wigner-Ville distribution

xwvd*

Cross Wigner-Ville distribution and cross smoothed pseudo Wigner-Ville distribution

WLAN Toolbox

C and C++ code generation for the following functions and System objects requires the WLAN Toolbox™ software.

An asterisk (*) indicates that the reference page has usage notes and limitations for C/C++ code generation.

comm.ConstellationDiagram*

Display constellation diagram for input signals

comm.ErrorRate*

Compute bit or symbol error rate of input data

comm.EVM*

Measure error vector magnitude

comm.PhaseFrequencyOffset*

Apply phase and frequency offsets to input signal

displayIEs

Display the list of information elements (IEs)

dsp.ArrayPlot*

Display vectors or arrays

dsp.SpectrumAnalyzer*

Display frequency spectrum of time-domain signals

dsp.TimeScope*

Time domain signal display and measurement

getPSDULength

Return HE format PSDU length

getSIGBLength

Return information relevant to HE-SIG-B field length

info

Return characteristic information about TGay multipath fading channel

interpretHESIGABits

Update recovery configuration object with HE-SIG-A bits

packetFormat

Return WLAN packet format

ruInfo

Return HE format resource unit allocation information

showEnvironment

Display channel environment with D-Rays from ray tracing

wlanAMPDUDeaggregate

Deaggregate A-MPDU and extract MPDUs

wlanAPEPLength

Calculate APEP length in octets

wlanBCCDecode

Convolutionally decode input data

wlanBCCDeinterleave

Deinterleave binary convolutionally interleaved input

wlanBCCEncode

Convolutionally encode binary data

wlanBCCInterleave

Interleave binary convolutionally encoded input

wlanClosestReferenceSymbol

Find closest constellation points

wlanCoarseCFOEstimate

Coarse estimate of carrier frequency offset

wlanConstellationDemap

Constellation demapping

wlanConstellationMap

Constellation mapping

wlanDMGConfig

Create DMG-format configuration object

wlanDMGDataBitRecover

Recover data bits from DMG data field

wlanDMGHeaderBitRecover

Recover header bits from DMG header field

wlanDMGOFDMDemodulate

Demodulate fields of DMG waveform

wlanDMGOFDMInfo

Get OFDM information for DMG transmission

wlanFieldIndices

Generate PPDU field indices

wlanFineCFOEstimate

Fine estimate of carrier frequency offset

wlanFormatDetect

Detect packet format

wlanGolaySequence

Generate Golay sequence

wlanHEDataBitRecover

Recover data bits from HE-Data field

wlanHEDemodulate

Demodulate fields of HE waveform

wlanHEMUConfig

Create multiuser high-efficiency-format configuration object

wlanHEOFDMInfo

Get OFDM information for HE transmission

wlanHERecoveryConfig

Create HE recovery configuration object

wlanHESIGABitRecover

Recover information bits in HE-SIG-A field

wlanHESIGBCommonBitRecover

Recover common field bits in HE-SIG-B field

wlanHESIGBUserBitRecover

Recover user field bits in HE-SIG-B field

wlanHESUConfig

Create single-user high-efficiency-format configuration object

wlanHTConfig

Create HT-format configuration object

wlanHTData

Generate HT-Data field waveform

wlanHTDataRecover

Recover HT data

wlanHTLTF

Generate HT-LTF waveform

wlanHTLTFChannelEstimate

Channel estimation using HT-LTF

wlanHTLTFDemodulate

Demodulate HT-LTF waveform

wlanHTOFDMInfo

Return OFDM information for HT transmission

wlanHTSIG

Generate HT-SIG waveform

wlanHTSIGRecover

Recover HT-SIG information bits

wlanHTSTF

Generate HT-STF waveform

wlanLLTF

Generate L-LTF waveform

wlanLLTFChannelEstimate

Channel estimation using L-LTF

wlanLLTFDemodulate

Demodulate L-LTF waveform

wlanLSIG

Generate L-SIG waveform

wlanLSIGBitRecover

Recover information bits in L-SIG field

wlanLSIGRecover

Recover L-SIG information bits

wlanLSTF

Generate L-STF waveform

wlanMACFrame

Generate WLAN MAC frame (MPDU or A-MPDU)

wlanMACFrameConfig

Create WLAN MAC frame configuration object

wlanMACManagementConfig

Create WLAN MAC management frame-body configuration object

wlanMPDUDecode

Decode MPDU

wlanMSDULengths

Calculate MSDU lengths

wlanNonHTConfig

Create non-HT-format configuration object

wlanNonHTData

Generate non-HT-Data field waveform

wlanNonHTDataRecover

Recover non-HT data

wlanNonHTOFDMInfo

Get OFDM information for non-HT transmission

wlanPacketDetect

OFDM packet detection using L-STF

wlanPSDULength

Calculate PSDU length in octets

wlanRecoveryConfig

Create data recovery configuration object

wlanReferenceSymbols

Find reference symbols of constellation diagram

wlanS1GConfig

Create S1G-format configuration object

wlanS1GDemodulate

Demodulate fields of S1G waveform

wlanS1GOFDMInfo

Get OFDM Information for S1G transmission

wlanScramble

Scramble and descramble binary input sequence

wlanSegmentDeparseBits

Segment-deparse data bits

wlanSegmentDeparseSymbols

Segment-deparse data subcarriers

wlanSegmentParseBits

Segment-parse data bits

wlanSegmentParseSymbols

Segment-parse data subcarriers

wlanStreamDeparse

Stream-deparse binary input

wlanStreamParse

Stream-parse binary input

wlanSymbolTimingEstimate

Fine symbol timing estimate using L-LTF

wlanTGacChannel*

Filter signal through 802.11ac multipath fading channel

wlanTGahChannel*

Filter signal through 802.11ah multipath fading channel

wlanTGaxChannel*

Filter signal through an 802.11ax™ multipath fading channel

wlanTGayChannel*

Filter signal through 802.11ay™ multipath fading channel

wlanTGnChannel*

Filter signal through 802.11n multipath fading channel

wlanURAConfig

Create antenna array configuration object for 802.11ay channel model

wlanVHTConfig

Create VHT-format configuration object

wlanVHTData

Generate VHT-Data field

wlanVHTDataRecover

Recover VHT data

wlanVHTLTF

Generate VHT-LTF waveform

wlanVHTLTFChannelEstimate

Channel estimation using VHT-LTF

wlanVHTLTFDemodulate

Demodulate VHT-LTF waveform

wlanVHTOFDMInfo

Get OFDM information for VHT transmission

wlanVHTSIGA

Generate VHT-SIG-A waveform

wlanVHTSIGARecover

Recover VHT-SIG-A information bits

wlanVHTSIGB

Generate VHT-SIG-B waveform

wlanVHTSIGBRecover

Recover VHT-SIG-B information bits

wlanVHTSTF

Generate VHT-STF waveform

wlanWaveformGenerator

Generate WLAN waveform

Note

WLAN Toolbox functionality with the MATLAB Function block is not supported.

Related Topics