Abstract: A device receives code generated via a technical computing environment (TCE), performs a test on the code to generate a test result, and generates test information based on the performance of the test on the code. The device outputs or stores the test result, and receives, based on the test result, a request for a diagnostic analysis of the code. The device performs, based on the request, the test information, and at least one diagnostic, a diagnostic analysis of the code to generate a diagnostic result, and outputs or stores the diagnostic result.

Abstract: The described embodiments present techniques for recovering from syntax errors. These techniques correct potential errors while preserving the shape of the parse tree, and the specific implementation of the techniques can be automatically generated from the grammar. These techniques may operate by looking back at states associated with previously-received tokens to determine pair matching status, when a synchronizing symbol is received. The techniques can respond to the pair matching status determination by potentially adding a synthesized token or by deleting a token that has already been received. The techniques may use a structure referred to herein as a tuple to assist with the evaluation of the pair matching status. Some of the techniques utilize indentation information to evaluate the pair matching status, while other techniques ignore such information. The described embodiments also include a technique for automatically generating the tuples from a set of grammar rules associated with the parser.

Abstract: A system and method of exposing debugging information in a graphical modeling and execution environment is disclosed. The present invention allows a user to view debugging information in the same window as the graphical view of the model being executed. Debugging data is associated with relevant components of the model displayed in the graphical view. A separate execution list view shows the methods called during the execution of the block diagram in the current time step up until the current point in execution. User-set breakpoints and conditional breakpoints may be set in both the model view and the execution list view. Values may be obtained for all of the displayed methods. The debugging tool may be implemented by using it in conjunction with a graphical modeling and execution environment, such as a block diagram environment or state diagram environment.

Abstract: A system and method determines the differences between versions of an object, such as a file. The object versions are compared using a differencing tool to identify the differences between the versions. A scoring algorithm may be selected for the object based on one or more attributes of the object. The scoring algorithm is used to compute a difference score for the object. The difference score may be a function of the differences between the object versions and the characteristics or qualities of those differences. The difference score provides an indication of the relative importance of the changes made to the object. The difference scores from multiple objects may be presented in an interactive report, and sorted to identify those objects that underwent the most significant or noteworthy changes.

Abstract: In an embodiment of the invention, one or more tangible non-transitory computer-readable storage media may store the following instructions. Defining representation type spaces R1 and R2 and correctness type spaces C1 and C2 over the representation type spaces R1 and R2, respectively. Defining a representation type space R and a correctness type space C over the representation type space R, such that a semilattice associated with the correctness type space C is a function semilattice over respective semilattices associated with the correctness type spaces C1 and C2.

Abstract: Exemplary embodiments provide an interactive tool that allows users to design and evaluate storage mechanisms while program code executes. For example, an embodiment uses compact histogram density scales (CHDS's) to display count information for bins making up the storage mechanism (e.g., a register). The user can determine whether counts are within a desirable range, exceeding an overflow threshold, or exceeding an underflow threshold for a bin. Embodiments allow the user to observe overflow/underflow thresholds, signedness, word lengths, fraction lengths, etc., while program code that interacts with the register executes.

Abstract: A device receives a search query, and transforms the search query into a transformed search query understood by a technical computing environment (TCE)-based search engine. The device determines information requested by the transformed search query, and selects one or more TCE models from a repository based on the information requested by the transformed search query. The device provides the information requested by the transformed search query to the selected one or more TCE models. The device executes the selected one or more TCE models, based on the information requested by the transformed search query, to generate an answer to the search query, and provides the answer for display.

Abstract: A device receives a model that includes blocks and lines provided between the blocks, and identifies first candidate boundaries for the model. Each of the first candidate boundaries defines a group of blocks. The device generates an intermediate representation (IR) of the model, performs an optimization of the IR to generate an optimized IR, and identifies second candidate boundaries for the model based on the optimized IR. Each of the second candidate boundaries defines a group of blocks, and the first and second candidate boundaries define a set of candidate boundaries. The device reduces the set of candidate boundaries, to a reduced set of boundaries, based on code efficiency metrics or metrics associated with a hardware platform. The device generates code for the model based on the reduced set of boundaries, and outputs the code.

Abstract: A device receives code in a modeling environment format, receives a model in the modeling environment format, and receives relationships information associated with one or more relationships between the code and the model. The device combines the code, the model, and the relationships information to generate an output file in a non-modeling environment format, and outputs or stores the output file.

Abstract: A system for facilitating system design includes a back-annotation tool that annotates a model of a hardware system with information derived from results of synthesizing the model to the target hardware description. The derived information may include timing information, information about area usage, power consumption, etc. The derived information may be displayed in conjunction with the model in a modeling environment.

Abstract: In one embodiment, a method for displaying elements of an attribute in an executable block diagram model is provided. The method may include displaying an executable block diagram model in a first window and receiving a first input from an input device, wherein the first input associates with a first parameter of a block diagram modeling component in the executable block diagram model, the first parameter is represented in the executable block diagram model by a first graphical affordances. The method may include triggering the display of a value of a first parameter in a first user interface widget in the first window.

Abstract: In an illustrative embodiment, an apparatus, computer-readable medium, or method may be configured to avoid command mistakes and suggest corrections. Known commands may be accessed which may include at least one expected identifier, alternative identifier, and/or identifier pattern. The frequencies of occurrence of the known commands may be calculated. A command with entered identifiers may be received and at least one possible mistake in the entered identifiers may be detected. A first numerical score for the known commands may be calculated using a string matching algorithm, a keystroke penalty matrix, and/or the detected at least one possible mistake. A second numerical score may be calculated using the frequencies of occurrence of the known commands and the first numerical score. Expected identifiers may be selected using the first and second numerical scores. A user-selectable command may be created using the expected known commands and displayed.

Abstract: A virtual driver interface and strategy are presented for interfacing a device driver with an application. Devices connected to a computing device and device drivers capable of communicating with the device are provided on the computing device. The virtual driver interface determines which of the device drivers to use to allow an application to interact with a device based on a strategy.

Abstract: A device performs a verification analysis of source code, where the verification analysis includes a coding rules check of the source code based on coding standards, and run-time error check of the source code. The device provides, for display, results of the coding rules check of the source code, and provides, for display, results of the run-time error check of the source code. The device provides, for display, from the results of the coding rules check of the source code, at least one of a coding rule error violation associated with the source code, or a coding rule warning violation associated with the source code.

Abstract: Systems and methods are provided for using partial evaluation techniques to efficiently generate code for a fixed-point operation. The present invention uses partial evaluation techniques to evaluate a fixed-point rule of a fixed-point operation. The fixed-point rules, which may be customized by a user, determine the data type of the result or output of the operation. Although the values of all the inputs may not be known at code generation time, the present invention determines via static or known information associated with the input the portion of the fixed-point rule known at code generation time. As such, the present invention can generate more efficient code by generating code representing the static analysis of the inputs and fixed-point typing rules of the fixed-point operation.

Abstract: Blocks in a graphical model of a system may be assigned aliases. A user may interact with the aliases. In one implementation, a method may include displaying the alias in a view of the model that does not include the block associated with the alias and modifying, in response to user interaction with the alias, a graphical view of the model or properties of the block associated with the alias.

Abstract: A device may obtain first program code, and may cause the first program code to be executed. The device may determine a first execution state generated based on causing the first program code to be executed. The device may store the first execution state. The device may obtain second program code that includes a modification to the first program code, and may cause the second program code to be executed. The device may determine a second execution state generated based on causing the second program code to be executed. The device may store the second execution state. The device may receive an indication to restore the first execution state, and may restore the first execution state based on receiving the indication.

Abstract: A device is configured to determine a contour vector that delineates an object in an image from a remaining portion of the image, and to generate a hash value by applying a hash function to the contour vector. The device is configured to compare the hash value to a previous hash value generated by applying the hash function to a previous contour vector, where the previous contour vector is determined prior to determining the contour vector. The device is configured to determine that the hash value matches the previous hash value and, based on determining that the hash value matches the previous hash value, segment the image using the contour vector.

Abstract: A graphical user interface for an interactive concurrent computing environment is discussed. The graphical interface conveys the concurrent nature of the computing environment and allows a user to monitor the status of the concurrent process being executed. The graphical interface may indicate the status of the process, the status of the various computing units of the process, or the status of groups of computing units. This allows the user to monitor the concurrent process as the process is executing including whether or not computing units of the concurrent process are idle, busy or stopped.

Abstract: A device may partition program code into multiple portions. The device may detect a first modification to a first portion of program code from a first version to a second version, and may detect a second modification to a second portion of program code from a third version to a fourth version. The device may detect the second modification after detecting the first modification. The device may store a first version history that identifies the first version, the second version, and a first temporal relationship between the first and second versions. The device may store a second version history that identifies the third version, the fourth version, and a second temporal relationship between the third and fourth versions. The device may receive an indication to undo the first modification after detecting the second modification, and may undo the first modification, without undoing the second modification, based on receiving the indication.