summaryrefslogtreecommitdiff
path: root/lang/dynamo/1.8.7/doc
diff options
context:
space:
mode:
Diffstat (limited to 'lang/dynamo/1.8.7/doc')
-rw-r--r--lang/dynamo/1.8.7/doc/dynamo handbuch1826
-rw-r--r--lang/dynamo/1.8.7/doc/dynamo handbuch.index69
-rw-r--r--lang/dynamo/1.8.7/doc/dynamo handbuch.inhalt131
3 files changed, 2026 insertions, 0 deletions
diff --git a/lang/dynamo/1.8.7/doc/dynamo handbuch b/lang/dynamo/1.8.7/doc/dynamo handbuch
new file mode 100644
index 0000000..4012973
--- /dev/null
+++ b/lang/dynamo/1.8.7/doc/dynamo handbuch
@@ -0,0 +1,1826 @@
+#block##pageblock##page (2)##setcount (1)##count per page#
+#head#
+#center#DYNAMO-Compiler
+#center#____________________________________________________________
+
+#end#
+#bottom odd#
+#center#____________________________________________________________
+GMD #right#DYNAMO - %
+#end#
+#bottom even#
+#center#____________________________________________________________
+DYNAMO - % #right#GMD
+#end#
+
+#ib#1. Einleitung#ie#
+
+
+
+Diese Handbuch beschreibt die Funktion des EUMEL-DYNAMO-Compilers in der
+Version 3.3+ und seine Einschränkungen oder Änderungen gegenüber dem
+DYNAMO-Sprachstandard. In keiner Weise kann diese Beschreibung eine Einfüh­
+rung in die Programmiersprache DYNAMO ersetzen!
+
+Die beschriebene Compilerversion enthält nun auch ein Modul zur Unterstützung von
+hochauflösender Grafik durch die häufig in IBM-PC/AT-Kompatiblen eingesetzte
+CGA-Grafikkarte. Dennoch ist es einfach möglich, diesen Grafikmodus auszuschal­
+ten, und somit die alte, zeichenorientierte Grafik weiter zu verwenden.
+
+Der DYNAMO-Compiler wurde 1983 von Robert Keil und Torsten Fröhlich (Helm­
+holtz-Gymnasium, Bonn) im Rahmen des MIKROS-Projektes am Informatik-Kolleg
+der GMD entwickelt. Für Spezifikation und Betreuung der Entwicklung war Dr. Diether
+Craemer verantwortlich, software-technische Unterstützung kam von Prof. John
+Henize, Dr. Peter Heyderhoff, Rudolf Legde und Dipl.- Math. Lothar Oppor. Die
+Grafik wurde von D.Giffeler beigesteuert.
+
+
+
+
+#ib#1.1. Referenzliteratur#ie#
+
+
+
+
+ [1] Craemer, Diether
+ "Mathematisches Modellieren dynamischer Vorgänge"
+ e. Einf. in die Programmiersprache DYNAMO
+ Stuttgart, Teuber, 1985
+ ISBN 3-519-02477-2
+
+ [2] Craemer, Diether
+ "Fluß und Zustand - Simulation dynamischer Vorgänge in DYNAMO"
+ in: LOGIN 5 (1985), Heft 1, S. 20-23
+
+ [3] Pugh, Alexander L.
+ "DYNAMO II User's Manual"
+ Cambridge, London 1973: MIT-Press
+ ISBN 0-262-66018-0
+#page#
+
+#ib#1.2. Die Programmiersprache DYNAMO#ie#
+
+
+
+DYNAMO wurde von einer Gruppe um Jay FORRESTER am Massachusetts Institute
+of Technology (MIT) um 1960 entwickelt. Die Sprache basiert auf der #on ("i")# System
+Dynamic#off ("i")# von FORRESTER.
+
+In DYNAMO (#on ("u")##on ("b")#Dyna#off ("b")##off ("u")#mic #on ("u")##on ("b")#Mo#off ("b")##off ("u")#delling Language) können Systeme, in denen Veränderun­
+gen kontinuierlich geschehen, modelliert und simuliert werden.
+
+Kontinuierliche Veränderungen von Größen werden über deren Veränderungsrate im
+Wesentlichen nach folgender Gleichung berechnet
+
+Größe jetzt = Größe früher + DT * Veränderungsrate,
+
+dabei ist DT die Länge des Zeitintervalls von "früher" bis "jetzt".
+
+Außer diesen Gleichungen für Größen braucht man Gleichungen für die Verände­
+rungsraten, für Hilfsgrößen, zur Initialisierung von Größen, zur Definition von Konstan­
+ten und Tabellen, zu Angaben von Simulationsläufen und zur Wiedergabe von Ergeb­
+nissen in Zahlentabellen oder Diagrammen.
+
+Alle diese Gleichungen können einfach in der Form, wie man sie aus dem Mathema­
+tik-Unterricht der Sekundarstufe kennt, hingeschrieben werden, ohne sich Gedanken
+über den Ablauf des Programms machen zu müssen.
+
+#on ("b")#
+DYNAMO ist also eine einfache funktional-applikative, nicht-prozedurale Sprache.#off ("b")#
+
+Das macht ihren Reiz und ihre Leistungsfähigkeit aus, die zur Formulierung der be­
+kannten Weltmodelle von FORRESTER, MEADOWS ("Die Grenzen des Wachstums"),
+PESTEL, MESAROVIC u.a. in dieser Sprache führten.
+
+Anwendungsgebiete der Sprache sind ökologische, gesellschaftliche, wirtschaftliche
+und technische Systeme, deren dynamisches Verhalten der Modellbildner nachbilden
+und studieren möchte.
+
+Im Allgemeinen verfolgt der Modellbildner mit seinem Modell einen Zweck (Verhaltens­
+änderung des nachgebildeten Systems), so daß auch neben gesicherten Fakten die
+Wertvorstellungen des Modellbildners in das Modell eingehen.
+
+
+
+
+#ib#1.3 Kurz-Einführung in die DYNAMO-
+Schreibweise#ie#
+
+
+
+Die System Dynamic Methode benutzt als Analogie-Bild den Archetyp des Flusses:
+
+ - Wasser fließt durch das Flußbett, kann in Seen gestaut und in der Ge­
+ schwindigkeit durch Schleusen und Wehre reguliert werden.
+
+ - Analog dazu "fließt" Geld auf dem Überweisungsweg, wird in Konten gestaut,
+ und die Liquidität kann durch Zinssätze reguliert werden.
+
+ - Gedanken "fließen" auf Nervenbahnen, werden im Gehirn gespeichert, und
+ Gedankenströme werden über Synapsen reguliert.
+
+ - Autos "fließen" über Straßen, werden auf Parkplätzen gestaut, und der Ver­
+ kehrsfluß wird über Ampeln reguliert.
+
+ - Menschen "fließen" über Wanderwege, halten sich in Wohnorten auf, und die
+ Bevölkerungsdynamik wird durch ein komplexes, rückgekoppeltes Zusammen­
+ spiel von Ein- und Auswanderungsraten sowie Geburts- und Sterberaten
+ reguliert.
+
+Am letzten Beispiel wird deutlich, daß sich ein soziales Phänomen nur im Zusam­
+menwirken vieler netzartig miteinander verbundener Variablen beschreiben läßt (wenn
+überhaupt).
+
+Solange jedoch einigen Variablen ZUSTANDS-CHARAKTER ("Wasserstand") und
+anderen VERÄNDERUNGS-CHARAKTER ("Flußgeschwindigkeit") zugeordnet
+werden kann, können die Größen für Berechnungen folgender Art verwendet werden:
+
+
+ Wasserstand jetzt = Wasserstand früher + vergangene Zeit *
+ (Zuflußrate - Abflußrate)
+
+
+analog:
+
+ Bevölkerung jetzt = Bevölkerung früher + vergangene Zeit *
+ (Geburtsrate - Sterberate)
+
+
+Diese Schreibweise kann praktisch so in ein Computerprogramm übernommen wer­
+den. Mit geringfügigen Änderungen handelt es sich bei diesen Gleichungen schon um
+gültige Zeilen in der Programmiersprache DYNAMO.
+
+In DYNAMO wird er Zeitpunkt "jetzt" durch das Anhängsel .K, der Zeitpunkt "früher"
+durch das Anhängsel .J, die Zeitspanne von jetzt bis später durch das Anhängsel .KL,
+die Zeitspanne von früher bis jetzt durch das Anhänsel .JK und die vergangene Zeit
+mit DT (wie "Delta Tempus": Zeitdifferenz) bezeichnet. Die Variablen mit Zustands-
+Charakter heißen LEVELS (Niveaus) und die Veränderungs-Charakter heißen RATES
+(Veränderungsraten, Geschwindigkeiten). Die entsprechenden Gleichungen werden mit
+L bzw. R gekennzeichnet. Es gib weitere Kennzeichnungen:
+
+ C für Konstantendefinition (constant)
+ T für Tabellendefintion (table)
+ A für Hilfsgrößen (auxiliaries)
+ N für Anfangswerte (initial)
+ X für Folgezeile (extension)
+ PRINT für Ausgabe von Zahlen
+ PLOT für Ausgabe von Diagrammen
+
+Ein einfaches Bevölkerungsmodell könnte z.B. so geschriben werden:
+
+
+ L BEVÖLKERUNG.K=BEVÖLKERUNG.J+DT*(GEBURTENRATE.JK
+ X -STERBERATE.JK)
+ R STERBERATE.KL=5
+ R GEBURTENRATE.KL=20
+ N BEVÖLKERUNG=1000
+ C DT=1 (jedes Jahr wird neu berechnet)
+ C LENGTH=60 (60 Jahre werden simuliert)
+ PRINT BEVÖLKERUNG
+
+
+Für eine tiefere Einführung in DYNAMO sollte man die Referenzliteratur zu Rate
+ziehen.
+
+
+
+
+#ib#1.4 Eine erste, kleine Sitzung mit dem
+DYNAMO-System#ie#
+
+
+
+Wir gehen davon aus, daß das DYNAMO-System in ihrer Task generiert worden ist
+(siehe 2.).
+
+ 1. Tippen Sie das obrige Programm mittels des EUMEL-Editors ab.
+
+ 2. Verlassen Sie den Editor mit <ESC><q> und starten Sie den DYNAMO-
+ Compiler durch die Eingabe des Befehls "dynamo".
+
+ 3. Nach erfolgreichem Übersetzen sollte Ihnen nun das DYNAMO-Runtime-
+ System zur Verfügung stehen. Durch den Befehl 'run' wird das Programm aus­
+ geführt und Sie erhalten eine Zahlenkolonne, die die Entwicklung der Bevöl­
+ kerung in den zu untersuchenden 60 Jahren angibt. Falls Ihnen beim Abtippen
+ des Programms Fehler unterlaufen sein sollten, so kann das Programm nicht
+ fehlerfrei übersetzt werden. Fehlermeldunggen zur Compile-Zeit des
+ DYNAMO-Compilers werden im Paralleleditor angezeigt; das Programm kann
+ im oberen der beiden Editorfenster (in diesem befinden Sie sich auch nach
+ Fehlern) korrigiert werden. Danach können Sie erneut wie nach Punkt 2 ver­
+ fahren.
+#page#
+
+
+
+#ib#2. Generierung des DYNAMO-Compilers#ie#
+
+
+
+Der DYNAMO-Compiler, seine Funktionen und die Beispielprogramme werden auf
+zwei Archiv-Disketten a#b#' 360 KB ausgeliefert.
+
+Zum Generieren des DYNAMO-Systems legen Sie bitte die erste Diskette in das
+Dikettenlaufwerk Ihres Rechners und durch folgende Kommandozeile lesen Sie den
+Generator vom Archiv und starten ihn:
+
+
+ archive ("dynamo"); fetch ("dyn.inserter", archive); run
+
+
+Danach holt der Generator alle benötigten Dateien vom eingelegten Archiv bzw. von
+dem zweiten Archiv (nachdem er Sie zum Wechseln der Diskette aufgefordert hat).
+Anschließend wird der DYNAMO-Compiler insertiert. Am Ende der Generierung
+werden Sie gefragt werden, ob Sie den Compiler mit Grafik#u##count ("Grafik")##e# oder ohne benutzen
+wollen. Nach der Meldung "dynamo system generiert" können Sie den Compiler#foot#
+#u##value ("Grafik")##e# Es kann z.Zt. nur eine CGA-Grafikkarte betrieben werden
+#end#
+nutzen.
+#page#
+
+
+
+#ib#3. Der EUMEL-DYNAMO-Compiler#ie#
+
+
+
+Der im EUMEL-System implementierte DYNAMO-Compiler ist ein 2-Pass-
+Compiler, der die DYNAMO-Programme zunächst in ELAN übersetzt. Der Vorteil
+dieser Methode besteht darin, daß es möglich ist, übersetzte Programme unabhängig
+vom DYNAMO-Compiler zur Ausführung bringen zu können.
+
+Die Notation der im folgenden aufgeführten ELAN-Prozeduren des Compilers ent­
+spricht der in den EUMEL-Handbüchern üblichen Prozedurkopf-Schreibweise.
+
+Als Beispiel:
+
+
+ dynamo ("dyn.grasshasenfuchs")
+
+
+ein Beispiel für den Aufruf der Prozedur mit der Prozedurkopf-Schreibweise
+
+ PROC dynamo (TEXT CONST filename)
+
+auf der Kommando-Ebene des Betriebssystems EUMEL.
+
+Der Prozedur 'dynamo' wird beim Aufruf der Dateiname (TEXT) 'filename' übergeben
+und dadurch der Compiler auf die Datei mit dem Namen 'filename' angewendet.
+
+
+
+
+#ib#3.1. Benutzung des DYNAMO-Compiler#ie#
+
+
+
+Um ein DYNAMO-Programm zu Übersetzen, gibt es grundsätzlich zwei Möglichkei­
+ten. Erst einmal kann man ein DYNAMO-Programm in ein ELAN-Programm um­
+wandeln, jedoch ohne es dabei zur Ausführung zu bringen. Dieses ELAN-Programm
+kann man nun unabhängig vom eingentlichen Compiler starten. Die zweite, wohl öfter
+angewendete Methode ist, ein DYNAMO-Programm in ein ELAN-Programm zu
+compilieren, wobei es danach direkt ausgeführt wird. Ob danach ein ELAN-
+Programm zur Verfügung stehen soll, kann der Benutzer selbst entscheiden.
+
+
+PROC dynamo
+
+ Zweck: Aufruf des DYNAMO-Compilers mit 'quelldatei' = 'last param', d.h. das
+ zu übersetzende Programm steht in der zuletzt bearbeiteten Datei.
+
+
+PROC dynamo (TEXT CONST quelldatei)
+
+ Zweck: Ruft den DYNAMO-Compiler für die Datei 'quelldatei' auf. Anmerkung:
+ Gleichbedeutend mit 'dynamo (quelltext, quelltext + ".elan", TRUE)', s.
+ nächste Prozedur.
+
+ Beispiel:
+
+
+ dynamo ("dyn.grashasenfuchs")
+
+
+ Der DYNAMO-Compiler wird auf die Datei "dyn.grashasenfuchs" ange­
+ wendet.
+
+
+PROC dynamo (TEXT CONST quelldatei, zieldatei,
+ BOOL CONST pass2 ausfuehren)
+
+ Zweck: Diese Prozedur startet den DYNAMO-Compiler. 'quelldatei' gibt den
+ Namen der Datei an, in welcher der DYNAMO-Quelltext enthalten ist,
+ 'zieldatei' ist der Name der Datei, die das erzeugte ELAN-Programm
+ beinhalten soll. Wenn 'pass2 ausfuehren' = TRUE, dann wird dieses auch
+ durch den ELAN-Compiler weiterverarbeitet (das Programm wird zur
+ Ausführung gebracht).
+
+ Beispiel:
+
+
+ dynamo ("dyn.grashasenfuchs",
+ "grashasenfuchs.elanprogramm", FALSE)
+
+
+ Im obigen Beispiel wird der in der Datei "dyn.grashasenfuchs" enthaltene
+ DYNAMO-Quelltext in die Datei "grashasenfuchs.elanprogramm" als
+ ELAN-Programm geschrieben. Das ELAN-Programm wird nicht ausge­
+ führt.
+
+
+PROC erase (BOOL CONST erase option)
+
+ Zweck: Wenn 'erase option' = TRUE, so werden die erzeugten ELAN-Programme
+ nach Beendigung der Ausführung gelöscht, bei 'erase option' = FALSE
+ bleiben sie erhalten (Voreinstellung: 'erase option' = FALSE).
+
+
+PROC error listing (TEXT CONST fehlerdatei)
+
+ Zweck: Falls gewünscht ist, die Fehlermeldungen, die ggf. beim Übersetzen ein­
+ treten, auch in eine Datei zu schreiben, so können Sie hier unter 'fehler­
+ datei' einen Dateinamen angeben. Bei der Angabe von "" wird die Umlei­
+ tung in die Datei ausgeschaltet werden (Voreingestellt ist 'fehlerdatei' =
+ "").
+
+
+PROC graphic (BOOL CONST graphic option)
+
+ Zweck: Mit dieser Prozedur läßt sich einstellen, ob bei der DYNAMO-Anweisung
+ PLOT die hochauflösende Grafik ('graphic option' = TRUE) oder die zei­
+ chenorientierte Grafik ('grafik option' = FALSE) verwendet werden soll. Die
+ Voreinstellung wird bei der Installation des Compilers erfragt.
+
+
+PROC protokoll (BOOL CONST protokoll option)
+
+ Zweck: Bei 'protokoll option' = TRUE werden alle Textausgaben, die bei der
+ Laufzeit des DYNAMO-Programmes auftreten, nicht nur auf dem Bild­
+ schirm dargestellt, sondern auch in eine Datei mit dem Namen "dyn.out"
+ protokolliert (voreingestellt ist 'protokoll option' = FALSE). Die Datei
+ "dyn.out" enthält auch Seitenvorschubbefehle ('\#page\#') und sollte nur mit
+ einem EUMEL-Printer ausgedruckt werden.
+
+
+
+
+#ib#3.2. Abweichungen gegenüber dem
+ Sprachstandard#ie#
+
+
+
+ - Die Länge der Namen ist nicht auf 7 Zeichen festgelegt, sondern praktisch be­
+ liebig (32000). Dies ist eine Erweiterung; wer seine Programme auch auf ande­
+ ren DYNAMO-Compilern laufen lassen will, sollte sich aber auf 7 Zeichen be­
+ schränken.
+
+ - Zahlen werden intern mit einer Mantisse von 13 Stellen abgespeichert, von denen
+ nur die ersten 7 bei der Ausgabe dargestellt werden. Die größte darstellbare Zahl
+ ist daher 9.999999999999e126.
+
+ - Die maximale Anzahl der Gleichungen ist auf 950 festgelegt.
+
+ - Der Compiler akzeptiert aus Gründen der besseren Lesbarkeit auch Programme,
+ die in Kleinschrift geschrieben sind. Dabei ist es sinnvoll, die Quellprogramme
+ konsistent zu halten (d.h. Groß- und Kleinschrift nicht zu vermischen). Man
+ sollte grundsätzlich Kleinschrift vorziehen, da diese vom Compiler auch effizienter
+ verarbeitet werden kann.
+
+ - Quellprogramme dürfen eine beliebige Zahl von Leerzeilen enthalten. X - Befeh­
+ le (Fortschreibungszeilen) werden davon nicht beeinflußt.
+
+ - In der augenblicklichen Version 3.3 des Compilers gelten folgende Einschränkun­
+ gen :
+
+ 1. Bei der Verarbeitung von Array-Gleichungen werden Compilerseitig keine
+ Semantik-Überprüfungen auf eventuell unzureichende Initialisierung oder
+ Überlappung (d.h. mehrfaches Setzen desselben Elements) durchgeführt.
+ Defaultmäßig bekommen alle Elemente einer Array-Gleichung bei der Initiali­
+ sierung den Wert '0.0' zugewiesen.
+
+ 2. Die maximale Größe von Tables und Array-Gleichungen ist durch Verwen­
+ dung des Vector-Pakets auf 4000 Elemente festgelegt. Da pro Table-Ele­
+ ment aber zur Zeit eine Zeile im Zielprogramm generiert wird, sollte man dies
+ besser nicht ausnutzen.
+
+ 3. Supplementary-Gleichungen werden aus Kompatibilitäts-Gründen korrekt
+ übersetzt, aber sonst wie Auxiliary-Gleichungen behandelt.
+
+ 4. Print ('prtper')- und Plotperiode ('pltper') werden nur als Konstanten verarbei­
+ tet. Falls Gleichungen für 'prtper' oder 'pltper' angegeben werden, so bewirken
+ diese keine Veränderung.
+
+ 5. Array-Gleichungen dürfen nicht mehr als eine Dimension besitzen.
+
+ 6. Für Gleichungen, die Makro-Aufrufe enthalten, sollten Initialisierungs (N)-
+ Gleichungen angegeben werden.
+
+
+
+#ib#3.3. Das DYNAMO Runtime-System#ie#
+
+
+
+Nach erfolgreicher Übersetzung wird vom Zielprogramm das Runtime-System aufge­
+rufen. In diesem Modus (das DYNAMO-Runtime-System meldet sich mit "dynamo
+runtime system :") ist es möglich, Konstanten zu ändern und DynamoProgramme zur
+Ausführung zu bringen.
+
+Im DYNAMO-Runtime-System stehen folgende Kommandos zur Verfügung (näheres
+zur Notation siehe Kapitel 4, S. #to page ("Anweisungen und Funktionen")#).
+
+
+ run
+
+ Zweck: Ausführen des übersetzten Programms
+
+
+ run <name>
+
+ Zweck: Ausführen des übersetzten Programms und retten des Konstantendaten­
+ raums in des Datenraum mit dem Namen "<name>.const". Existiert der
+ Datenraum bereits, werden die Konstanten aus dem Datenraum in den
+ Lauf übernommen. Somit ermöglicht der Compiler, Konstantenwerte aus
+ einem früheren Lauf wieder zu verwenden.
+
+
+ c <Konstantenname>=Wert [/<Konstantenname>=Wert [...]]
+
+ Zweck: Änderung einer oder mehrerer Konstanten
+
+
+ ?
+
+ Zweck: Anzeigen der Konstanten und ihrer Werte
+
+
+ quit
+
+ Zweck: Verlassen des Runtime-Systems
+
+
+ help
+
+ Zweck: Zeigt eine kurze Erklärung
+
+
+Bei PRINT- und PLOT-Ausgaben sind folgende Kommandos möglich:
+
+ + Nächster Bildschirm
+ o (Off), keine Unterbrechung der Ausgabe (nicht möglich bei hochauflösen­
+ der Grafik)
+ e (End), Zurück zum Runtime System
+ p Phasendiagramm (nur bei hochauflösender Grafik möglich)
+
+
+
+#ib#3.4. Fehlermeldungen des
+ DYNAMO-Compilers#ie#
+
+
+
+Falls der Compiler einen Fehler im DYNAMO-Programm entdeckt, gibt er eine Feh­
+lermeldung nach dem folgenden Muster aus:
+"Fehler in Zeile <zeilennummer> bei >> <symbol> << : <fehlertext>.
+
+Im folgenden sind alle Fehlermeldungen und Möglichkeiten zur Abhilfe aufgelistet,
+sofern diese nicht klar ersichtlich sind:
+
+ 1 GLEICHUNG DOPPELT DEFINIERT
+
+ 2 DOPPELTE INITIALISIERUNG
+
+ 3 FALSCHER ZEILENTYP
+ -> Erlaubt sind : a, c, l, n, r, s, print, plot, note, spec, *, x, macro, mend,
+ for, noise, run.
+
+ 4 VERSCHACHTELTE MAKRO-DEFINITION
+ -> 'mend' - Befehl fehlt.
+
+ 5 MAKRO-NAME ERWARTET
+
+ 6 '(' ERWARTET
+
+ 7 FORMALER PARAMETER ERWARTET
+
+ 8 ')' NACH PARAMETERLISTE ERWARTET
+
+ 9 BEI AUXILIARIES NUR SUBSKRIPTION MIT '.K' ERLAUBT
+
+10 BEI KONSTANTEN-DEFINITION NAME ERWARTET
+
+11 BEI LEVELS NUR SUBSKRIPTION MIT '.K' ERLAUBT
+
+12 BEI RATES NUR SUBSKRIPTTION MIT '.KL' ERLAUBT
+
+13 BEI TABLE-DEFINITIONEN KEINE SUBSKRIPTION ERLAUBT
+
+14 X - BEFEHL HIER NICHT ERLAUBT
+
+15 BEI FOR-DEFINITION NAME ERWARTET
+
+16 '=' NACH FOR-VARIABLE ERWARTET
+
+17 BEREICHSANGABE ERWARTET
+
+18 ',' ERWARTET
+
+19 LOKALE GLEICHUNG NUR IN MAKRO ERLAUBT
+
+20 BEI DEFINITION NAME ERWARTET
+
+21 '=' ERWARTET
+
+22 INDEX NICHT KORREKT
+ -> Als Index ist nur erlaubt : <for variable> !,
+ <add op> <ganze zahl>!.
+ <add op> ::= "+"; "-".
+
+23 ')' NACH INDIZIERUNG ERWARTET
+
+24 PRTPER NICHT DEFINIERT
+ -> Wenn das Programm einen Print-Befehl enthält, muß 'prtper' (Printperiode)
+ als Konstante definiert werden.
+
+25 PLTPER NICHT DEFINIERT
+ -> Wenn das Programm einen Plot-Befehl enthält, muß 'pltper' (Plotperiode)
+ als Konstante definiert werden.
+
+26 '/' ODER ',' BEI PLOT ERWARTET
+
+27 NAME ALS PLOTPARAMETER ERWARTET
+
+28 DOPPELTE SCALE - ANGABE IN EINER GRUPPE
+ -> Wenn mehrere Plotparameter mit ',' getrennt werden (also die gleiche Ska­
+ lierung erhalten), dürfen nicht mehrere feste Skalierungen angegeben wer­
+ den.
+
+29 ERSTE SCALE - ANGABE ERWARTET
+
+30 ZWEITE SCALE - ANGABE ERWARTET
+
+31 ')' NACH SCALE - ANGABE FEHLT
+
+32 PRINTPARAMETER NICHT DEFINIERT
+
+33 PRINTPARAMETER ERWARTET
+
+34 TIME DARF NUR INITIALISIERT WERDEN
+
+35 DT NICHT DEFINIERT
+
+36 LENGTH NICHT DEFINIERT
+
+37 BEI KONSTANTEN - DEFINITION ZAHL ERWARTET
+
+38 BEI INITIALISIERUNG KONSTANTE ERWARTET
+
+39 LEVELS MUESSEN INITIALISIERT WERDEN
+
+40 KONSTANTE BEI TABLE ERWARTET
+
+41 '/' ODER "," ERWARTET
+
+42 TABLE - DEFINITION OHNE BENUTZUNG
+
+43 SIMULTANE GLEICHUNGEN
+ -> Bei dem Versuch, A, R, oder N - Gleichungen zu sortieren, trat eine
+ direkte oder indirekte Rekursion auf.
+
+44 FAKTOR ERWARTET
+ -> Erwartet : <zahl>;
+ <funktions aufruf>;
+ <macro aufruf>;
+ <gleichungs name>;
+ '(', <ausdruck>, ')';
+ <monadischer operator>, <faktor>.
+ <monadischer operator> ::= '+'; '-'.
+
+45 TIME MUSS MIT '.J' ODER '.K' SUBSKRIBIERT WERDEN
+
+46 SYMBOL NICHT DEFINIERT
+
+47 FUNKTION NICHT DEFINIERT
+
+48 UNZULAESSIGE INDIZIERUNG
+ -> Die Indices auf beiden Seiten der Gleichung müssen immer gleich sein.
+
+49 FALSCHE PARAMETERANZAHL
+
+50 FALSCHES TRENNSYMBOL ZWISCHEN PARAMETERN
+
+51 ALS PARAMETER TABLE ERWARTET
+
+52 FALSCHER PARAMETER IN TABLEFUNKTION
+
+53 ZU VIELE AKTUELLE PARAMETER
+
+54 ')' NACH MAKROAUFRUF FEHLT
+
+55 REKURSIVER MAKROAUFRUF
+
+56 BEI N - GLEICHUNG KEINE SUBSKRIPTION ERLAUBT
+
+57 FALSCHE SUBSKRIPTION IN AUXILIARY - GLEICHUNG
+
+58 ')' ERWARTET
+
+59 FALSCHE SUBSKRIPTION IN LEVEL - GLEICHUNG
+
+60 FALSCHE SUBSKRIPTION IN RATE - GLEICHUNG
+
+61 FOR - VARIABLE NICHT DEFINIERT
+ -> Eine FOR - Variable muß vor der ersten Benutzung definiert werden.
+
+62 KONSTANTE ERWARTET
+
+63 FALSCHES REAL - FORMAT
+ -> Exponent fehlt
+
+64 GLOBALE GLEICHUNG IN MACRO NICHT ERLAUBT
+
+65 DOPPELTE DEFINITION BEI MEHRFACHEM MAKROAFRUF
+
+66 ALS NOISE - PARAMETER ZAHL ERWARTET
+#page#
+
+#ib#4. Anweisungen und Funktionen des
+ EUMEL-DYNAMO-Compilers#ie#
+#goal page ("Anweisungen und Funktionen")#
+
+
+Dieses Kapitel gibt eine alphabetische Übersicht über die im EUMEL-DYNAMO-
+Compiler realisierten Anweisungen und Funktionen (wertliefernde Algorithmen).
+
+Die Beschreibung der Anweisungen und Funktionen ist nach der DYNAMO-
+Syntaxregel angegeben, wobei folgende Zeichen mit besonderer Bedeutung verwendet
+werden:
+
+ [] optionale Angabe
+ [...] beliebig häufige Wiederholung der letzten optionalen Angabe
+ < > in spitzen Klammern stehende Namen sind Variablen- bzw. Konstan­
+ tennamen
+ <Name> steht für einen beliebigen Bezeichner gemäß der DYNAMO-Syntax
+ <Zahl> bezeichnet einen beliebigen Wert (also auch eine Ausdruck)
+ {} Alternative Angabe
+
+ X DYNAMO Anweisung, kennzeichnet eine Fortsetzungsszeile der
+ vorhergegangenen Anweiung (S. #to page ("X")#)
+
+Alle Anweisungen und Funktionen werden nach dem gleichen Schema dargestellt:
+
+
+
+Funktionsname#right#Typ (Funkt. oder Anweisung)
+
+
+Zweck: Schlagwort zur Wirkung
+
+Format: Beschreibung des Formates (spezielle Zeichen s.o.)
+
+Erklärung: kurze Beschreibung der Anweisung/Funktion
+
+Beispiel: Anwendung der Anweisung/Funktion
+
+Programm: Beispielprogramm, in welchem die Anweisung/Funktion angewendet wird.
+
+Referenz: Verweis auf ähnliche oder äquivalente Anweisungen/Funktionen im
+ Format '<Funktions- bzw. Anweisungsname>, Seitennummer'.
+
+
+Eine oder mehrere dieser Felder können fehlen (z.B. wenn es keine Referenz oder
+kein Beispielprogramm gibt).
+#page#
+
+
+
+#ib#4.1. Übersicht über die Anweisungen und
+ Funktionen#ie#
+
+
+
+#goal page ("A")##ib (2)#A#ie (2)##on ("i")##right#Anweisung#off ("i")#
+
+
+Zweck: Auxiliary-Gleichung (A-Gleichung, Hilfsgleichung)
+
+Format: A <Auxiliary-Name>.K=<Ausdruck>#u##count ("Ausdruck")##e#
+#foot#
+#u##value ("Ausdruck")##e# genaueres über die Definition eines Ausdruckes siehe [1], S. 93
+#end#
+
+Erklärung: Mit Hilfe von Auxiliary-Gleichungen werden Level- und Hilfsgrößen
+ (Auxiliaries) zum selben Zeitpunkt verknüpft.
+
+Beispiel: A JM.K=MM.K/MEJ
+
+Programm: "dyn.workfluc"
+
+
+
+#ib (2)#ABS#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Absolutbetrag
+
+Format: ABS(<Zahl>)
+
+Erklärung: Liefert den Absolutbetrag
+
+
+ IF <Zahl> >= 0 THEN
+ <Zahl>
+ ELSE
+ - <Zahl>
+ END IF
+
+Beispiel: N X=ABS(A*2.0)
+
+
+
+#goal page ("ARCTAN")#ARCTAN#on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Berechnung der trigonometrischen Funktion Arcustangens
+
+Format: ARCTAN(<Zahl>)
+
+Erklärung: Berechnet den Arcustangens von <Zahl>; Ergebnis im Bogenmaß.
+
+Beispiel: N X=ARCTAN(TAN(1.3)) (X = 1.3)
+
+
+Referenz: COSD, S. #to page ("COSD")#
+ SIN, S. #to page ("SIN")#
+ SIND, S. #to page ("SIND")#
+ TAN, S. #to page ("TAN")#
+ TAND, S. #to page ("TAND")#
+ ARCTAND, S. #to page ("ARCTAN")#
+ COS, S. #to page ("COS")#
+
+
+
+#goal page ("ARCTAND")##ib (2)#ARCTAND#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Berechnung der trigonometrischen Funktion Arcustangens
+
+Format: ARCTAND(<Zahl>)
+
+Erklärung: Berechnet den Arcustangens von <Zahl>; Ergebnis im Gradmaß
+
+Beispiel: N X=ARCTAND(TAND(45.0)) (X = 45.0)
+
+
+Referenz: COSD, S. #to page ("COSD")#
+ SIN, S. #to page ("SIN")#
+ SIND, S. #to page ("SIND")#
+ TAN, S. #to page ("TAN")#
+ TAND, S. #to page ("TAND")#
+ COS, S. #to page ("COS")#
+ ARCTAN, S. #to page ("ARCTAND")#
+
+
+
+#goalpage ("C")##ib (2)#C#ie (2)##on ("i")##right#Anweisung#off ("i")#
+
+
+Zweck: Konstantendefinition
+
+Format: C <Name>=<Zahl>
+
+Erklärung: Werte, die während eines Simulationslaufes gleich bleiben, können durch
+ die Konstantendefintion benannt werden (s. auch 'c' im Runtime-
+ System).
+
+Beispiel: C POPI=30.3
+
+Programm: "dyn.wohnen"
+
+
+
+#goal page ("CLIP")##ib (2)#CLIP#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Wert nach Bedingung
+
+Format: CLIP(<Zahl1>,<Zahl2>,<Zahl3>,<Zahl4>)
+
+Erklärung: Liefert den Wert des ersten Argumentes, wenn das dritte Argument
+ größer oder gleich dem vierten Argument ist. Andernfalls wird der Wert
+ des zweiten Argumentes geliefert.
+
+
+ IF <Zahl3> >= <Zahl4> THEN
+ <Zahl1>
+ ELSE
+ <Zahl2>
+ END IF
+
+Beispiel: N X=CLIP(1.0,2.0,3.0,4.0) (X = 2.0)
+
+
+Programm: "dyn.welt/forrester"
+
+Referenz: FIFGE, S. #to page ("FIFGE")# (äquivalente Funktion)
+
+
+
+#goalpage ("COS")#COS#on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Berechnung der trigonometrischen Funktion Cosinus
+
+Format: COS(<Zahl>)
+
+Erklärung: Es wird der Cosinus des Wertes <Zahl>, welcher im Bogenmaß vorlie­
+ gen muß, geliefert.
+
+Beispiel: N X=COS(1.6)
+
+Referenz: COSD, S. #to page ("COSD")#
+ SIN, S. #to page ("SIN")#
+ SIND, S. #to page ("SIND")#
+ TAN, S. #to page ("TAN")#
+ TAND, S. #to page ("TAND")#
+ ARCTAN, S. #to page ("ARCTAN")#
+ ARCTAND, S. #to page ("ARCTAND")#
+
+
+
+#goal page ("COSD")##ib (2)#COSD#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Berechnung der trigonometrischen Funktion Cosinus
+
+Format: COSD(<Zahl>)
+
+Erklärung: Es wird der Cosinus des Wertes <Zahl>, welcher im Gradmaß vorliegen
+ muß, geliefert.
+
+Beispiel: N X=COSD(33.5)
+
+Referenz: COS, S. #to page ("COS")#
+ SIN, S. #to page ("SIN")#
+ SIND, S. #to page ("SIND")#
+ TAN, S. #to page ("TAN")#
+ TAND, S. #to page ("TAND")#
+ ARCTAN, S. #to page ("ARCTAN")#
+ ARCTAND, S. #to page ("ARCTAND")#
+
+
+
+#goal page ("EXP")##ib (2)#EXP#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Exponentialfunktion zur Basis e
+
+Format: EXP(<Zahl>)
+
+Erklärung: Liefert e#u#<Zahl>#e#
+
+Beispiel: N X=EXP(1.0) (X = 2.71 = e)
+
+
+Referenz: LN, S. #to page ("LN")# (Umkehrfunktion)
+
+
+
+#goal page ("FIFGE")##ib (2)#FIFGE#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Wert nach Bedingung (#on ("u")#f#off ("u")#irst #on ("u")#if#off ("u")# #on ("u")#g#off ("u")#reater or #on ("u")#e#off ("u")#qual)
+
+Format: FIFGE(<Zahl1>,<Zahl2>,<Zahl3>,<Zahl4>)
+
+Erklärung: Liefert den Wert des ersten Argumentes, wenn das dritte Argument
+ größer oder gleich dem vierten Argument ist. Andernfalls wird der Wert
+ des zweiten Argumentes geliefert.
+
+
+ IF <Zahl3> >= <Zahl4> THEN
+ <Zahl1>
+ ELSE
+ <Zahl2>
+ END IF
+
+Beispiel: N X=FIFGE(1.0,2.0,3.0,4.0) (X = 2.0)
+
+
+Referenz: CLIP, S. #to page ("CLIP")# (äquivalente Funktion)
+
+
+
+#goal page ("FIFZE")##ib (2)#FIFZE#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Wert nach Bedingung (#on ("u")#f#off ("u")#irst #on ("u")#if#off ("u")# #on ("u")#ze#off ("u")#ro)
+
+Format: FIFZE(<Zahl1>,<Zahl2>,<Zahl3>)
+
+Erklärung: Wenn der Parameter <Zahl3> den Wert 0 hat, so wird <Zahl1>
+ geliefert, andernfalls <Zahl2>
+
+
+ IF <Zahl3> = 0 THEN
+ <Zahl1>
+ ELSE
+ <Zahl2>
+ END IF
+
+Beispiel: N X=FIFZE(1.0,2.0,3.0) (X = 2.0)
+
+
+Referenz: SWITCH, S. #to page ("SWITCH")#
+
+
+
+#goal page ("FLOOR")##ib (2)#FLOOR#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Vorkommastellen
+
+Format: FLOOR(<Zahl>)
+
+Erklärung: Liefert die Vorkommastellen von <Zahl>
+
+Beipiel: N X=FLOOR(3.14) (X = 3.0)
+
+
+Referenz: FRAC, S. #to page ("FRAC")#
+
+
+
+#ib (2)#FOR#ie (2)##on ("i")##right#Anweisung#off ("i")#
+
+
+Zweck: Schleifen-Definition
+
+Format: FOR <Name>=<Zahl1>,<Zahl2>
+
+Erklärung: <Name> bezeichnet eine Schleifenvariable, die von <Zahl1> bis
+ <Zahl2> hochgezählt wird. Somit ist es möglich, gleiche Berechnungen
+ für die verschiedenen Werte einer Tabelle durchzuführen.
+
+Beispiel: FOR BERECHNUNGSZEITRAUM=1900,2100
+
+
+Programm: "dyn.bev"
+
+
+
+#goal page ("FRAC")##ib (2)#FRAC#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Nachkommastellen
+
+Format: FRAC(<Zahl>)
+
+Erklärung: Liefert die Nachkommastellen von <Zahl>
+
+Beispiel: N X=FRAC(3.14) (X = 0.14)
+
+
+Referenz: FLOOR, S. #to page ("FLOOR")#
+
+
+
+#goal page ("L")##ib (2)#L#ie (2)##on ("i")##right#Anweisung#off ("i")#
+
+
+Zweck: Level-Gleichung
+
+Format: L <Level-Name>.K=<Level-Name>.J+
+ <Vergangenheitsausdruck>
+
+Erklärung: Die Level-Gleichung stellt einen gegenwärtigen Wert in Bezug zu
+ seinem Wert in der Vergangenheit und seiner Veränderungsrate in der
+ bis dahin vergangenen Zeit (Vergangenheitsausdruck s. [1], S. 96).
+
+Beispiel: L HASEN.K=CLIP(HASEN.J+DT*(HGRATE.JK
+ X -HSRATE.JK),0,HASEN.J,0)
+
+Programm: "dyn.grashasenfuchs"
+
+
+
+#goal page ("LN")##ib (2)#LN#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Logarithmus-Funktion
+
+Format: LN(<Zahl>)
+
+Erklärung: Berechnet den natürlichen Logarithmus von <Zahl>
+
+Beispiel: N X=LN(1.0) (X = 0.0)
+
+
+Programm: "dyn.wasseröko"
+
+Referenz: LOG2, S. #to page ("LOG2")#
+ LOG10, S. #to page ("LOG10")#
+ EXP, S. #to page ("EXP")#
+
+
+
+#goal page ("LOG2")##ib (2)#LOG2#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Logarithmus-Funktion
+
+Format: LOG2(<Zahl>)
+
+Erklärung: Berechnet den Logarithmus von <Zahl> zur Basis 2
+
+Beispiel: N X=LOG2(8.0) (X = 3.0)
+
+
+Referenz: LN, S. #to page ("LN")#
+ LOG10, S. #to page ("LOG10")#
+
+
+
+#goal page ("LOG10")##ib (2)#LOG10#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Logarithmus-Funktion
+
+Format: LOG10(<Zahl>)
+
+Erklärung: Berechnet den Logarithmus von <Zahl> zur Basis 10
+
+Beispiel: N X=LOG10(100.0) (X = 2.0)
+
+
+Referenz: LOG2, S. #to page ("LOG2")#
+ LN, S. #to page ("LN")#
+ EXP, S. #to page ("EXP")#
+
+
+
+#goal page ("MACRO")##ib (2)#MACRO#ie (2)##on ("i")##right#Anweisung#off ("i")#
+
+
+Zweck: Macro-Definition
+
+Format: MACRO <Name>(<Ausdruck>[,<Ausdruck>[...]])
+
+Erklärung: Durch die Verwendung der MACRO-Anweisung können Sie einer oder
+ mehreren DYNAMO-Gleichungen einen Namen geben (<Name>).
+ Macros müssen durch MEND abgeschloßen werden und dürfen #on ("u")#nicht#off ("u")#
+ rekursiv aufgerufen werden (vergl. Refinements in ELAN).
+
+Beispiel: MACRO SMOOTH(IN,DEL)
+ L SMOOTH.K=SMOOTH.J+DT*(IN.J-SMOOTH.J)/DEL
+ N SMOOTH=IN
+ MEND
+
+Programm: "dyn.mac" (diese Datei enthält alle bisherigen Makros)
+
+Referenz: MEND, S. #to page ("MEND")#
+
+
+
+#goal page ("MAX")##ib (2)#MAX#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Maximum zweier Größen
+
+Format: MAX(<Zahl1>,<Zahl2>)
+
+Erklärung: Liefert die größere Zahl aus <Zahl1> und <Zahl2>
+
+
+ IF <Zahl1> > <Zahl2> THEN
+ <Zahl1>
+ ELSE
+ <Zahl2>
+ END IF
+
+Beispiel: N X=MAX(1.0,2.0) (X = 2.0)
+
+
+Referenz: MIN, S. #to page ("MIN")#
+
+
+
+#goal page ("MEND")##ib (2)#MEND#ie (2)##on ("i")##right#Anweisung#off ("i")#
+
+
+Zweck: Macro-Definition
+
+Format: MEND
+
+Erklärung: MEND beendet eine Macro-Definition
+
+Beispiel: MACRO SMOOTH(IN,DEL)
+ L SMOOTH.K=SMOOTH.J+DT*(IN.J-SMOOTH.J)
+ X /DEL
+ N SMOOTH=IN
+ MEND
+
+Programm: "dyn.mac" (diese Datei enthält alle bisherigen Makros)
+
+Referenz: MACRO, S. #to page ("MACRO")#
+
+
+
+#goal page ("MIN")##ib (2)#MIN#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Minimum zweier Größen
+
+Format: MIN(<Zahl1>,<Zahl2>)
+
+Erklärung: Liefert die kleinere Zahl aus <Zahl1> und <Zahl2>
+
+Beispiel: N X=MIN(1.0,2.0) (X = 1.0)
+
+
+Programm: "dyn.forst7"
+
+Referenz: MAX, S. #to page ("MAX")#
+
+
+
+#goal page ("N")##ib (2)#N#ie (2)##on ("i")##right#Anweisung#off ("i")#
+
+
+Zweck: Initialisierungsgleichung
+
+Format: N <Name>=<Zahl>
+
+Erklärung: Initialisert eine Variable mit dem Bezeichner <Name> auf den Wert
+ <Zahl>, d.h. es wird ihr ein Startwert zugewiesen.
+
+Beispiel: N X=1900
+
+Programm: "dyn.grashasenfuchs"
+
+
+
+#goal page ("NOISE")##ib (2)#NOISE#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Pseudo-Zufallszahlen-Generator
+
+Format: NOISE(<Zahl>)
+
+Erklärung: Diese Funktion liefert eine Pseudo-Zufallszahl zwischen -0.5 und +0.5
+ und setzt einen neuen Startwert für den Generator fest. Der Parameter
+ <Zahl> wird nicht ausgewertet.
+
+Beispiel: N X=NOISE(0)
+
+Referenz: NORMRN, S. #to page ("NORMRN")#
+
+
+
+#goal page ("NORMRN")##ib (2)#NORMRN#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Pseudo-Zufallszahlen-Generator
+
+Format: NORM(<Zahl1>,<Zahl2>)
+
+Erklärung: Liefert einen Wert zwischen <Zahl1> - <Zahl2> * 2.4 und <Zahl1>
+ + <Zahl2> * 2.4.
+
+Beispiel: N X=NORM(1.0,10.0)
+
+Referenz: NOISE, S. #to page ("NOISE")#
+
+
+
+#ib (2)#NOTE#ie (2)##on ("i")##right#Anweisung#off ("i")#
+
+
+Zweck: Kommentar
+
+Format: NOTE <Kommentarzeile>
+
+Erklärung: Die Zeilen, die mit NOTE gekennzeichnet sind, werden vom Compiler als
+ Kommentarzeilen erkannt und nicht beachtet. NOTE-Zeilen haben nur
+ dokumentierenden Charakter und sind für den Programmlauf ohne jede
+ Bedeutung. Dennoch sollte man, wenn immer möglich, Kommentare in
+ sein DYNAMO-Programm einfügen, denn sie sind in DYNAMO an­
+ nähernd die einzige Möglichkeit, ein Programm lesbar zu machen, damit
+ es auch nach längerer Zeit noch korrigiert werden kann.
+
+Beispiel: NOTE Dies ist eine Kommentarzeile
+
+Programm: "dyn.welt/forrester"
+
+
+
+#goal page ("PLOT")##ib (2)#PLOT#ie (2)##on ("i")##right#Anweisung#off ("i")#
+
+
+Zweck: Darstellen der Ergebnisse in Diagrammform
+
+Format: PLOT <Name>[=<Druckzeichen>][(<Skalenbegin>,
+ <Skalenende>)][/...][,...]
+
+Erklärung: Durch diese Anweisung werden die Größen nach PLTPER Zeiteinheiten
+ in einem Diagramm ausgegeben. Die Angabe eines Druckzeichens ist
+ nur bei zeichenorientierten Grafik erforderlich, denn bei hochauflösender
+ Grafik werden die Graphen der verschiedenen Größen durch unterschied­
+ liche Linientypen gezeichnet; fehlt bei der zeichenorientierten Grafik das
+ Druckzeichen, so werden die Graphen durch die Zahlen von 0...9 darge­
+ stellt. Bei "/" werden verschiedene, bei "," gleiche Skalen benutzt.
+
+Beispiel: PLOT GRAS=G(995,1005)/HASEN=H(85,115)
+ X /FUECHS=F(15,35)
+
+Programm: "dyn.grashasenfuchs"
+
+Referenz: PRINT, S. #to page ("PRINT")#
+
+
+
+#goal page ("POWER")##ib (2)#POWER#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Potenzfunktion
+
+Format: POWER(<Zahl1>,<Zahl2>)
+
+Erklärung: Liefert <Zahl1>#u#<Zahl2>#e#
+
+Beipiel: N X=POWER(2, 2) (X = 4)
+
+
+Referenz: SQRT, S. #to page ("SQRT")#
+
+
+
+#goal page ("PRINT")##ib (2)#PRINT#ie (2)##on ("i")##right#Anweisung#off ("i")#
+
+
+Zweck: Darstellung der Ergebnisse in Tabellenform
+
+Format: PRINT <Name>[/...][,...]
+
+Erklärung: Durch diese Anweisung werden die Werte (<Name>) nach PRTPER
+ Zeiteinheiten in einer Tabelle ausgegeben. Die Ausgabe kann umgeleitet
+ werden (s. 'protokoll').
+
+Beispiel: PRINT GBEV,BEV(1),BEV(40),BEV(60),BEV(63)
+ X ,BEV(65),ZBEV,PRENT
+
+Programm: "dyn.bev"
+
+Referenz: PLOT, S. #to page ("PLOT")#
+
+
+
+#goal page ("R")##ib (2)#R#ie (2)##on ("i")##right#Anweisung#off ("i")#
+
+
+Zweck: Rate-Gleichung
+
+Format: R<Rate-Name>.KL=<Gegenwartsausdruck>
+
+Erklärung: Eine Rate-Gleichung stellt die Veränderungsrate in Bezug zu den aktu­
+ ellen Level-Größen.
+
+Beispiel: R FGRATE.KL=FGK*HASEN*FUECHS.K
+
+
+Programm: "dyn.grashasenfuchs"
+
+Referenz: A, S. #to page ("A")#
+ C, S. #to page ("C")#
+ L, S. #to page ("L")#
+
+
+
+#ib (2)#RAMP#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Wert nach Bedingung
+
+Format: RAMP(<Zahl1>,<Zahl2>)
+
+Erklärung: Wenn TIME kleiner <Zahl2>, dann liefert RAMP 0, andernfalls wird
+ <Zahl1> * (TIME - <Zahl2>) geliefert.
+
+
+ IF TIME < <Zahl2> THEN
+ 0
+ ELSE
+ <Zahl1> * (TIME - <Zahl2>)
+ END IF
+
+
+
+#goal page ("RUN")##ib (2)#RUN#ie (2)##on ("i")##right#Anweisung#off ("i")#
+
+
+Zweck: Überschrift
+
+Format: RUN <Überschrift>
+
+Erklärung: Gibt dem aktuellen Lauf eine Überschrift. Gleichzeitig ist
+ "<Überschrift>.const" der Name eines Datenraums, in dem die Kon­
+ stanten dieses Laufs aufgehoben werden (s. 'run' im Runtime-System).
+
+Beispiel: RUN Überschrift
+
+Referenz: *, S. #to page ("*")#
+
+
+
+#ib (2)#S#ie (2)##on ("i")##right#Anweisung#off ("i")#
+
+
+Zweck: Supplementary-Gleichung
+
+Format: S <Name>.K=<Vergangenheitsausdruck>
+
+Erklärung: Gleichungen für Hilfsgrößen werden durch Supplementary-Gleichungen
+ ausgedrückt.
+
+Beispiel: S SCHADSTOFFVERHÄLTNIS.K=COZWEI.K/OZWEI.K
+
+
+
+
+#ib (2)#SCLPRD#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Skalarprodukt
+
+Format: SCLPRD(<Tabelle1>,<Zahl1>,<Zahl2>,<Tabelle2>,<Zahl3>)
+
+Erklärung: Liefert das Skalarprokukt der Tabellen <Tabelle1> und <Tabelle2>,
+ wobei <Zahl1> und <Zahl2> den Ausschnitt aus der ersten Tabelle
+ angeben und <Zahl3> den Startindex für den Vektor in der zweiten
+ Tabelle angibt.
+
+Beispiel: GB.K=SCLPRD(BEV.K,15,44,GR,1)/2
+
+
+Programm: "dyn.bev"
+
+
+
+#goal page ("SIN")##ib (2)#SIN#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Berechnung der trigonometrischen Funktion Sinus
+
+Format: SIN(<Zahl>)
+
+Erklärung: Berechnet den Sinus von <Zahl>, welche im Bogenmaß angegeben
+ wird.
+
+Beispiel: N X=SIN(0.5)
+
+Referenz: COS, S. #to page ("COS")#
+ COSD, S. #to page ("COSD")#
+ SIND, S. #to page ("SIND")#
+ TAN, S. #to page ("TAN")#
+ TAND, S. #to page ("TAND")#
+ ARCTAN, S. #to page ("ARCTAN")#
+ ARCTAND, S. #to page ("ARCTAND")#
+
+
+
+#goal page ("SIND")##ib (2)#SIND#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Berechnung der trigonometrischen Funktion Sinus
+
+Format: SIND(<Zahl>)
+
+Erklärung: Berechnet den Sinus von <Zahl>, welche im Gradmaß angegeben wird.
+
+Beispiel: N X=SIND(45.0)
+
+Referenz: COS, S. #to page ("COS")#
+ SIN, S. #to page ("SIN")#
+ COSD, S. #to page ("COSD")#
+ TAN, S. #to page ("TAN")#
+ TAND, S. #to page ("TAND")#
+ ARCTAN, S. #to page ("ARCTAN")#
+ ARCTAND, S. #to page ("ARCTAND")#
+
+
+
+#ib (2)#SPEC#ie (2)##on ("i")##right#Anweisung#off ("i")#
+
+
+Zweck: Lauf-Anweisung
+
+ DT=<Zahl1>
+Format: SPEC { LENGTH=<Zahl2> }[/...]
+ PLTPER=<Zahl3>
+ PRTPER=<Zahl4>
+
+Erklärung: Durch die Lauf-Anweisung werden die Systemkonstanten festgesetzt.
+ Sie darf pro Lauf nur einmal benutzt werden.
+
+Beispiel: SPEC DT=1/PLTPER=1/PRTPER=1/LENGTH=2000
+
+
+Referenz: C, S. #to page ("C")# (SPEC kann durch C-Def. ersetzt werden)
+
+
+
+#goal page ("SQRT")##ib (2)#SQRT#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Quadratwurzel
+
+Format: SQRT(<Zahl>)
+
+Erklärung: Berechnet die Quadratwurzel aus <Zahl>
+
+Beispiel: N X=SQRT(4.0) (X = 2.0)
+
+
+Referenz: POWER, S. #to page ("POWER")#
+
+
+
+#ib (2)#STEP#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+Zweck: Wert nach Bedingung
+
+Format: STEP(<Zahl1>,<Zahl2>)
+
+Erklärung: Ist TIME kleiner <Zahl2>, so wird 0 geliefert, ansonsten <Zahl1>
+
+
+ IF TIME < <Zahl2> THEN
+ 0.0
+ ELSE
+ <Zahl1>
+ END IF
+
+Beispiel: N X=STEP(12.0,12.0)
+
+
+
+#goal page ("SUM")##ib (2)#SUM#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Summierung einer Tabelle
+
+Format: SUM(<Tabelle>)
+
+Erklärung: Liefert die Summe der Einträge in einer Tabelle
+
+Beispiel: A GESAMTBEV.K=SUM(BEV.K)
+
+Programm: "dyn.bev"
+
+Referenz: SUMV, S. #to page ("SUMV")#
+
+
+
+#goal page ("SUMV")##ib (2)#SUMV#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Summierung einer Tabelle
+
+Format: SUMV(<Tabelle>,<Zahl1>,<Zahl2>)
+
+Erklärung: Summierung der Einträge in der Tabelle von Element <Zahl1> bis
+ Element <Zahl2>
+
+Beispiel: A ZBEV.K=SUMV(BEV.K,16,59) Teilbevölkerung
+
+
+Programm: "dyn.bev"
+
+Referenz: SUM, S. #to page ("SUM")#
+
+
+
+#goal page ("SWITCH")##ib (2)#SWITCH#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Wert nach Bedingung
+
+Format: SWITCH(<Zahl1>,<Zahl2>,<Zahl3>)
+
+Erklärung: Wenn der Parameter <Zahl3> den Wert 0 hat, so wird <Zahl1>
+ geliefert, andernfalls <Zahl2> (gleichbedeutend mit FIFZE).
+
+
+ IF <Zahl3> = 0 THEN
+ <Zahl1>
+ ELSE
+ <Zahl2>
+ END IF
+
+Beispiel: N X=SWITCH(1.0,2.0,3.0) (X = 2.0)
+
+
+Referenz: FIFZE, S. #to page ("FIFZE")#
+
+
+
+#goal page ("T")##ib (2)#T#ie (2)##on ("i")##right#Anweisung#off ("i")#
+
+
+Zweck: Tabellen-Definition
+
+Format: T <Name>=<Zahl1>[/<Zahl2>[....]]
+
+Erklärung: Durch die T-Anweisung wird eine Tabelle definiert, die Elemente wer­
+ den durch "/" getrennt hintereinander angegeben.
+
+Beispiel: T TABELLE=1/2/3/4/5/6/8/9/10/11/12
+
+
+Programm: "dyn.bev"
+
+Referenz: TABLE, S. #to page ("TABLE")#
+ TABHL, S. #to page ("TABHL")#
+
+
+
+#goal page ("TABHL")##ib (2)#TABHL#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Tabellenfunktion
+
+Format: TABHL(<Tabelle>,<Zahl1>,<Zahl2>,<Zahl3>)
+
+Erklärung: IF <Zahl1> < <Zahl2> THEN
+ <Tabelle> (<Zahl2>)
+ ELIF <Zahl2> <= <Zahl1> AND <Zahl1> <= <Zahl3> THEN
+ TABLE (<Tabelle>, <Zahl1>, <Zahl2>, <Zahl3>)
+ ELSE
+ <Tabelle> (<Zahl3>)
+ END IF
+
+Beispiel: A BRMM.K=TABHL(BRMMT,MSL.K,0,5,1)
+
+
+Programm: "dyn.welt/forrester"
+
+Referenz: T, S. #to page ("T")#
+ TABLE, S. #to page ("TABLE")#
+
+
+
+#goal page ("TABLE")##ib (2)#TABLE#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Tabellenfunktion
+
+Format: TABLE(<Tabelle>,<Zahl1>,<Zahl2>,<Zahl3>,<Zahl4>)
+
+Erklärung: Verknüpft die Werte aus <Tabelle> mit <Zahl1>, wobei <Zahl2> den
+ ersten und <Zahl3> den letzten Tabelleneintrag angibt. <Zahl4> stellt
+ die Schrittweite dar.
+
+Beispiel: T TABELLE=1/2/3/4/5
+ A BEISP.K=TABLE(TABELLE,X.K,2,4,1)
+
+Programm: "dyn.welt/forrester"
+
+Referenz: T, S. #to page ("T")#
+ TABHL, S. #to page ("TABHL")#
+
+
+
+#goal page ("TAN")##ib (2)#TAN#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Berechnung der trigonometrischen Funktion Tangens
+
+Format: TAN(<Zahl>)
+
+Erklärung: Berechnet den Tangens von <Zahl>, welche im Bogenmaß angegeben
+ wird.
+
+Beispiel: N X=TAN(0.5)
+
+Referenz: COS, S. #to page ("COS")#
+ SIN, S. #to page ("SIN")#
+ COSD, S. #to page ("COSD")#
+ SIND, S. #to page ("TAN")#
+ TAND, S. #to page ("TAND")#
+ ARCTAN, S. #to page ("ARCTAN")#
+ ARCTAND, S. #to page ("ARCTAND")#
+
+
+
+#goal page ("TAND")##ib (2)#TAND#ie (2)##on ("i")##right#Funktion#off ("i")#
+
+
+Zweck: Berechnung der trigonometrischen Funktion Tangens
+
+Format: TAND(<Zahl>)
+
+Erklärung: Berechnet den Tangens von <Zahl>, welche im Gradmaß angegeben
+ wird.
+
+Beispiel: N X=TAND(45.0)
+
+Referenz: COS, S. #to page ("COS")#
+ SIN, S. #to page ("SIN")#
+ COSD, S. #to page ("COSD")#
+ TAN, S. #to page ("TAN")#
+ SIND, S. #to page ("SIND")#
+ ARCTAN, S. #to page ("ARCTAN")#
+ ARCTAND, S. #to page ("ARCTAND")#
+
+
+
+#goalpage ("X")##ib (2)#X#ie (2)##on ("i")##right#Anweisung#off ("i")#
+
+
+Zweck: Fortsetzungszeile
+
+Format: X <Fortsetzungszeile>
+
+Erklärung: Eine in der vorangegangenen Zeile nicht beendete Anweisung wird nach
+ einer X-Anweisung fortgesetzt (Es können beliebig viele X-Anweisun­
+ gen nacheinander folgen).
+
+Beispiel: T TABELLE=1/2/3/4/5/6/7/8/9/10/11/12/13/14
+ X /15/16/17/18/19
+
+Programm: "dyn.bev"
+
+
+
+#goal page ("*")##ib (2)#*#ie (2)##on ("i")##right#Anweisung#off ("i")#
+
+
+Zweck: Überschrift
+
+Format: * <Überschrift>
+
+Erklärung: Gibt dem aktuellen Lauf eine Überschrift
+
+Beispiel: * Überschrift
+
+Referenz: RUN, S. #to page ("RUN")#
+#page#
+
+#ib#5. Makros in DYNAMO#ie#
+
+
+
+
+Der DYNAMO-Compiler bietet die Möglichkeit, benutzereigene Funktionen zu definie­
+ren. Makros werden ähnlich wie Refinements in ELAN in das DYNAMO-Programm
+eingesetzt. Beim EUMEL-DYNAMO-Compiler werden mit "zz" beginnende Namen
+generiert, so daß Sie es vermeiden sollten, eigene Namen mit "zz" beginnen zu
+lassen. Weiterhin sollte man als Namen der aktuellen Parameter nicht die Namen der
+formellen Parameter verwenden.
+
+Folgende Makros werden standardmäßig vom DYNAMO-Compiler zur Verfügung
+gestellt:
+
+ macro delay1 (in, del) Verzögerung erster Ordnung
+
+ macro delay3 (in, del) Verzögerung dritter Ordnung
+ Material
+
+ macro delay3p (in, del, ppl) Verzögerung dritter Ordnung mit
+ Pipeline
+
+ macro delinf3 (in, del) Verzögerung dritter Ordnung für
+ Information
+
+ macro smooth (in, del) Verzögerung erster Ordnung für
+ Information
+
+
+
+
+#ib#5.1. Insertieren von Makros#ie#
+
+
+
+
+Makros werden durch folgende Prozedur in die Compilertabelle eingetragen:
+
+
+PROC insert macro (TEXT CONST filename):
+
+ Zweck: Fügt die in der Datei 'filename' enthaltenen Makros in die Makrotabelle ein.
+ Die Datei sollte zweckmäßigerweise nur Makrodefinitionen enthalten. Es ist
+ - im Gegensatz zu normalen DYNAMO-Programmen - nicht nötig, die
+ Systemkonstanten zu definieren (die Standard-Makros sind in der Datei
+ "dyn.mac" enthalten; diese Datei kann beliebig ergänzt werden).
+
+
+
+
+#ib#5.2. Aufbau eines Makros#ie#
+
+
+
+
+Makros beginnen in DYNAMO immer mit der Anweisung MACRO (s. auch Seite #to page ("MACRO")#)
+und enden mit MEND (s. Seite #to page ("MEND")#). Dazwischen steht ein Makrorumpf, bestehend
+aus einer oder mehreren DYNAMO-Gleichungen. Beim Makroaufruf können, soweit
+vorher definiert, Parameter angegeben werden, jedoch rekursiv aufrufen kann man
+Makros nicht.
+
+Beispiel: MACRO SMOOTH (IN, DEL)
+ L SMOOTH.K = SMOOTH.J + DT * (IN.J - SMOOTH.J)
+ X /DEL
+ N SMOOTH = IN
+ MEND
+
+Lokale Variablen in Makros beginnen mit einem $-Zeichen. Der Makro-Expandierer
+ersetzt das $-Zeichen durch "zz" gefolgt von einer Zahl. Aus diesem Grund sollen
+eigene Namen nicht mit "zz" beginnen.
+
+Falls Sie eine Fehlermeldung bekommen, die sich auf einen mit "zz" beginnenden
+Namen bezieht, sollten Sie den Fehler in dem entsprechenden Makro suchen.
+
+#on ("b")#
+Achtung: #off ("b")#Makros sollten nur von fortgeschrittenden DYNAMO-Programmieren
+ verwendet werden, da Makros Eigenschaften von Refinements (textuelle
+ Ersetzung) und Prozeduren (Parameterübergabe) vereinigen. Der daraus
+ folgende Effekt ist nicht ganz einfach zu durchschauen.
+#page#
+
+
+
+#ib#6. Erweiterung des Sprachumfangs#ie#
+
+
+
+
+Während Makros in DYNAMO geschrieben werden, ist es ferner möglich, die Menge
+der Funktionen mittels der Sprache ELAN zu erweitern.
+
+Hierbei geht man wie folgt vor:
+
+ 1. Schreiben einer Funktion in ELAN (näheres siehe unten)
+
+ 2. Einbinden der Funktion in die Tabellen des DYNAMO-Compilers
+
+ 2.1. Einschreiben des Namens der Funktion, gefolgt von den Typen der Ein­
+ gabeparameter in die bestehende Datei "dyn.std", wobei folgende Typen
+ existieren:
+
+ r real (Datentyp REAL)
+ t table (Datentyp TAB)
+
+ Abgeschlossen wird die "dyn.std"-Datei durch die Zeichensequenz "/*".
+
+ Beispiele:
+
+ power rr table trrrr /*
+
+
+ 2.2. Laden der Funktion(en) mittels der Prozedur 'init std ("dyn.std")'
+
+
+Eine zur Einbindung in den DYNAMO-Compiler vorgesehene ELAN-Funktion wird
+unter Beachtung gewisser Regeln erstellt:
+
+ 1. Die deklarierten ELAN-Prozeduren dürfen nur Parameter vom Typ REAL oder
+ TAB besitzen oder gänzlich ohne Parameter sein.
+
+ 2. Der Typ des Resultaten muß vom Typ REAL sein.
+
+Zur Manipulation von Tabellen wurde der Datentyp TAB geschaffen, auf welchen man
+wie auf das Standard-Vektorpaket zugreifen kann.
+
+Beispiel:
+
+ REAL PROC abs (REAL CONST a):
+ IF a < 0.0 THEN
+ -a
+ ELSE
+ a
+ END IF
+ END PROC abs;
+
+ PROC sumv (TAB CONST tab, REAL CONST erstes, letztes):
+ REAL VAR summe := 0.0;
+ INT VAR i;
+ FOR i FROM int (erstes) UPTO int (letztes) REPEAT
+ summe INCR wert (tab, i)
+ END REPEAT;
+ summe
+ END PROC sumv
+
+
+
+
+#ib#6.1. Für fortgeschrittende ELAN-Program­
+ mierer#ie#
+
+
+
+Der Quellcode des EUMEL-DYNAMO-Compilers wird mit ausgeliefert. Daher
+können Einschränkungen (s. 3.2 Abweichungen gegenüber dem Sprachstandard)
+leicht beseitigt werden. Wem z.B. die Anzahl der Gleichungen (950) zu wenig ist, der
+kann im Quelltext des Compilers diesen Wert (annähernd) beliebig nach oben hin
+erhöhen.
+
diff --git a/lang/dynamo/1.8.7/doc/dynamo handbuch.index b/lang/dynamo/1.8.7/doc/dynamo handbuch.index
new file mode 100644
index 0000000..af77d79
--- /dev/null
+++ b/lang/dynamo/1.8.7/doc/dynamo handbuch.index
@@ -0,0 +1,69 @@
+#block##pageblock##page (52)#
+#head#
+#center#DYNAMO-Compiler
+#center#____________________________________________________________
+
+#end#
+#bottom odd#
+#center#____________________________________________________________
+GMD #right#DYNAMO - %
+#end#
+#bottom even#
+#center#____________________________________________________________
+DYNAMO - % #right#GMD
+#end#
+Anhang - Übersicht über Anweisungen und
+Funktionen
+
+
+#clear pos##l pos (0.0)##r pos (10.0)##fillchar (" ")#
+#table#
+A 21
+ABS 21
+ARCTAND 22
+C 23
+CLIP 23
+COSD 24
+EXP 25
+FIFGE 25
+FIFZE 26
+FLOOR 26
+FOR 27
+FRAC 27
+L 28
+LN 28
+LOG2 29
+LOG10 29
+MACRO 30
+MAX 31
+MEND 31
+MIN 32
+N 32
+NOISE 33
+NORMRN 33
+NOTE 34
+PLOT 35
+POWER 35
+PRINT 36
+R 36
+RAMP 37
+RUN 37
+S 38
+SCLPRD 38
+SIN 39
+SIND 39
+SPEC 40
+SQRT 40
+STEP 41
+SUM 41
+SUMV 42
+SWITCH 42
+T 43
+TABHL 43
+TABLE 44
+TAN 44
+TAND 45
+X 45
+* 46
+#table end#
+
diff --git a/lang/dynamo/1.8.7/doc/dynamo handbuch.inhalt b/lang/dynamo/1.8.7/doc/dynamo handbuch.inhalt
new file mode 100644
index 0000000..2d1b1f3
--- /dev/null
+++ b/lang/dynamo/1.8.7/doc/dynamo handbuch.inhalt
@@ -0,0 +1,131 @@
+____________________________________________________________________________
+
+
+#on("b")##on ("u")#
+#center#Betriebssystem E U M E L
+#off ("u")#
+
+
+#center#DYNAMO
+
+
+
+
+#off("b")#
+#center#Lizenzfreie Software der
+#on ("b")#
+
+#center#Gesellschaft für Mathematik und Datenverarbeitung mbH,
+#center#5205 Sankt Augustin
+
+
+#off("b")#
+#center#Die Nutzung der Software ist nur im Schul- und Hochschulbereich für
+#center#nichtkommerzielle Zwecke gestattet.
+
+#center#Gewährleistung und Haftung werden ausgeschlossen
+
+
+____________________________________________________________________________
+#page#
+#block#
+#center#____________________________________________________________________________
+
+ Copyright 1988
+
+ Selbstverlag GMD
+ Alle Rechte vorbehalten.
+ Insbesondere ist die Überführung in maschinenlesbare
+ Form, sowie das Speichern in Informationssystemen, auch
+ auszugsweise, nur mit schriftlicher Genehmigung der
+ GMD gestattet.
+#center#____________________________________________________________________________
+
+
+ Herausgeber:
+
+ Gesellschaft für Mathematik und Datenverarbeitung mbH
+
+ Postfach 1240, Schloß Birlinghoven
+ D-5205 Sankt Augustin 1
+ Telefon(02241) 14-1, Telex 8 89 469 gmd d
+ Telefax(02241) 14 28 89, BTX *43900\#
+ Teletex 2627-224135=GMDVV
+
+
+Autor:
+
+ Christian Szymanski
+
+nach Anregungen von:
+
+ Diether Craemer, Robert Keil
+
+überarbeitet von:
+
+ Thomas Müller
+
+Texterstellung:
+
+ Dieser Text wurde mit der EUMEL-Textverarbeitung erstellt und aufbereitet und
+ mit dem Agfa Laserdrucksystem P400 gedruckt.
+
+
+
+ Hinweis:
+
+#on("italics")#
+ Diese Dokumentation wurde mit größtmöglicher Sorgfalt erstellt. Dennoch wird
+ für die Korrektheit und Vollständigkeit der gemachten Angaben keine Gewähr
+ übernommen. Bei vermuteten Fehlern der Software oder der Dokumentation
+ bitten wir um baldige Meldung, damit eine Korrektur möglichst rasch erfolgen
+ kann. Anregungen und Kritik sind jederzeit willkommen.#off("italics")#
+#page#
+#pagenr ("%", 1")##setcount (1)##block##pageblock##count per page#
+#head#
+#center#DYNAMO-Compiler
+#center#____________________________________________________________
+
+#end#
+#bottom odd#
+#center#____________________________________________________________
+GMD #right#DYNAMO - %
+#end#
+#bottom even#
+#center#____________________________________________________________
+DYNAMO - % #right#GMD
+#end#
+
+Inhalt
+
+
+
+#clear pos##lpos (0.0)##r pos (10.0)##fillchar (" ")#
+#table#
+1. Einleitung 2
+ 1.1. Referenzliteratur 2
+ 1.2. Die Programmiersprache DYNAMO 3
+ 1.3. Kurz-Einführung in die DYNAMO-Schreibweise 4
+ 1.4. Eine erste, kleine Sitzung mit dem DYNAMO-System 6
+
+2. Generierung des DYNAMO-Compilers 7
+
+3. Der EUMEL-DYNAMO-Compiler 8
+ 3.1. Benutzung des DYNAMO-Compiler 8
+ 3.2. Abweichungen gegenüber dem Sprachstandard 11
+ 3.3. Das DYNAMO Runtime-System 12
+ 3.4. Fehlermeldungen des DYNAMO-Compilers 14
+
+4. Anweisungen und Funktionen des EUMEL-DYNAMO-Compilers 19
+ 4.1. Übersicht über die Anweisungen und Funktionen 21
+
+5. Makros in DYNAMO 47
+ 5.1. Insertieren von Makros 48
+ 5.2. Aufbau eines Makros 48
+
+6. Erweiterung des Sprachumfangs 50
+ 6.1. Für fortgeschrittende ELAN-Programmierer 51
+
+Anhang - Übersicht über Anweisungen unf Funktionen 52
+#table end#
+