Abstract: A method of specifying a truth table includes generating a block diagram model, generating a statechart in the block diagram model, selecting a truth table graphical function in the statechart, and applying a set of graphical semantics for logic specification to the truth table graphical function combined with textual language predicates and actions.

Abstract: A method, performed by a computer device, may include generating a first executable graphical model representing a dynamic system and generating a second executable graphical model representing costs and constraints associated with the dynamic system. The method may further include generating an interface model based on the first and second executable graphical models; obtaining one or more solution parameters for solving a trajectory optimization problem defined by the dynamic system and the cost and constraints; expanding the generated interface model based on the obtained one or more solution parameters to generate a direct transcription representation of the trajectory optimization problem; evaluating the expanded interface model to obtain a solution to the trajectory optimization problem; and providing, in an interface, the solution as a solution to the trajectory optimization problem, wherein the solution has a reduced cost compared to a cost associated with an initial guess solution.

Abstract: A method of specifying and configuring a causal relationship between the dynamics of a graphical model and the execution of components of the model is disclosed. Model component execution is tied to the occurrence of model events. Model events are first defined in the modeling environment. The occurrence of conditions in the model specified in the definition of the event causes the event to be “posted”. Model components that have been associated with the occurrence of the event “receive” the notice of the posting of the event and then execute. Random components within a subsystem may be designated to execute upon the occurrence of an event, as may non-contiguous components within a model. The association between model events and component execution may be specified without drawing graphical indicators connecting components in the view of the model.

Abstract: A mechanism for processing graphical block diagram parameter expressions is presented. The mechanism achieves optimal implementation of block equations in the execution (run-time) environment by defining a mapping between user-defined block parameters and a run-time version of the parameters. The parameter processing mechanism also pools like, non-interfaced parameter expressions, allowing reuse of both uniform and non-uniform data across constant block parameters in the generated code and during model execution. The parameter processing mechanism further maintains an execution structure that maps the run-time parameter expressions containing interfaced variables to generated code for the block diagram so that the interfaced variables appear in the generated code. This mapping thus allows for interfacing to the interfaced variables in the generated code from any execution framework.

Abstract: A mechanism in a block diagram environment allows the modeling of an execution behavior of a block in a block diagram, where a user selects the execution behavior from a plurality of functions related to the block diagram and where the execution behavior of the block is performed when at least one model variable associated with the block satisfies a user-specified condition is disclosed. States and other internal data in the designated block are initialized upon the satisfaction of the user-specified condition. The illustrative embodiment of the present invention also allows the internal data to be reset upon the ending of the event, such as the modeled introduction or withdrawal of power. The execution behavior may be suspended and resumed multiple times during the simulation in response to multiple occurrences of the specified event. The present invention also allows for selected data to be exempt from the reset process so that the selected data is non-volatile.

Abstract: A system is configured to receive a task. The task is received over a first network, includes authentication credentials, and is processed using an application. The system is further configured to send the authentication credentials to a licensing server. The authentication credentials are sent over a second network, and are sent prior to processing the task using the application. The system is also configured to receive an authorization. The authorization is received over the second network, and authorizes the application to process the task.

Abstract: A mechanism for using stream objects in stream processing operations is provided. A definition of a class of stream objects used in stream processing algorithms can define output and update operations included in instances of the stream objects and the API (application programming interface) through which they may be called. The class definition may further include the type of state information to be held by the instantiated stream objects. An instance of the stream object may be instantiated in a text-based computing environment and the operations may be used to process streams of data.

Abstract: A system and method graphically display ports in a discrete event system (DES) environment. A graphical representation of a model having at least one DES component is provided in the DES environment. A first port of the DES component and a second port of the DES component are indicated by symbols. The first port is indicated by a first symbol representing a port type of the DES environment and the second port is indicated by a second symbol representing a port type of a non-DES environment.

Abstract: A tool for viewing data in a software environment is disclosed. The data may be a multi-dimensional data set. The viewer tool provides various features for viewing and exploring the data set. The viewer tool may be coupled to a test environment that generates data from the tests of a unit under test (UUT). The data may be generated from one or more sequences of tests that can be divided into batches. The viewer tool may receive the data from the test environment and analyze the data to provide a user with useful information on the data. The viewer tool may display the data with the information so that the user can obtain the information on the data. In particular, the viewer tool may enable the user to understand the relationship between the measured test data and the various test conditions under which the test data has been measured.

Abstract: An embodiment can include an interactive memory map that includes a graphical representation of a region of memory used by a program. The memory map may dynamically update as the program executes and may provide a user with indicators that identify how the program interacts with the memory. The indicators may identify memory locations that are being written by the program and/or memory locations that are being read by the program while the program executes. The memory map may assist a user in understanding how the executing program interacts with memory. The interactive memory map may further allow the user to manipulate how information is stored in the memory by allowing the user to select, add, remove, modify, move, etc., program information stored in the memory.

Abstract: A computer-readable media may store instructions for receiving text-based technical computing code from a first technical computing environment running on a remote computer, where the first technical computing environment includes a set of functions. The media may store instructions for processing data captured using an instrument, where the data is processed using the received technical computing code in a second technical computing environment that includes a subset of the functions, where the captured data processed in non-real-time, and where the processing produces a result. The media may store instructions for translating the technical computing code from a first format compatible with the second technical computing environment into a second format adapted for parallel execution by a field programmable gate array (FPGA), the translating performed by a code generator when the result is satisfactory. The media may store instructions for processing input data in real-time using the FPGA.

Abstract: An algorithm and architecture are disclosed for performing multi-argument associative operations. The algorithm and architecture can be used to schedule operations on multiple facilities for computations or can be used in the development of a model in a modeling environment. The algorithm and architecture resulting from the algorithm use the latency of the components that are used to process the associative operations. The algorithm minimizes the number of components necessary to produce an output of multi-argument associative operations and also can minimize the number of inputs each component receives.

Abstract: In one embodiment, a test and measurement application executing on a computing device is interfaced with one or more external device coupled to the computing device. A device driver is selected for use with one of the external device from two or more available device drivers that are each compatible with the external device. The device driver is coupled to a virtual driver interface that provides the test and measurement application with a standardized interface to any of the two or more available device drivers. The test and measurement application communicates with the external device through the virtual driver interface.

Abstract: A list of constructs is displayed on a user interface screen for a user to select a desired construct. A construct selected by the user is determined. Computing environments are presented on the user interface screen for the user to place the selected construct. The computing environments include at least one textual and at least one graphical computing environment. A selected computing environment into which the selected construct is being placed is identified. A position of the placed construct in the selected computing environment is determined. A template based on the selected computing environment is selected. The selected template is inserted into the selected computing environment.

Abstract: A method of preventing interference between subsystem blocks includes obtaining an integrity level for a first subsystem block, obtaining an integrity level for a second subsystem block, assigning an integrity level property to at least one input port of the first block, the integrity level property assigned to the input port of the first block being based on the integrity level defined for the first block, and assigning an integrity level property to at least one output port of the second block, the integrity level property assigned to the output port of the second block being based on the integrity level defined for the second block. The method further includes evaluating the integrity level property of at least one input/output pair to determine whether an inappropriate connection exists, and performing a first action when an inappropriate connection exists, or performing a second action when an appropriate connection exists.

Abstract: A device receives program code, and receives size/type information associated with inputs to the program code. The device determines, prior to execution of the program code and based on the input size/type information, a portion of the program code that is executable by a graphical processing unit (GPU), and determines, prior to execution of the program code and based on the input size/type information, a portion of the program code that is executable by a central processing unit (CPU). The device compiles the GPU-executable portion of the program code to create a compiled GPU-executable portion of the program code, and compiles the CPU-executable portion of the program code to create a compiled CPU-executable portion of the program code. The device provides, to the GPU for execution, the compiled GPU-executable portion of the program code, and provides, to the CPU for execution, the compiled CPU-executable portion of the program code.

Abstract: In an embodiment, a network may represent a physical system. The network may have an element that represents an entity of the physical system. A value of a state associated with the network may be identified (e.g., generated) using various techniques. The state may be a low-level state associated with the network. The techniques may include, but are not limited to, for example, generating the value based on a scaffold defined for the network, generating the value based on a target value for the state, and/or generating the value based on applying an operation to various values of the state. The identified value may be associated with an identifier. The identifier may distinguish the value, for example, from other values of other states in the network and/or other values of states in other networks.

Abstract: Exemplary embodiments provide annotations for dynamic dispatch of threads from scripting language code. Exemplary embodiments may provide scripting language code and execute the code causing examination of at least one annotation associated with a referenced collection of code. Exemplary embodiments may dynamically dispatch a first task to a first thread automatically from the scripting language code at runtime based on the examination of the at least one annotation associated with the referenced collection of code.

Abstract: Embodiments of the present application may simplify an integration of statically typed and dynamically typed languages by automatically generating an implementation of a statically typed native interface for a given set of dynamically typed functions. In an embodiment, functions in a dynamically typed language are automatically interconnected with functions in a statically typed language. Code that bridges and/or connects a statically typed interface and a dynamically typed interface embodied in the dynamically typed source code may be automatically generated. The statically typed interface may be provided by a user. Further, an extensible set of runtime rules that determine how to convert between statically typed and dynamically typed data may be provided.

Abstract: Exemplary embodiments allow configurable execution of operations associated with a state enabled system in a graphical modeling or graphical programming environment. In an embodiment, a state enabled system may be identified in a graphical model, or a graphical program, or both. The state enabled system may be associated with a first operation and a second operation, and may include instructions to execute the first and second operations. The state enabled system may be configured to always execute the first operation regardless of an enabling condition. The state enabled system may also be configured to prevent an execution of the second operation unless the enabling condition is satisfied.