Krister Åhlander

On the Role of Mathematical Abstractions for Scientific Computing

A distinguished feature of scientific computing is the necessity to design software abstractions for approximations. The approximations are themselves abstractions of mathematical models, and the mathematical models are also abstractions of the real world.

Einstein summation for multidimensional arrays

Abstract One of the most common data structures, at least in scientific computing, is the multidimensional array. Some numerical algorithms may conveniently be expressed as a generalized matrix multiplication, which computes a multidimensional array from two other multidimensional arrays. By adopting index notation with the Einstein summation convention, an elegant tool for expressing generalized matrix multiplications is obtained. Index notation is the succinct and compact notation primarily used in tensor calculus. In this paper, we develop computer support for index notation as a domain specific language. Grammar and semantics are proposed, yielding an unambiguous interpretation algorithm. An object-oriented implementation of a C++ library that supports index notation is described. A key advantage with computer support of index notation is that the notational gap between a mathematical index notation algorithm and its implementation in a computer language is avoided. This facilitates program construction as well as program understanding. Program examples that demonstrate the close resemblance between code and the original mathematical formulation are presented.

Object-oriented construction of parallel PDE solvers

An object-oriented approach is taken to the problem of formulating portable, easy-to-modify PDE solvers for realistic problems in three space dimensions. The resulting software library, Cogito, contains tools for writing programs to be executed on MIMD computers with distributed memory. Difference methods on composite, structured grids are supported. Most of the Cogito classes have been implemented in Fortran 77, in such a way that the object-oriented design is visible. With respect to parallel performance, these tools yield code that is comparable to parallel solvers written in plain Fortran 77. The resulting programs can be executed without modifications on a large number of multicomputer platforms, and also on serial computers.

Supporting tensor symmetries in EinSum

Abstract Exploiting symmetries are important in numerical mathematics, both with respect to efficient memory usage and with respect to symmetry exploiting algorithms. In this paper, the symmetries of tensors are in focus. A convenient notation for describing coordinate-free tensor symmetries is established, based on sets of permutations. Completely symmetric and antisymmetric tensors are included as special cases. The extensions to multidimensional arrays with other kinds of symmetries or invariant features are also treated. The symmetry information is used to represent tensors with symmetries more economically with respect to memory. In addition, three algorithms that exploit symmetries are presented. First, a Frobenius norm computation is derived. Second, a projection to an index space with general symmetries is shown, and proven to be optimal in the Frobenius norm. Third, a symmetry utilizing formula for a dual mapping between completely antisymmetric index spaces is shown. The implementation of symmetry support in EinSum is discussed. EinSum is a C++ package primarily intended for tensor algebra, capable of supporting the Einstein summation convention. Details on the symmetry part of the implementation are explained. Code for the implementation of the Frobenius norm, the general projection, and the dual mapping is shown, illustrating how symmetry aware software may decrease both the memory usage and the number of arithmetic operations.

Object-oriented Modeling of Parallel PDE Solvers

This is a status report of a long-term research effort focusing on object-oriented modeling of parallel PDE solvers, based on finite difference methods on composite, structured grids. Two previous results of this effort are reviewed, the class libraries Cogito and Compose. Cogito is implemented in Fortran 90, with MPI for the message passing, and provides abstract data types for parallel composite-grid methods. Compose is in C++ and allows for fully object-oriented construction of PDE solvers by composition of objects. The object model behind Compose is described, and some research issues related to the refinement of the model are outlined. Finally, some recent results are presented, which are initial steps in addressing these issues.

Mesh generation for symmetrical geometries

Symmetries are not only fascinating, but they can also be exploited when designing numerical algorithms and data structures for scientific engineering problems in symmetrical domains. Geometrical symmetries are studied, particularly in the context of so called equivariant operators, which are relevant to a wide range of numerical applications. In these cases, it is possible to exploit the symmetry via the generalized Fourier transform, thereby considerably reducing not only storage requirement but also computational cost. The aim of this paper is to introduce group theoretical aspects of symmetry, to point out the benefits of using these concepts when designing numerical algorithms, and to state the implications for the generation of the mesh.

Computational database technology applied to option pricing via finite differences

Computational database technology spans the two research fields data-base technology and scientific computing. It involves development of database capabilities that support computational-intensive applications found in science and engineering. This includes support for representing and processing of mathematical models within the database environment without any significant performance loss compared to conventional implementations. This paper describes how an existing database management system, AMOS II, is extended with capabilities to solve the Black–Scholes equation commonly used in option pricing. The numerical method used is finite differences, and a flexible database framework that can deal with complex mathematical objects and numerical methods is created. We describe how computational data representations and operations are adapted to the database management system and the approach is evaluated with respect to performance, extensibility, and ease of use.

Towards an Expressive Language for PDE Solvers

Many significant real-life applications, e.g., air-craft design and environmental modelling, involve simulations based on the numerical solution of systems of time-dependent partial differential equations. In general, the computational domain has a complicated geometry, and the computations demand high-performance computers. The present paper lays a foundation for an expressive notation for this kind of application. By an object-oriented analysis concepts are identified, that can be combined flexibly enough to allow a programmer to express real computational problems (as opposed to model problems). The resulting concepts have been implemented as classes in C++. In a sense, this class library (referred to as Cogito/Solver) will specialize C++ into a language for the application domain under consideration. However, the aim is to use Cogito/Solver as a basis for higher-level interfaces. As a first attempt in this direction, an object-oriented database for Cogito/Solver objects has been implemented. Through an interface to this database, a programmer can compose an executable object (a Numerical Experiment), from various smaller objects, related to the different Cogito/Solver concepts.

Sorting out the relationships between pairs of iterators, values, and references

Motivated by a wish to sort an array A while simultaneously permuting another array B, iteration over array pairs (A,B) is considered. Traditional solutions to this problem require an adaption of either the algorithm or of the data structure. The generic programming approach described in this paper involves the construction of an iterator adaptor: an iterator pair. The different approaches are implemented in C++ and compared with respect to flexibility and performance. Our design is also compared with another iterator-based design. When examining our solution, we identify the relationship between a reference type and a value type as an independent abstraction. We find that a valid “reference type” to a value type T is not necessarily T&. The reference pair developed in this paper serves as an example of a reference type which refers to a standard value pair without being a standard reference. Our understanding of the relationships between iterator pairs, value pairs, and reference pairs, makes our design simpler than the alternative. It is argued that a recognition of these relationships is useful in many other generic programming contexts as well.

On object-oriented frameworks and coordinate free formulations of PDEs

Abstract. An object-oriented (OO) framework for Partial Differential Equations (PDEs) provides software abstractions for numerical simulation of PDEs. The design of such frameworks is not trivial, and the outcome of the design is highly dependent on which mathematical abstractions one chooses to support. In this paper, coordinate free abstractions for PDEs are advocated. The coordinate free formulation of a PDE hides the underlying coordinate system. Therefore, software based on these concepts has the prospect of being more modular, since the PDE formulation is separated from the representation of the coordinates. Use of coordinate free methods in two independent OO frameworks are presented, in order to exemplify the viability of the concepts. The described applications simulate seismic waves for various classes of rock models and the incompressible Navier-Stokes equations on curvi-linear grids, respectively. In both cases, the possibility to express the equations in a domain independent fashion is crucial. Similarities and differences between the two coordinate free frameworks are discussed. A number of places where such frameworks should be designed for modification is identified. This identification is of interest both for framework developers and for tentative framework users.