PASCAL-XSC

A Report on Basic Concepts and Current Development of the Language

Peter Januschke

Institute of Applied Mathematics, University of Karlsruhe Kaiserstrasse 12, D–76128 Karlsruhe, Federal Republic of Germany Internet: ae24@rz.uni-karlsruhe.de

December 6, 1993

Abstract

The programming language PASCAL–XSC has been designed as a powerful and easy to handle programming tool. It offers the user a lot of facilities to implement sophisticated numerical algorithms. PASCAL–XSC also is an ideal programming language to teach students modern programming concepts.

PASCAL–XSC provides a large number of predefined data types and operators for elements of the most commonly used spaces in numerical analysis. All operators deliver a result of maximum accuracy and the rounding mode of each operation may be controlled by the user. Additionally, the scalar product of two vectors can be computed accurately and the floating point result of this operation can be obtained by applying only one final rounding.

Further characteristics of PASCAL–XSC include dynamic arrays and strings, functions with arbitrary result type, user defined operators and overloading of assignment, operators, functions and procedures. Moreover, PASCAL–XSC supports implementing libraries and splitting large programs into smaller units by means of modules.

The concept of dynamic arrays has been significantly extended. A user now is allowed to allocate a dynamic array variable several times and with different size during the execution of the subprogram which contains its declaration. Moreover, dynamic arrays may now be declared as components of other PASCAL structures such as records, static arrays, or pointers.

1 Introduction

The implementation of numerical algorithms which compute reliable results requires a precise definition of the underlying arithmetic. Every operation should be of highest accuracy, i.e. it should be defined by means of a semimorphism (see [13]). Furthermore, a programming language should facilitate the direct use of operations and the control of the computation^{1}. Additionally, data types and operations for elements of commonly used sets in numerical algorithms should be available. Since none of the commonly used programming languages meets these conditions, the PASCAL–XSC system has been developed. The first part of this article presents the main features of PASCAL–XSC and the PASCAL–XSC development system. Due to the fact that these were the subject of several talks and publications in the past, I give a summary of features here rather than a detailed description. The second part of the article describes the extension to the concept of dynamic arrays. Up to now, the size of a dynamic array^{2} declared locally in a subprogram could not be changed within the statement part of that subprogram. Future releases of PASCAL–XSC will allow this operation. The user will have the possibility of allocation and deallocation of dynamic arrays within a program. This article describes the new syntax and the semantics for dynamic arrays. It should be regarded as a supplement to the PASCAL–XSC Language Reference [10].

2 The PASCAL–XSC System

This section gives an overview about the components of the PASCAL–XSC system. The first part summarizes the features of the language while the second part is about the development system and its availability.

2.1 Language Features

PASCAL–XSC ist an e\underline{X}tension of the programming language PASCAL for \underline{S}cientific \underline{C}omputation. The following list gives a summary of the language features. A more detailed description can be found in [5] and, of course, in [10].

• Standard PASCAL

With some minor exceptions, PASCAL–XSC complies with the ISO Standard for PASCAL [8]. Most of the few deviations arise from the fact that PASCAL–XSC compilers generate C programs from PASCAL sources and that particular PASCAL constructs can not be mapped to C efficiently. For example, a goto statement may not leave the immediately surrounding block. See [14] for a complete description of the deviations.

1e.g. rounding modes

2i.e. the number of its elements

• Operator Concept (User-defined Operators)

The possibility of defining operators for arbitrary data types allows the user to represent a mathematical formula in a PASCAL–XSC program by transcribing the mathematical notation. Thus the use of operators simplifies the development and increases the readability of programs.

Example:

Compute the expression z := u + v + w, where u, v, w and z are binary numbers^{3}.

With the declarations

  CONST max_digits = 32;
  TYPE  binary = ARRAY[ 1 .. max_digits ] OF 0 .. 1;
  VAR   u, v, w, z : binary;
  OPERATOR + ( a, b : binary ) addbb : binary;
  VAR i, c : INTEGER;
  BEGIN
    c := 0;
    FOR i := 1 TO max_digits DO
    BEGIN
      c := a[ i ] + b[ i ] + c;
      addbb[ i ] :=  c MOD 2;
      c := c DIV 2
    END
  END;

we are able to write the following assignment statement:

  z := u + v + w;

• Functions and Operators with Arbitrary Result Type

Standard PASCAL only allows functions with scalar data types^{4} as their result type. As the above example of an operator declaration shows, the result of a function or an operator in PASCAL–XSC may also have a composite data type, such as a set, an array, or a record.

3For simplification, we assume that no overflow will occur 4Integers, floating-point numbers, pointers etc.

• Overloading of Subroutines

The operator + for binary arithmetic^{5} can be invoked by using the same notation as for the PASCAL operator + for addition of integer and floating-point numbers. This is possible because PASCAL–XSC allows overloading of operators as well as overloading of functions or procedures. Subroutines may be declared with the same subroutine name (or operator symbol) as existing or predefined subroutines. A PASCAL–XSC compiler distinguishes overloaded subroutines by the number and type of their parameters.

• Overloading of the Assignment Operator

Example:

  TYPE COMPLEX = RECORD re, im : REAL END;
  VAR z : COMPLEX;
  OPERATOR := ( VAR a : COMPLEX; b : REAL );
  BEGIN
    a.re := b;
    a.im := 0
  END;
  {usage}
  z := 1.25;

• Overloading of READ and WRITE

The standard I/O procedures READ and WRITE may also be overloaded. The usual syntax can be used to call the user-defined I/O procedures.

Example:

  TYPE mytype = ... { user-defined data type }
  VAR  a, c : INTEGER;
       b    : mytype;
  PROCEDURE WRITE( VAR f : TEXT; x : mytype; width : INTEGER );
     { specify output of x to f here }
  {usage}
     WRITE( a, b : 10, c );

5See the example above

• Module Concept

Three new keywords module, global, and use have been added to the PASCAL language to permit the use of modules in PASCAL–XSC. module has to be used instead of program to declare a piece of program not to be directly executable but importable by another program or module. Within a module, entities that should be usable by programs or modules that import this module have to be marked with a preceding global at the point of their declararation.

Example:

  MODULE my_mod;
  GLOBAL TYPE my_type = ARRAY[ 1 .. 10 ] OF INTEGER;
  {further declarations}
  END.

Modules can be imported by programs or other modules by using the use keyword followed by the name of a module or a list of module names. Any entitity that has been marked with the global keyword in an imported module is then usable within the importing program or module.

Example:

  PROGRAM my_prog;
  USE my_mod;
  VAR my_var : my_type;
   ...

• Dynamic Arrays

Dynamic Arrays allow the user to declare dynamic entities within subprograms. They are extensively described in section 3.

• String Concept

A new data type STRING and some string handling subroutines have been added to the PASCAL language to facilitate text processing.

• Controlled Rounding

The rounding mode of any of the predefined arithmetic operators and the calculation of scalar products in PASCAL–XSC can be controlled by the user. When specifying the usual operator symbols +, −, ∗, or / in an expression the corresponding operation carries out rounding to the nearest floating-point number. If the operator symbol is followed by <, rounding towards −∞ is used. If it is followed by >, rounding towards +∞ is used. Scalar product computations can be handled in a similar way while interval operations always compute the smallest enclosure of the mathematically correct result.

• Optimal Scalar Product

As I stated before, optimal matrix and vector arithmetic requires the calculation of the exact value of a scalar product. This operation is available in PASCAL–XSC by means of so-called sharp expressions (#-expressions, see next point).

• Exact Evaluation of Expressions (#-Expressions)

A new data type DOTPRECISION has been added to the PASCAL language. Variables of type DOTPRECISION can hold the exact value of a dot product. Due to the fact that a scalar product may be computed in an accumulative way DOT-PRECISION variables are often called long accumulators. DOTPRECISION values are computed by sharp expressions. A sharp expression is always introduced by the symbol # which is followed by an optional rounding mode symbol and an expression that can be computed as a scalar product, enclosed in brackets.

Example:

  #<( a * b - c * d )

• Additional arithmetic standard Types

Numerical algorithms are formulated not only for real numbers but also for complex numbers, intervals, complex intervals, and vectors and matrices over these sets. PASCAL–XSC provides standard data types for elements of each of these spaces.

• Highly accurate Arithmetic for all standard Types

• Highly accurate standard Functions

2.2 The PASCAL–XSC system

A main goal for the design of the PASCAL–XSC system was to create a highly portable system (see [1]). Therefore, the implementation of the whole PASCAL–XSC package, in particular of the compiler and the runtime library, was based on ANSI C [2]. The compiler translates PASCAL–XSC programs into C programs which then are compiled to an executable program by an ANSI C compliant compiler. The availability of such a compiler is the only requirement for the installation of the PASCAL–XSC system on a given platform. Besides, the arithmetic has been based on the IEEE 754 standard for floating-point arithmetic [3]. Thus PASCAL–XSC programs produce the same results on any platform, which means that programs written in PASCAL–XSC are portable too. For example, a program may be developed and tested on a small computer (PC) and then run on a so-called supercomputer. A PASCAL–XSC development system includes a configuration program, a manager program that controls the compilation steps, a PASCAL–XSC to C compiler, a listing generator and a runtime library. Additionally precompiled arithmetic modules for basic types, as there are intervals, complex numbers, and complex intervals, as well as modules for vectors and matrices with components of any basic type (including real numbers) belong to a complete system. Each module provides arithmetic and relational operators as well as standard and transfer functions for one of the standard data types of PASCAL–XSC. PASCAL–XSC already has been ported to various platforms. The latest release is PASCAL–XSC version 2.03, released in October 1992. The following table gives a summary of the available versions. It is an update of a table given in [5].

Computer  Operating system  C compiler  Hardware support
IBM PC  DOS  Microsoft C 7.0  yes
IBM PC  DOS  Borland C++ 3.1  yes
IBM PC  DOS  Zortech C 3.0  yes
IBM PC  OS/2 2.0  IBM C Set/2
Atari ST  TOS( Gulam shell )  Turbo C 2.0
Sun SPARC station Sun OS 4.1, Solaris  System  yes
Micro VAX station  ULTRIX  System
DEC Station 3100  ULTRIX  System
IBM PS/2  AIX  System
IBM RS 6000  AIX  System
HP 9000/300 series  HP UX  System
HP 9000/800 series  HP UX  System
HP 9000/700 series  HP UX  System  yes
NeXT  UNIX  System
CONVEX  UNIX  System
VAX  VMS  System
Transputer T800  HELIOS  System
Data General  ULTRIX  System

Table 1: Availability of the PASCAL–XSC system

3 New features of Dynamic Arrays

This section describes the concept of dynamic arrays. First, a summary of the present concept (see [10]) is given. After that the new features are discussed. For this article is intended to be a supplement to the Language Reference [10], I use the same notation than the latter for describing the syntax of the new constructs. It is a simplified Backus-Naur-Form which looks similar to usual program code. Syntax descriptions are marked by a vertical black bar at the left margin. The representation of the syntax consists of

• basic symbols in their usual notation. Keywords are written in boldface letters,

• syntax variables,

• predefined identifiers,

• repetition symbols …, and

• comments enclosed in braces { }.

Syntax variables are English nouns or composite nouns which are used as abbreviations of other syntactical units. Predefined identifiers are written in slanted characters. The repetition symbol … denotes an arbitrary number of a part of the syntax, i.e. the preceding group of language elements within the same line. This group may occur zero or more times if no comment to the contrary is given. To generate PASCAL code by means of this syntax representation, we have to read line after line from left to right and note the basic symbols and the syntax variables in the appropriate number of repetitions. Then we must successively replace the syntax variables by their own definitions to eliminate them. This process ends when all syntax variables are eliminated. Example: Syntax description of an expression.

MonadicOperator

Operand { not empty }
DyadicOperator Operand ...

3.1 Dynamic Arrays

The basic characteristic of this concept is the possibility of using dynamic entities within subroutines. Locally declared dynamic array variables are automatically allocated and deallocated during the execution of the subroutine they belong to. Further, it is possible to access subarrays.

The type declaration for a dynamic array is similar to the declaration of a static array type. One only has to insert the keyword dynamic and to replace the index ranges by asterisks. Example: Type declaration for a real vector.

  TYPE vector = DYNAMIC ARRAY[ * ] OF REAL;

The index ranges have to be declared for every dynamic array variable individually in the variable declaration part belonging to it. Example: Declaration of a real vector variable.

  VAR v : vector[ 1 .. 10 ];

The main application of dynamic arrays is their use within subroutines. Consider the following schematic example of the procedure do_something:

  PROCEDURE do_something( n : integer );
  VAR local : vector[ 1 .. n ];
  BEGIN
    { do something ... }
  END;

Here, the procedure is declared with an integer parameter n. By means of this parameter the index bounds of the local variable local are specified. This means, that local may hold a different number of elements upon different calls of do_something. The disadvantage of this method is that it is not possible to reallocate local while the procedure is being executed. In practice, however, it is desirable to be able to use a structure^{6} with a different number of elements for different purposes within a single subroutine. This could be realized by declaring several dynamic array variables with different element numbers. However, to minimize memory usage it should be possible to reuse variables, i.e. to reallocate them, whenever this is appropriate. This is the motivation for the extension to the concept of dynamic arrays which is discussed later. Access to the components of a dynamic array can be controlled by means of the standard functions lbound and ubound or their abbreviations lb and ub. Example:

  OPERATOR + ( a, b : vector ) add : vector[ LB( a ) .. UB( a ) ];
  VAR i, h : INTEGER;

6In our example this is a real vector

  BEGIN
    h := LB( b ) - LB( a );
    FOR i := LB( a ) TO UB( a ) DO add[ i ] := a[ i ] + b[ h + i ]
  END;

Please notice that the index bounds of a are not only used to access the elements of the arrays but also to specify the index bounds of the operator’s result. Further, to simplify the example, we are assuming that both, a and b, have the same number of elements^{7}. Remark : The following text describes the features of reallocatable dynamic arrays. I call these arrays flexible arrays and use this term only temporarily to have the possibility of clearly distinguishing the declaration syntax and semantics of the new and the old concept. After having described the declaration of flexible arrays, dynamic and flexible arrays are no longer distinguished.

3.2 Flexible arrays

Future releases^{8} of PASCAL–XSC will include the concept of flexible arrays. We call an array a flexible array if it can be reallocated with new index bounds and new size at any time during its lifetime. The realization of this concept led to the following basic ideas:

• The syntax and semantics for declaring dynamic array types and dynamic array variables has to be extended.

• The use of flexible arrays according to the present rules for dynamic arrays shall not result in different behaviour of PASCAL–XSC programs.

• Standard procedures for memory allocation and deallocation for flexible arrays have to be provided.

• Assignment of a flexible array to another flexible array implicitely allocates the destination array, if it has not been allocated before.

• The semantics of type declarations has to be extended; flexible arrays may be used as components of other composite data types.

7In practice this condition should be checked in the statement part of the operator

8The next release will be version 3.01

3.2.1 Declaring a Flexible Array Type

The syntax for declaring flexible array types is as follows:

dynamic array [DimensionList] of Type

A DimensionList is either a list^{9} of asterisks (*) or a list of index types. An index type is specified by either the type identifier of an integer subrange type or by explicitely specifying the index bounds in the usual way:

IntegerExpression .. IntegerExpression

From this follows that there are two possibilities of declaring flexible array types. The first possiblity simply is the adaption of the old declaration rules, e.g. every dynamic array is also a flexible array.

  TYPE vector = DYNAMIC ARRAY[ * ] OF REAL;

The second possibility is to provide default index ranges for flexible array variables. In practice it oftenly occurs that a program uses many array variables of the same array type with identical index bounds and only a few variables of the same structure with other index bounds. The extended rules for array declaration allow for this situation.

  TYPE vec = DYNAMIC ARRAY[ 1 .. 10 ] OF REAL;
    { or }
  TYPE vec = vector[ 1 .. 10 ];

When declaring flexible array types with several index ranges it is not allowed to mix asterisks with default index ranges. Thus the semantics for using flexible arrays is kept simple.

3.2.2 Declaring Flexible Array Variables

The syntax for a dynamic array variable declaration has been extended according to the changes for type declarations in section 3.2.1.

var IdentifierList : FlexTypeIdentifier [DimensionList];

As usual, variables may be declared without using a predefined or user-defined array type:

9A list always consist of at least one element. If more than on element is to be specified then the elements have to be separated by commas.

var IdentifierList : FlexTypeIdentifier;

Here, FlexTypeIdentifier stands for the construction rule for flexible array types given in 3.2.1. Again, these rules allow several possibilities of declaring flexible array variables. For the type identifiers used in this example, please refer to the examples in 3.2.1.

• Specifying index ranges:

  VAR v : vector[ 1 .. 10 ];
    { or }
  VAR v : DYNAMIC ARRAY[ 1 .. 10 ] OF REAL;

Variables declared in this way are automatically allocated resp. deallocated upon entry resp. exit of the subprogram they belong to, i.e. they behave the same way as dynamic arrays do. Further, those variables may be reallocated during the execution of the subroutine they belong to.

• Omitting index ranges:

  VAR v : vector;
    { or }
  VAR v : DYNAMIC ARRAY[ * ] OF REAL;

In this case v has to be explicitely allocated by the user. Nevertheless, it will be automatically deallocated upon exit of the subroutine it belongs to. Of course, v may be reallocated by the user.

• Using flexible arrays with default index ranges:

  VAR v : vec;
    { or }
  VAR v : vec[ 1 .. 20 ];

In both cases automatic memory allocation and deallocation will be carried out, but the allocation process is different. When omitting the specification of the index bounds for v the default index bounds of vec are used, otherwise the specified index bounds replace the default bounds. Again, v may be reallocated by the user in any case.

The preceding and this section should have shown that the concept of flexible arrays is an extension to that of dynamic arrays. It should have become clear that programs that have been developed by exclusively using the dynamic array features can be compiled with future compiler versions without change. In the following descriptions of further language extensions it is no longer necessary to distinguish between dynamic and flexible arrays; these features apply to both. Consequently we will only speak of dynamic arrays from now on.

3.2.3 Memory Management Subroutines

This section introduces a set of subroutines for handling dynamic arrays, in particular for memory management. The first routine is the procedure allocate which allows the explicit allocation of a dynamic array with the specified index bounds. It is called in the form:

allocate (DynamicArrayVariable

, IndexRange ...  {not empty}

);

Its first parameter is a dynamic array variable which is followed by a list of index ranges. Index ranges are specified in the usual way by specifying the index bounds:

IntegerExpression .. IntegerExpression

The number of index ranges specified must be the same as the number of index ranges in the declaration of the dynamic array type belonging to the dynamic array parameter. If the array variable passed to allocate is not allocated yet, it will be allocated with the specified index bounds. If an array variable is already allocated, it first will be deallocated. The latter allows the user to reallocate an array with new index bounds and new size. A further procedure provides the possibility of freeing memory occupied by a dynamic array variable, i.e. a dynamic array may explicitely be deallocated. It is called by:

free ( DynamicArrayVariable );

free has only a single parameter which must be a dynamic array variable. After a call to free the index bounds of the array parameter are undefined as long as the array is not allocated again. free will have no effect if an array is not allocated when it is passed as a parameter. Access to an array which is not allocated may have undesirable consequences such as a runtime error (see 3.2.5). Therefore, PASCAL–XSC provides a function for testing the accessibility of dynamic arrays. It is called by

allocated ( DynamicArrayVariable )

and delivers a boolean result. allocated yields the value true, if the dynamic array variable which has to be passed as the only parameter is allocated, and false otherwise.

3.2.4 First Examples

1. do_something

In 3.1 I gave the procedure do_something as an example of how to use dynamic arrays within subroutines. It contained a declaration of a local variable named local the size of which was specified by the integer parameter of the procedure. Now let us assume that we want to double the size of local within the procedure. By means of the new standard subroutines described in 3.2.3, we may change do_something as follows:

  TYPE vector = DYNAMIC ARRAY[ * ] OF REAL;
  PROCEDURE do_something( n : INTEGER );
  VAR local : vector;
  BEGIN
    ALLOCATE( local, 1 .. n );
      { do something ... }
    FREE( local );               { might be omitted }
    ALLOCATE( local, 1 .. 2 * n );
      { do something else ... }
  END;

The first call to allocate sets up the variable local with indices ranging from 1 to n. After some further statements we deallocate local by calling free. In this example this would not be necessary because the following call to allocate first would deallocate local automatically. However, if the program was in danger to run out of memory and local was not be used in the remaining statements of the procedure, it would surely be useful to deallocate the array here. Finally, the second call to allocate sets up local once more, this time with an index range from 1 to 2 n.

2. Input of a real vector from a textfile.

n real numbers shall be read from a textfile into an array of real numbers. The input file first specifies the dimension n of the vector, and then its n components. Without the possibility of reallocation of dynamic arrays the solution of this problem is very laborious. Having the new features available the solution is very simple:

  PROCEDURE read( VAR f : TEXT; VAR v : vector );
  VAR i, n : INTEGER;
  BEGIN
    IF ALLOCATED( v ) THEN FREE( v );
    READ( f, n );
    ALLOCATE( v, 1 .. n );
    FOR i := LB( v ) TO UB( v ) DO READ( f, v[ i ] )
  END;

The if statement is rather a demonstration of the use of the function allocated than it is necessary. It causes v to be deallocated in any case. Next, the number n of vector elements in the textfile is read. Then this number is used to allocate v with the appropriate size. Finally, the for statement reads the vector elements from the textfile.

3.2.5 Access to and Assigment of Dynamic arrays

Compared to the present implementation (see [10]), the semantics of the assignment statement

           A := B;

where A and B are assignment compatible dynamic arrays, will not change with the following exceptions.

1. A runtime error will be issued if B is not allocated.

2. If A is not allocated, it will be allocated before assignment will be carried out. A will have the same size and index bounds as B.

A runtime error is issued if a dynamic array which is not allocated is accessed in an expression and if array indices are to be checked. Otherwise, if array indices are not checked then the effect of accessing a dynamic array which is not allocated is undefined^{10}.

3.2.6 Dynamic arrays as components of other types

Dynamic arrays may now be declared as components of other composite data types as there are

• static arrays • records

10The checking of array indices is controlled by compiler options, see [14]

• pointers

This is not a syntax extension but an extension to the semantics of type declarations. The declaration of a dynamic array type as the component type of a composite data type follows the rules for dynamic array type declarations in 3.2.1. In particular, default index ranges may be specified. Example:

  TYPE rec = RECORD
               a, b : REAL;
               v    : DYNAMIC ARRAY[ * ] OF REAL
             END;
    { or }
  TYPE rec = RECORD
               a, b : REAL;
               v    : DYNAMIC ARRAY[ 1 .. 5 ] OF REAL
             END;

The rules for allocation and deallocation of dynamic components are the same as for dynamic array variables. Special care has to be taken when a program uses pointers to dynamic arrays. Consider the following example:

  TYPE dyn  = DYNAMIC ARRAY[ * ] OF INTEGER;
       dyn2 = DYNAMIC ARRAY[ 1 .. 10 ] OF INTEGER;
  VAR p1 = ^dyn;
      p2 = ^dyn2;
  BEGIN
    NEW( p2 );                  {automatic allocation of p2^}
    NEW( p1 );                  {allocation of a runtime descriptor only}
    ALLOCATE( p1^, 1 .. 10 );   {explicit allocation of p1^}
       {further statements}
  END

As you can see p2 points to a dynamic array with default index range from 1 to 10. Therefore, the call to new automatically allocates the dynamic array p2 points to. This is not the case for new (p1). Because p1 points to a dynamic array which has no default index ranges new only creates a runtime descriptor for the array. The array itself has to be explicitely allocated with a call to allocate.

4 Conclusion

Dynamic arrays allow for the need of flexiblity in data management in programs. The concept presented here includes some basic features that are sufficient for solving elementary problems that deal with dynamic structures, in particular in connection with the possibility of declaring dynamic arrays as components of composite data types. Further extensions to this concepts may be possible. For example, a resize operation could be defined that allows changing the size of an array without deallocation of that structure. Moreover, functions and operators could have dynamic arrays as their results without a specification of the size of that results in the declarations of that subroutines. If tests proved that such a feature would be useful, it should be added to the language. The extensions to PASCAL–XSC as described in this article are currently being implemented and tested. They will be available with the next release of the PASCAL–XSC system which hopefully will be issued in the first quarter of 1994.

References

[1] Allendörfer, U.; Shiriaev, D.: PASCAL–XSC. A portable Development System. Proceedings of the 13th World Congress on Computation and Applied Mathematics, IMACS ’91, Dublin, 1991.

[2] American National Standards Institute: American National Standard for Information Systems – Programming Language C. ANSI Standard X3.159-1989, New York, 1989.

[3] American National Standards Institute/Institute of Electrical and Electronics: A Standard for Binary Floating-Point Arithmetic. ANSI/IEEE Standard 754-1985, New York, 1985.

[4] Cordes, D.: Runtime System for a PASCAL–XSC Compiler. In [9], pp. 151–160, 1991.

[5] Geörg, S.; Hammer, R.; Neaga, M.; Ratz, D.; Shiriaev, D.: PASCAL–XSC. A PAS-CAL Extension for Scientific Computation and Numerical Data Processing. Technical report, Insitute of Applied Mathematics, University of Karlsruhe, May 1993.

[6] Hammer, R.; Hocks, M.; Kulisch, U.; Ratz, D.: Numerical Toolbox for Verified Computing I: Basic Numerical Problems. Springer-Verlag, Berlin, Heidelberg, New York, 1993.

[7] IBM: ACRITH–XSC: IBM High Accuracy Arithmetic — Extended Scientific Computation. Version 1, Release 1. IBM Deutschland GmbH, Department 3282, Schönaicher Strasse 220, D–71032 Böblingen, 3rd edition, 1986.

[8] Jensen, K.:, Wirth, N.: PASCAL User Manual and Report. ISO Pascal Standard, 3rd ed., Springer, New York, 1985.

[9] Kaucher, E.; Mayer, G.; Markov, S. M. (Eds.): Computer Arithmetic, Scientific Computation and Mathematical Modelling. Proceedings of SCAN–90. IMACS Annals on Computing and Applied Mathematics, Vol. 12 (1992), published Oct. 1991, J.C.Baltzer AG, Basel, 1991.

[10] Klatte, R.; Kulisch, U.; Neaga, M.; Ratz, D.; Ullrich, Ch.: PASCAL–XSC — Language Reference with Examples. Springer-Verlag, Berlin/Heidelberg/New York, 1992

[11] Klatte, R.; Kulisch, U.; Lawo, C.; Rauch, M.; Wiethoff, A.: C–XSC, A C++ Class Library for Extended Scientific Computing. Springer-Verlag, Berlin/Heidelberg, New York, 1993.

[12] Krämer, W.; Kulisch, U.; Lohner, R.: Numerical Toolbox for Verified Computing II. Springer-Verlag, Berlin/Heidelberg/New York, to appear 1994.

[13] Kulisch, U.; Miranker, W.L.: Computer Arithmetic in Theory and Practice. Academic Press, New York, 1981.

[14] Numerik Software GmbH: PASCAL-XSC: A PASCAL Extension for Scientific Computation. User’s Guide., Numerik Software GmbH, P.O.Box 2232, D–76492 Baden-Baden, 1991.