diff options
Diffstat (limited to 'doc/user-manual/1.7.3-pd/doc/pd.Handbuch.Teil9')
| -rw-r--r-- | doc/user-manual/1.7.3-pd/doc/pd.Handbuch.Teil9 | 936 |
1 files changed, 936 insertions, 0 deletions
diff --git a/doc/user-manual/1.7.3-pd/doc/pd.Handbuch.Teil9 b/doc/user-manual/1.7.3-pd/doc/pd.Handbuch.Teil9 new file mode 100644 index 0000000..318dd06 --- /dev/null +++ b/doc/user-manual/1.7.3-pd/doc/pd.Handbuch.Teil9 @@ -0,0 +1,936 @@ + EUMEL-Benutzerhandbuch + + TEIL 9: Standard-Datentypen + +1. VECTOR und MATRIX + +Vektoren und Matrizen enthalten Elemente vom Datentyp REAL. Für beide Daten- +typen sind die üblichen Operatoren definiert. Im Unterschied zu "normalen" +'ROW n REAL' bzw. 'ROW n ROW m REAL' brauchen die Anzahl der Elemente, die +sich in einem Vektor bzw. in einer Matrix befinden, nicht bereits zur Über- +setzungszeit deklariert, sondern können "dynamisch" zur Laufzeit eines ELAN- +Programms festgelegt werden. Somit ist es möglich, eine zur Übersetzungszeit +noch unbekannte Anzahl von REAL-Elementen zu bearbeiten und dabei nur soviel +Speicherplatz wie notwendig zu verwenden. Bei beiden Datentypen ist die +maximale Anzahl von Elementen jeweils 4 000. + +Bei VECTOR und MATRIX ist auf die üblichen Rundungsfehler bei der Verwendung +von REALs zu achten, die bei umfangreicheren Rechnungen unvermeidlich ent- +stehen. Rundungsfehler durch Ein- bzw. Ausgaberoutinen können z.Zt. im +EUMEL-System jedoch nicht vorkommen, weil REAL-Werte dezimal im Rechner +abgespeichert werden (13 Stellen, von denen jedoch nur 7 ausgegeben werden). + + + +VECTOR + +Folgende VECTOR-Operationen stehen zur Verfügung: + +vector Erzeugung eines VECTOR-Objekts +get Eingabe der Elemente vom Terminal +put Ausgabe der Elemente auf das Terminal +replace Ersetzung eines Elementes eines VECTORs +SUB Zugriff auf ein REAL-Element eines VECTORs +LENGTH Anzahl der Elemente eines VECTORs +length dito +NORM Euklidische Norm + + + - + * + / + := + = + <> + + + +Beschreibung der VECTOR-Operationen + +Aus Optimierungsgründen (Heapbelastung) wurde der Datentyp INITVECTOR ge- +schaffen. Dieser wird im VECTOR-Paket intern gehalten (wird nicht über das +Interface herausgereicht) und kann somit nicht in einer Deklaration benutzt +werden. INITVECTOR wird nur für die Operationen + + := + vector + +verwendet. Bei Verwendung eines Datenobjekts vom Datentyp INITVECTOR wird +nicht soviel Speicherplatz wie bei einem Objekt vom Datentyp VECTOR benötigt. + += + BOOL OP = (VECTOR CONST a, b) + Zweck: 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 *) + +<> + BOOL OP <> (VECTOR CONST a, b) + Zweck: Vergleich zweier Vektoren auf Ungleichheit (NOT (a = b)). + +:= + OP := (VECTOR VAR ziel, VECTOR CONST quelle) + Zweck: 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 Zu- + weisung mehr oder weniger Elemente als 'quelle' besaß. Beispiel: + + VECTOR VAR y :: vector (10, 1.0), + z :: vector (15, 2.0); + ... + y := z; (* length (y) liefert nun 15 ! *) + + OP := (VECTOR VAR ziel, INITVECTOR CONST quelle) + Zweck: 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 Speicher- + platz verbraucht. + ++ + VECTOR OP + (VECTOR CONST a) + Zweck: Monadisches '+' für VECTOR. Keine Auswirkung. + + VECTOR OP + (VECTOR CONST a, b) + Zweck: Elementweise Addition der Vektoren 'a' und 'b'. Beispiel: + + VECTOR VAR x, (* 'x' hat undefinierte Laenge *) + a :: vector (10, 1.0), + b :: vector (10, 2.0); + ... + x := a + b; (* 'x' hat nun 10 Elemente mit Werten '3.0' *) + Fehlerfall: + * VECTOR OP + : LENGTH a <> LENGTH b + 'a' und 'b' haben nicht die gleiche Anzahl von Elementen. + +- + VECTOR OP - (VECTOR CONST a) + Zweck: Monadisches '-'. + + VECTOR OP - (VECTOR CONST a, b) + Zweck: Elementweise Subtraktion der Vektoren 'a' und 'b'. + Fehlerfall: + * VECTOR OP - : LENGTH a <> LENGTH b + 'a' und 'b' haben nicht die gleiche Anzahl von Elementen. + +* + REAL OP * (VECTOR CONST a, b) + Zweck: Skalarprodukt zweier Vektoren. Liefert die Summe der element- + weisen Multiplikation der Vektoren 'a' und 'b'. Beachte even- + tuelle Rundungsfehler! Beispiel: + + REAL VAR a; + VECTOR VAR b :: vector (10, 2.0), + c :: vector (10, 2.0); + ... + a := b * c; (* 40.0 *) + Fehlerfall: + * REAL OP * : LENGTH a <> LENGTH b + 'a' und 'b' haben nicht die gleiche Anzahl von Elementen. + + VECTOR OP * (VECTOR CONST a, REAL CONST s) + Zweck: Multiplikation des Vektors 'a' mit dem Skalar 's'. + + VECTOR OP * (REAL CONST s, VECTOR CONST a) + Zweck: Multiplikation des Skalars 's' mit dem Vektor 'a'. + +/ + VECTOR OP / (VECTOR CONST a, REAL CONST s) + Zweck: 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' *) + +get + PROC get (VECTOR VAR a, INT CONST l) + Zweck: Einlesen der Elemente von 'a' vom Terminal, wobei 'l' die Anzahl + der Elemente angibt. + Fehlerfall: + * PROC get : size <= 0 + Die angeforderte Elementanzahl 'l' muß > 0 sein. + +length + INT PROC length (VECTOR CONST a) + Zweck: 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 *) + +LENGTH + INT OP LENGTH (VECTOR CONST a) + Zweck: Liefert die Anzahl der Elemente von 'a'. + +NORM + REAL OP NORM (VECTOR CONST v) + Zweck: Euklidische Norm (Wurzel aus der Summe der Quadrate der Elemente). + +put + PROC put (VECTOR CONST v) + Zweck: Ausgabe der Werte der Elemente von 'v' auf dem Terminal. + +replace + PROC replace (VECTOR VAR v, INT CONST i, REAL CONST r) + Zweck: 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' *) + Fehlerfälle: + * PROC replace : subscript overflow + Der Index 'i' mit dem Wert 'm' liegt außerhalb des Vektors (i > + LENGTH v). + * PROC replace : subscript underflow + Der Index 'i' mit dem Wert 'm' liegt außerhalb des Vektors + (i < 1). + +SUB + REAL OP SUB (VECTOR CONST v, INT CONST i) + Zweck: Liefert das 'i'-te Element von 'v'. + Fehlerfälle: + * OP SUB : subscript overflow + Der Index 'i' mit dem Wert 'm' liegt außerhalb des Vektors (i > + LENGTH v). + * OP SUB : subscript underflow + Der Index 'i' mit dem Wert 'm' liegt außerhalb des Vektors + (i < 1). + +vector + INITVECTOR PROC vector (INT CONST l) + Zweck: 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. + Fehlerfall: + * PROC vector : size <= 0 + Die angeforderte Elementanzahl 'l' muß > 0 sein. + + INITVECTOR PROC vector (INT CONST l, REAL CONST value): + Zweck: 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' *) + Fehlerfall: + * PROC vector : size <= 0 + Die angeforderte Elementanzahl 'l' muß > 0 sein. + + + +MATRIX + +Folgende Operationen stehen für MATRIX zur Verfügung: + +matrix Erzeugung eines MATRIX-Objekts +idn Erzeugung einer Einheitsmatrix +put Ausgabe der MATRIX auf dem Terminal +get Eingabe der Matrix vom Terminal +replace row Ersetzung einer Zeile +replace column Ersetzung einer Spalte +replace element Ersetzung eines Elements +row Liefert einen VECTOR (Zeile einer MATRIX) +column Liefert einen VECTOR (Spalte einer MATRIX) +sub Liefert ein REAL-Elemement +COLUMNS Anzahl Spalten +ROWS Anzahl Zeilen +INV Inverse +DET Determinante +TRANSP Transponierte +transp Transponierte (speicherfreundlich) + + + - + * + := + = + <> + + + +Beschreibung der MATRIX-Operationen + +Aus Optimierungsgründen (Heapbelastung) wurde der Datentyp INITMATRIX +geschaffen. Dieser wird im MATRIX-Paket intern gehalten (wird nicht über das +Interface herausgereicht) und kann somit nicht in einer Deklaration benutzt +werden. INITMATRIX wird nur für die Operationen + + := + idn + matrix + +verwendet. Bei Verwendung eines Objekts vom Datentyp INITMATRIX wird nicht +der Speicherplatz für eine MATRIX benötigt. + ++ + MATRIX OP + (MATRIX CONST m) + Zweck: Monadisches '+'. Keine Auswirkungen. + + MATRIX OP + (MATRIX CONST l, r) + Zweck: 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' *) + Fehlerfälle: + * 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. + +- + MATRIX OP - (MATRIX CONST m) + Zweck: Monadisches Minus. Beispiel: + + MATRIX VAR a :: matrix (3, 4, 10.0) + a := - a; (* Alle Elemente haben den Wert '-10.0' *) + + MATRIX OP - (MATRIX CONST l, r) + Zweck: Subtraktion zweier Matrizen. Die Anzahl der Reihen und Spalten + muß gleich sein. + Fehlerfälle: + * 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. + +* + MATRIX OP * (REAL CONST r, MATRIX CONST m) + Zweck: 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' *) + + MATRIX OP * (MATRIX CONST m, REAL CONST r) + Zweck: Multiplikation einer Matrix 'm' mit einem Skalar 'r'. + + MATRIX OP * (MATRIX CONST l, r) + Zweck: 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' *) + Fehlerfall: + * MATRIX OP * : COLUMNS l <> ROWS r + Die Anzahl der Spalten von 'l' muß mit der Anzahl der Zeilen + von 'r' übereinstimmen. + + VECTOR OP * (VECTOR CONST v, MATRIX CONST m) + Zweck: Multiplikation des Vektors 'v' mit der Matrix 'm'. + Fehlerfall: + * VECTOR OP * : LENGTH v <> ROWS m + Die Anzahl der Elemente von 'v' stimmt nicht mit den Anzahl der + Zeilen von 'm' überein. + + VECTOR OP * (MATRIX CONST m, VECTOR CONST v) + Zweck: Multiplikation der Matrix 'm' mit dem Vektor 'v'. + Fehlerfall: + * VECTOR OP * : COLUMNS m <> LENGTH v + Die Anzahl der Spalten von 'm' stimmt nicht mit der Anzahl der + Elementen von 'v' überein. + += + BOOL OP = (MATRIX CONST l, r) + Zweck: 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 *) + +<> + BOOL OP <> (MATRIX CONST l, r) + Zweck: Vergleich der Matrizen 'l' und 'r' auf Ungleichheit. + +:= + OP := (MATRIX VAR l, MATRIX CONST r) + Zweck: 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 *) + + OP := (MATRIX VAR l, INITMATRIX CONST r) + Zweck: 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 Speicher- + platz verbraucht. + +column + VECTOR PROC column (MATRIX CONST m, INT CONST i) + Zweck: 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' *) + Fehlerfälle: + * 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). + +COLUMNS + INT OP COLUMNS (MATRIX CONST m) + Zweck: 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 + REAL OP DET (MATRIX CONST m) + Zweck: Es wird der Wert der Determinanten von 'm' geliefert. + Fehlerfall: + * OP DET : no square matrix + Die Matrix ist nicht quadratisch, d.h. ROWS m <> COLUMNS m + +get + PROC get (MATRIX VAR m, INT CONST rows, columns) + Zweck: Einlesen von Werten für die Matrix 'm' vom Terminal mit 'rows'- + Zeilen und 'columns'-Spalten. + +idn + INITMATRIX PROC idn (INT CONST size) + Zweck: 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 + Diagonalelemente, die den Wert '1.0' haben. *) + Fehlerfall: + * PROC idn : size <= 0 + Die angeforderte 'size' Anzahl Spalten oder Zeilen muß > 0 sein. + +INV + MATRIX OP INV (MATRIX CONST m) + Zweck: Liefert als Ergebnis die Inverse von 'm' (Achtung: starke Run- + dungsfehler möglich). + Fehlerfälle: + * 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. + +matrix + INITMATRIX PROC matrix (INT CONST rows, columns) + Zweck: 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); + Fehlerfälle: + * PROC matrix : rows <= 0 + Die angeforderte Zeilenanzahl 'rows' muß > 0 sein. + * PROC matrix : columns <= 0 + Die angeforderte Spaltenanzahl 'columns' muß > 0 sein. + + INITMATRIX PROC matrix (INT CONST rows, columns, REAL CONST value) + Zweck: Erzeugen eines Datenobjekts vom Datentyp MATRIX mit 'rows' + Zeilen und 'columns' Spalten. Alle Elemente der erzeugten MATRIX + werden mit dem Wert 'value' initialisiert. Beispiel: + + MATRIX CONST :: matrix (3, 3, 3.14); + Fehlerfälle: + * PROC matrix : rows <= 0 + Die angeforderte Zeilenanzahl 'rows' muß > 0 sein. + * PROC matrix : columns <= 0 + Die angeforderte Spaltenanzahl 'columns' muß > 0 sein. + +put + PROC put (MATRIX CONST m) + Zweck: Ausgabe der Werte einer Matrix auf dem Terminal. + +replace column + PROC replace column (MATRIX VAR m, INT CONST column index, + VECTOR CONST column value) + Zweck: 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 *) + Fehlerfälle: + * 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 + PROC replace element (MATRIX VAR m , INT CONST row, column, + REAL CONST value) + Zweck: 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); + Fehlerfälle: + * 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 + PROC replace row (MATRIX VAR m, INT CONST rowindex, + VECTOR CONST rowvalue) + Zweck: 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 *) + Fehlerfälle: + * 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). + +row + VECTOR PROC row (MATRIX CONST m, INT CONST i) + Zweck: Die 'i'-te Reihe von 'm' wird als VECTOR mit 'COLUMNS m' + Elementen geliefert. Beispiel: + + MATRIX CONST a :: matrix (3, 4); + VECTOR VAR b :: row (a, 1); + (* 'b' hat vier Elemente mit den Werten '0.0'*) + Fehlerfälle: + * 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). + +ROWS + INT OP ROWS (MATRIX CONST m) + Zweck: 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 *) + +sub + REAL PROC sub (MATRIX CONST m, INT CONST row, column) + Zweck: 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)); + Fehlerfälle: + * 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 + MATRIX OP TRANSP (MATRIX CONST m) + Zweck: Liefert als Ergebnis die transponierte Matrix 'm'. + +transp + PROC transp (MATRIX VAR m) + Zweck: Transponieren der Matrix 'm', wobei kaum zusätzlicher Speicher- + platz benötigt wird. + + + +2. COMPLEX + +Das COMPLEX-Paket ist im ausgelieferten Standard-System noch nicht vorüber- +setzt, sondern wird im Quellcode ausgeliefert und kann so bei Bedarf von +jeder EUMEL-Installation in die implementationsabhängigen Standard-Pakete +aufgenommen werden. + +Folgende Operationen stehen für COMPLEX zur Verfügung: + +put Ausgabe auf dem Terminal +get Eingabe auf dem Terminal +complex zero Denotierungsprozedur +complex one dito +complex i dito +complex dito +real part Realteil eines komplexen Werts +imag part Imaginärteil eines komplexen Werts +phi Winkel in der Polardarstellung (Radiant) +dphi dito, in Winkelgrad +CONJ Konjugiert komplexer Wert +sqrt Wurzelfunktion + + + - + * + / + := + = + <> + + + +Beschreibung der COMPLEX-Operationen + += + BOOL OP = (COMPLEX CONST a, b) + Zweck: Vergleich von 'a' und 'b' auf Gleichheit. + +:= + OP := (COMPLEX VAR a, COMPLEX CONST b) + Zweck: Zuweisung. + +<> + BOOL OP <> (COMPLEX CONST a, b) + Zweck: Vergleich von 'a' und 'b' auf Ungleichheit. + ++ + COMPLEX OP + (COMPLEX CONST a, b) + Zweck: Summe von 'a' und 'b'. + +- + COMPLEX OP - (COMPLEX CONST a, b) + Zweck: Differenz von 'a' und 'b'. + +* + COMPLEX OP * (COMPLEX CONST a, b) + Zweck: Multiplikation von 'a' mit 'b'. + +/ + COMPLEX OP / (COMPLEX CONST a, b) + Zweck: Division von 'a' mit 'b'. + +ABS + REAL OP ABS (COMPLEX CONST x) + Zweck: REAL-Betrag von 'x'. + +complex + COMPLEX PROC complex (REAL CONST re, im) + Zweck: Denotierungsprozedur. Angabe in kartesischen Koordinaten. + +complex i + COMPLEX PROC complex i + Zweck: Denotierungsprozedur für den komplexen Wert '0.0 + i 1.0'. + +complex one + COMPLEX PROC complex one + Zweck: Denotierungsprozedur für den komplexen Wert '1.0 + i 0.0'. + +complex zero + COMPLEX PROC complex zero + Zweck: Denotierungsprozedur für den komplexen Wert '0.0 + i 0.0'. + +CONJ + COMPLEX OP CONJ (COMPLEX CONST number) + Zweck: Liefert den konjugiert komplexen Wert von 'number'. + +dphi + REAL PROC dphi (COMPLEX CONST x) + Zweck: Winkel von 'x' (Polardarstellung). + +get + PROC get (COMPLEX VAR a) + Zweck: Einlesen eines komplexen Wertes vom Bildschirm in der Form + zweier REAL-Denoter. Die Eingabe kann editiert werden. + +imag part + REAL PROC imag part (COMPLEX CONST number) + Zweck: Liefert den Imaginärteil des komplexen Wertes 'number'. + +phi + REAL PROC phi (COMPLEX CONST x) + Zweck: Winkel von 'x' (Polardarstellung) in Radiant. + +put + PROC put (COMPLEX CONST a) + Zweck: Ausgabe eines komplexen Wertes auf dem Bildschirm in Form zweier + REAL-Werte. Hinter jedem REAL-Wert wird ein Leerzeichen angefügt. + +real part + REAL PROC real part (COMPLEX CONST number) + Zweck: Liefert den Real-Teil des komplexen Wertes 'number'. + +sqrt + COMPLEX PROC sqrt (COMPLEX CONST x) + Zweck: Wurzelfunktion für komplexe Werte. + + + +3. LONGINT + +LONGINT ist ein Datentyp, für den (fast) alle Prozeduren und Operatoren des +Datentyps 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: + +get Eingabe vom Terminal +put Ausgabe vom Terminal +ABS, abs Absolutbetrag +INCR, DECR Addition und Zuweisung bzw. Subtraktion und Zuweisung +DIV Division ohne Rest +int, text Konvertierungen +longint dito +max, min Maximum bzw. Minimum zweier LONGINTs +MOD Modulo-Funktion +random Zufallszahlen +sign Vorzeichen + < + > + <= + <> + = + - + + + * + ** + + + +Beschreibung der LONGINT-Operationen + +< + BOOL OP < (LONGINT CONST left, right) + Zweck: Vergleichen zweier LONGINTs auf kleiner. + +> + BOOL OP > (LONGINT CONST left, right) + Zweck: Vergleichen zweier LONGINTs auf größer. + +<= + BOOL OP <= (LONGINT CONST left, right) + Zweck: Vergleichen zweier LONGINTs auf kleiner gleich. + +>= + BOOL OP >= (LONGINT CONST left, right) + Zweck: Vergleichen zweier LONGINTs auf größer gleich. + +<> + BOOL OP <> (LONGINT CONST left, right) + Zweck: Vergleichen zweier LONGINTs auf Ungleichheit. + += + BOOL OP = (LONGINT CONST left, right) + Zweck: Vergleichen zweier LONGINTs auf Gleichheit. + +- + LONGINT OP - (LONGINT CONST argument) + Zweck: Vorzeichenumkehrung. + + LONGINT OP - (LONGINT CONST left, right) + Zweck: Subtraktion zweier LONGINTs. + ++ + LONGINT OP + (LONGINT CONST argument) + Zweck: Monadischer Operator. Ohne Wirkung. + + LONGINT OP + (LONGINT CONST left, right) + Zweck: Addition zweier LONGINTs. + +* + LONGINT OP * (LONGINT CONST left, right) + Zweck: Multiplikation von zwei LONGINTs. + +** + LONGINT OP ** (LONGINT CONST argument, exponent) + Zweck: Exponentiation zweier LONGINTs mit positivem Exponenten. + Fehlerfälle : + * LONGINT OP ** : negative exponent + Der 'exponent' muß >= 0 sein. + * 0 ** 0 is not defined + 'argument' und 'exponent' dürfen nicht gleich 0 sein. + + + LONGINT OP ** (LONGINT CONST argument, INT CONST exponent) + Zweck: Exponentiation eines LONGINT mit positiven INT Exponenten. + Fehlerfälle : + * LONGINT OP ** : negative exponent + Der 'exponent' muß >= 0 sein. + * 0 ** 0 is not defined + 'argument' und 'exponent' dürfen nicht gleich 0 sein. + +ABS + LONGINT OP ABS (LONGINT CONST argument) + Zweck: Absolutbetrag eines LONGINT. + +abs + LONGINT PROC abs (LONGINT CONST argument) + Zweck: Absolutbetrag eines LONGINT. + +DECR + OP DECR (LONGINT VAR resultat, LONGINT CONST ab) + Zweck: resultat := resultat - ab + +DIV + LONGINT OP DIV (LONGINT CONST left, right) + Zweck: Division zweier LONGINTs. + Fehlerfall : + * divide by zero + 'right' muß <> 0 sein. + +get + PROC get (LONGINT VAR zahl) + Zweck: Eingabe eines LONGINTs vom Terminal. + + PROC get (FILE VAR file, LONGINT VAR zahl) + Zweck: Einlesen von 'zahl' aus der sequentiellen Datei 'file'. Die + Datei muß mit 'input' assoziiert sein (vergl. 'sequential file'). + Fehlerfälle : + * file not open + Die Datei 'file' ist gegenwärtig nicht assoziiert. + * input after end of file + Es wurde versucht, über die letzte Zeile einer Datei zu lesen. + * input access to output file + Es wurde versucht, von einem mit 'output' assoziierten FILE zu + lesen. + +INCR + LONGINT OP INCR (LONGINT VAR resultat, LONGINT CONST dazu) + Zweck: resultat := resultat + dazu + +int + INT PROC int (LONGINT CONST longint) + Zweck: Konvertierung von LONGINT nach INT. + Fehlerfall : + * integer overflow + 'longint' ist größer als 'maxint'. + +longint + LONGINT PROC longint (INT CONST int) + Zweck: Konvertierung von 'int' nach LONGINT. + + LONGINT PROC longint (TEXT CONST text) + Zweck: Konvertierung von 'text' nach LONGINT. + +max + LONGINT PROC max (LONGINT CONST left, right) + Zweck: Liefert das Maximum zweier LONGINTs. + +min + LONGINT PROC min (LONGINT CONST left, right) + Zweck: Liefert das Minimum zweier LONGINTs. + +MOD + LONGINT OP MOD (LONGINT CONST left, right) + Zweck: Modulo-Funktion für LONGINTs. Der Rest einer LONGINT-Division + wird ermittelt. + Fehlerfall : + * text (left) + 'MOD 0' + 'right' muß ungleich null sein. + +put + PROC put (LONGINT CONST longint) + Zweck: 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 fort- + gesetzt. + + PROC put (FILE VAR file, LONGINT CONST zahl) + Zweck: Ausgabe von 'zahl' in die sequentielle Datei 'file'. 'file' muß + mit 'output' assoziiert sein. + Fehlerfälle : + * file not open + Die Datei 'file' ist gegenwärtig nicht assoziiert. + * output access to input file + Es wurde versucht, auf einem mit 'input' assoziierten FILE zu + schreiben. + +random + LONGINT PROC random (LONGINT CONST lower bound, upper bound) + Zweck: Pseudo-Zufallszahlen-Generator im Intervall 'lower bound' und + 'upper bound' einschließlich. Es handelt sich hier um den + 'LONGINT Random Generator'. + +SIGN + INT OP SIGN (LONGINT CONST longint) + Zweck: Feststellen des Vorzeichens von 'longint'. Liefert: + + 0 wenn 'longint' = 0, + 1 wenn 'longint' > 0, + -1 wenn 'longint' < 0. + +sign + INT PROC sign (LONGINT CONST longint) + Zweck: Feststellen des Vorzeichens von 'longint'. Liefert: + + 0 wenn 'longitt' = 0, + 1 wenn 'longint' > 0, + -1 wenn 'longint' < 0. + +text + TEXT PROC text (LONGINT CONST longint) + Zweck: Konvertierung von 'longint' nach TEXT. + + TEXT PROC text (LONGINT CONST longint, INT CONST laenge) + Zweck: 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' eingetragen. 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)) > length + + wird ein Text mit der Länge 'length' geliefert, der mit + '*'-Zeichen gefüllt ist. + |