Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- cpm:mumath_einstieg [2010/09/22 13:10] – volkerp
+++ cpm:mumath_einstieg [2013/02/04 17:47] (aktuell) – [2.6 PROPERTY-FUNKTIONEN] volkerp
@@ Zeile 5: / Zeile 5: @@
 ===== Kurz-Anleitung zum Arbeiten mit "muMATH-83" =====
-<file - mumath.txt>
 Kurz-Anleitung zum Arbeiten mit "muMATH-83" + Übungs- und Demo-Texte
 TGM_96: MUMATH.TXT, TGM_97: MUMATH.ARC
-Dr. Fridbert Widder, #326
-Auf der PCC-TGM Diskette #1187 befinden sich das Programm  MUSIMP.COM
-und die vier "memory image files"                          ALGEBRA.SYS
-                                                           CALCULUS.SYS
-                                                           MATSOL.SYS
-                                                           PDS.SYS
-Um algebraische Umformungen zu machen bzw., um die vier Rechentechnik-
+**Dr. Fridbert Widder**, #326
+Auf der PCC-TGM Diskette #1187 befinden sich das Programm  MUSIMP.COM\\
+und die vier "memory image files" ALGEBRA.SYS, CALCULUS.SYS, MATSOL.SYS, PDS.SYS
+Um algebraische Umformungen zu machen bzw. um die vier Rechentechnik-
 Übungen CLES1.ALG bis CLES4.ALG zu bearbeiten, startet man am besten mit
 (der DOS-Eingabe):
-MUSIMP ALGEBRA
-Nach kurzer Lade-Zeit kommt die System-Meldung und das "?", das eine
+**MUSIMP ALGEBRA**
+Nach kurzer Lade-Zeit kommt die System-Meldung und das "**?**", das eine
 muSIMP-Eingabe erwartet.
@@ Zeile 26: / Zeile 25: @@
 "interaction cycle" aus: Abschließen der muSIMP-Eingaben mit dem ";"
 nicht vergessen - sonst geschieht nichts!
-(Verlassen des Programms mit:  SYSTEM();)
+(Verlassen des Programms mit:  **SYSTEM();**)
 Oder/und man geht der Reihe nach die "Calculator mode LESssons" durch -
 mit dem "ReaD Select"-Kommando:
-                               RDS(CLES1, ALG, A);
-gelangt man sofort "in" die erste Übung (, wenn sich CLES1.ALG auf der
+**RDS(CLES1, ALG, A);**
+gelangt man sofort "in" die erste Übung (wenn sich CLES1.ALG auf der
 Diskette im angegebenen Laufwerk A befindet).
@@ Zeile 40: / Zeile 41: @@
 die man am Ende der diversen "muMATH source files" findet).
-(Vorher noch ein Hinweis zu den weiteren bereitge-
+(Vorher noch ein Hinweis zu den weiteren bereitgestellten "memory image files": Der Zweck der zwei Dateien  CALCULUS und
-stellten "memory image files": Der Zweck der zwei Dateien  CALCULUS und
 MATSOL.SYS  ist offensichtlich - PDS.SYS hilft beim Studieren der
 Programmier-Lektionen PLES1 bis PLES5 und PLES7 und PLES8.PDS. "SYS"-
@@ Zeile 50: / Zeile 50: @@
 anschließend die Texte zu den "muMATH"-Demonstrationsbeispielen folgen,
 füge ich*) noch ein "Inhalts-Verzeichnis" dieser Zusammenfassung ein --
-die Seiten-Numerierung wurde so gewählt, daß man diese Seiten als Er-
+die Seiten-Numerierung wurde so gewählt, daß man diese Seiten als Ergänzung zu den Seiten 8-1 und 8-2 des Handbuches ansehen kann.
-gänzung zu den Seiten 8-1 und 8-2 des Handbuches ansehen kann.
-                                                       *) F. Widder
+*) F. Widder\\
-                                                       Graz, 15. 9.1988
+Graz, 15. 9.1988
-   INHALT der Zusammenfassung der Übungs- und Demonstrations-Beispiele
+==== INHALT der Zusammenfassung der Übungs- und Demonstrations-Beispiele "muMATH-83" ====
-                                "muMATH-83"
 Seite  Inhalt:
 -3  CLES1: Übungsablauf, Eingeben und Auswerten einfacher algebraischer
-          Formeln, Zuweisungen (von Werten an Variable)
+Formeln, Zuweisungen (von Werten an Variable)
 -5  CLES2: Kontrollvariable RDS, ECHO, BELL, POINT, PBRCH, Funktion
-          RADIX, Faktorielle, #PI, #I, #E
+RADIX, Faktorielle, #PI, #I, #E
 -7  CLES3: Variable (mit bzw. ohne Wertzuweisung - der 'Operator),
-          Funktionen EXPAND, EXPD, FCTR, DIVOUT, PQUOT, PREM, PGCD,
+Funktionen EXPAND, EXPD, FCTR, DIVOUT, PQUOT, PREM, PGCD,
-          PARFRAC, NUM, DEN, COEFF, CODIV, BASE, EXPON, CONJ, RATIONALIZE,
+PARFRAC, NUM, DEN, COEFF, CODIV, BASE, EXPON, CONJ, RATIONALIZE,
-          Speicherplatz-Abfrage RECLAIM();
+Speicherplatz-Abfrage RECLAIM();
 -9  CLES4: Aktuelle Werte von Variablen - EVAL, ESUB
-          Kontrollvariable (Übersicht - FLAGS();) - NUMNUM, ... DENDEN
+Kontrollvariable (Übersicht - FLAGS();) - NUMNUM, ... DENDEN
 -12 Ergänzungen, NEWLINE, ....
@@ Zeile 79: / Zeile 81: @@
 -15 EQN.ALG: Der Gleichungs-Operator == , Umformen von Gleichungen,
-     SOLVE.EQN: Lösen mit SOLVE(Glg, Var)  -  vgl. S. 8-21: LINEQN.MAT
+SOLVE.EQN: Lösen mit SOLVE(Glg, Var)  -  vgl. S. 8-21: LINEQN.MAT
 -16 ODE.SOL:  "Ordinary Differential Equations"
 -17 ODENTH.ODE: "   ---   "  -   of N-TH order"
 -18 ODEMORE.ODE: "   ---   " -  , MORE about"
 -19 ARRAY.ARI: (Spalten- und Zeilen-)Vektoren, Matrizen
 -20 MATRIX.ARR: Matrix-Operationen
 -21 LINEQN.MAT: Lineare Gleichungssysteme - Matrix-Inversion
-     ABSVAL.ALG: ABS als Präfix-Operator
+ABSVAL.ALG: ABS als Präfix-Operator
 -22 LOG.ALG: Logarithmus-Funktionen
@@ Zeile 99: / Zeile 105: @@
 -27 INT.DIF: bestimmte und unbestimmte Integrale
--28 INTMORE.INT: Mehr darüber -  "  -
-     LIM.DIF: Grenzwertbestimmung
+-28 INTMORE.INT: Mehr über Integrale
+LIM.DIF: Grenzwertbestimmung
 -29 SIGMA.DIF: Summationen
@@ Zeile 107: / Zeile 114: @@
 -31 VECDIF.VEC: Vektor-Differential- und Integral-Operationen,
-                (DIV, CURL, GRAD, ...)
+(DIV, CURL, GRAD, ...)
 Anm.d.Red.: Den Abdruck der hier nur zusammenfassend erwähnten Übungs- und Demonstrationsbeispiele finden Sie in der Datei MUMATH.DOC.
-</file>
 ===== PROGRAMMIEREN mit muSIMP =====
-<file - musimp.txt>
+PROGRAMMIEREN mit muSIMP\\
-                         PROGRAMMIEREN mit muSIMP
+TGM_96: MUSIMP.TXT, TGM_97: MUSIMP.ARC\\
-TGM_96: MUSIMP.TXT, TGM_97: MUSIMP.ARC
+**Dr. Fridbert Widder**, #326
-Dr. Fridbert Widder, #326
 muSIMP (und ähnliche Programm-Sprachen wie z.B. ST-MATH für den ATARI-ST)
@@ Zeile 127: / Zeile 132: @@
-.1 STRUKTUR der DATEN
+==== 1.1 STRUKTUR der DATEN ====
 Es gibt drei elementare Grundstrukturen:
-NAMEn
+NAMEn\\
-INTEGERs = Zahlen
+INTEGERs = Zahlen\\
 NODEs = Knoten
@@ Zeile 139: / Zeile 144: @@
-NAME: Ein Name besteht aus drei Zeigern - die beiden ersten Zeiger erhält
+**NAME**: Ein Name besteht aus drei Zeigern - die beiden ersten Zeiger erhält
-        man durch Anwendung der Funktionen FIRST bzw. REST:
+man durch Anwendung der Funktionen FIRST bzw. REST:
-.Zeiger (FIRST-->) weist auf den Wert des Namens; bei der ersten
+  * 1.Zeiger (FIRST-->) weist auf den Wert des Namens; bei der ersten Verwendung eines Namens weist der 1.Zeiger auf den Namen selbst.
-        Verwendung eines Namens weist der 1.Zeiger auf den Namen selbst.
-.Zeiger (REST -->) weist auf die "property"-Liste; bei der ersten
+  * 2.Zeiger (REST -->) weist auf die "property"-Liste; bei der ersten Verwendung wird dem Namen die "leere Eigenschaft" FALSE beigegeben.
-        Verwendung wird dem Namen die "leere Eigenschaft" FALSE beigegeben.
-.Zeiger weist auf Funktions-Definition, falls der Name eine Funktion
+  * 3.Zeiger weist auf Funktions-Definition, falls der Name eine Funktion definiert - sonst auf FALSE.
-        definiert - sonst auf FALSE.
 Hinter diesen drei Zeigern steht noch die ASCII-Zeichenkette des "Namens"
@@ Zeile 158: / Zeile 160: @@
-INTEGER: ist aus verarbeitungs-technischen Gründen analog strukturiert:
+**INTEGER**: ist aus verarbeitungs-technischen Gründen analog strukturiert:
-.Zeiger --> Wert der Zahl
+  * 1.Zeiger --> Wert der Zahl
-.Zeiger --> Vorzeichen (als "property") der Zahl: + = FALSE
+  * 2.Zeiger --> Vorzeichen (als "property") der Zahl: + = FALSE, - = TRUE\\ Daher also Vorzeichentest durch REST(zahl)& - Eingabe!
-                                                   - = TRUE
+  * 3.Zeiger weist auf den Speicherbereich, in dem die Zahl binär gespeichert ist. (Kein Zugriff durch den Benutzer)
-             Daher also Vorzeichentest durch REST(zahl)& - Eingabe!
-.Zeiger weist auf den Speicherbereich, in dem die Zahl binär gespeichert
-             ist. (Kein Zugriff durch den Benutzer)
 Mit den "recognicer"-Funktionen NAME(argum) und INTEGER(argum) kann man
@@ Zeile 171: / Zeile 170: @@
-NODE: Ein Knoten besteht aus ZWEI ZEIGERN, die auf die Adressen beliebiger
+**NODE**: Ein Knoten besteht aus ZWEI ZEIGERN, die auf die Adressen beliebiger
-      Daten-Strukturen zeigen - sowohl auf Atome, als auch wieder auf
+Daten-Strukturen zeigen - sowohl auf Atome, als auch wieder auf
-      Knoten, so daß beliebig komplexe Netzwerke entstehen können.
+Knoten, so daß beliebig komplexe Netzwerke entstehen können.
+Eine einfache graphische Darstellung:
+<code>
+Knoten-Nummer => Zahl.
+.Zeiger (FIRST) =>  |
+.Zeiger (REST)  => ---
+</code>
-Eine einfache graphische Darstellung:  Knoten-Nummer => Zahl.
-.Zeiger (FIRST) =>  |
-.Zeiger (REST)  => ---
 Einfache Beispiele:
+<code>
 .---31
                        |
@@ Zeile 194: / Zeile 199: @@
  |    |    |    |
  A    B    C    D
+</code>
 Die dritte Ketten-Struktur hat einen eigenen Namen - es ist eine LISTE.
@@ Zeile 200: / Zeile 206: @@
 & Befehl. - Am besten dazu ein Beispiel probieren:
-        Falls Sie nicht ohnehin muSIMP geladen haben, dazu also
+Falls Sie nicht ohnehin muSIMP geladen haben, dazu also
-        MUSIMP PDS eingeben (- lädt den Progamm-Demo System-file -)
+MUSIMP PDS eingeben (- lädt den Progamm-Demo System-file -)
-                   und beispielsweise den Unterschied zwischen den
+und beispielsweise den Unterschied zwischen den
-                   Ausgabe-Befehlen ; und & ausprobieren:
+Ausgabe-Befehlen ; und & ausprobieren:
         ? a: -5$
         ? a;
         ? a&
-        Viele weitere Übungen zu den Grund-Strukturen sind im muMATH-
+Viele weitere Übungen zu den Grund-Strukturen sind im muMATH-
-        Paket PLES1.PDS enthalten - einzulesen mit RDS(PLES1,PDS<,Laufw.>);
+Paket PLES1.PDS enthalten - einzulesen mit RDS(PLES1,PDS<,Laufw.>);
 In der Folge beziehe ich mich auf diese erste "Programming LESson 1".
@@ Zeile 216: / Zeile 223: @@
 erklärt - es handelt sich um die "dotted pair"-Darstellung, die wie folgt
 eingegeben wird:
 Beginn mit dem (= Präfix-Operator) '
 ein Knoten, dessen 1. bzw. 2.Zeiger auf A bzw. B weist, wird dargestellt
@@ Zeile 230: / Zeile 238: @@
 SECOND() = FIRST(REST())           (auch als FREST zu bezeichnen)
 THIRD() = FIRST(REST(REST()))      (analog: FRREST) -
-RREST, FFIRST, RFIRST, FFREST, RFREST, RRREST, FFFIRST, FRFIRST, RFFIRST,
+RREST, FFIRST, RFIRST, FFREST, RFREST, RRREST, FFFIRST, FRFIRST, RFFIRST, RRFIRST.
-                                                                 RRFIRST.
@@ Zeile 241: / Zeile 248: @@
 muSIMP-Programmieren) eignet sich gut der
-.2 muSIMP "PDS"-EDITOR
+==== 1.2 muSIMP "PDS"-EDITOR ====
 (Wie der Name sagt, im PDS.SYS-file integriert - beschrieben in PLES1.PDS)
@@ Zeile 249: / Zeile 257: @@
 Um eine Funktion, beispielsweise eine "recognizer"-Funktion namens NODE zu
 erzeugen, gibt man (bei geladenem PDS.SYS) ein:
         EDIT ('NODE) &
 - der Schirminhalt verschwindet zugunsten des Editor-Displays: in der
-ersten Zeile steht bereits FUNCTION (),
+ersten Zeile steht bereits FUNCTION (), und in der 2. das abschließende ENDFUN$
-und in der 2. das abschließende ENDFUN$
 - dazwischen schreibt man seine Funktion hinein, im Beispiel etwa:
@@ Zeile 274: / Zeile 283: @@
 einfügen.
-. GRUNDFUNKTIONEN
+==== 2. GRUNDFUNKTIONEN ====
 Bereits bekannt sind u.a. die Zuweisungsfunktion :
@@ Zeile 280: / Zeile 289: @@
 und die Terminatoren, die nach der Auswertung des Ausdruckes folgende
 Ausgabe bewirken:
-                 $ keine Ausgabe am Bildschirm
-                 ; Ausgabe - womöglich in mathematischer Notation
+**$** keine Ausgabe am Bildschirm\\
-                 & Listen-Ausgabe
+**;** Ausgabe - womöglich in mathematischer Notation\\
+**&** Listen-Ausgabe
 Um die Unterschiede an Beispielen zu demonstrieren, seien folgende
 Namen, Zahlen und Listen definiert:
+<code>
 NAM1: MAX
 NAM2: MORITZ
@@ Zeile 299: / Zeile 310: @@
 L4: LIST(NAM1,ZAHL1,ZAHL2,ZAHL3)
 L5: LIST(10,11,LIST(12,13),LIST(14),15)
+</code>
 Dabei wurde die LISTen-Erzeugungs-Funktion LIST(ob1,ob2,...,obN) benutzt,
@@ Zeile 304: / Zeile 316: @@
-.1 Die Terminatoren ; und &
+==== 2.1 Die Terminatoren ; und & ====
 bewirken bei Zahlen und Namen genau die gleiche Ausgabe - Unterschiede gibt
 es bei Listen:
-L1& --> (1 2 3 4 5 6)
+  L1& --> (1 2 3 4 5 6)
-L1; --> 1 (2, 3, 4, 5, 6)
+  L1; --> 1 (2, 3, 4, 5, 6)
 ; unterteilt eine Liste in FIRST- und (REST)-Teil, dabei werden Elemente
-        durch Beistriche getrennt. Ein weiterer Unterschied bei geschach-
+durch Beistriche getrennt. Ein weiterer Unterschied bei geschachtelten Listen:
-        telten Listen:
-L5& --> (10 11 (12 13) (14) 15)
+  L5& --> (10 11 (12 13) (14) 15)
-L5; --> 10 (11, 12(13), 14(), 15)
+  L5; --> 10 (11, 12(13), 14(), 15)
 & zeigt Anfang und Ende jeder Ebene durch ( und ) an.
-; zeigt die REST-Listen in ( ) an -- einzelne Atome, die als Liste
-          eingegeben wurden, werden mit der leeren Liste () angezeigt.
+; zeigt die REST-Listen in ( ) an -- einzelne Atome, die als Liste eingegeben wurden, werden mit der leeren Liste () angezeigt.
 In jedem Falle werden Listen vor der Ausgabe ausgewertet, also:
-L4; --> MAX (100, -23, 0)
+  L4; --> MAX (100, -23, 0)
-.2 Selektions- und Konstruktions-Funktionen
+==== 2.2 Selektions- und Konstruktions-Funktionen ====
 wurden z.T. auch schon im 1.Abschnitt behandelt. So die SELEKTIONS-
@@ Zeile 336: / Zeile 348: @@
 schälen:
-RRREST(L2)& --> (HEIDI)
+  RRREST(L2)& --> (HEIDI)
 Von den KONSTRUKTIONS-Funktionen kennen wir LIST(ob1, ... obN) durch den
@@ Zeile 345: / Zeile 357: @@
 ADJOIN(ob1,ob2) -- sie liefert den Knoten in der "dotted pair" Darstellung
-ADJOIN(a,b)& --> (a . b)
+  ADJOIN(a,b)& --> (a . b)
-ADJOIN(1,FALSE)& --> (1)
+  ADJOIN(1,FALSE)& --> (1)
-ADJOIN(NAM1,L1)& --> (MAX 1 2 3 4 5 6)
+  ADJOIN(NAM1,L1)& --> (MAX 1 2 3 4 5 6)
 Während bei Listen die REST-Zelle immer auf einen Knoten oder auf FALSE
@@ Zeile 354: / Zeile 366: @@
 Man beachte den Unterschied zwischen der Konstruktion eines Knotens mit
 ADJOIN bzw. durch die direkte Konstruktion mittel "evaluator" ':
-                                                        '(a . b) &
+'(a . b) &
 Vergleiche dazu die "Programming LESson"2 -- s.S. PLES2-5 !
@@ Zeile 360: / Zeile 374: @@
 REVERSE(liste) dreht die Reihenfolge der Listen-Elemente um:
-REVERSE(L5)& --> (15 (14) (12 13) 11 10)
+  REVERSE(L5)& --> (15 (14) (12 13) 11 10)
 REVERSE(liste1, liste2) dreht liste1 um und vereinigt sie mit liste2:
-REVERSE(L1,L2)& --> (6 5 4 3 2 1 KARIN ELKE THEA HEIDI)
+  REVERSE(L1,L2)& --> (6 5 4 3 2 1 KARIN ELKE THEA HEIDI)
 Wird aber statt liste1 nur ein Atom eingegeben, dann wird nur liste2
 ausgegeben:
-           REVERSE(7,L1)& --> (1 2 3 4 5 6)
-aber bei    REVERSE(L1,7)& --> (6 5 4 3 2 1 . 7)
+  REVERSE(7,L1)& --> (1 2 3 4 5 6)
+aber bei
+  REVERSE(L1,7)& --> (6 5 4 3 2 1 . 7)
 OBLIST()& konstruiert eine Liste, in der ALLE NAMEN aufscheinen, die
@@ Zeile 378: / Zeile 394: @@
-.3 ARITHMETISCHE FUNKTIONEN
+==== 2.3 ARITHMETISCHE FUNKTIONEN ====
 Neben den Operatoren +, -, * gibt es auch Funktionen  PLUS(a,b),
@@ Zeile 384: / Zeile 400: @@
 Divisions-Funktionen:
-QUOTIENT(5,2)&  -->  2
+QUOTIENT(5,2)&  -->  2\\
 QUOTIENT(-5,2)& --> -3
-MOD(5,2)&  -->  1
+MOD(5,2)&  -->  1\\
 MOD(-5,2)& -->  1
@@ Zeile 395: / Zeile 411: @@
-.4 LOGISCHE FUNKTIONEN
+==== 2.4 LOGISCHE FUNKTIONEN ====
 NOT(obj) gibt dann und nur dann TRUE, wenn obj auf FALSE zeigt.
@@ Zeile 402: / Zeile 419: @@
-.5 MODIFIZIERUNGS-FUNKTIONEN
+==== 2.5 MODIFIZIERUNGS-FUNKTIONEN ====
 Sie greifen direkt auf Knoten zu und können diese (manchmal gefährlich!)
@@ Zeile 408: / Zeile 426: @@
 REPLACEF(o1, o2)  ersetzt die FIRST-Zelle von "o1" durch einen Zeiger auf
-                 "o2".  Wenn "o1" ein Atom ist, wird die FIRST-Zelle des
+"o2".  Wenn "o1" ein Atom ist, wird die FIRST-Zelle des
-                 Atoms ersetzt: gefährlich wäre z.B.: REPLACEF(1,2) !
+Atoms ersetzt: gefährlich wäre z.B.: REPLACEF(1,2) !
-                 "o1" = Liste: erstes Element der Liste durch "o2" ersetzt
+"o1" = Liste: erstes Element der Liste durch "o2" ersetzt
-                 "o1" = Knoten: das linke Element wird durch "o2" ersetzt.
+"o1" = Knoten: das linke Element wird durch "o2" ersetzt.
 REPLACER(o1, o2)  ersetzt die REST-Zelle von "o1" durch Zeiger auf "o2".
@@ Zeile 418: / Zeile 436: @@
-.6 PROPERTY-FUNKTIONEN
+==== 2.6 PROPERTY-FUNKTIONEN ====
 Aufbau und Verwendung von "Property"-Listen.
@@ Zeile 431: / Zeile 449: @@
 Beispiel: Erstellen einer Telefon-Liste "telefon":
-PUT(telefon,HANS,12345)&
+  PUT(telefon,HANS,12345)&
-PUT(telefon,MAX,23456)&
+  PUT(telefon,MAX,23456)&
-PUT(telefon,BOB,34567)&
+  PUT(telefon,BOB,34567)&
@@ Zeile 440: / Zeile 458: @@
 Die Antwort im Beispiel:
-REST(telefon) ---> ((BOB . 34567)  (MAX . 23456) (HANS . 12345))
+REST(telefon) ---> ( (BOB . 34567)  (MAX . 23456) (HANS . 12345) )
 Die Speicherbelegung sieht kompliziert aus:
-NODE-Nummer  Inhalt der FIRST-Zelle  Inhalt der REST-Zelle
+^ NODE-Nummer ^ Inhalt der FIRST-Zelle ^ Inhalt der REST-Zelle ^
-       Zeiger auf node2        Zeiger auf node3
+| 1 | Zeiger auf node2 | Zeiger auf node3 |
-       Zeiger auf BOB          Zeiger auf 34567
+| 2 | Zeiger auf BOB | Zeiger auf 34567 |
-       Zeiger auf node4        Zeiger auf node5
+| 3 | Zeiger auf node4 | Zeiger auf node5 |
-       Zeiger auf MAX          Zeiger auf 23456
+| 4 | Zeiger auf MAX | Zeiger auf 23456 |
-       Zeiger auf node6        Zeiger auf node7
+| 5 | Zeiger auf node6 | Zeiger auf node7 |
-       Zeiger auf HANS         Zeiger auf 12345
+| 6 | Zeiger auf HANS | Zeiger auf 12345 |
 Als Eigenschaften können selbstverständlich auch Namen und sogar Listen
@@ Zeile 458: / Zeile 476: @@
 PUT(name, indikator, property). Sollte also "BOB" eine neue Telefon-Nummer
 bekommen haben:
 PUT(telefon, BOB, NNN)
@@ Zeile 463: / Zeile 482: @@
 ASSOC(NAM, PLIST) prüft, ob der Indikator "NAM" in der P-Liste "PLIST"
-                 enthalten ist; dabei muß aber die P-Liste selbst (und
+enthalten ist; dabei muß aber die P-Liste selbst (und
-                nicht bloß ihr Name) als zweiter Parameter übergeben
+nicht bloß ihr Name) als zweiter Parameter übergeben
-                werden. Im Beispiel:
+werden. Im Beispiel:
-ASSOC(HANS, REST(telefon)) ---> (HANS . 12345)
+ASSOC(HANS, REST(telefon)) ---> (HANS . 12345)\\
-ASSOC(HANS, telefon)       ---> telefon
+ASSOC(HANS, telefon)       ---> telefon\\
 ASSOC(MITZI, REST(telefon)) --> FALSE
 GET(name, indikator)  liest den Eigenschaftswert aus der P-Liste, die
-                     unter "name" eingerichtet wurde, der dem eingegebenen
+unter "name" eingerichtet wurde, der dem eingegebenen
-                     Indikator zugeordnet ist; wenn keiner vorhanden: FALSE
+Indikator zugeordnet ist; wenn keiner vorhanden: FALSE
-GET(telefon, HANS) ---> 12345
+GET(telefon, HANS) ---> 12345\\
 GET(telefon, Maxi) ---> FALSE
-.7 "SUBATOMARE" FUNKTIONEN
+==== 2.7 "SUBATOMARE" FUNKTIONEN ====
 Wie der Name andeutet, können diese (drei) Funktionen ATOME "spalten".
-LENGTH(objekt) - wenn objekt ein NAME ist, ---> Anzahl der Zeichen
+LENGTH(objekt) - wenn objekt ein NAME ist, --> Anzahl der Zeichen
-               - wenn object = INTEGER ---> Anzahl der Ziffern (bezogen
+- wenn object = INTEGER ---> Anzahl der Ziffern (bezogen auf die geltende Basis)
-                                             auf die geltende Basis)
+- wenn objekt = LISTE   --> Anzahl der Listenelemente.
-               - wenn objekt = LISTE   ---> Anzahl der Listenelemente.
-EXPLODE(atom)  - NAME / INTEGER ---> in einzelne Zeichen / Ziffern aufge-
+EXPLODE(atom)  - NAME / INTEGER ---> in einzelne Zeichen / Ziffern aufgespalten (Listenform der Ausgabe)
-                                        spalten (Listenform der Ausgabe)
 Umgekehrt kann man die einzelnen Bestandteile wieder zum ATOM verschmelzen
 mit COMPRESS(liste).
-.8 TEST-Funktionen
+==== 2.8 TEST-Funktionen ====
 Dienen zur Abfrage von (Eigenschaften von) Datenobjekten - als Ergebnis
@@ Zeile 500: / Zeile 518: @@
 NAME(obj)       prüft, ob es sich bei "obj" um einen NAMEN handelt -
-                NAME(LISTE1) ---> FALSE
+NAME(LISTE1) ---> FALSE,
-                NAME('LISTE1) ---> TRUE  (zu "'" vgl. auch 2.10!)
+NAME('LISTE1) ---> TRUE  (zu "'" vgl. auch 2.10!)
 INTEGER(obj)    INTEGER-Prüfung
@@ Zeile 508: / Zeile 526: @@
 EMPTY(obj)      dient dazu, leere Listen zu erkennen. Nur wenn "obj" gleich
-                FALSE ist, wird als Ergebnis TRUE geliefert. EMPTY() ist
+FALSE ist, wird als Ergebnis TRUE geliefert. EMPTY() ist
-                der Funktion NOT() identisch.
+der Funktion NOT() identisch.
-POSITIVE(obj) ---> TRUE, wenn "obj" eine positive Zahl ist; analog
+POSITIVE(obj) ---> TRUE, wenn "obj" eine positive Zahl ist; analog\\
-NEGATIVE()      für negative Zahlen-Prüfung und
+NEGATIVE()      für negative Zahlen-Prüfung und\\
 ZERO(o)   --->  TRUE, wenn "o" Null ist.
@@ Zeile 518: / Zeile 536: @@
-.9 VERGLEICHS-Funktionen
+==== 2.9 VERGLEICHS-Funktionen ====
 geben (wie Testfunktionen) TRUE oder FALSE als Antwort, wenn der Vergleich
 stimmt oder nicht.
-GREATER(zahl1,zahl2)
+GREATER(zahl1,zahl2)\\
 LESSER(zahl1,zahl2)
@@ Zeile 531: / Zeile 549: @@
 objekt1 EQ objekt2 -- Der Infix-Operator "EQ" prüft auf Gleichheit (von
-                Namen, Zahlen, Listen). Beispiele:
+Namen, Zahlen, Listen). Beispiele:
-NAM1 EQ MAX --> TRUE
+  NAM1 EQ MAX --> TRUE
 EQ ZAHL1 -> TRUE
 LIST(1,2,3) EQ LIST(1,2,3) ---> FALSE, weil bei der Auswertung dieser
-                Funktion zwei an verschiedenen Speicherplätzen stehende -
+Funktion zwei an verschiedenen Speicherplätzen stehende -
-                also verschiedene! - Listen erzeugt werden. Listen werden
+also verschiedene! - Listen erzeugt werden. Listen werden
-                nur durch folgende Zuweisung identisch gemacht:
+nur durch folgende Zuweisung identisch gemacht:
 LISTE6:LISTE1$  - danach gibt
 LISTE1 EQ LISTE6 tatsächlich TRUE.
@@ Zeile 552: / Zeile 570: @@
 ORDERP(name1,name2) vergleicht, ob "name1" in der OBLIST() vor "name2"
-                steht. (Jeder neu eingeführte Name wird in die OBLIST()
+steht. (Jeder neu eingeführte Name wird in die OBLIST()
-                aufgenommen und zwar in der Reihenfolge der Einführung:
+aufgenommen und zwar in der Reihenfolge der Einführung:
-                früher eingeführte stehen weiter rechts in der OBLIST().)
+früher eingeführte stehen weiter rechts in der OBLIST().)
-.10 ZUWEISUNGS-Funktionen
+==== 2.10 ZUWEISUNGS-Funktionen ====
 Der Infix-Operator ":" ist schon bekannt. Links muß immer ein NAME stehen -
@@ Zeile 565: / Zeile 582: @@
 wird dann die FIRST-Zelle des NAMEns entsprechend modifiziert. Z.B.:
-? NAME2 : SUSI &
+  ? NAME2 : SUSI &
-@: SUSI
+  @: SUSI
 Nach & und "return"-Eingabe geschieht folgendes: Wenn "NAME2" noch nicht in
@@ Zeile 577: / Zeile 594: @@
 Der Prefix-Operator "'" bewirkt, daß NICHT der WERT einer Variable, sondern
 ihr Name, ihre Bezeichnung übernommen wird:
-NAME2  ---> SUSI
+  NAME2  ---> SUSI
-'NAME2 ---> NAME2
+  'NAME2 ---> NAME2
-'ZAHL1 ---> ZAHL1
+  'ZAHL1 ---> ZAHL1
 Der QUOTE-Operator ' verhindert also die Auswertung des Daten-Objektes, vor
 dem er steht.
 Etwas "trickreicher" wirkt die ASSIGN(name,objekt) Funktion; ein Beispiel:
+<code>
 ? NAME2:SUSI&
 @: SUSI
@@ Zeile 593: / Zeile 610: @@
 ? SUSI&
 @: BLOND
+</code>
 und jetzt:
+<code>
 ? ASSIGN(NAME2,'?)&
 @: ?
@@ Zeile 604: / Zeile 623: @@
 ? SUSI&
 @: ?
+</code>
 Die ASSIGN-Funktion belegt nicht wie ":" die FIRST-Zelle von "name",
@@ Zeile 610: / Zeile 630: @@
 PUSH(objekt,liste) legt das "objekt" auf die "liste", die gewissermaßen
-                als ein Stapel dient:
+als ein Stapel dient:
+<code>
 ? STAPEL&
 @: STAPEL
@@ Zeile 621: / Zeile 643: @@
 ? STAPEL&
 @: (HEIDI, . . KARIN . STAPEL)
+</code>
 Die "Umkehr"-Funktion POP(liste) nimmt das oberste Element von der "liste":
+<code>
 ? POP(STAPEL)&
 @: HEIDI
@@ Zeile 629: / Zeile 653: @@
 ? STAPEL&
 @: ( . . KARIN . STAPEL)
+</code>
 Eine "echte" Liste wird mit PUSH(... ,stap) erzeugt, wenn der Wert von
 "stap" am Anfang auf FALSE gesetzt wird.
@@ Zeile 642: / Zeile 665: @@
-                                             F.Widder, Graz, 15.10.88
+F.Widder, Graz, 15.10.88\\
+(F.Widder, Inst.für Theoret.Physik, Univ.platz 5, 8010 GRAZ)
-        (F.Widder, Inst.für Theoret.Physik, Univ.platz 5, 8010 GRAZ)
-</file>