Chapter 14 Preparing Models for Use with Reactis
To use Reactis on a Simulink / Stateflow model, you must ensure
that the model satisfies certain constraints. This chapter
describes what these constraints are. Please note that,
while every effort is made to maintain the accuracy of the
following list of supported and unsupported features, due to
the complexity and continual evolution of the Simulink / Stateflow
notation, this description may not be complete. For example,
some blocks listed as supported do not support all
parameters for the block. A block or feature not listed as
either supported or unsupported should be assumed to be
unsupported. We encourage all potential customers to take advantage of a free evaluation
license for Reactis to determine if the subset of Simulink / Stateflow supported by
Reactis is adequate for your models. If it’s not, please let us know
what features or blocks you would like to see Reactis support. Reactive
Systems uses such feedback to prioritize enhancements to Reactis.
14.1 MATLAB
Reactis can process Simulink / Stateflow models that contain MATLAB code in callbacks
or mask initializations, provided that certain conventions are observed. On the
one hand, files that define workspace data items referred to in a model must be
“connected” to the model appropriately, and certain MATLAB functions should
be avoided. The remainder of this section elaborates on these points.
14.1.1 Workspace Data Items
Reactis invokes MATLAB to evaluate many MATLAB expressions, but it does
not directly interact with an executing MATLAB session in the same way that
Simulink does. For this reason, any workspace data items that a model uses
must be initialized within one of the following locations : 
Any Simulink model callback or block callback that is executed when
loading or running the model (PreLoadFcn, PostLoadFcn, InitFcn, StartFcn).
 A “startup.m” file located in the folder where the model file is located.
When using this method, make sure that the “Execute startup.m and pathdef.m scripts
in model folder” is checked in the “General” tab of the Reactis Info File Editor.
 The “Callbacks” tab of the Reactis Info File Editor. If in your environment
the MATLAB workspace for your model is set up via some external script or graphical
user interface prior to loading the model, you can add the initialization code here
so Reactis knows how to set up the workspace. Reactis will automatically execute
the “PreLoad Function” code prior to loading the model and the “PostLoad Function”
code after loading the model. This method allows you to use Reactis in such an
environment without having to modify your model.
For the cruisecontrol example, the
file
cruise_constants.m
defines two workspace variables that are used in
cruise.mdl. One attaches
cruise_constants.m
to cruise.mdl as
follows: 
Load cruise.mdl into Simulink.
 From the Simulink window, select the File > Model Properties
menu item.
 In the resulting dialog, select the Callbacks tab.
 In the Model preload function entry box enter
cruise_constants; .
 Save the model.
In general, using the PreLoadFcn callback in this manner is good modeling
practice, since once the .m files are attached to a model file, loading the
model file into Simulink (and not just Reactis) will automatically load
the .m files as well.
14.1.2 Unsupported MATLAB Features
While Reactis supports most of MATLAB, the following exceptions may not be
used in Simulink / Stateflow models, e.g. in callbacks or mask initializations. Note, that a
feature added in V2010.2 adds partial support for these commands. To enable the
feature for a model, load the model, select menu item Edit > General, and then
check the box “Propagate set_param changes by saving the model to a temporary
file”. To enable this feature for all models, select File > Model Defaults...
and then check the box “Propagate set_param changes by saving the model to a temporary
file” in the General tab. If this setting is enabled, Reactis
will cause Simulink to apply all the changes to the model, then automatically
save them to a temporary file. Reactis then imports the temporary model
to see the applied changes.
Expression Evaluation 
ASSIGNIN  Assign variable in workspace. 
EVALIN  Evaluate expression in workspace. 
Model Construction/Modification 
ADD_BLOCK  Add a block to a Simulink system. 
ADD_LINE  Add a line to a Simulink system. 
ADD_PARAM  Add a parameter to a Simulink system. 
DELETE_BLOCK  Delete a block from a Simulink system. 
DELETE_LINE  Delete a line from a Simulink system. 
DELETE_PARAM  Deletes a parameter from a Simulink system. 
NEW_SYSTEM  Create a new empty Simulink system. 
REPLACE_BLOCK  Replace blocks in model. 
SET_PARAM  Set Simulink system and block parameters. 
14.2 Simulink
Reactis currently supports Simulink releases R2012b through R2022b. Most features
of Simulink are supported; but the following are not supported by Reactis:

Continuoustime blocks.
 The use of complex values (i.e. values with real
and imaginary parts).
 Models containing corresponding DataStoreWrite/DataStoreRead
blocks whose execution order is not explicitly defined by either the model
logic or priorities.
For the subset of Simulink blocks supported by Reactis please refer to
Section 14.2.3. For blocks that can be either continuous or
discretetime, only the discretetime version is supported. For some blocks
identified as supported, not all settings are supported.
14.2.1 SFunctions
Reactis supports both CCoded and MFile Sfunctions, with some
restrictions. For CCoded Sfunctions, the following
are not supported by Reactis:

Portbased sample times.
 Multiple sample times.
 Complex number signals.
 Zerocrossing detection.
 Output of functioncalls.
 Level 1 Sfunctions (For a guide on how to convert Level 1 Sfunctions
to Level 2 Sfunctions — which are supported by Reactis  please consult
the MathWorks documentation)
 Calling any function from MATLAB’s “mex” library (including
mexCallMATLAB, mexEvalString and mexGetVariable) from an SFunction.
For MFile Sfunctions, the following are not supported by Reactis:

Multiple sample times.
 Complex number signals.
 Level 2 Sfunctions.
In addition to the above restrictions, care must be taken about any internal
data that is stored by Sfunctions. In order to work properly,
Reactis must be able to retrieve and reset the values of all internal
states of any Sfunction occurring within a model. The best way to make
internal states visible to
Reactis (and Simulink) is to declare the appropriate number of discrete
states in the
mdlInitializeSizes() function and then use the state vector that
Reactis and
Simulink will provide. Reactis will also save and restore
memory that an Sfunction allocates as a result of calling the
ssGetNumRWork() and
ssGetNumIWork() during mdlInitializeSizes . Reactis has no way of knowing about any other persistent data that an
Sfunction maintains by other means, such as:

global or static variables in Ccode;
 memory allocated by malloc() or mxMalloc() functions
in Ccode;
 Use of workspace variables in MFile Sfunctions.
Reactis will also not save and restore memory requested by
ssGetNumPWork() , since otherwise pointers stored in this vector by your
Sfunction might get lost or mangled, resulting in memory leaks or crashes. If an Sfunction stores internal states in any of the unsupported ways
described above, Reactis will seem to work properly, but the test
suites generated by Tester may include wrong outputs. One sign of
this can be if you run a test suite in Simulator and get an error
message saying “Model fails test”. Another problem of such
invalid use of internal states may be invalid outputs after using the
“back” buttons in Simulator.
In general, Reactis passes SFunction parameters as fixed values at the time
the SFunction is first initialized (i.e. when Tester or Simulator is
started). Therefore, if a configuration variable is used as a parameter to an
SFunction, the SFunction will not see any changes to the configuration
variable unless the SFunction is designed to process such updates. To have an
SFunction be updated on changes to its parameters, define a mdlProcessParameters function (see Simulink documentation) within the
SFunction code. If this function is present, then Reactis will propagate the
parameter changes into the SFunction by calling the SFunction’s mdlProcessParameters function at each step with the new parameter values. In the mdlProcessParameters function, the SFunction can then take appropriate actions
if any parameters have changed.
14.2.2 Lookup Tables
This section describes the settings for each of the standard Simulink
lookup table blocks that are supported by Reactis. Note that MathWorks
has changed the names of these blocks and their settings over different
releases. We use the R2022b terminology here. If you are using an older
version of MATLAB your block names and settings may be slightly different.
14.2.2.1 1D Lookup Table
Note that this block was previously named Lookup Table.
All block settings and the data type combinations listed below are supported
(note that fixpoint includes all fixedpoint data types and integer
data types int8, uint8, int16, uint16, int32 and uint32).
Supported Data Type Combinations 
Input of LUT  Output of LUT 
double  double 
single  double 
fixpoint  double 
single  single 
fixpoint  single 
double  fixpoint 
single  fixpoint 
fixpoint  fixpoint 
double  boolean 
single  boolean 
fixpoint  boolean 
14.2.2.2 2D Lookup Table
Note that this block was previously named Lookup Table (2D).
All block settings are supported.
Supported data type combinations are listed in the table
below (note that fixpoint includes all fixedpoint data types and integer
data types int8, uint8, int16, uint16, int32 and uint32).
Supported Data Type Combinations 
1st Input of LUT  2nd Input of LUT  Output of LUT 
double  double  double 
double  fixpoint  double 
double  bool  double 
single  single  double 
fixpoint  double  double 
fixpoint  fixpoint  double 
bool  double  double 
single  single  single 
single  fixpoint  single 
single  bool  single 
fixpoint  single  single 
fixpoint  fixpoint  single 
bool  single  single 
double  double  fixpoint 
single  single  fixpoint 
fixpoint  fixpoint  fixpoint 
fixpoint  fixpoint  bool 
double  double  bool 
single  single  bool 
14.2.2.3 nD Lookup Table
Note that this block was previously named Lookup Table (nD).
Reactis supports a wide variety of nD lookup tables,
subject to restrictions which depend on the number of table dimensions.
There are two levels of support, native and via Sfunction. Native support means Reactis will natively execute the nD Lookup Table
block and track coverage for it. Only nD lookup tables which satisfy the
following requirements are natively supported in Reactis: 
The number of table dimensions is at most three, or the number of dimensions is four
and all input, output and internal data types are the same floatingpoint data type.
 The interpolation and extrapolation methods are not cubic spline.
 The types used in the table are restricted to the following:
fixedpoint types with a bias of zero
and a slope that is a (negative) power of two, integer types,
single or doubleprecision floatingpoint types, Boolean.
 None of the inputs or outputs have enumerated types.
Support via Sfunction requires MATLAB R2017b or earlier:
it is not available with R2018a and later.
Support via Sfunction means Reactis can execute the nD lookup block
but not track coverage. In order to execute the block,
Reactis requires the sfun_lookupnd.mexw32 SFunction that
comes with MATLAB R2007a or earlier. Starting with MATLAB R2007b,
this SFunction is no longer included in the MATLAB distribution.
However, if a sfun_lookupnd.mexw32 from R2007a
or earlier is placed in Reactis’ search path,
Reactis can use that SFunction with MATLAB R2007b to R2017b,
but not with R2018a and later. nD lookup tables which meet the following six requirements are supported via Sfunction
in Reactis: 
The input and output types are the same floatingpoint type.
 The fraction data type is set to Inherit via internal rule.
 The table data type is set to Inherit: same as output.
 The breakpoint data type is set to Inherit: same as corresponding input.
 All inputs are scalars.
 If the table has more than one dimension,
then the intermediate data type is set to Inherit: same as output.
14.2.2.4 Lookup Table Dynamic
All parameters and the data type configurations listed for the 1D Lookup Table block above
are supported.
14.2.2.5 Prelookup
There are two levels of support for the Prelookup block in Reactis, native and
via Sfunction. Native support means Reactis will natively execute the Prelookup
block and track coverage for it.
Reactis natively supports Prelookup blocks which use the following types:
fixedpoint types with a bias of zero
and a slope that is a (negative) power of two, integer types,
single or doubleprecision floatingpoint types, Boolean. Support via Sfunction means Reactis can execute the Prelookup block
but not track coverage. In order to execute the block,
Reactis requires the sfun_idxsearch.mexw32 SFunction that
comes with all versions of MATLAB. All parameters are supported. The following data type restrictions apply:

Only floatingpoint (double and single) input data types are supported.
 Only “int32” and “uint32” are supported as the data type of the “index” output.
 Only “single” and “double” are supported as the data type of the “fraction” output.
14.2.2.6 Interpolation Using Prelookup
There are two levels of support for the Interpolation Using Prelookup block in Reactis,
native and via Sfunction. Native support means Reactis will natively execute the
Interpolation block and track coverage for it. Only Interpolation Using
Prelookup blocks which satisfy the following requirements are natively
supported in Reactis: 
The number of table dimensions is at most four.
 The interpolation and extrapolation methods are not cubic spline.
 The types used in the table are restricted to the following:
fixedpoint types with a bias of zero
and a slope that is a (negative) power of two, integer types,
single or doubleprecision floatingpoint types, Boolean.
Support via Sfunction means Reactis can execute the Interpolation block
but not track coverage. In order to execute the block,
Reactis requires the sfun_kflookupnd.mexw32 SFunction that
comes with all versions of MATLAB. All parameters are supported. The following data type restrictions apply:

Only floatingpoint (double and single) data types are supported for “fraction” inputs.
 Data types of all “fraction” inputs must be the same as the output data type.
 Only “int32” and “uint32” are supported as the data type of the “index” input.
 Table data type must match output data type
 Intermediate results data type must match output data type.
14.2.3 Table of Supported Blocks
Block  Introduced  Reactis
Support  Notes

Commonly Used Blocks 
Bus Creator  preR14  Y  
Bus Selector  preR14  Y  
Constant  preR14  Y  
DataType Conversion  preR14  Y  
Delay  R2011b  Y  Only supported if Input processing is set to Elements as channels (sample based) 
Demux  preR14  Y  
DiscreteTime Integrator  preR14  Y  
Gain  preR14  Y  
Ground  preR14  Y  
Inport  preR14  Y  
Integrator  preR14  N  
Logical Operator  preR14  Y  
Mux  preR14  Y  
Outport  preR14  Y  
Product  preR14  Y  
Relational Operator  preR14  Y  
Saturation  preR14  Y  
Scope  preR14  Y  
Subsystem  preR14  Y  
Sum  preR14  Y  
Switch  preR14  Y  
Terminator  preR14  Y  
Vector Concatenate  R14  Y  
Continuous 
Derivative  preR14  N  
Descriptor StateSpace  R2018b  N  
Entity Transport Delay  R2019b  N  
First Order Hold  R2019b  N  
Integrator  preR14  N  
Integrator Limited  R2010a  N  
Integrator SecondOrder  R2010a  N  
Integrator SecondOrder Limited  R2010a  N  
PID Controller  R2009b  N  
PID Controller (2DOF)  R2009b  N  
StateSpace  preR14  N  
Transfer Fcn  preR14  N  
Transport Delay  preR14  N  
Variable Time Delay  R2007b  N  
Variable Transport Delay  preR14  N  
ZeroPole  preR14  N  
Discontinuities 
Backlash  preR14  Y  
Coulomb & Viscous Friction  preR14  Y  
Dead Zone  R14  Y  
Dead Zone Dynamic  R14  Y  
Hit Crossing  R14  Y  
PWM  R2020b  N  
Quantizer  preR14  Y  
Rate Limiter  preR14  Y  
Rate Limiter Dynamic  R14  Y  
Relay  preR14  Y  
Saturation  preR14  Y  
Saturation Dynamic  R14  Y  
Wrap To Zero  R14  Y  
Discrete 
Delay  R2011b  Y  Only supported if Input processing is set to Elements as channels (sample based) 
Difference  R14  Y  
Discrete Derivative  R14  Y  
Discrete Filter  preR14  Y  
Discrete FIR Filter  R2008a  Y  
Discrete PID Controller  R2009b  N  
Discrete PID Controller (2DOF)  R2009b  N  
Discrete StateSpace  preR14  Y  
DiscreteTime Integrator  preR14  Y  
Discrete Transfer Fcn  preR14  Y  
Discrete ZeroPole  R14  Y  
Enabled Delay  preR2006  Y  
Memory  preR14  Y  
Resettable Delay  R2012b  Y  
Tapped Delay  R14  Y  
Transfer Fcn First Order  R14  Y  
Transfer Fcn Lead or Lag  R14  Y  
Transfer Fcn Real Zero  R14  Y  
Unit Delay  preR14  Y  
Variable Integer Delay  R2012b  N  
ZeroOrder Hold  preR14  Y  
Logic and Bit Operations 
Bit Clear  preR14  Y  
Bit Set  preR14  Y  
Bit To Integer Converter  R2022a  Y  
Bitwise Operator  preR14  Y  
Combinatorial Logic  preR14  Y  
Compare To Constant  preR14  Y  
Compare To Zero  preR14  Y  
Detect Change  preR14  Y  
Detect Decrease  preR14  Y  
Detect Fall Negative  preR14  Y  
Detect Fall Nonpositive  preR14  Y  
Detect Increase  preR14  Y  
Detect Rise Nonnegative  preR14  Y  
Detect Rise Positive  preR14  Y  
Extract Bits  R14  Y  
Integer To Bit Converter  R2022a  Y  
Interval Test  preR14  Y  
Interval Test Dynamic  preR14  Y  
Logical Operator  preR14  Y  
Relational Operator  preR14  Y  
Shift Arithmetic  preR14  Y  
Lookup Tables 
1D Lookup Table  preR14  Y  Previously named Lookup Table.
See Section 14.2.2.1 
2D Lookup Table  preR14  Y  Previously named Lookup Table (2D).
See Section 14.2.2.2 
Cosine  preR14  Y  Only output formula cos 
Direct Lookup Table (nD)  preR14  Y  
Interpolation using Prelookup  preR14  Y  See Section 14.2.2.6 
Lookup Table Dynamic  R14  Y  See Section 14.2.2.4 
nD Lookup Table  preR14  Y  Previously named Lookup Table (nD).
See Section 14.2.2.3 
Prelookup  preR14  Y  See Section 14.2.2.5 
Sine  preR14  Y  Only output formula sin 
Math Operations 
Abs  preR14  Y  
Add  preR14  Y  
Algebraic Constraint  preR14  N  
Assignment  preR14  Y  
Bias  R14  Y  
Complex to MagnitudeAngle  preR14  N  
Complex to RealImag  preR14  N  
Divide  preR14  Y  
Dot Product  preR14  Y  
Find Nonzero Elements  R2010a  N  
Gain  preR14  Y  
MagnitudeAngle to Complex  preR14  N  
Math Function  preR14  Y  Except Hermitian 
Matrix Concatenate  preR14  Y  
MinMax  preR14  Y  
MinMax Running Resettable  preR14  Y  
Permute Dimensions  R2007a  Y  2 dimensions only 
Polynomial  preR14  Y  
Product  preR14  Y  
Product of Elements  preR14  Y  
RealImag to Complex  preR14  N  
Reciprocal Sqrt  R2010a  Y  
Reshape  preR14  Y  
Rounding Function  preR14  Y  
Sign  preR14  Y  
Signed Sqrt  R2010a  Y  
Sine Wave Function  preR14  Y  Using simulation time 
Slider Gain  preR14  Y  
Sqrt  R2010a  Y  
Squeeze  R2007a  N  
Subtract  preR14  Y  
Sum  preR14  Y  
Sum of Elements  preR14  Y  
Trigonometric Function  preR14  Y  Approximation method must be None 
Unary Minus  preR14  Y  
Vector Concatenate  R14  Y  
Weighted Sample Time Math  R14  Y  
Matrix Operations 
Concatenate  R2022a  Y  
Create Diagonal Matrix  R2022a  Y  
Cross Product  R2021b  Y  
Extract Diagonal  R2022a  Y  
Hermitian Transpose  R2021b  Y  
IdentityMatrix  R2021b  Y  
IsHermitian  R2022a  N  
IsSymmetric  R2021b  Y  
IsTriangular  R2021b  Y  
MatrixSquare  R2021b  Y  
Multiply  R2022a  Y  
Permute Matrix  R2022a  Y  
Submatrix  R2022a  Y  
Transpose  R2021b  Y  
Messages & Events 
Hit Crossing Probe  R2006a  Y  
Message Merge  R2021a  N  
Message Triggered Subsystem  R202a  N  
Queue  R2016a  N  
Receive  R2016a  N  
Send  R2016a  N  
Sequence Viewer  R2015b  N  
Model Verification 
Assertion  preR14  N  
Check Discrete Gradient  preR14  N  
Check Dynamic Gap  preR14  N  
Check Dynamic Lower Bound  preR14  N  
Check Dynamic Range  preR14  N  
Check Dynamic Upper Bound  preR14  N  
Check Input Resolution  preR14  N  
Check Static Gap  preR14  N  
Check Static Lower Bound  preR14  N  
Check Static Range  preR14  N  
Check Static Upper Bound  preR14  N  
ModelWide Utilities 
Block Support Table  R2007a  N  
DocBlock  preR14  Y  
Model Info  preR14  Y  
TimeBased Linearization  preR14  N  
TriggerBased Linearization  preR14  N  
Ports & Subsystems 
Atomic Subsystem  preR14  Y  
CodeReuse Subsystem  R14  N  
Configurable Subsystem  preR14  Y  
Enable  preR14  Y  
Enabled Subsystem  preR14  Y  
Enabled and Triggered Subsystem  preR14  Y  
For Each Subsystem  R2010a  Y  
For Iterator Subsystem  preR14  Y  
FunctionCall Feedback Latch  R2011a  Y  
FunctionCall Generator  preR14  Y  
FunctionCall Split  R2010a  Y  
FunctionCall Subsystem  preR14  Y  
If  preR14  Y  
If Action Subsystem  preR14  Y  
In Bus Element  R2017a  Y  
Inport  preR14  Y  
Model  R14  Y  
Out Bus Element  R2017a  Y  
Outport  preR14  Y  
Resettable Subsystem  R2015a  Y  
Subsystem  preR14  Y  
Switch Case  preR14  Y  
Switch Case Action Subsystem  preR14  Y  
Trigger  preR14  Y  Except trigger type “message” 
Triggered Subsystem  preR14  Y  Except trigger type “message” 
Variant Model  R2010b  Y  
Variant Subsystem  R2010b  Y  
While Iterator Subsystem  preR14  Y  
Signal Attributes 
Bus to Vector  R2007b  Y  
Data Type Conversion  preR14  Y  
Data Type Conversion Inherited  preR14  Y  
Data Type Duplicate  preR14  Y  
Data Type Propagation  preR14  Y  
Data Type Scaling Strip  preR14  Y  
IC  preR14  Y  
Probe  preR14  Y  
Rate Transition  preR14  Y  
Signal Conversion  preR14  Y  
Signal Specification  preR14  Y  
Unit Conversion  R2016a  N  
Weighted Sample Time  R14  Y  
Width  preR14  Y  
Signal Routing 
Bus Assignment  R14  Y  
Bus Creator  preR14  Y  
Bus Selector  preR14  Y  
Connection Port  R2007a  N  
Data Store Memory  preR14  Y  
Data Store Read  preR14  Y  
Data Store Write  preR14  Y  
Demux  preR14  Y  
Environment Controller  R14  Y  
From  preR14  Y  
Goto  preR14  Y  
Goto Tag Visibility  preR14  Y  
Index Vector  preR14  Y  
Manual Switch  preR14  N  
Manual Variant Sink  R2016b  Y  
Manual Variant Source  R2016b  Y  
Merge  preR14  Y  
Multiport Switch  preR14  Y  ’Data port for default case’ must be ’Last data port’ and
’Diagnostic for default case’ must be ’Error’ 
Mux  preR14  Y  
Parameter Writer  R2022a  N  
Selector  preR14  Y  
State Reader   Y  
State Writer   Y  
Switch  preR14  Y  
Vector Concatenate  R14  Y  
Sinks 
Display  preR14  Y  
Floating Scope  preR14  Y  
Out Bus Element  R2017a  Y  
Outport  preR14  Y  
Record  2021a  N  
Scope  preR14  Y  
Stop Simulation  preR14  N  
Terminator  preR14  Y  
To File  preR14  N  You can configure Reactis to ignore
To File blocks from the Settings dialog. 
To Workspace  preR14  N  You can configure Reactis to ignore
To Workspace blocks from the Settings dialog. 
XY Graph  preR14  N  
Sources 
BandLimited White Noise  preR14  N  
Chirp Signal  preR14  N  
Clock  preR14  Y  
Constant  preR14  Y  
Counter FreeRunning  preR14  Y  
Counter Limited  preR14  Y  
Digital Clock  preR14  Y  
Enumerated Constant  R2009b  Y  
From File  preR14  Y  .mat file must be in ’Array’ format, not ’MATLAB timeseries object’ format.
Linear interpolation and extrapolation must be used. 
From Workspace  preR14  Y  
Ground  preR14  Y  
In Bus Element  R2017a  Y  
Inport  preR14  Y  
Pulse Generator  preR14  Y  ’Pulse type’ must be ’sample based’ and ’Time (t)’ must be ’Use simulation time’ 
Ramp  preR14  Y  
Random Number  preR14  Y  This block may only be used in virtual sources. 
Repeating Sequence  preR14  Y  
Repeating Sequence Interpolated  R14  Y  
Repeating Sequence Stair  R14  Y  
Signal Builder  preR14  Y  
Signal Editor  R2017b  N  
Signal Generator  preR14  Y  ’Wave form’ of ’random’ not supported 
Sine Wave  preR14  Y  ’Time (t)’ must be ’Use simulation time’ 
Step  preR14  Y  
Uniform Random Number  preR14  N  
Waveform Generator  R2015b  N  
String 
ASCII to String  R2018a  N  
Compose String  R2018a  N  
Scan String  R2018a  N  
String Compare  R2018a  N  
String Concatenate  R2018a  N  
String Constant  R2018a  N  
String Contains  R2020a  N  
String Count  R2020a  N  
String Ends With  R2020a  N  
String Find  R2018a  N  
String Length  R2018a  N  
String Starts With  R2020a  N  
String to ASCII  R2018a  N  
String to Double  R2018a  N  
String to Enum  R2018a  N  
String to Single  R2018a  N  
Substring  R2018a  N  
To String  R2018a  N  
UserDefined Functions 
C Caller  R2018b  Y  Supported in Reactis if using MATLAB R2019b or later 
C Function  R2020a  N  
Function Caller  R2015a  Y  
Initialize Function  R2016b  Y  
Interpreted MATLAB Function  preR14  N  Previously named MATLAB Fcn 
Level2 MATLAB SFunction  preR14  N  
MATLAB Function  preR14  Y  Previously named Embedded MATLAB Function. Only
a subset of the Embedded MATLAB language is supported.
See Section 14.4 for details.

MATLAB System  R2013b  N  
Reset Function  R2018b  Y  
Sfunction  preR14  Y  
Sfunction Builder  preR14  Y  
Simulink Function  R2014b  Y  
Terminate Function   N  
Additional Discrete 
FixedPoint StateSpace  R14  Y  
Transfer Fcn Direct Form II  R14  N  
Transfer Fcn Direct Form II Time Varying  R14  N  
Additional Math 
Decrement Real World  preR14  Y  
Decrement Stored Integer  preR14  Y  
Decrement Time To Zero  preR14  Y  
Decrement To Zero  preR14  Y  
Increment Real World  preR14  Y  
Increment Stored Integer  preR14  Y  
Stateflow 
Chart  preR14  Y  See Section 14.3. 
Truth Table  R14  Y  See Section 14.4 for supported subset of the
underlying Embedded MATLAB language. 
14.2.4 Simulink Extras
The following table lists the supported blocks from the
“Simulink extras” library which is available in all MATLAB
versions:
Additional Discrete 
Supported: 
Discrete Transfer Fcn (with initial outputs),
Discrete Transfer Fcn (with initial states),
Discrete ZeroPole (with initial outputs),
Discrete ZeroPole (with initial states),
Idealized ADC Quantizer

Unsupported:  
Additional Linear 
Supported:  
Unsupported: 
StateSpace (with initial outputs),
Transfer Fcn (with initial outputs),
Transfer Fcn (with initial states),
ZeroPole (with initial outputs),
ZeroPole (with initial states)

Additional Sinks 
Supported:  
Unsupported: 
Auto Correlator,
Averaging Power Spectral Density,
Averaging Spectrum Analyzer,
Cross Correlator,
Floating Bar Plot,
Power Spectral Density,
Spectrum Analyzer

Flip Flops 
Supported: 
D FlipFlop,
D Latch,
JK FlipFlop,
SR FlipFlop

Unsupported: 
Clock

Linearization 
Supported:  
Unsupported: 
Switched derivative for linearization,
Switched transport delay for linearization

Transformations 
Supported: 
Cartesian to Polar,
Cartesian to Spherical,
Celsius to Fahrenheit,
Degrees to Radians,
Fahrenheit to Celsius,
Polar to Cartesian,
Radians to Degrees,
Spherical to Cartesian

Unsupported:  
14.2.5 HDL Coder Blockset
The following table lists the supported blocks from the
HDL Coder blockset:
Discontinuities 
Supported: 
Backlash,
Coulomb and Viscous Friction,
Dead Zone,
Dead Zone Dynamic,
Hit Crossing,
Relay,
Saturation,
Saturation Dynamic,
Wrap To Zero

Unsupported:  
Discrete 
Supported: 
Delay,
Discrete FIR Filter,
DiscreteTime Integrator,
Discrete Transfer Fcn,
Enabled Delay,
Enabled Resettable Delay,
Memory,
Resettable Delay,
Unit Delay,
Unit Delay Enabled Resettable Synchronous,
Unit Delay Enabled Synchronous,
Unit Delay Resettable Synchronous,
ZeroOrder Hold

Unsupported: 
Discrete PID Controller,
Tapped Delay

HDL Floating Point Operations 
Supported: 
Abs, Acos, Acosh, Add, Asin, Asinh, Atan, Atan2, Atanh, Bias, Ceil, Conjugate, Cos, Cosh,
Data Type Conversion, Discrete FIR Filter, DiscreteTime Integrator, Discrete Transfer Fcn,
Divide, Exp, Fix, Floor, Gain, Hypot, Log, Log10, Magnitude Square, Math Reciprocal, Max,
Min, Mod, Pow, Pow10, Product, Product of Elements, Reciprocal, Reciprocal Sqrt, Relational Operator,
Rem, Round, Sign, SignedSqrt, Sin, Sincos, Sinh, Sqrt, Square, Subtract, Sum of Elements, Tan, Tanh,
Transpose, Unary Minus

Unsupported: 
cos+jsin,
Discrete PID Controller,
Float Typecast,
Hermitian,
MagnitudeAngle to Complex

HDL Operations 
Supported: 
MultiplyAccumulate,
MultiplyAdd

Unsupported: 
Deserializer1D,
Serializer1D

HDL RAMs 
Supported: 
Dual Port RAM,
Simple Dual Port RAM
Single Port RAM,

Unsupported: 
Dual Port RAM System,
Dual Rate Dual Port RAM,
HDL FIFO
Simple Dual Port RAM System,
Single Port RAM System

HDL Subsystems 
Supported:  
Unsupported: 
Enabled Synchronous Subsystem,
Resettable Synchronous Subsystem,
State Control,
Synchronous Subsystem

Logic and Bit Operations 
Supported: 
Bit Clear, Bit Slice (R2020b and later),
Bitwise Operator, Compare To Constant, Compare To Zero, Detect Change,
Detect Decrease, Detect Increase, Extract Bits, Logical Operator, Relational Operator,
Shift Arithmetic

Unsupported: 
Bit Concat, Bit Reduce, Bit Rotate, Bit Shift, Bit Slice (before R2020b)

Lookup Tables 
Supported: 
1D Lookup Table, 2D Lookup Table, Direct Lookup Table (nD), nD Lookup Table, Prelookup

Unsupported: 
Cosine HDL Optimized, Sine HDL Optimized

Math Operations 
Supported: 
Abs, Add, Assignment, Bias, Decrement Real World, Decrement Stored Integer, Divide,
Dot Product, Gain, Increment Real World, Increment Stored Integer, Math Function,
Matrix Concatenate, MatrixMultiply, MinMax, Product, Product of Elements, Reciprocal,
Reciprocal Sqrt, Reshape, Sign, Sqrt, Subtract, Sum, Sum of Elements, Trigonometric Function,
Unary Minus, Vector Concatenate

Unsupported: 
Complex to RealImag,
HDL Reciprocal,
RealImag to Complex

Model Verification 
Supported:  
Unsupported: 
Assertion, Check Dynamic Gap, Check Dynamic Range, Check Static Gap, Check Static Range,
Check Dynamic Lower Bound, Check Input Resolution, Check STatic Lower Bound,
Check Static Upper Bound, Check Discrete Gradient

ModelWide Utilities 
Supported: 
DocBlock, Model Info

Unsupported:  
Ports & Subsystems 
Supported: 
Atomic Subsystem, Enable, Enabled Subsystem, For Each Subsystem, In Bus Element, In,
Model, Out Bus Element, Out, Subsystem, Trigger, Triggered Subsystem, Variant Subsystem

Unsupported:  
Signal Attributes 
Supported: 
Bus to Vector, Data Type Conversion, Data Type Duplicate, Data Type Propagation, Probe,
Rate Transition, Signal Specification, Signal Conversion

Unsupported:  
Signal Routing 
Supported: 
Bus Element In, Bus Element Out, Bus Assignment, Bus Creator, Bus Selector, Demux, From,
Goto, Index Vector, Multiport Switch, Mux, Selector, Switch, Vector Concatenate

Unsupported:  
Sinks 
Supported: 
Display, Floating Scope, Out Bus Element, Out, Scope, Terminator, To File, To Workspace

Unsupported: 
Stop Simulation, XY Graph

Sources 
Supported: 
Constant, Counter FreeRunning, Counter Limited, Enumerated Constant, Ground, HDL Counter, In Bus Element, In

Unsupported:  
User Defined Functions 
Supported: 
MATLAB Function

Unsupported: 
MATLAB System

14.2.6 TargetLink 2.2.1 Library Blocks
The following table lists the supported blocks from the
dSPACE TargetLink library (version 2.2.1), if installed:
Main TargetLink Library 
Supported: 
Inport,
Outport,
Constant,
Sum,
Gain,
Product,
Logical Operator,
Relational Operator,
Fcn,
LookUp Table,
Lookup Table (2D),
Direct Lookup Table (nD),
PreLookUp Index Search,
Interpolation (nD) using PreLookUp,
Saturation,
MinMax,
Abs,
Sign,
Relay,
Trigonometric Function,
Math,
Unit Delay,
Discrete Transfer Fcn,
FIR Filter,
DiscreteTime Integrator,
Discrete StateSpace,
Data Store Write,
Data Store Memory,
Data Store Read,
Merge,
Sink,
Bus Inport,
Bus Outport,
Switch,
Multiport Switch,
Unit Delay (Reset Enabled),

Unsupported:  Rate Limiter

NonLinear 
Supported: 
Dead Zone Positive,
Dead Zone Negative,
Saturation Dynamic,
Backlash

Unsupported:  Dead Zone,
Dead Zone Dynamic 
Math 
Supported: 
Rounding Function,
Transport Delay

Unsupported:  
Extras 
Supported: 
D FlipFlop,
D Latch,
JK FlipFlop,
SR FlipFlop,
Preprocessor IF

Unsupported:  
Bit Operations 
Supported: 
U8 Bit Set,
U16 Bit Set,
U32 Bit Set ,
U8 Bit Clear,
U16 Bit Clear,
U32 Bit Clear,
Split U16,
Split U32,
Combine U16,
Combine U32,
8Bit Decoder,
8Bit Encoder,
16Bit Decoder,
16Bit Encoder,
Bitwise Logical Operator

Unsupported:  
TargetLinkSupported Simulink Blocks 
Supported: 
Please see list of ReactisSupported Simulink Blocks 
Unsupported:  
14.2.7 TargetLink 2.3.1 Library Blocks
The following table lists the supported blocks from the
dSPACE TargetLink library (version 2.3.1), if installed:
Main TargetLink Library 
Supported: 
Inport,
Outport,
Constant,
Sum,
Gain,
Product,
Logical Operator,
Relational Operator,
Fcn,
LookUp Table,
Lookup Table (2D),
Direct Lookup Table (nD),
PreLookUp Index Search,
Saturation,
MinMax,
Abs,
Sign,
Relay,
Trigonometric Function,
Math,
Unit Delay,
Discrete Transfer Fcn,
FIR Filter,
DiscreteTime Integrator,
Discrete StateSpace,
Data Store Write,
Data Store Memory,
Data Store Read,
Merge,
Sink,
Bus Inport,
Bus Outport,
Switch,
Multiport Switch,
Unit Delay (Reset Enabled),

Unsupported:  Interpolation (nD) using PreLookUp,
Rate Limiter

NonLinear 
Supported: 
Dead Zone Positive,
Dead Zone Negative,
Saturation Dynamic,
Backlash

Unsupported:  Dead Zone,
Dead Zone Dynamic 
Math 
Supported: 
Rounding Function,
Transport Delay

Unsupported:  
Extras 
Supported: 
D FlipFlop,
D Latch,
JK FlipFlop,
SR FlipFlop,
Preprocessor IF

Unsupported:  
Bit Operations 
Supported: 
U8 Bit Set,
U16 Bit Set,
U32 Bit Set ,
U8 Bit Clear,
U16 Bit Clear,
U32 Bit Clear,
Split U16,
Split U32,
Combine U16,
Combine U32,
8Bit Decoder,
8Bit Encoder,
16Bit Decoder,
16Bit Encoder,
Bitwise Logical Operator

Unsupported:  
TargetLinkSupported Simulink Blocks 
Supported: 
Please see list of ReactisSupported Simulink Blocks 
Unsupported:  
14.2.8 TargetLink 3.0 to 3.4 Library Blocks
The following table lists the supported blocks from the
dSPACE TargetLink library (versions 3.0 to 3.4), if installed:
Main TargetLink Library 
Supported: 
Inport,
Outport,
Constant,
Sum,
Gain,
Product,
Logical Operator,
Relational Operator,
Fcn,
LookUp Table,
Lookup Table (2D),
Direct Lookup Table (nD),
PreLookUp Index Search,
Interpolation (nD) using PreLookUp,
Saturation,
MinMax,
Abs,
Sign,
Rate Limiter,
Relay,
Trigonometric Function,
Math,
Unit Delay,
Discrete Transfer Fcn,
FIR Filter,
DiscreteTime Integrator,
Discrete StateSpace,
Data Store Write,
Data Store Memory,
Data Store Read,
Merge,
Sink,
Bus Inport,
Bus Outport,
Switch,
Multiport Switch,
Unit Delay (Reset Enabled),

Unsupported:  
NonLinear 
Supported: 
Backlash,
Dead Zone Positive,
Dead Zone Negative,
Saturation Dynamic,
Dead Zone,
Dead Zone Dynamic

Unsupported:  
Math 
Supported: 
Rounding Function,
Transport Delay

Unsupported:  
Extras 
Supported: 
D FlipFlop,
D Latch,
JK FlipFlop,
SR FlipFlop,
Preprocessor IF

Unsupported:  
Bit Operations 
Supported:  U8 Bit Set,
U16 Bit Set,
U32 Bit Set ,
U8 Bit Clear,
U16 Bit Clear,
U32 Bit Clear,
Split U16,
Split U32,
Combine U16,
Combine U32,
8Bit Decoder,
8Bit Encoder,
16Bit Decoder,
16Bit Encoder,
Bitwise Logical Operator 
Unsupported:  
TargetLinkSupported Simulink Blocks 
Supported: 
Please see list of ReactisSupported Simulink Blocks 
Unsupported:  
14.2.9 TargetLink 3.5 to 22.1 Library Blocks
The following table lists the supported blocks from the
dSPACE TargetLink library (versions 3.5 to 22.1), if installed:
Main TargetLink Library 
Supported: 
Inport,
Outport,
Constant,
Sum,
Gain,
Product,
Logical Operator,
Relational Operator,
Fcn,
LookUp Table,
Lookup Table (2D),
Direct Lookup Table (nD),
PreLookUp Index Search,
Interpolation (nD) using PreLookUp,
Saturation,
MinMax,
Abs,
Sign,
Rate Limiter,
Relay,
Trigonometric Function,
Math,
Unit Delay,
Discrete Transfer Fcn,
DiscreteTime Integrator,
Discrete StateSpace,
Data Store Write,
Data Store Memory,
Data Store Read,
Merge,
Sink,
Bus Inport,
Bus Outport,
Switch,
Multiport Switch,
Unit Delay (Reset Enabled)

Unsupported:  FIR Filter

NonLinear 
Supported: 
Backlash,
Dead Zone Positive,
Dead Zone Negative,
Saturation Dynamic,
Dead Zone,
Dead Zone Dynamic

Unsupported:  
Math 
Supported: 
Rounding Function

Unsupported:  Transport Delay 
Extras 
Supported: 
D FlipFlop,
D Latch,
JK FlipFlop,
SR FlipFlop,
Preprocessor IF

Unsupported:  
Bit Operations 
Supported:  U8 Bit Set,
U16 Bit Set,
U32 Bit Set ,
U8 Bit Clear,
U16 Bit Clear,
U32 Bit Clear,
Split U16,
Split U32,
Combine U16,
Combine U32,
8Bit Decoder,
8Bit Encoder,
16Bit Decoder,
16Bit Encoder,
Bitwise Logical Operator 
Unsupported:  
TargetLinkSupported Simulink Blocks 
Supported: 
Please see list of ReactisSupported Simulink Blocks 
Unsupported:  
14.3 Stateflow
Reactis supports most of Stateflow. Some exceptions are the
following unsupported features:

Charts with the action language set to MATLAB are currently
supported if they use the language subset described in Section 14.4.
Charts with “C” action language are supported.
 Implicit “enter”, “exit” and “change” events
 Range limits for variables.
 “ml.” namespace operator and “ml()” function call.
 Embedded MATLAB code. Reactis supports the language subset
described in Section 14.4.
 Using Stateflow keywords as variable names. The Stateflow
keywords are:
at, after, before, change, du, during, enter, en, entry,
every, ex, exit, in, on, ml, send, abs, acos, asin,
atan, atan2, ceil, cos, cosh, exp, fabs, floor,
fmod, labs, ldexp, log, log10, min, max, pow,
rand, rem, sin, sinh, sqrt, tan, tanh, int8,
int16, int32, uint8, uint16, uint32, double,
boolean.
 The explicit type cast function (“cast”).
 The address operator (
& ) is supported only in calls to external
C functions.
 The pointer operator (
* ) is supported only inside a literal C code
section.
 Charts without trigger or sample time are supported only if the
model has a fixed sample time.
 In some cases, the detection of inner transitions fails for
oddshaped transitions (for example, single transition segments which
leave and reenter a state).
 The
temporalCount operator.
 Atomic Subcharts (introduced in R2010b).
14.4 Embedded MATLAB
Reactis V2012 introduced blackbox support for Embedded MATLAB. This includes:
Simulink
• MATLAB Function block
• Truth Table block
Stateflow
• MATLAB functions
• Truth Table functions with MATLAB language option
• MATLAB action language in Stateflow
Note that a subset of the full Embedded MATLAB language is supported. To use
models containing Embedded MATLAB in Reactis, your model must only use the
language subset supported by Reactis. Note that the same language restrictions
apply no matter which of the five model constructs listed above are used
to incorporate Embedded MATLAB into your model. To avoid confusion, we use the
following abbreviations in the following discussion:

Embedded MATLAB (EML)
 the subset of MATLAB supported by MathWorks for code generation.
 Reactis Embedded MATLAB (REML)
 the subset of EML supported by Reactis.
REML is under active development towards the ultimate goal of supporting a
very large subset of EML. Please send requests to Reactive Systems
(help@reactivesystems.com) if there are unsupported EML features you would
like to use. The V2015 release of Reactis included a new product: the Reactis for EML Plugin. It integrates
with Reactis to offer whitebox testing of the EML portions of a model. See
Chapter 17 for a description of the Reactis for EML Plugin. If not using the
new product, you can still test models containing EML; however, exercising coverage
targets within the EML will not be an objective of test generation and tracking
this coverage will not be available. Whether in whitebox or blackbox mode
for EML, Reactis supports the same subset of EML. This subset is defined
in Section 17.4.
