path: root/doc/programmer-manual/1.8.7/doc/programmierhandbuch.6

#pagenr("%",1)##setcount(1)##block##pageblock# 
#headeven# 
#center#EUMEL-Benutzerhandbuch 
#center#____________________________________________________________ 
 
#end# 
#headodd# 
#center#TEIL 6 : Das Archiv 'std.zusatz' 
#center#____________________________________________________________ 
 
#end# 
#bottomeven# 
#center#____________________________________________________________ 
6 - % #right#GMD 
#end# 
#bottomodd# 
#center#____________________________________________________________ 
GMD #right#6 - % 
#end# 
 
TEIL 6:  Das Archiv 'std.zusatz' 
 
Das Archiv 'std.zusatz' enthält Pakete, die nur bei Bedarf insertiert werden sollen.
Eine Einbindung in das EUMEL Grundsystem würde dieses ungebührlich unfangreich
machen. 
 
Das Archiv enthält zusätzliche Software für: 
 
- mathematische Operationen :  complex , longint , vector , matrix 
 
- Analyse                   :  reporter , referencer 
 
- Taschenrechnerfunktion 
  zur Editor-Erweiterung    :  TeCal , TeCal Auskunft 
 
 
#page# 

6.1.  Erweiterungen um 
      Mathematische Operationen
 
 
6.1.1  COMPLEX 
 
Das Packet COMPLEX erweitert das System um den Datentyp COMPLEX (komplexe
Zahlen) und Operationen auf komplexen Zahlen. Folgende Operationen stehen für
COMPLEX zur Verfügung: 
 
- Einfache Operatoren       :  := , = , <> , + ,- , * 
 
- Eingabe/Ausgabe           :  get , put 
 
- Denotierungsprozedur      :  complex , complex i , complex one , com­ 
                               plex zero 
 
- Komponenten               :  real part , imag part 
 
- bes. Funktionen           :  ABS , CONJ , phi , dphi , sqrt 
 
#page# 

COMPLEX Operationen 
 
 
'TYPE COMPLEX' 
   Komplexe Zahl, bestehend aud Realteil 're' und Imaginärteil 'im'. 
 
 
':=' 
   #on("b")#OP := (COMPLEX VAR a, COMPLEX CONST b) #off("b")# 
   Zuweisung. 
 
 
'=' 
   #on("b")#BOOL OP = (COMPLEX CONST a, b) #off("b")# 
   Vergleich von 'a' und 'b' auf Gleichheit. 
 
 
'<>' 
   #on("b")#BOOL OP <> (COMPLEX CONST a, b) #off("b")# 
   Vergleich von 'a' und 'b' auf Ungleichheit. 
 
 
'+' 
   #on("b")#COMPLEX OP + (COMPLEX CONST a, b) #off("b")# 
   Summe von 'a' und 'b'. 
 
 
'-' 
   #on("b")#COMPLEX OP - (COMPLEX CONST a, b) #off("b")# 
   Differenz von 'a' und 'b'. 
 
 
'*' 
   #on("b")#COMPLEX OP * (COMPLEX CONST a, b) #off("b")# 
   Multiplikation von 'a' mit 'b'. 
 
 
'/' 
   #on("b")#COMPLEX OP / (COMPLEX CONST a, b) #off("b")# 
   Division von 'a' mit 'b'. 
 
#page# 
'get' 
   #on("b")#PROC get (COMPLEX VAR a) #off("b")# 
   Einlesen eines komplexen Wertes vom Bildschirm in der Form zweier REAL-De­
   noter. Die Eingabe kann editiert werden. 
 
 
'put' 
   #on("b")#PROC put (COMPLEX CONST a) #off("b")# 
   Ausgabe eines komplexen Wertes auf dem Bildschirm in Form zweier REAL-
   Werte. Hinter jedem REAL-Wert wird ein Leerzeichen angefügt. 
 
 
'complex' 
   #on("b")#COMPLEX PROC complex (REAL CONST re, im) #off("b")# 
   Denotierungsprozedur. Angabe in kartesischen Koordinaten. 
 
 
'complex i' 
   #on("b")#COMPLEX PROC complex i #off("b")# 
   Denotierungsprozedur für den komplexen Wert '0.0 + i 1.0'. 
 
 
'complex one' 
   #on("b")#COMPLEX PROC complex one #off("b")# 
   Denotierungsprozedur für den komplexen Wert '1.0 + i 0.0'. 
 
 
'complex zero' 
   #on("b")#COMPLEX PROC complex zero #off("b")# 
   Denotierungsprozedur für den komplexen Wert '0.0 + i 0.0'. 
 
 
'imag part' 
   #on("b")#REAL PROC imag part (COMPLEX CONST number) #off("b")# 
   Liefert den Imaginärteil des komplexen Wertes 'number'. 
 
 
'real part' 
   #on("b")#REAL PROC real part (COMPLEX CONST number) #off("b")# 
   Liefert den Real-Teil des komplexen Wertes 'number'. 
 
 
'ABS' 
   #on("b")#REAL OP ABS (COMPLEX CONST x) #off("b")# 
   REAL-Betrag von 'x'. 
 
 
'CONJ' 
   #on("b")#COMPLEX OP CONJ (COMPLEX CONST number) #off("b")# 
   Liefert den konjugiert komplexen Wert von 'number'. 
 
 
'dphi' 
   #on("b")#REAL PROC dphi (COMPLEX CONST x) #off("b")# 
   Winkel von 'x' (Polardarstellung). 
 
 
'phi' 
   #on("b")#REAL PROC phi (COMPLEX CONST x) #off("b")# 
   Winkel von 'x' (Polardarstellung) in Radiant. 
 
 
'sqrt' 
   #on("b")#COMPLEX PROC sqrt (COMPLEX CONST x) #off("b")# 
   Wurzelfunktion für komplexe Werte. 
 
#page# 

6.1.2  LONGINT 
 
LONGINT ist ein Datentyp, für den (fast) alle Prozeduren und Operatoren des Daten­
typs INT implementiert wurden. LONGINT unterscheidet sich von INT dadurch, daß
erheblich größere Werte darstellbar sind. 
 
Für den Datentyp LONGINT stehen folgende Operationen zur Verfügung: 
 
- Operatoren                :  := , = , <> , < , <= ,> , >= , + , - , * , 
                               ** , 
                               ABS , DECR , DIV , INCR , MOD , SIGN 
 
- Eingabe/Ausgabe           :  get , put 
 
 
- Math. Prozeduren          :  abs , int , longint , max , max logint , min , 
                               random , sign , text , zero 
 
 
 
LONGINT-Operationen 
 
 
'TYPE LONGINT' 
   Datentyp 
 
 
':=' 
   #on("b")#OP := (LONGINT VAR links, LONGINT CONST rechts) : #off("b")# 
   Zuweisungsoperator 
 
 
'= ' 
   #on("b")#BOOL OP = (LONGINT CONST links, rechts) #off("b")# 
   Vergleichen zweier LONGINTs auf Gleichheit. 
 
 
'<>' 
   #on("b")#BOOL OP <> (LONGINT CONST links, rechts) #off("b")# 
   Vergleichen zweier LONGINTs auf Ungleichheit. 
 
 
'< ' 
   #on("b")#BOOL OP < (LONGINT CONST links, rechts) #off("b")# 
   Vergleichen zweier LONGINTs auf kleiner. 
 
 
'<=' 
   #on("b")#BOOL OP <= (LONGINT CONST links, rechts) #off("b")# 
   Vergleichen zweier LONGINTs auf kleiner gleich. 
 
 
'> ' 
   #on("b")#BOOL OP > (LONGINT CONST links, rechts) #off("b")# 
   Vergleichen zweier LONGINTs auf größer. 
 
 
'>=' 
   #on("b")#BOOL OP >= (LONGINT CONST links, rechts) #off("b")# 
   Vergleichen zweier LONGINTs auf größer gleich. 
 
 
'+ ' 
   #on("b")#LONGINT OP + (LONGINT CONST argument) #off("b")# 
   Monadischer Operator. Ohne Wirkung. 
 
   #on("b")#LONGINT OP + (LONGINT CONST links, rechts) #off("b")# 
   Addition zweier LONGINTs. 
 
 
'- ' 
   #on("b")#LONGINT OP - (LONGINT CONST argument) #off("b")# 
   Vorzeichenumkehrung. 
 
   #on("b")#LONGINT OP - (LONGINT CONST links, rechts) #off("b")# 
   Subtraktion zweier LONGINTs. 
 
 
'* ' 
   #on("b")#LONGINT OP * (LONGINT CONST links, rechts) #off("b")# 
   Multiplikation von zwei LONGINTs. 
 
 
'**' 
   #on("b")#LONGINT OP ** (LONGINT CONST argument, exponent) #off("b")# 
   Exponentiation zweier LONGINTs mit positivem Exponenten. 
 
   FEHLER : 
            LONGINT OP ** : negative exponent 
            Der 'exponent' muß >= 0 sein. 
            0 ** 0 is not defined 
            'argument' und 'exponent' dürfen nicht gleich 0 sein. 
 
 
   #on("b")#LONGINT OP ** (LONGINT CONST argument, INT CONST exponent)#off("b")# 
   Exponentiation eines LONGINT mit positiven INT Exponenten. 
 
   FEHLER : 
            LONGINT OP ** : negative exponent 
            Der 'exponent' muß >= 0 sein. 
            0 ** 0 is not defined 
            'argument' und 'exponent' dürfen nicht gleich 0 sein. 
 
'ABS' 
   #on("b")#LONGINT OP ABS (LONGINT CONST argument) #off("b")# 
   Absolutbetrag eines LONGINT. 
 
 
'DECR' 
   #on("b")#OP DECR (LONGINT VAR resultat, LONGINT CONST ab) #off("b")# 
   resultat := resultat - ab 
 
 
'DIV' 
   #on("b")#LONGINT OP DIV (LONGINT CONST links, rechts) #off("b")# 
   Division zweier LONGINTs. 
 
   FEHLER : 
             Division durch 0 
            'rechts' muß <> 0 sein. 
 
 
'INCR' 
   #on("b")#LONGINT OP INCR (LONGINT VAR resultat, LONGINT CONST dazu)#off("b")# 
   resultat := resultat + dazu 
 
 
 
'MOD' 
   #on("b")#LONGINT OP MOD (LONGINT CONST links, rechts) #off("b")# 
   Modulo-Funktion für LONGINTs. Der Rest einer LONGINT-Division wird ermit­
   telt. 
 
   FEHLER : 
           text (links) + 'MOD 0' 
           'rechts' muß ungleich null sein. 
 
 
'SIGN' 
   #on("b")#INT OP SIGN (LONGINT CONST longint) #off("b")# 
   Feststellen des Vorzeichens von 'longint'. Liefert: 
 
 
           0 wenn 'longint' = 0, 
           1 wenn 'longint' > 0, 
          -1 wenn 'longint' < 0. 
 
 
#page# 
'get' 
   #on("b")#PROC get (LONGINT VAR zahl) #off("b")# 
   Eingabe eines LONGINTs vom Terminal. 
 
   #on("b")#PROC get (FILE VAR file, LONGINT VAR zahl) #off("b")# 
   Einlesen von 'zahl' aus der sequentiellen Datei 'file'. Die Datei muß mit 'input'
   assoziiert sein (vergl. 'sequential file'). 
 
   FEHLER : 
           Datei zu 
           Leseversuch nach Daateiende 
           Leseversuch auf output-FILE 
 
 
'put' 
   #on("b")#PROC put (LONGINT CONST longint) #off("b")# 
   Ausgabe eines LONGINTs auf dem Bildschirm. Anschließend wird ein Leerzeichen
   ausgegeben. Hardwareabhängig sind die Aktionen, wenn eine Ausgabe über die
   Bildschirmzeilengrenze vorgenommen wird. Meist wird jedoch die Ausgabe auf der
   nächsten Zeile fortgesetzt. 
 
   #on("b")#PROC put (FILE VAR file, LONGINT CONST zahl) #off("b")# 
   Ausgabe von 'zahl' in die sequentielle Datei 'file'. 'file' muß mit 'output' assoziiert
   sein. 
 
   FEHLER : 
           Datei zu 
           Schreibversuch auf input-FILE 
#page# 
'abs' 
   #on("b")#LONGINT PROC abs (LONGINT CONST argument) #off("b")# 
   Absolutbetrag eines LONGINT. 
 
 
'int' 
   #on("b")#INT PROC int (LONGINT CONST longint) #off("b")# 
   Konvertierung von LONGINT nach INT. 
 
   FEHLER : 
           integer overflow 
           'longint' ist größer als 'maxint'. 
 
 
'longint' 
   #on("b")#LONGINT PROC longint (INT CONST int) #off("b")# 
   Konvertierung von 'int' nach LONGINT. 
 
   #on("b")#LONGINT PROC longint (TEXT CONST text) #off("b")# 
   Konvertierung von 'text' nach LONGINT. 
 
 
'max' 
   #on("b")#LONGINT PROC max (LONGINT CONST links, rechts) #off("b")# 
   Liefert das Maximum zweier LONGINTs. 
 
 
'maxlongint' 
   #on("b")#LONGINT PROC max longint #off("b")# 
   Liefert größten LONGINT Wert. 
 
 
'min' 
   #on("b")#LONGINT PROC min (LONGINT CONST links, rechts) #off("b")# 
   Liefert das Minimum zweier LONGINTs. 
 
 
'random' 
   #on("b")#LONGINT PROC random (LONGINT CONST lower bound, upper bound)#off("b")# 
   Pseudo-Zufallszahlen-Generator im Intervall 'lower bound' und 'upper bound'
   einschließlich. Es handelt sich hier um den 'LONGINT Random Generator'. 
 
 
'sign' 
   #on("b")#INT PROC sign (LONGINT CONST longint) #off("b")# 
   Feststellen des Vorzeichens von 'longint'. Liefert: 
 
 
           0 wenn 'longint' = 0, 
           1 wenn 'longint' > 0, 
          -1 wenn 'longint' < 0. 
 
 
 
'text' 
   #on("b")#TEXT PROC text (LONGINT CONST longint) #off("b")# 
   Konvertierung von 'longint' nach TEXT. 
 
   #on("b")#TEXT PROC text (LONGINT CONST longint, INT CONST laenge) #off("b")# 
   Konvertierung von 'longint' nach TEXT. Die Anzahl der Zeichen soll 'laenge'
   betragen. Für 
 
 
           LENGTH (text (longint)) < laenge 
 
 
   werden die Zeichen rechtsbündig in einen Text mit der Länge 'laenge' eingetra­
   gen. Ist der daraus entstehende TEXT kleiner als 'laenge', werden die an 'laenge'
   fehlenden Zeichen im TEXT mit Leerzeichen aufgefüllt. Für 
 
 
          LENGTH (text (longint)) > laenge 
 
 
   wird ein Text mit der Länge 'laenge' geliefert, der mit '*'-Zeichen gefüllt ist. 
 
 
'zero' 
   #on("b")#LONGINT PROC zero #off("b")# 
   Liefert LONGINT Wert Null. 
 
 
#page# 

6.1.3  VECTOR 
 
Der Datentyp VECTOR erlaubt Operationen auf Vektoren aus Elementen vom Typ
REAL. Im Gegensatz zur Struktur 'ROW m REAL' muß die Anzahl der Elemente nicht
zur Übersetzungszeit deklariert werden, sondern kann zur Laufzeit festgelegt werden.
Somit kann eine zur Übersetzungszeit unbekannte Anzahl von REALs bearbeitet
werden, wobei nur soviel Speicherplatz wie nötig verwendet wird. Die maximale Größe
eines VECTOR beträgt 4000 Elemente. 
 
Der in den Operationen ':=', 'idn' und 'vector' benutzte Datentyp INITVECTOR wird
nur intern gehalten. Er dient der Speicherplatzersparnis bei der Initialisierung. 
 
 
- Operatoren                :  := , = , <> , + , - , * , / 
                               LENGTH , SUB 
 
- Eingabe/Ausgabe           :  get , put 
 
- Besondere Vector-         :  length , nilvector , norm , vector , replace 
  Operationen 
 
#page# 
':=' 
   #on("b")#OP := (VECTOR VAR ziel, VECTOR CONST quelle) #off("b")# 
   Zuweisung. Nach der Zuweisung gilt auch 
 
 
           length (quelle) = length (ziel) 
 
 
   d.h. der linke Operand besitzt nach der Zuweisung genauso viele Elemente wie
   'quelle', unabhängig davon, ob 'ziel' vor der Zuweisung mehr oder weniger Ele­
   mente als 'quelle' besaß. Beispiel: 
 
 
           VECTOR VAR y :: vector (10, 1.0), 
                      z :: vector (15, 2.0); 
                ... 
           y := z; (* length (y) liefert nun 15 ! *) 
 
 
   #on("b")#OP := (VECTOR VAR ziel, INITVECTOR CONST quelle) #off("b")# 
   Dient zur Initialisierung eines VECTORs. Beispiel: 
 
 
           VECTOR VAR x :: vector (17); 
 
 
   'vector' erzeugt ein Objekt vom Datentyp INITVECTOR. Dieses Objekt braucht
   nicht soviel Speicherplatz wie ein VECTOR-Objekt. Dadurch wird vermieden, daß
   nach erfolgter Zuweisung nicht ein durch 'vector' erzeugtes Objekt auf dem Heap
   unnötig Speicherplatz verbraucht. 
 
 
'=' 
   #on("b")#BOOL OP = (VECTOR CONST a, b) #off("b")# 
   Vergleich zweier Vektoren. Der Operator liefert FALSE, wenn die Anzahl der
   Elemente von 'a' und 'b' ungleich ist oder wenn zwei Elemente mit gleichem
   Index ungleich sind. Beispiel: 
 
 
           VECTOR VAR x :: vector (10, 1.0), 
                      y :: vector (15, 2.0), 
                      z :: vector (10, 1.0); 
                   ... x = y ... (* FALSE *) 
                   ... x = z ... (* TRUE  *) 
 
 
'<>' 
   #on("b")#BOOL OP <> (VECTOR CONST a, b) #off("b")# 
   Vergleich zweier Vektoren auf Ungleichheit (NOT (a = b)). 
 
 
'+' 
   #on("b")#VECTOR OP + (VECTOR CONST a) #off("b")# 
   Monadisches '+' für VECTOR. Keine Auswirkung. 
 
   #on("b")#VECTOR OP + (VECTOR CONST a, b) #off("b")# 
   Elementweise Addition der Vektoren 'a' und 'b'. Beispiel: 
 
 
           VECTOR VAR x, (* 'x' hat undefinierte Länge *) 
                      a :: vector (10, 1.0), 
                      b :: vector (10, 2.0); 
                 ... 
           x := a + b; (* 'x' hat nun 10 Elemente mit Werten'3.0'
           *) 
 
   FEHLER : 
           VECTOR OP + : LENGTH a <> LENGTH b 
           'a' und 'b' haben nicht die gleiche Anzahl von Elementen. 
 
 
'-' 
   #on("b")#VECTOR OP - (VECTOR CONST a) #off("b")# 
   Monadisches '-'. 
 
   #on("b")#VECTOR OP - (VECTOR CONST a, b) #off("b")# 
   Elementweise Subtraktion der Vektoren 'a' und 'b'. 
 
   FEHLER : 
           VECTOR OP - : LENGTH a <> LENGTH b 
           'a' und 'b' haben nicht die gleiche Anzahl von Elementen. 
 
'*' 
   #on("b")#REAL OP * (VECTOR CONST a, b) #off("b")# 
   Skalarprodukt zweier Vektoren. Liefert die Summe der elementweisen Multiplika­
   tion der Vektoren 'a' und 'b'. Beachte eventuelle Rundungsfehler! Beispiel: 
 
 
           REAL VAR a; 
           VECTOR VAR b :: vector (10, 2.0), 
                      c :: vector (10, 2.0); 
                 ... 
           a := b * c; (* 40.0 *) 
 
   FEHLER : 
           REAL OP * : LENGTH a <> LENGTH b 
           'a' und 'b' haben nicht die gleiche Anzahl von Elementen. 
 
   #on("b")#VECTOR OP * (VECTOR CONST a, REAL CONST s) #off("b")# 
   Multiplikation des Vektors 'a' mit dem Skalar 's'. 
 
   #on("b")#VECTOR OP * (REAL CONST s, VECTOR CONST a) #off("b")# 
   Multiplikation des Skalars 's' mit dem Vektor 'a'. 
 
 
'/' 
   #on("b")#VECTOR OP / (VECTOR CONST a, REAL CONST s) #off("b")# 
   Division des Vektors 'a' durch den Skalar 's'. Beispiel: 
 
 
           VECTOR VAR a, (* 'a' hat undefinierte Laenge *) 
                      b :: vector (10, 4.0); 
                ... 
           a := b / 2.0; 
           (* 'a' hat nun 10 Elemente mit Werten '2.0' *) 
 
 
 
'LENGTH' 
   #on("b")#INT OP LENGTH (VECTOR CONST a) #off("b")# 
   Liefert die Anzahl der Elemente von 'a'. 
 
 
'SUB' 
   #on("b")#REAL OP SUB (VECTOR CONST v, INT CONST i) #off("b")# 
   Liefert das 'i'-te Element von 'v'. 
 
   FEHLER : 
           OP SUB : subscript overflow 
           Der Index 'i' liegt außerhalb des Vektors (i > LENGTH v). 
           OP SUB : subscript underflow 
           Der Index 'i' liegt außerhalb des Vektors (i < 1). 
 
#page# 
'get' 
   #on("b")#PROC get (VECTOR VAR a, INT CONST l) #off("b")# 
   Einlesen der Elemente von 'a' vom Terminal, wobei 'l' die Anzahl der Elemente
   angibt. 
 
   FEHLER : 
           PROC get : size <= 0 
           Die angeforderte Elementanzahl 'l' muß > 0 sein. 
 
 
'put' 
   #on("b")#PROC put (VECTOR CONST v) #off("b")# 
   Ausgabe der Werte der Elemente von 'v' auf dem Terminal. 
 
 
#page# 
'length' 
   #on("b")#INT PROC length (VECTOR CONST a) #off("b")# 
   Liefert die Anzahl der Elemente von 'a'. Beispiel: 
 
 
           VECTOR VAR a :: vector (10, 1.0), 
                      b :: vector (15, 2.0); 
                ... 
            ... length (a) ... (* 10 *) 
            ... length (b) ... (* 15 *) 
 
 
 
'nilvector' 
   #on("b")#INITVECTOR PROC nilvector #off("b")# 
   Erzeugen eines Vektors mit einem Element mit dem Wert '0.0'. 
 
 
'norm' 
   #on("b")#REAL PROC norm (VECTOR CONST v) #off("b")# 
   Euklidische Norm (Wurzel aus der Summe der Quadrate der Elemente). 
 
 
 
'replace' 
   #on("b")#PROC replace (VECTOR VAR v, INT CONST i, REAL CONST r)#off("b")# 
   Zuweisung des i-ten Elementes von 'v' mit dem Wert von 'r'. Beispiel: 
 
 
           VECTOR VAR v :: ...; 
               ... 
           replace (v, 13, 3.14); 
           (* Das 13. Element von 'v' bekommt den Wert '3.14' *) 
 
   FEHLER : 
           PROC replace : subscript overflow 
           Der Index 'i' liegt außerhalb des Vektors (i > LENGTH v). 
           PROC replace : subscript underflow 
           Der Index 'i' liegt außerhalb des Vektors (i < 1). 
 
 
'vector' 
   #on("b")#INITVECTOR PROC vector (INT CONST l) #off("b")# 
   Erzeugen eines Vektors mit 'l' Elementen. Ein INITVECTOR-Objekt benötigt nicht
   soviel Speicherplatz wie ein VECTOR-Objekt. Die Elemente werden mit dem
   Wert '0.0' initialisiert. 
 
   FEHLER : 
           PROC vector : size <= 0 
           Die angeforderte Elementanzahl 'l' muß > 0 sein. 
 
   #on("b")#INITVECTOR PROC vector (INT CONST l, REAL CONST value)#off("b")# 
   Erzeugen eines Vektors mit 'l' Elementen. Ein INITVECTOR-Objekt benötigt nicht
   soviel Speicherplatz wie ein VECTOR-Objekt. Die Elemente werden mit dem
   Wert 'value' initialisiert. Beispiel: 
 
 
           VECTOR VAR v := vector (17, 3.14159); 
           (* 'v' hat 17 Elemente mit den Wert '3.14159' *) 
 
    FEHLER : 
           PROC vector : size <= 0 
           Die angeforderte Elementanzahl 'l' muß > 0 sein. 
 
#page# 

6.1.4  MATRIX

Der Datentyp MATRIX erlaubt Operationen auf m x n Matrizen. Im Gegensatz zur
Struktur 'ROW m ROW n REAL' muß die Anzahl der Elemente nicht zur Überset­
zungszeit deklariert werden, sondern kann zur Laufzeit festgelegt werden. Somit kann
eine zur Übersetzungszeit unbekannte Anzahl von REALs bearbeitet werden, wobei
nur soviel Speicherplatz wie nötig verwendet wird. Die maximale Größe einer MATRIX
beträgt 4000 Elemente. 
 
Der in den Operationen ':=', 'idn' und 'matrix' benutzte Datentyp INITMATRIX wird
nur intern gehalten. Er dient der Speicherplatzersparnis bei der Initialisierung. 
 
 
- Operatoren                :  := , = , <> , + , - , * 
                               COLUMNS , DET , INV , ROWS , TRANSP , 
 
- Eingabe/Ausgabe           :  get , put 
 
- Besondere Matrix-         :  column , idn , matrix , row , sub 
  Operationen                  transp , 
                               replace column , replace element , 
                               replace row 
 
 
 
#page# 
':=' 
   #on("b")#OP := (MATRIX VAR l, MATRIX CONST r) #off("b")# 
   Zuweisung von 'r' auf 'l'. Die MATRIX 'l' bekommt u.U. eine neue Anzahl von
   Elementen. Beispiel: 
    
 
           MATRIX VAR a :: matrix (3, 4, 0.0), 
                      b :: matrix (5, 5, 3.0); 
                          ... 
           a := b; (* 'a' hat jetzt 5 x 5 Elemente *) 
 
 
   #on("b")#OP := (MATRIX VAR l, INITMATRIX CONST r) #off("b")# 
   Dient zur Initialisierung einer Matrix. Beispiel: 
 
 
           MATRIX VAR x :: matrix (17, 4); 
 
 
   'matrix' erzeugt ein Objekt vom Datentyp INITMATRIX. Dieses Objekt braucht
   nicht soviel Speicherplatz wie ein MATRIX-Objekt. Dadurch wird vermieden, daß
   nach erfolgter Zuweisung nicht ein durch 'matrix' erzeugtes Objekt auf dem Heap
   unnötig Speicherplatz verbraucht. 
 
'=' 
   #on("b")#BOOL OP = (MATRIX CONST l, r) #off("b")# 
   Vergleich zweier Matrizen. Der Operator '=' liefert FALSE, wenn die Anzahl
   Spalten oder Reihen der Matrizen 'l' und 'r' ungleich ist und wenn mindestens ein
   Element mit gleichen Indizes der zwei Matrizen ungleiche Werte haben. Beispiel: 
 
 
           MATRIX VAR a :: matrix (3, 3), 
                      b :: matrix (3, 3, 1.0), 
                      c :: matrix (4, 4); 
                 ... a = b ... 
           (* FALSE wegen ungleicher Werte   *) 
                 ... a = c ... 
           (* FALSE wegen ungleicher Groesse *) 
                 ... b = c ... 
           (* FALSE wegen ungleicher Groesse *) 
 
 
 
'<>' 
   #on("b")#BOOL OP <> (MATRIX CONST l, r) #off("b")# 
   Vergleich der Matrizen 'l' und 'r' auf Ungleichheit. 
 
 
'+' 
   #on("b")#MATRIX OP + (MATRIX CONST m) #off("b")# 
   Monadisches '+'. Keine Auswirkungen. 
 
   #on("b")#MATRIX OP + (MATRIX CONST l, r) #off("b")# 
   Addition zweier Matrizen. Die Anzahl der Reihen und der Spalten muß gleich sein.
   Beispiel: 
 
           MATRIX VAR a :: matrix (3, 43, 1.0), 
                      b :: matrix (3, 43, 2.0), 
                           summe; 
                      summe := a + b; 
           (* Alle Elemente haben den Wert '3.0' *) 
 
 
     FEHLER: 
           MATRIX OP + : COLUMNS l <> COLUMNS r 
           Die Anzahl der Spalten von 'l' und 'r' sind nicht gleich. 
           MATRIX OP + : ROWS l <> ROWS r 
           Die Anzahl der Zeilen von 'l' und 'r' sind nicht gleich. 
 
 
'-' 
   #on("b")#MATRIX OP - (MATRIX CONST m) #off("b")# 
   Monadisches Minus. Beispiel: 
 
 
           MATRIX VAR a :: matrix (3, 4, 10.0) 
           a := - a; (* Alle Elemente haben den Wert '- 10.0' *) 
 
 
   #on("b")#MATRIX OP - (MATRIX CONST l, r) #off("b")# 
   Subtraktion zweier Matrizen. Die Anzahl der Reihen und Spalten muß gleich sein. 
 
   FEHLER: 
           MATRIX OP - : COLUMNS l <> COLUMNS r 
           Die Anzahl der Spalten von 'l' und 'r' sind nicht gleich. 
           MATRIX OP - : ROWS l <> ROWS r 
           Die Anzahl der Zeilen von 'l' und 'r' sind nicht gleich. 
 
'*' 
   #on("b")#MATRIX OP * (REAL CONST r, MATRIX CONST m) #off("b")# 
   Multiplikation einer Matrix 'm' mit einem Skalar 'r'. Beispiel: 
 
 
           MATRIX VAR a :: matrix (3, 4, 2.0); 
                ... 
           a := 3 * a; (* Alle Elemente haben den Wert '6.0' *) 
 
 
   #on("b")#MATRIX OP * (MATRIX CONST m, REAL CONST r) #off("b")# 
   Multiplikation einer Matrix 'm' mit einem Skalar 'r'. 
 
   #on("b")#MATRIX OP * (MATRIX CONST l, r) #off("b")# 
   Multiplikation zweier Matrizen. Die Anzahl der Spalten von 'l' und die Anzahl der
   Zeilen von 'r' müssen gleich sein. Beispiel: 
 
 
           MATRIX VAR a :: matrix (3, 4, 2.0), 
                      b :: matrix (4, 2, 3.0), 
                      produkt; 
           produkt := a * b; 
           (* Alle Elemente haben den Wert '24.0' *) 
 
 
   FEHLER : 
           MATRIX OP * : COLUMNS l <> ROWS r 
           Die Anzahl der Spalten von 'l' muß mit der Anzahl der Zeilen von 'r'
           übereinstimmen. 
 
   #on("b")#VECTOR OP * (VECTOR CONST v, MATRIX CONST m) #off("b")# 
   Multiplikation des Vektors 'v' mit der Matrix 'm'. 
 
   FEHLER : 
            VECTOR OP * : LENGTH v <> ROWS m 
            Die Anzahl der Elemente von 'v' stimmt nicht mit den Anzahl der Zeilen
            von 'm' überein. 
 
   #on("b")#VECTOR OP * (MATRIX CONST m, VECTOR CONST v) #off("b")# 
   Multiplikation der Matrix 'm' mit dem Vektor 'v'. 
 
   FEHLER : 
            VECTOR OP * : COLUMNS m <> LENGTH v 
            Die Anzahl der Spalten von 'm' stimmt nicht mit der Anzahl der Ele­
            menten von 'v' überein. 
 
 
'COLUMNS' 
   #on("b")#INT OP COLUMNS (MATRIX CONST m) #off("b")# 
   Liefert die Anzahl der Spalten von 'm'. Beispiel: 
 
 
           MATRIX VAR a :: matrix (3, 4), 
                      b :: matrix (7, 10); 
           put (COLUMNS a); (* 4 *) 
           put (COLUMNS b); (* 10 *) 
 
 
 
'DET' 
   #on("b")#REAL OP DET (MATRIX CONST m) #off("b")# 
   Es wird der Wert der Determinanten von 'm' geliefert. 
 
   FEHLER : 
           OP DET : no square matrix 
           Die Matrix ist nicht quadratisch, d.h. ROWS m <> COLUMNS m 
 
 
'INV' 
   #on("b")#MATRIX OP INV (MATRIX CONST m) #off("b")# 
   Liefert als Ergebnis die Inverse von 'm' (Achtung: starke Rundungsfehler möglich). 
 
   FEHLER: 
           OP INV : no square matrix 
           Die Matrix 'm' ist nicht quadratisch, 
           d.h. ROWS m <> COLUMNS m 
           OP INV : singular matrix 
           Die Matrix ist singulär. 
 
 
'ROWS' 
   #on("b")#INT OP ROWS (MATRIX CONST m) #off("b")# 
   Liefert die Anzahl der Zeilen von 'm'. Beispiel: 
 
 
           MATRIX VAR a :: matrix (3, 4), 
                      b :: matrix (7, 10); 
                ... 
           put (ROWS a); (* 3 *) 
           put (ROWS b); (* 7 *) 
 
 
 
'TRANSP' 
   #on("b")#MATRIX OP TRANSP (MATRIX CONST m) #off("b")# 
   Liefert als Ergebnis die transponierte Matrix 'm'. 
 
#page# 
'get' 
   #on("b")#PROC get (MATRIX VAR m, INT CONST rows, columns) #off("b")# 
   Einlesen von Werten für die Matrix 'm' vom Terminal mit 'rows'-Zeilen und
   'columns'-Spalten. 
 
 
'put' 
   #on("b")#PROC put (MATRIX CONST m) #off("b")# 
   Ausgabe der Werte einer Matrix auf dem Terminal. 
#page# 
'column' 
   #on("b")#VECTOR PROC column (MATRIX CONST m, INT CONST i) #off("b")# 
   Die 'i'-te Spalte von 'm' wird als VECTOR mit 'ROWS m' Elementen geliefert.
   Beispiel: 
 
 
           MATRIX CONST a :: matrix (3, 4); 
           VECTOR VAR b   :: column (a, 1); 
           (* 'b' hat drei Elemente mit den Werten '0.0' *) 
 
   FEHLER: 
           PROC column : subscript overflow 
           Der Index 'i' liegt außerhalb der Matrix 'm' (i > COLUMNS m). 
           PROC column : subscript underflow 
           Der Index 'i' liegt außerhalb der Matrix 'm' (i < 1). 
 
'idn' 
   #on("b")#INITMATRIX PROC idn (INT CONST size) #off("b")# 
   Erzeugen einer Einheitsmatrix vom Datentyp INITMATRIX. Beispiel: 
 
 
           MATRIX VAR a :: idn (10); 
           (* Erzeugt eine Matrix mit 10 x 10 Elementen, deren
            Werte '0.0' sind, mit der Ausnahme der Diagonalele­
            mente, die den Wert '1.0' haben.*) 
 
   FEHLER : 
           PROC idn : size <= 0 
           Die angeforderte 'size' Anzahl Spalten oder Zeilen muß > 0 sein. 
 
 
'matrix' 
   #on("b")#INITMATRIX PROC matrix (INT CONST rows, columns) #off("b")# 
   Erzeugen eines Datenobjekts vom Datentyp INITMATRIX mit 'rows' Zeilen und
   'columns' Spalten. Alle Elemente werden mit dem Wert '0.0' initialisiert. Beispiel: 
 
 
           MATRIX CONST :: matrix (3, 3); 
 
   FEHLER: 
           PROC matrix : rows <= 0 
           Die angeforderte Zeilenanzahl 'rows' muß > 0 sein. 
           PROC matrix : columns <= 0 
           Die angeforderte Spaltenanzahl 'columns' muß > 0 sein. 
 
   #on("b")#INITMATRIX PROC matrix (INT CONST rows, columns, REAL CONST value)#off("b")# 
   Erzeugen eines Datenobjekts vom Datentyp MATRIX mit 'rows' Zeilen und 'co­
   lumns' Spalten. Alle Elemente der erzeugten MATRIX werden mit dem Wert
   'value' initialisiert. Beispiel: 
 
 
           MATRIX CONST :: matrix (3, 3, 3.14); 
 
   FEHLER: 
           PROC matrix : rows <= 0 
           Die angeforderte Zeilenanzahl 'rows' muß > 0 sein. 
           PROC matrix : columns <= 0 
           Die angeforderte Spaltenanzahl 'columns' muß > 0 sein. 
 
 
'row' 
   #on("b")#VECTOR PROC row (MATRIX CONST m, INT CONST i) #off("b")# 
   Die 'i'-te Reihe von 'm' wird als VECTOR mit 'COLUMNS m' Elementen gelie­
   fert. Beispiel: 
 
 
           MATRIX CONST a :: matrix (3, 4); 
           VECTOR VAR b   :: row (a, 1); 
           (* 'b' hat vier Elemente mit den Werten '0.0'*) 
 
   FEHLER: 
           PROC row : subscript overflow 
           Der Index 'i' liegt außerhalb der Matrix 'm' (i > ROWS m). 
           PROC row : subscript underflow 
           Der Index 'i' liegt außerhalb der Matrix 'm' (i < 1). 
 
 
'sub' 
   #on("b")#REAL PROC sub (MATRIX CONST m, INT CONST row, column) #off("b")# 
   Liefert den Wert eines Elementes von 'm', welches durch die Indizes 'row' und
   'column' bestimmt wird. Beispiel: 
 
 
           MATRIX VAR m :: matrix (5, 10, 1.0); 
           put (sub (m, 3, 7)); 
 
   FEHLER: 
           PROC sub : row subscript overflow 
           Der Index 'row' liegt außerhalb von 'm' (row > ROWS m). 
           PROC sub : row subscript underflow 
           Der Index 'row' liegt außerhalb von 'm' (row < 1). 
           PROC sub : column subscript overflow 
           Der Index 'column' liegt außerhalb von 'm' (column > ROWS m). 
           PROC sub : row subscript underflow 
           Der Index 'column' liegt außerhalb von 'm' (column < 1). 
 
 
'transp' 
   #on("b")#PROC transp (MATRIX VAR m) #off("b")# 
   Transponieren der Matrix 'm', wobei kaum zusätzlicher Speicherplatz benötigt
   wird. 
 
#page# 
'replace column' 
   #on("b")#PROC replace column (MATRIX VAR m, INT CONST column index, VECTOR
                        CONST column value)  #off("b")# 
   Ersetzung der durch 'column index' definierten Spalte in der MATRIX 'm' durch
   den VECTOR 'column value'. Beispiel: 
 
 
           MATRIX VAR a :: matrix (3, 5, 1.0); 
           VECTOR VAR b :: vector (3, 2.0); 
                 ... 
           replace column (a, 2, b); 
           (* Die zweite Spalte von 'a' wird durch die Werte von
              'b' ersetzt *) 
 
   FEHLER: 
           PROC replace column : LENGTH columnvalue <> ROWS m 
           Die Anzahl der Zeilen der MATRIX 'm' stimmt nicht mit der Anzahl der
           Elemente von 'columnvalue' überein. 
           PROC replace column : column subscript overflow 
           Der Index 'columnindex' liegt außerhalb von 'm' 
           (columnindex > COLUMNS m). 
           PROC sub : column subscript underflow 
           Der Index 'columnindex' liegt außerhalb von 'm' (columnindex < 1). 
 
 
'replace element' 
   #on("b")#PROC replace element (MATRIX VAR m , INT CONST row, column, 
                        REAL CONST value) #off("b")# 
   Ersetzung eines Elementes von 'm' in der 'row'-ten Zeile und 'column'-ten
   Spalte durch den Wert 'value'. Beispiel: 
 
 
           MATRIX VAR a :: matrix (5, 5); 
                 ... 
           replace element (1, 1, 3.14159); 
 
   FEHLER: 
           PROC replace element : row subscript overflow 
           Der Index 'row' liegt außerhalb von 'm' (row > ROWS m). 
           PROC replace element : row subscript underflow 
           Der Index 'row' liegt außerhalb von 'm' (row < 1). 
           PROC replace element : column subscript overflow 
           Der Index 'column' liegt außerhalb von 'm' (column > COLUMNS m). 
           PROC replace element : row subscript underflow 
           Der Index 'column' liegt außerhalb von 'm' (column < 1). 
 
 
'replace row' 
   #on("b")#PROC replace row (MATRIX VAR m, INT CONST rowindex, 
                    VECTOR CONST rowvalue) #off("b")# 
   Ersetzung der Reihe 'rowindex' in der MATRIX 'm' durch den VECTOR 'rowvalue'.
   Beispiel: 
 
 
           MATRIX VAR a :: matrix (3, 5, 1.0); 
           VECTOR VAR b :: vector (5, 2.0); 
                 ... 
           replace row (a, 2, b); 
           (* Die 2. Reihe von 'a' wird durch Werte von 'b'ersetzt *) 
 
   FEHLER: 
           PROC replace row : LENGTH rowvalue <> COLUMNS m 
           Die Anzahl der Spalten der MATRIX 'm' stimmt nicht mit der Anzahl der
           Elemente von 'rowvalue' überein. 
           PROC replace row : row subscript overflow 
           Der Index 'rowindex' liegt außerhalb von 'm' 
           (rowindex > ROWS m). 
           PROC sub : row subscript underflow 
           Der Index 'rowindex' liegt außerhalb von 'm' (rowindex < 1). 

6.2  Programmanalyse 
 
Das Packet 'reporter' ermöglicht: 
 
a) Ablaufinformationen ("trace"); 
b) #ib#Häufigkeitszählung#ie# ("frequency count"); 
c) Programmunterbrechung bei Nichterfüllung einer Bedingung ("#ib#assertion#ie#"). 
 
 
'Installation' 
Das Programm befindet sich in der Datei 'reporter' und kann wie üblich insertiert
werden. Jedoch muß es mit 'check off' übersetzt werden, damit keine Zeilennummern
für 'reporter' generiert werden. Dies ist notwendig, damit die Zeilennummern des zu
testenden Programms nicht mit den Zeilennummern des Programms 'reporter' ver­
wechselt werden können. Beispiel: 
 
 
     check off; insert ("reporter"); check on 
 
 
Mit dem Kommando 
 
 
     #ib#generate reports#ie# ("testdatei") 
 
 
werden die oben erwähnten Prozeduraufrufe ('#ib#report#ie#') in das zu testende Programm,
welches in der Datei 'testdatei' steht, geschrieben. Die Prozeduraufrufe werden nach
jedem Prozedur-, Operator- oder Refinement-Kopf eingefügt und erhalten den
entsprechenden Namen als Parameter. Diese Prozeduraufrufe werden gekennzeichnet,
damit sie von der Prozedur 
 
 
     eliminate reports ("testdatei") 
 
 
automatisch wieder entfernt werden können. Beispiel (für die eingefügten Prozedurauf­
rufe): 
 
 
    ... 
    PROC beispiel (INT CONST mist): 
    \#\#report ("PROC beispiel");\#\# 
    ... 
 
 
 
'Automatische Ablaufinformation' 
Ist ein Programm mit 'generate reports' mit 'report'-Aufrufen versehen worden, kann
es wie gewohnt übersetzt werden. Wird das Programm vom ELAN-Compiler kor­
rekt übersetzt und dann gestartet, wird bei jedem Antreffen eines 'report'-Aufrufs der
Parameter (Name der Prozedur, Operator oder Refinement) in eine Datei, die
TRACE-Datei geschrieben. Die TRACE-Datei wird beim Programmlauf automatisch
von 'reporter' unter dem Namen 'TRACE' eingerichtet. 
 
Mit Hilfe dieser Datei kann der Programmablauf verfolgt werden. Es ist damit auch
möglich festzustellen, wo eine "Endlos-Rekursion" auftritt. Die Ablaufinformationen
bestehen nur aus den Namen der angetroffenen Prozeduren und Refinements. Trotz­
dem können die Anzahl der Informationen sehr umfangreich werden. Deshalb gibt es
die Möglichkeit, die Erzeugung der Ablaufinformationen ab- bzw. wieder anzuschal­
ten. Dazu gibt es die Möglichkeit, in das zu testende Programm die Prozeduren 
 
 
     #ib#report on#ie# 
     #ib#report off#ie# 
 
 
einzufügen und das zu testende Programm mit diesen Prozeduraufrufen (erneut) zu
übersetzen. 
 
 
'Benutzereigene Ablaufinformation' 
Zusätzlich zu den von 'generate reports' eingefügten 'report'-Aufrufen kann ein
Benutzer eigene Aufrufe an geeigneten Stellen in ein Programm schreiben. Dafür
werden weitere 'report'-Prozeduren zur Verfügung gestellt, die als ersten Parameter
ein TEXT-Objekt (meist Name des Objekts oder der Ausdruck selbst) und als zwei­
ten ein INT/REAL/TEXT/ BOOL-Objekt (der zu überprüfende Wert oder Ausdruck)
enthalten. Beispiel: 
 
 
    ... 
    PROC beispiel (INT CONST mist): 
    \#\#report ("beispiel");\#\#     (* automatisch eingefuegte *) 
    INT VAR mist :: ...; ... 
    \#\#report ("mist:", mist);\#\#  (* vom Benutzer per Hand einge­
                                    fuegt *) 
    ... 
 
 
Folgende 'report'-Routinen stehen zur Verfügung, damit man sie "von Hand" in ein
zu testendes Programm einfügen kann: 
 
 
     PROC report on 
     PROC report off 
     PROC report (TEXT CONST message) 
     PROC report (TEXT CONST message,  INT CONST value) 
     PROC report (TEXT CONST message, REAL CONST value) 
     PROC report (TEXT CONST message, TEXT CONST value) 
     PROC report (TEXT CONST message, BOOL CONST value) 
 
 
Wichtig: Hier - wie bei allen anderen "von Hand eingefügten" Aufrufen - sollte
ein Nutzer sich an die Konvention halten, diese in "\#\#" einzuklammern. Mit 'eliminate
reports' werden diese Einfügungen automatisch entfernt. Sollen diese Aufrufe aber
immer im Programm erhalten bleiben (jedoch nicht wirksam sein), sollten sie 
 
a) vor 'generate reports'-Aufruf mit jeweils '\#\#\#' eingefaßt werden. Beispiel: 
   \#\#\# report ("...") \#\#\# 
   So steht das 'report'-Statement in einem Kommentar. 'generate reports' wandelt
   '\#\#\#' --> '\#\#\#\#' um, so daß ein solches Statement wirksam wird. 'eliminate
   reports' wandelt ein '\#\#\#\#' --> '\#\#\#' zurück. 
 
b) nach 'generate reports' in '\#\#\#\#' eingefaßt werden. 
 
 
'Häufigkeitszählung' 
Eine Häufigkeitszählung erhält man, in dem man in das zu testende Programm die
Aufrufe 
 
 
     count on 
     count off 
 
 
einfügt. Ist die Häufigkeitszählung eingeschaltet, merkt sich 'reporter' die Anzahl der
Durchläufe für jede Prozedur bzw. Refinement. Mit der Prozedur 
 
 
     #ib#generate counts#ie# ("zu testende datei") 
 
 
werden die vermerkten Häufigkeiten in das zu testende Programm direkt eingefügt.
Die Häufigkeiten werden wie oben beschrieben gekennzeichnet, so daß sie mit 'elimi­
nate reports' entfernt werden können. 
 
 
'Assertions' 
Zusätzlich zu den oben erwähnten Möglichkeiten bietet 'reporter' noch die Prozedur 
 
 
     #ib#assert#ie# 
 
 
an. Diese Prozedur kann von einem Programmierer an einer Stelle in das zu testende
Programm eingefügt werden, an der bestimmte Bedingungen erfüllt sein müssen. Die
Prozedur 'assert' steht in zwei Formen zur Verfügung: 
 
 
     PROC #ib#assert#ie# (BOOL CONST zusicherung) 
     PROC assert (TEXT CONST message, BOOL CONST zusicherung) 
 
 
Ist der Wert von 'zusicherung' nicht TRUE, wird der Programmlauf abgebrochen. 
 
 
 
reporter - Kommandos 
 
 
'count on' 
   #on("b")#PROC count on #off("b")# 
   Schaltet die Häufigkeitszählung ein. 
 
'count off' 
   #on("b")#PROC count off #off("b")# 
   Schaltet die Häufigkeitszählung aus. 
 
'eliminate reports' 
   #on("b")#PROC eliminate reports (TEXT CONST datei) #off("b")# 
   Entfernt gekennzeichnete 'report'-Aufrufe aus der Datei 'datei'. 
 
'generate reports' 
   #on("b")#PROC generate reports (TEXT CONST datei) #off("b")# 
   Fügt 'report'-Aufrufe in die Datei 'datei' ein und kennzeichnet diese mit '\#\#'. 
 
'report on' 
   #on("b")#PROC report on #off("b")# 
   Schaltet die Ablaufinformationen in die Datei 'TRACE' ein. 
 
'report off' 
   #on("b")#PROC report off #off("b")# 
   Schaltet die Ablaufinformationen wieder aus. 
 
'generate counts' 
   #on("b")#PROC generate counts (TEXT CONST datei) #off("b")# 
   Bringt die Häufigkeitszählung (wie oft eine Prozedur oder Refinement durchlaufen
   wurde) in die Programmdatei 'datei'. Mit 'eliminate reports' werden diese wieder
   automatisch entfernt. 
 
'assert' 
   #on("b")#PROC assert (TEXT CONST message, BOOL CONST value) #off("b")# 
   Schreibt 'message' und den Wert von 'value' in die TRACE-Datei. Ist 'value'
   FALSE, wird angefragt, ob das Programm fortgesetzt werden soll. 
#page# 

Referencer 
 
 
'referencer' wird durch 
 
 
     referencer ("ref datei", "referenz liste") 
 
 
aufgerufen, wobei die Datei 'referenz liste' nicht existieren darf. 'referenz liste' enthält
nach Ablauf des Programms die gewünschte Liste, die sogenannte #ib# Referenzliste#ie#. 
 
#ub#Achtung#ue#: 'referencer' arbeitet ausschließlich mit Namen und verarbeitet nur wenige
syntaktische Konstrukte. Darum ist es nur erlaubt, ein PACKET auf einmal von 'refe­
rencer' verarbeiten zu lassen. Verarbeitet man mehrere PACKETs auf einmal, kann es
geschehen, daß gleichnamige Objekte in unterschiedlichen Paketen zu Warnungen
(vergl. die unten beschriebenen Überprüfungen) führen. 
 
In der Referenzliste sind 
 
- alle Objekte mit ihrem Namen (in der Reihenfolge ihres Auftretens im Programm) 
 
- alle Zeilennummern, in der das Objekt angesprochen wird 
 
- die Zeilennummern, in der das Objekt deklariert wurde ('L' für ein lokales und 'G'
  für ein globales Objekt, 'R' für ein Refinement) 
 
verzeichnet. 
 
Die Referenzliste kann u.a. dazu dienen, zu kontrollieren, ob und wie (bzw. wo) ein
Objekt angesprochen wird. Dies lohnt sich selbstverständlich nur bei etwas umfan­
greicheren Programmen (bei "Mini"-Programmen kann man dies sofort sehen). 
 
Bei der Erstellung der Referenzliste nimmt das Programm 'referencer' gleichzeitig
einige Überprüfungen vor, die helfen können, ein Programm zu verbessern: 
 
1. Warnung bei mehrzeiligen Kommentaren. 
 
2. Überdeckungsfehler. Wird ein Objekt global (auf PACKET-Ebene) und nochmals
   lokal in einer Prozedur deklariert, ist das globale Objekt nicht mehr ansprechbar.
   Überdeckungen sind nach der gültigen Sprachdefinition z.Zt. noch erlaubt, werden
   aber bei einer Revision des Sprachstandards verboten sein. 
 
3. Mehrmaliges Einsetzen von Refinements. Wird ein Refinement mehrmals einge­
   setzt (das ist völlig legal), sollte man überlegen, ob sich dieses Refinement nicht
   zu einer Prozedur umgestalten läßt. 
 
4. Nicht angewandte Refinements. Wird ein Refinement zwar deklariert, aber nicht
   "aufgerufen", erfolgt eine Warnung. 
 
5. Nicht angesprochene Daten-Objekte. Werden Daten-Objekte zwar deklariert,
   aber im folgenden nicht angesprochen, wird eine Warnung ausgegeben. Hinweis:
   Alle Objekte, die nur wenig angesprochen werden, also nur wenige Zeilennum­
   mern in der Referenzliste besitzen, sind verdächtig (Ausnahmen: importierte
   Prozeduren, LET-Objekte u.a.m.). 
 
 

referencer - Kommandos
 
 
'referencer' 
   #on("b")#PROC referencer (TEXT CONST check file, dump file) #off("b")# 
   Überprüft 'check file'. In 'dump file' steht nach Abschluß die Referenzliste. 
 
#page# 

6.3  Rechnen im Editor 
 
Das Programm TeCal ermöglicht einfache Rechnungen (ähnlich wie mit einem Ta­
schenrechner) unter der Benutzung des Editors. Gleichzeitig stehen dem Benutzer
aber alle Fähigkeiten des Editors zur Verfügung. TeCal ermöglicht Rechnungen auf
einfache Weise zu erstellen oder Tabellenspalten zu berechnen. Zur Benutzung 
müssen 'TeCal' und 'TeCal Auskunft' insertiert werden. 
 
TeCal wird aus dem Editor heraus durch 'ESC t' oder durch das Editor-Kommando 
 
 
           tecal 
 
 
aktiviert. Dadurch wird in der untersten Zeile des Bildschirms eine Informationszeile
aufgebaut, in der die (Zwischen-) Ergebnisse einer Rechnung zur Kontrolle fest­
gehalten werden. 
 
 
 
Arbeitsweise 
 
 
Wenn TeCal insertiert ist, kann die Taschenrechnerfunktion jederzeit durch <ESC> <t>
aufgerufen werden. Aus der editierten Datei werden Werte mit <ESC> <L> gelesen,
durch <ESC> <+> (bzw. -,*,/) verknüpft und mit <ESC> <S> an die aktuelle Cursor­
position geschrieben werden. 
 
Der von TeCal errechnete Wert wird durch <ESC> <S> derart ausgegeben, daß an der
Stelle an der der Cursor steht die letzte Stelle vor dem Dezimalpunkt geschrieben
wird. 
 
Die Eingabe von Klammern geschieht durch <ESC> <(> <ESC> <)>. 
 
Durch die Hilfsfunktion <ESC> <?> lassen sich die TeCal Funktionen auflisten. 
 
Der Prozentoperator <ESC> <%> erlaubt einfache Rechnungen der Form: 'zahl' <ESC> <+>
<ESC> <%> <ESC> <=> . 
 
Derartige Folgen können natürlich mit der bekannten Editor-Lernfunktion auch ge­
lernt werden, so daß sich z.B. die Mehrwertsteuerberechnung auf wenige Tasten 
reduziert. 
 
Spalten können summiert werden, indem auf der #on("u")#untersten#off("u")# Zahl einer Spalte <ESC> <V>
eingegeben wird. Daraufhin werden alle darüberliegende Zahlen addiert, bis ein
Zeichen auftritt, das nicht in einer Zahl auftritt (Leerzeichen stören nicht!). 
 
____________________________________________________________________________ 
         ............ 
               55.00 
               66.99 
              123.45 
 
               99.99 
 
             9876.54 
         ........... 
 
 Anzeige:            0.00  14.00%  Memory:       0.00 
 
____________________________________________________________________________ 
 
 
TeCal Prozeduren 
 
 
'evaluate' 
   #on("b")#evaluate (TEXT CONST zeile, INT CONST von) #off("b")# 
   Ausdruck 'zeile' ab der Stelle 'von' berechnen. 
 
   #on("b")#evaluate (TEXT CONST zeile) #off("b")# 
   Ausdruck 'zeile' ab Stelle 1 berechnen. 
 
 
'kommastellen' 
   #on("b")#kommastellen (INT CONST stellen) #off("b")# 
   Berechnungen auf 'stellen' Zahlen hinter dem Komma einstellen. 
 
 
'merke' 
   #on("b")#PROC merke (INT CONST zahl)#off("b")# 
   Integer 'zahl' im Merkregister abspeichern. 
 
   #on("b")#PROC merke (REAL CONST zahl)#off("b")# 
   Real 'zahl' im Merkregister abspeichern. 
 
'prozentsatz' 
   #on("b")#PROC prozentsatz (INT CONST zahl) #off("b")# 
   Prozentsatz von 'zahl' Prozent einstellen. Der Wert wird automatisch konvertiert. 
 
   #on("b")#PROC prozentsatz (REAL CONST zahl) #off("b")# 
   Prozentsatz von 'zahl' Prozent einstellen. 
 
 
'tecal' 
   #on("b")#PROC tecal (FILE VAR f) #off("b")# 
   Datei 'f', die mit 'sequential file' assoziiert ist, mit TeCal editieren. 
 
   #on("b")#PROC tecal (TEXT VAR datei) #off("b")# 
   'datei' mit TeCal editieren. 
 
   #on("b")#PROC tecal #off("b")# 
   Zuletzt editierte Datei mit TeCal editieren. 
 
 
'tecalauskunft' 
   #on("b")#PROC tecalauskunft #off("b")# 
   Auskunft zeigen. 
 
   #on("b")#PROC tecalauskunft (TEXT CONST zeichen) #off("b")# 
   Auskunft zu 'zeichen' zeigen.