The Mathworks, Inc.

Frederick Mattsson Smith

Yao Ren

John Elliott

Alexander Jean-Claude Bottema

Martin Clark

Ricardo A Losada

Denis Gurchenkov

Takshak Desai

Ji W Lee

Alexander J Von Alt

Irwin H Kwan

Arnab De

A user interface may display visual traces between semantic constructs in representations of functionality. The representations of functionality may include textual programming language code, graphical programming language code, graphical or textual models, and/or text. The visual trace enables a party to visually review the correlations between the semantic constructs. The visual trace may include unique visual cues for distinguishing a degree of nesting of programming language constructs. For example, each successive level of nesting of a programming language construct may be associated with a different shade of a color. The user interface may be interactive and provide real-time feedback based upon actions of a party. The system determines what semantic constructs are to be visually distinguished on the user interface based on the location of an action and based on the hierarchy of semantic constructs and correlations.

Determining and providing correlations between semantic constructs in a representation of functionality and semantic constructs in another representation of functionality

Described are methods, systems and computer-readable media storing instructions that when executed on one or more processors execute a process for generating second program code in a statically typed programming language from first program code in a dynamically typed programming language. The first program code contains or, when executed, generates or operates on a dynamically typed array. The second program code may be generated by classifying the dynamically typed array into one of multiple categories, such as homogeneous, heterogeneous, or another, based on the array contents, array usage, and/or user input, and generating the second program code in the statically typed programming language based on the classification(s).

Generating code in statically typed programming languages for dynamically typed array-based language

Exemplary embodiments enable debugging executable code using a debugger in a computational device that provides a programming environment including a presentation layer. For example, an exemplary method includes providing a first marshalling function that receives a portion of information manipulated by the executable code and produces a presentation layer representation of the portion of the information. The presentation layer representation is compatible with a debugger that debugs the executable code. An exemplary method also includes debugging the executable code to produce a presentation layer representation of the portion of the information with the first marshalling function so as to display the presentation layer representation of the portion of the information to a user via a display device. The debugging also includes modifying the presentation layer representation of the portion of the information to produce modified information for use by the executable code, a device, or a user.

Debugging using presentation layer representations of objects

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.

Code evaluation of fixed-point math in the presence of customizable fixed-point typing rules

Disclosed herein are methods and compilers for compiling code. The methods and compilers disclosed can compile a callable compilable unit of code free of declarations and assertions that identify attributes of arguments expressed therein. The attributes of the arguments in the callable compilable unit of code are inferred by the compilers and methods disclosed herein from information provided by a call site that calls a compiler to compile the callable compilable unit of code.

Inferring data types from compiler call site

Methods, systems and computer program products are provided for creating and compiling source program code using one or more compiler directives a programming environment. The compiler directives may provide information on how to compile the source program code. The compiler directives may apply to the source program code under a given condition. The compiler directive may appear at the second or lower level of the source program code. The present invention may also provide a compiler that can determine the given condition of the source program code and apply the compiler directives based upon the determination of the given condition.

Growing community of inventors

Natick, MA, United States of America

Frederick Mattsson Smith