path: root/lang/dynamo/1.8.7/doc/dynamo handbuch

#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.