Peter Fritzson

Modelica - A Unified Object-Oriented Language for System Modelling and Simulation

A new language called Modelica for hierarchical physical modeling is developed through an international effort. Modelica 1.0 [http:// www.Dynasim.se/Modelica] was announced in September 1997. It is an object-oriented language for modeling of physical systems for the purpose of efficient simulation. The language unifies and generalizes previous object-oriented modeling languages. Compared with the widespread simulation languages available today this language offers three important advances: 1) non-causal modeling based on differential and algebraic equations; 2) multidomain modeling capability, i.e. it is possible to combine electrical, mechanical, thermodynamic, hydraulic etc. model components within the same application model; 3) a general type system that unifies object-orientation, multiple inheritance, and templates within a single class construct.

Heart sound analysis for symptom detection and computer-aided diagnosis

Heart auscultation (the interpretation by a physician of heart sounds) is a fundamental component of cardiac diagnosis. It is, however, a difficult skill to acquire. In this work, we develop a simple model for the production of heart sounds, and demonstrate its utility in identifying features useful in diagnosis. We then present a prototype system intended to aid in heart sound analysis. Based on a wavelet decomposition of the sounds and a neural network-based classifier, heart sounds are associated with likely underlying pathologies. Preliminary results promise a system that is both accurate and robust, while remaining simple enough to be implemented at low cost.

Modelica - a general object-oriented language for continuous and discrete-event system modeling and simulation

Modelica is a general equation-based object-oriented language for continuous and discrete-event modeling of physical systems for the purpose of efficient simulation. The language unifies and generalizes previous object-oriented modeling languages. It is bringing about a revolution in this area, based on its ease of use, visual design of models with combination of Lego-like predefined model building blocks, its ability to define model libraries with re-usable components and its support for modeling and simulation of complex applications involving parts from several application domains. In this paper we present the Modelica language with emphasis on its language features and one of the associated simulation environments. Simulation models can be developed in an integrated problem-solving environment by using a graphical editor for connection diagrams. Connections are established just by drawing lines between objects picked from a class library. The principles of object oriented physical systems modeling and the multi-domain capabilities of the language are presented in the paper by several examples.

Lossless compression of high-volume numerical data from simulations

Summary form only given. We propose a lossless algorithm of delta compression (a variant of predictive coding) that attempts to predict the next point from previous points using higher-order polynomial extrapolation. In contrast to traditional predictive coding our method takes into account varying (non-equidistant) domain (typically, time) steps. To save space and guarantee lossless compression, the actual and predicted values are converted to 64-bit integers. The residual (difference between actual and predicted values) is computed as difference of integers. The unnecessary bits of the residual are truncated, e.g., 1111110101 is replaced by 10101. The length of the bit sequence (5/sub 10/=(000101)/sub 2/) is prepended.

Generalized algorithmic debugging and testing

This paper presents a method for semi-automatic bug localization, generalized algorithmic debugging, which has been integrated with the category partition method for functional testing. In this way the efficiency of the algorithmic debugging method for bug localization can be improved by using test specifications and test results. The long-range goal of this work is a semi-automatic debugging and testing system which can be used during large-scale program development of nontrivial programs. The method is generally applicable to procedural langua ges and is not dependent on any ad hoc assumptions regarding the subject program. The original form of algorithmic debugging, introduced by Shapiro, was however limited to small Prolog programs without side-effects, but has later been generalized to concurrent logic programming languages. Another drawback of the original method is the large number of interactions with the user during bug localization. To our knowledge, this is the first method which uses category partition testing to improve the bug localization properties of algorithmic debugging. The method can avoid irrelevant questions to the programmer by categorizing input parameters and then match these against test cases in the test database. Additionally, we use program slicing, a data flow analysis technique, to dynamically compute which parts of the program are relevant for the search, thus further improving bug localization. We believe that this is the first generalization of algorithmic debugging for programs with side-effects written in imperative languages such as Pascal. These improvements together makes it more feasible to debug larger programs. However, additional improvements are needed to make it handle pointer-related side-effects and concurrent Pascal programs. A prototype generalized algorithmic debugger for a Pascal subset without pointer side-effects and a test case generator for application programs in Pascal, C, dBase, and LOTUS have been implemented.

Algorithmic debugging for lazy functional languages

Lazy functional languages are declarative and allow the programmer to write programs where operational issues such as the evaluation order are left implicit. It is desirable to maintain a declarative view also during debugging so as to avoid burdening the programmer with operational details, for example concerning the actual evaluation order which tends to be difficult to follow. Conventional debugging techniques focus on the operational behaviour of a program and thus do not constitute a suitable foundation for a general-purpose debugger for lazy functional languages. Yet, the only readily available, general-purpose debugging tools for this class of languages are simple, operational tracers. This thesis presents a technique for debugging lazy functional programs declaratively and an efficient implementation of a declarative debugger for a large subset of Haskell. As far as we know, this is the first implementation of such a debugger which is sufficiently efficient to be useful in practice. Our approach is to construct a declarative trace which hides the operational details, and then use this as the input to a declarative (in our case algorithmic) debugger. The main contributions of this thesis are: A basis for declarative debugging of lazy functional programs is developed in the form of a trace which hides operational details. We call this kind of trace the Evaluation Dependence Tree (EDT). We show how to construct EDTs efficiently in the context of implementations of lazy functional languages based on graph reduction. Our implementation shows that the time penalty for tracing is modest, and that the space cost can be kept below a user definable limit by storing one portion of the EDT at a time. Techniques for reducing the size of the EDT are developed based on declaring modules to be trusted and designating certain functions as starting-points for tracing. We show how to support source-level debugging within our framework. A large subset of Haskell is handled, including list comprehensions. Language implementations are discussed from a debugging perspective, in particular what kind of support a debugger needs from the compiler and the run-time system. We present a working reference implementation consisting of a compiler for a large subset of Haskell and an algorithmic debugger. The compiler generates fairly good code, also when a program is compiled for debugging, and the resource consumption during debugging is modest. The system thus demonstrates the feasibility of our approach

Interprocedural dynamic slicing applied to interprocedural data flow testing

During the past ten years several variants of an analysis technique called program slicing have been developed. Program slicing has applications in maintenance tasks such as debugging, testing, program integration, program verification, etc. and can be characterized as a type of dependence analysis. A program slice can loosely be defined as the subset of a program needed to compute a certain variable value at a certain program position. A novel method for interprocedural dynamic slicing which is more precise than interprocedural static slicing methods and is useful for dependence analysis at the procedural abstraction level was given by M. Kamkar et al. (1992, 1993). It is demonstrated here how interprocedural dynamic slicing can be used to increase the reliability and precision of interprocedural data flow testing. The work on data flow testing reported by E. Duesterwald et al. (1992), which is a novel method for data flow testing through output influences, is generalized.<<ETX>>

Interprocedural Dynamic Slicing

This paper presents the first algorithm for interprocedural dynamic slicing. Previous methods for dynamic slicing only considered languages without procedures and procedure calls. This method generates summary information for each procedure call and represents a program as a summary graph of dynamic dependencies. A slice on this graph consists of nodes for all procedure calls of the program that affect the value of a given variable. The size of the information saved by this method is considerably smaller than what is needed by previous methods for dynamic slicing [AH90], since it only depends on the size of the programs execution tree, i.e. the number of executed procedure calls, which is much smaller than the size of a trace of all executed statements. In addition, work space for the temporary graph is needed, proportional to the maximum sum of the sizes of simultaneously active procedures. A program slice can be produced from the interprocedural slice on the graph if a suitable definition of control dependency is used when the summary graph is constructed. The interprocedural dynamic slicing introduced in this paper is being used to improve the bug localization properties of the Generalized Algorithmic Debugging Technique [FGKS91], a method for declarative semi-automatic debugging.

High-level mathematical modeling and programming

Scientific computing and advanced mechanical analysis demand high-level support for modeling and solving complex equations. To meet this need, the authors designed ObjectMath and applied it to real problems in machine-element analysis. >

OpenModelica - A free open-source environment for system modeling, simulation, and teaching

Modelica is a modern, strongly typed, declarative, and object-oriented language for modeling and simulation of complex systems. This paper gives a quick overview of some aspects of the OpenModelica environment - an open-source environment for modeling, simulation, and development of Modelica applications. An introduction of the objectives of the environment is given, an overview of the architecture is outlined and a number of examples are illustrated.