Abstract: Exemplary embodiments allow a user to create configurations for use in distributed computing environments. Configurations can be arranged in hierarchies in which elements of the hierarchy can inherit characteristics from elements in other layers of the hierarchy. Embodiments also allow a user to flatten a hierarchical configuration to remove hierarchical dependencies and/or inheriting capabilities of elements in the hierarchy. Exemplary embodiments further allow users to deploy a distributed computing configuration on their desktop to evaluate performance of the configuration and then deploy the configuration in a distributed computing environment without having to change programming code run on the desktop/distributed computing environment.

Abstract: A graphical user interface for a concurrent computing environment that conveys the concurrent nature of a computing environment and allows a user to monitor the status of a concurrent process being executed on multiple concurrent computing units is discussed. The graphical user interface allows the user to target specific concurrent computer units to receive commands. The graphical user interface also alters the command prompt to reflect the currently targeted concurrent computing units.

Abstract: In an embodiment, a plurality of graphical elements of a graphical model may be displayed on a display device. An indication of a graphical operation involving a first graphical element of the plurality of graphical elements may be received. The graphical operation when performed may establish a relationship between the first graphical element and one or more other graphical elements of the plurality of graphical elements that are compatible with the graphical operation. Two or more graphical elements of the plurality of graphical elements that are compatible with the graphical operation and one or more characteristics associated with the first graphical element may be identified. A visual indication may be provided on the display device. The visual indication may indicate that the identified plurality of graphical elements is compatible with the graphical operation.

Abstract: The present invention provides a method and system for providing customization in choosing what types of model responses are recorded and/or compared. An archive tool is provided so that a user can specify a rule or condition that would trigger the archive of a response. The archive tool can further provide the user with flexibility of how model attributes are stored with the archived response. The stored model attributes can be used to identify a specific archived response. The present invention further provides a browsing mechanism for browsing archives and selecting archives for comparison. Any number of archives may be selected and compared. The selected archives can have their responses plotted individually, together, or passed through analysis functions.

Abstract: A class definition syntax that leverages the array and math-oriented nature of a dynamically typed array-based programming language is discussed. Some embodiments of the present invention provides a mechanism for using meta-data to define a class implemented in the dynamically typed array-based programming language. The meta-data provide an easy way to provide class definitions and allow a user to access the class definitions from objects. The meta-data also support extension of class definitions without introducing backward incompatibility.

Abstract: In an embodiment, in a graphical modeling environment, users may create models that can be executed. Within the graphical modeling environment, users may use implicit iterator systems to manage multiple iterations of systems whereby the indexing of input and output signals may be defined by a user and state may be managed for an iteration. The number of iterations taken by the implicit iterator system can adapt to input and output signal dimensions.

Abstract: A method, performed by a computer device, includes obtaining an in-memory representation of computer code from a block step method of an executable model in a modeling application, wherein the computer code in-memory representation includes one or more variables. The method also includes identifying, from the one or more variables, a subset of persistent variables and determining if any of the one or more variables in the subset of persistent variables are state variables. When none of the subset of persistent variables are state variables, a block output method is generated based on the computer code in-memory representation and the one or more variables. When the subset of persistent variables includes a state variable, both the block output method and a block update method are generated based on the computer code in-memory representation and the one or more variables.

Abstract: A device receives variants associated with a model generated in a graphical modeling environment, and determines a hierarchy of the variants based on a hierarchy of the model. The device receives mode information for the variants, where the mode information includes a subset of a number of variant permutations. For each mode, the device receives control variables for the variants and optional constraints for the variants in the mode. The control variables define which variants are active, and the optional constraints ensure modeling correctness by enabling identification of conflicts between the variants. The device generates a variant manager tool based on the hierarchy of the variants, the mode information, the control variables, and the optional constraints, and outputs or stores variant information via the variant manager tool.

Abstract: The present application is generally directed to mediums, methods, and systems for identifying and manipulating active code components. In exemplary embodiments, a user control interface is provided for displaying a source design which includes instructions in a preprocessor language and instructions in a source language. A resolvable preprocessor condition may be identified along with an instruction in the source language that is associated with the resolvable condition. The resolvable condition and the associated condition may be displayed, and the associated condition may be graphically indicated as controllable by the resolvable condition. A user may supply an input that provides a value for the resolvable condition. In some embodiments, instructions in the source language are displayed and, upon selection of one or more source language instructions by a user, a preprocessor condition that is associated with the selected source language instructions may be displayed.

Abstract: A device may receive information that identifies code included in a document provided via a programming environment. The code may include executable program code capable of being executed via the programming environment. The device may receive information that identifies non-code included in the document. The non-code may include information other than executable program code. The device may receive an indication to link a code portion, included in the code, and a non-code portion, included in the non-code, and may create a link between the code portion and the non-code portion based on receiving the indication. The device may provide, via a user interface, content included in the document. The content may include the code portion, the non-code portion, and other information included in the document. The device may provide, via the user interface, a link indicator that identifies the link between the code portion and the non-code portion.

Abstract: A method, performed by a computer device, may include selecting one or more input and output points in an executable graphical model in a modeling application and simulating the executable graphical model over a plurality of time points. The method may further include generating a time domain response plot for the executable graphical model based on the simulating; obtaining matrices of partial derivatives based no the selected one or more input and output points at particular time points of the plurality of time points; generating a frequency domain response plot for the executable graphical model based on the obtained matrices of partial derivatives; and generating a bidomain simulator user interface, the bidomain simulator user interface including the generated time domain response plot and the generated frequency domain response plot.

Abstract: A system and method evaluates power information for a high-level model to be implemented in target hardware, and performs one or more power-reducing transmutations on the model. Transmutations may include moving one or more components from a fast rate region to a slow rate region, reducing bit width of data, signals, or other values, and replacing multiple instances of a resource with a shared instance of the resource. An in-memory representation of the model may be generated that reduces the model to a plurality of core components. A power score evaluation engine may assign power scores to the core components. Power scores may be retrieved from one or more power score database. The power scores may be non-dimensional scores representing power consumption relationships among the core components, and be target independent. Hints or alerts regarding suggested changes to the model to optimize power consumption may be presented to a user. A revised model incorporating the suggested changes may be constructed.

Abstract: A computing device may be configured to interact with a requirement object using an object-based requirements framework. The computing device may further provide a design to the object-based requirements framework. The design may comply with design criteria of the object-based requirements framework. The computing device may also determine whether the design complies with the requirement object. The determining may be based on the interacting, and may produce a result.

Abstract: A cloud-based instrument driver system enables a user device to interact with one or more instruments through a remotely located driver cloud. The driver cloud may store drivers and ancillary software. The user device may be connected to each instrument either directly or indirectly, for example, over one or more computer networks, and may be connected to and communicate directly with the driver cloud over the computer network. However, the driver cloud and the instrument may not be in direct communication. The user device relays commands and responses to and from the instrument to the driver cloud for translation into a format suitable for processing by the user device. Utilization of the driver cloud obviates the need to obtain, install and maintain any drivers and/or ancillary software on the user device in order to enable the device to interact with the instrument.

Abstract: A self-describing function object may be dynamically created based on a set of user provided parameters. In an implementation, a device may receive a request to create the function object based on one or more parameters and determine a number of ordered and hierarchical operations that correspond to the function object. The device may determine textual descriptions corresponding to what is performed by at least one of the ordered and hierarchical operations. The device may output documentation of the ordered and hierarchical operations included in the function object, the documentation including the textual descriptions arranged based on the determined order of the plurality of ordered and hierarchical operations.

Abstract: A MAP decoder may be implemented in parallel. In one implementation, a device may receive an input array that represents received encoded data and calculate, in parallel, a series of transition matrices from the input array. The device may further calculate, in parallel, products of the cumulative products of the series of transition matrices and an initialization vector. The device may further calculate, in parallel and based on the products of the cumulative products of the series of transition matrices and the initialization vector, an output array that corresponds to a decoded version of the received encoded data in the input array.

Abstract: A modeling environment is provided allowing a user to generate, from a source representation of a model, a target representation of a model and a listing of the optimization performed during generation of the target representation which is associated with the target representation or the source representation. The model may represent a system, such as a dynamic system. The source representation of the model may be a graphical or textual representation. In some embodiments a user may specify whether to implement the optimization.

Abstract: A device may receive an indication to perform a performance evaluation on program code. The device may partition the program code into multiple program code portions based on receiving the indication to perform the performance evaluation. The device may execute a first program code portion of the multiple program code portions. The device may determine that the first program code portion has finished executing, and may determine a performance characteristic associated with execution of the first program code portion based on determining that the first program code portion has finished executing. The device may execute a second program code portion, of the multiple program code portions, and may provide information that identifies the performance characteristic while the second program code portion is being executed.

Abstract: A device, including one or more processors, may obtain program code, determine a group of variables based on the program code, execute the program code, determine values of the group of variables based on the executing of the program code, determine a dynamic range of a characteristic for each variable based on the values, generate a visualization that presents the dynamic range of the characteristic for the group of variables, and provide the visualization for display.

Abstract: The present invention provides a set of blocks for creating device drivers. Since, for most computational devices, device driver code to configure and control an I/O interface may be decomposed into a small finite number of common software functions, by providing a block set comprising blocks representing the finite number of common software functions, custom device drivers can be created for any number of devices. Thus, by providing a set of generalized device driver blocks that can be parameterized by the user, specific instances of custom device drivers can be created as needed. Processor and device specific driver code can then be generated from the custom device driver.