Andre Vehreschild

Combining source transformation and operator overloading techniques to compute derivatives for MATLAB programs

Derivatives of mathematical functions play a key role in various areas of numerical and technical computing. Many of these computations are done in MATLAB, a popular environment for technical computing providing engineers and scientists with capabilities for mathematical computing, analysis, visualization, and algorithmic development. For functions written in the MATLAB language, a novel software tool is proposed to automatically transform a given MATLAB program into another MATLAB program capable of computing not only the original function but also user-specified derivatives of that function. That is, a program transformation known as automatic differentiation is performed to change the semantics of the program in a fashion based on the chain rule of differential calculus. The crucial ingredient of the tool is a combination of source-to-source transformation and operator overloading. The overall design of the tool is described and numerical experiments are reported demonstrating the efficiency of the resulting code for a sample problem.

A Macro Language for Derivative Definition in ADiMat

Any automatic differentiation tool for MATLAB needs to cope with the large number of functions provided by the toolboxes. For many of these functions, derivatives have to be defined. A powerful macro language for the derivative definition, embedded in the source transformation tool ADiMat, is introduced. The macro language consists of a part where the signature of a function is matched and another part specifying the derivative of that function. Several examples illustrate the expressiveness and use of the macro language. A subset of the macro language is available to the user of ADiMat to improve the performance of the generated derivative code by exploiting high-level structure.

Automatic generation of parallel code for Hessian computations

Given a program to compute some function, automatic differentiation can be used to mechanically generate another program capable of evaluating first- and higher-order derivatives of that function. A new strategy for the computation of Hessians by automatic differentiation is proposed where the generated code is automatically parallelized using OpenMP. The approach is applied to compute second-order derivatives of an atmospheric reference model and performance results on a Sun Fire E6900 system are reported.

Code Optimization Techniques in Source Transformations for Interpreted Languages

A common approach to implement automatic differentiation (AD) is based on source-to-source transformation. In contrast to the standard case in mathematical software that is concerned with compiled languages, AD for interpreted languages is considered. Here, techniques to improve code performance are introduced in transformations on a high-level rather than by an optimizing compiler carrying out these transformations on a lower-level intermediate representation. The languages MATLAB and CapeML are taken as examples to demonstrate these issues and quantify performance differences of codes generated by the AD tools ADiMat and ADiCape using the five code optimization techniques constant folding, loop unrolling, constant propagation, forward substitution, and common subexpression elimination.

Threads in an Undergraduate Course: A Java Example Illuminating Different Multithreading Approaches

Multithreading is a fundamental approach to expressing parallelism in programs. Since Java is emerging as the de facto standard language for platform independent software development in higher education, there is need for teaching multithreading in the context of Java. We use a simple problem from scientific computing to explain two different multithreading approaches to second-year students. More precisely, a simple boundary value problem is considered, which makes visible the differences between native Java threads and the OpenMP interface. So, the students are able to appreciate the respective merits and drawbacks of a thread package that is integrated into the Java programming language and an approach combining compiler support with library calls.

A system for interfacing MATLAB with external software geared toward automatic differentiation

MATLAB is commonly considered to be an attractive, high-productivity programming environment by many computational scientists and engineers. So-called MEX-files are dynamically linked subroutines produced from, say, C or Fortran source code that, when compiled, can be run directly from within MATLAB as if they were MATLAB built-in functions. When applying automatic differentiation to a MATLAB program that calls external software via MEX-files, code is mechanically generated for the MATLAB part and for the external part in two separate phases. These resulting code fragments need to be put together via new MEX-files. This work introduces a novel software tool called automatic differentiation mexfunction generator that automatically generates MEX interface functions for gluing these automatically generated code fragments.

Coping with a Variable Number of Arguments when Transforming MATLAB Programs

The programming language MATLAB supports default values for arguments as well as argument lists of variable length. This work analyzes the effects of these two language concepts on the design of source transformation tools for automatic differentiation. The term automatic differentiation refers to a collection of techniques to augment a given computer code with statements for the computation of user-specified derivatives. The focus here is on the source transformation tool ADiMat implementing automatic differentiation for programs written in MATLAB. The approach taken by ADiMat to cope with default arguments and argument lists of variable length is described. Implementation techniques and remaining open questions are discussed.

Tangent-Linear models by augmented LL-Parsers

We describe a novel method for the generation of tangent-linear code by augmentation of LL-parsers generated by the software tool ANTLR. The main advantage of this approach to source code augmentation is the missing requirement for an internal representation of the original program. We consider this work as the basis for further investigations into how far this technique can be extended in the context of more sophisticated transformations, for example, the automatic generation of adjoint codes. Our prototype tool AD_C_ANTLR currently accepts a subset of the ANSI C standard. We discuss its theoretical basis, and we present a case study to underline the elegance of the parser-based approach to source augmentation.