Übung 01 Harmonischer Oszillator

Transkript

1 Übung 01 Harmonischer Oszillator 1

2 1 Dokumentation des harmonischen Oszillator 1.1 Physikalischer Hintergrund Das vorliegende Programm löst die diskrete Bewegungsgleichung eines Teilchens in einem harmonischen Potential E pot = 1 rc r mit dem Reibungsfaktor α. 2 Die Berechnung der einzelnen Positionen und Energien des Teilchen geschieht iterativ. Dazu wird der Verlet-Algorithmus benutzt. Dieser Algorithmus wird zum Beispiel in der Molekulardynamikmethode angewandt, mit der man die Bewegung von Atomen in Molekulen und Materialien untersucht. Er zeichnet sich durch seine Einfachheit und Robustheit aus. Ausgehend von der Bewegungsgleichung m r = F ( r) α r (1.1) mit F ( r) = c r wird der sogenannte Zeitschritt eingeführt, der den zeitlichen Abstand der diskreten Punkte auf der zu berechnenden Bahnkurve der Teilchen bestimmt. Damit wird die Bewegungsgleichung diskretisiert. Das heißt, die Ableitungen des Ortes werden durch den entsprechenden Differenzenquotienten ersetzt. Daraus folgt: r r r(t + ) r(t ) 2 (1.2) r(t + ) 2 r(t) + r(t ) 2 (1.3) m [ r(t + ) 2 r(t) + r(t )] = F (r) α [ r(t + ) r(t )] (1.4) 2 2 Aufgelöst nach r(t + ) ergibt sich mit a := α 2m r(t + ) = r(t) 2 1 a r(t ) 1 + a 1 + a + F ( r(t)) 2 m a (1.5) 2

3 Als Anfangsbedingungen kennen wir r(0) und v(0). Benötigt wird aber r(t ), deshalb muss v(0) noch in r(t ) umgerechnet werden. Dazu wird die Formel (1.6) nach r(t+ ) aufgelöst und in die diskretisierte Bewegungsgleichung (1.1) eingesetzt. v(0) = r(t + ) r(t ) 2 Diese wird dann nach r(t ) aufgelöst und wir erhalten r(t ) als: (1.6) mit F ( r(0)) = c r(0). r(t ) = r(0) v(0) (1 + a) + 2 2m F ( r(0)) (1.7) Nun kann die Bewegung Schritt für Schritt iteriert werden. Die einzelnen Schritte bei der Iteration sind: 1. Berechne die Kräfte F ( r(t)) 2. Propagiere die Bahn r(t + ) 3. Verschiebe den Zeitschritt Die Daten werden dabei wie folgt umkopiert: r(t) r(t ) r(t + ) r(t) (1.8) Zu beachten ist, dass der Verlet-Algorithmus instabil wird bei einem zu großen Zeitschritt. Ist T die kürzeste Periode der Dynamik, dann muss der Zeitschritt die Bedingung <= 1 10 T erfüllen. 1.2 Beschreibung für den Benutzer Geschrieben ist das Programm in Fortran95. Die Eingabeparameter können mit Hilfe eines beliebigen Editors in der Datei in.dat modifiziert werden In der ersten Zeile stehen die Masse, der Reibungsfaktor α und die Konstante c, wobei c die Form einer Matrix hat. Die zweite Zeile der Datei in.dat enthält die Größe des Zeitschritts und die Anzahl der durchzuführenden Iterationen niter. In der dritten Zeile steht der Start-Orts-Vektor und in der vierten Zeile der Start-Geschwindigkeits- Vektor.

4 Zu beachten beim Einlesen der Matrix c ist, dass in Fortran Matrizen der Form M(Zeilen i,spalten j) zunächst die Spalten durchlaufen, im Gegensatz zu anderen Programmiersprachen wie C oder C++. Beispiel: Eine 3x3 Matrix wird folgendermaßen mit Werten belegt: 1 i n t e g e r ( 4 ) : : M( 3, 3 ) 2 M( :, : ) = ( / 1, 2, 3, 4, 5, 6, 7, 8, 9 / ) Dann sieht die initialisierte Matrix so aus: M = Die Ausgabe erfolgt in Form von zwei Dateien (Energies.dat und r.dat), die Energien und Ortskoordinaten beinhalten In jeder Zeile der Datei Energies.dat stehen: Aktueller Zeitpunkt(iter*dt), Gesamtenergie(etot), kinetische Energie(ekin) und potentielle Energie(epot). Die Visualisierung mit xmgrace ist in Bild (1.1) zu sehen. 2 1,5 1 0, Abbildung 1.1: Darstellung der Energien in Abhängigkeit von der Zeit. Die durchgezogene Linie entspricht der Gesamtenergie, die gestrichelte Linie der potentiellen Energie und die gepunktete der kinetischen Energie.

5 Die Datei r.dat enthält den aktuellen Zeitpunkt und den dazugehörigen Ortsvektor. Der Ortsvektor ist in Bild (1.2) zu sehen. 1 0,5 0-0, Abbildung 1.2: Darstellung des Ortsvektors in Abhängigkeit von der Zeit. 1.3 Beschreibung für den Programmierer Die folgende Beschreibung bezieht sich direkt auf die Syntax, die zum Programmieren mit Fortran verwendet wird. Zunächst wird hier das komplette Programm dargestellt und anschließend Zeile für Zeile erklärt. 1 program main 2 i m p l i c i t none 3 4!== D e f i n i t i o n d e r V a r i a b l e n ============================ 5 6 i n t e g e r ( 4 ), parameter : : n=3! Dimension d e r K o o r d i n a t e n 7 r e a l ( 8 ) : : r 0 ( n )! a k t u e l l e P o s i t i o n 8 r e a l ( 8 ) : : rm ( n )! v o r h e r i g e P o s i t i o n 9 r e a l ( 8 ) : : rp ( n )! n a e c h s t e P o s i t i o n 10 r e a l ( 8 ) : : v ( n )! G e s c h w i n d i g k e i t 11 r e a l ( 8 ) : : f ( n )! K r a f t 12 r e a l ( 8 ) : : c ( n, n )! K r a f t k o n s t a n t e n 13 r e a l ( 8 ) : : m! Masse 14 r e a l ( 8 ) : : dt! Z e i t s c h r i t t 15 r e a l ( 8 ) : : a l p h a! R e i b u n g s f a k t o r 16 r e a l ( 8 ) : : Etot! G e s a m t e n e r g i e 17 r e a l ( 8 ) : : Ekin! k i n e t i s c h e E n e r g i e 18 r e a l ( 8 ) : : Epot! p o t e n t i e l l e E n e r g i e 19 i n t e g e r ( 4 ) : : n i t e r! Anzahl d e r Z e i t s c h r i t t e 20 i n t e g e r ( 4 ) : : i t e r! I n d e x des Z e i t s c h r i t t s

6 21 r e a l ( 8 ) : : a! H i l f s v a r i a b l e 22 23! 24!== o e f f n e D a t e i e n f u e r Ein und Ausgabe ================ open ( u n i t =1000, f i l e = i n. dat, form = f o r m a t t e d ) 27 open ( u n i t =1001, f i l e = e n e r g i e s. dat, form = f o r m a t t e d ) 28 open ( u n i t =1002, f i l e = r. dat, form = f o r m a t t e d ) 29 30!== l e s e E i n g a b e d a t e n =================================== read ( , )m, alpha, c 33 read ( , ) dt, n i t e r 34 read ( , ) r 0 35 read ( , ) v 36 n i t e r =1000/ dt 37!== b e r e i t e Anfangsbedingungen v o r ====================== rm ( : )=r 0 ( : ) v ( : ) dt (1+a ) 0.5 d0/m matmul ( c ( :, : ), r 0 ( : ) ) dt !== Das i s t d i e S c h l e i f e u e b e r d i e Z e i t s c h r i t t e ========= do i t e r =1, n i t e r 44 45!== b e r e c h n e p o t e n t i e l l e E n e r g i e und K r a e f t e ========== c a l l c a l c e p o t ( n, c, r0, epot, f ) 48 49!== p r o p a g i e r e ======================================== a =0.5 d0 a l p h a dt /m 52 rp ( : )=r 0 ( : ) 2. d0/(1+a ) & 53 rm ( : ) (1 a ) /(1+a ) & 54 + f ( : ) dt 2/m/(1+a ) 55 56!== s c h r e i b e E n e r g i e und K o o r d i n a t e n ================== 57 v ( : ) =( rp ( : ) rm ( : ) ) / ( 2. d0 dt ) 58 e k i n =0.5 d0 m d o t p r o d u c t ( v, v ) 59 e t o t=e k i n+epot 60 w r i t e (, fmt = ( i t e r, i10, e t o t, e10. 5, e k i n & 61 &, e10. 5, epot, e10. 5 ) ) i t e r, e t o t, e k i n, epot 62 w r i t e ( , ) r e a l ( i t e r, k i n d =8) dt, e t o t, e k i n, epot 63 w r i t e ( , ) r e a l ( i t e r, k i n d =8) dt, r 0 ( : ) 64 65!== V e r t a u s c h e K o o r d i n a t e n f u e r n a e c h s t e n Z e i t s c h r i t t = rm ( : )=r 0 ( : ) 68 r 0 ( : )=rp ( : ) 69 end do 70 71!== nun s c h l i e s s e d i e D a t e i e n =========================== c l o s e (1000) 74 c l o s e (1001) 75 c l o s e (1002) 76 stop 77 end program main 78 79! s u b r o u t i n e c a l c e p o t ( n, c, r0, epot, f ) 82 i m p l i c i t none 83 i n t e g e r ( 4 ), i n t e n t ( i n ) : : n 84 r e a l ( 8 ), i n t e n t ( i n ) : : c ( n, n ) 85 r e a l ( 8 ), i n t e n t ( i n ) : : r ( n ) 86 r e a l ( 8 ), i n t e n t ( out ) : : epot

7 87 r e a l ( 8 ), i n t e n t ( out ) : : f ( n ) 88 89! epot =0.5 d0 d o t p r o d u c t ( r, matmul ( c ( :, : ), r 0 ( : ) ) ) 92 f ( : )= matmul ( c ( :, : ), r 0 ( : ) ) 93 r e t u r n 94 end s u b r o u t i n e c a l c e p o t Erklärung der einzelnen Programmabschnitte 30!== l e s e E i n g a b e d a t e n =================================== Kommentare im Code beginnen mit einem Ausrufezeichen. Nachfolgender Text in der selben Zeile wird vom Compiler nicht interpretiert. 1 program main 77 end program main Jedes Programm muss mit einem Programmnamen beginnen (hier: main) und kann auch damit beendet werden. Ansonsten steht am Ende nur ein END ohne Namen. Mit Ausnahme von Unterprogrammen befindet sich der komplette Code zwischen diesen Zeilen. 4!== D e f i n i t i o n d e r V a r i a b l e n ============================ 5 6 i n t e g e r ( 4 ), parameter : : n=3! Dimension d e r K o o r d i n a t e n 7 r e a l ( 8 ) : : r 0 ( n )! a k t u e l l e P o s i t i o n 8 r e a l ( 8 ) : : rm ( n )! v o r h e r i g e P o s i t i o n 9 r e a l ( 8 ) : : rp ( n )! n a e c h s t e P o s i t i o n 10 r e a l ( 8 ) : : v ( n )! G e s c h w i n d i g k e i t 11 r e a l ( 8 ) : : f ( n )! K r a f t 12 r e a l ( 8 ) : : c ( n, n )! K r a f t k o n s t a n t e n 13 r e a l ( 8 ) : : m! Masse 14 r e a l ( 8 ) : : dt! Z e i t s c h r i t t 15 r e a l ( 8 ) : : a l p h a! R e i b u n g s f a k t o r 16 r e a l ( 8 ) : : Etot! G e s a m t e n e r g i e 17 r e a l ( 8 ) : : Ekin! k i n e t i s c h e E n e r g i e 18 r e a l ( 8 ) : : Epot! p o t e n t i e l l e E n e r g i e 19 i n t e g e r ( 4 ) : : n i t e r! Anzahl d e r Z e i t s c h r i t t e 20 i n t e g e r ( 4 ) : : i t e r! I n d e x des Z e i t s c h r i t t s 21 r e a l ( 8 ) : : a! H i l f s v a r i a b l e Variablen müssen in Fortran nicht deklariert werden; es ist aber zweckmäßig, um Fehler zu vermeiden. Zunächst wird die Art der Variable angegeben (integer, real). Die Zahl in den Klammern entspricht dem Typ dieser Variablen. Ein INTEGER(1) entspricht einer Zahl von 128 bis Ein INTEGER(2) einer Zahl von bis und ein INTEGER(3 oder 4) einer Zahl von bis Das entspricht einer 32-Bit-Ganzzahl. Der Datentyp REAL(8) entspricht einer 64-Bit-Gleitkommazahl von bis Es gibt noch folgende

8 weitere integrierte Datentypen: CHARACTER für eine Zeichenfolge, COMPLEX bestehend aus zwei REAL für complexe Zahlen und LOGICAL für logische Werte wie TRUE und FALSE. 2 i m p l i c i t none Diese Anweisung bewirkt, dass der Typ der Variablen unabhängig vom Namen ist. Gegenbeispiel: 1 IMPLICIT COMPLEX ( r ) 2 REAL( 4 ) : : rm In diesem Fall sind alle Variablen, die mit einem r anfangen vom Typ COMPLEX mit Ausnahme der Variablen rm. Bei einem übersichtlichen Programmierstil wird immer IMPLICIT NONE verwendet. Auch werden alle Variablen vor der Benutzung deklariert. Der Begriff Parameter wird verwendet um eine Konstante zu erzeugen. Diese muss sofort mit einem Wert belegt werden. Der Wert dieser Variablen kann im weiteren Programm nicht mehr verändert werden. Der Compiler übersetzt diese Variable gleich mit dem zugewiesenen Wert. Im Binärcode des ausführbaren Programms steht statt dieser Variablen dann direkt der Wert. Steht hinter dem Variablennamen eine Klammer mit einer Zahl, enspricht diese Variable einem Vektor. Sind es zwei Zahlen wie bei der Variablen c(n,n), hat diese Variable die Form einer Matrix. Es sind beliebige Kombinationen möglich. Beispiel: T(a,b,c,d) mit a=4, b=5, c=2, d=8 ist ein vierdimensionaler Tensor. Dieser hat 4 Felder, die jeweils 5 Feldern enthalten, mit jeweils 2 Feldern, die jeweils 8 Felder beinhalten. 24!== o e f f n e D a t e i e n f u e r Ein und Ausgabe ================ open ( u n i t =1000, f i l e = i n. dat, form = f o r m a t t e d ) 27 open ( u n i t =1001, f i l e = e n e r g i e s. dat, form = f o r m a t t e d ) 28 open ( u n i t =1002, f i l e = r. dat, form = f o r m a t t e d ) Der Befehl open öffnet eine Datei zum Lesen und Schreiben. Ist keine Datei dieses Names vorhanden, wird eine erzeugt. Jeder Datei (file= Dateiname ) wird über unit eine Zahl zugeordnet, über die die Lese- und Schreibanweisungen ausgeführt werden. Der Parameter form= Format gibt das Format an, in dem die Daten in der Datei geschrieben sind bzw. geschrieben werden. In diesem Fall bedeutet formatted, dass der Inhalt in der Datei lesbar ist im Gegensatz zu unformatted, bei dem der Inhalt der Datei in Maschinencode geschrieben ist. 30!== l e s e E i n g a b e d a t e n =================================== read ( , )m, alpha, c 33 read ( , ) dt, n i t e r 34 read ( , ) r 0 35 read ( , ) v

9 Der Befehl read liest alle Daten einer Zeile der Datei (1000) im freien Format (*) in die angegebenen Variablen ein. Dabei stehen die einzulesenden Werte hintereinander und sind duch Leerzeichen voneinander getrennt. Beim nächsten read-befehl werden die Daten von der nächsten Zeile gelesen. Die Daten können auch alle in einer Zeile stehen. Die vorliegende Darstellung ist jedoch übersichtlicher. 37!== b e r e i t e Anfangsbedingungen v o r ====================== rm ( : )=r 0 ( : ) v ( : ) dt (1+a ) 0.5 d0/m matmul ( c ( :, : ), r 0 ( : ) ) dt 2 Der erste Wert wird berechnet.die hier angegebene Formel wird in der Mathematik folgendermaßen geschrieben: r m = r 0 v (1 + a) 1 2m c r 0 2 (1.9) Der Doppelpunkt bei einer Variablen in Vektor- oder Matrixform bewirkt, dass alle Zahlen der Variable in die Berechnung einfließen. Um z.b. nur die 1. Komponente anzusprechen, würde man statt v(:) v(1) schreiben. Statt einer Berechnung in Vektoren bewirkt der Doppelpunkt aber, dass die Vektoren elementweise berechnet werden. Bei [a(:)+b(:)] gibt es keinen Unterschied. Bei der Multiplikation von zwei Vektoren [a(:) b(:)] sieht die Sache aber ganz anders aus. Hier wird jeweils die Komponente von a und b miteinander multipliziert, was nicht das mathematische Skalarprodukt ist. Deshalb gibt es für das Skalarprodukt in Fortran die Funktion dot produkt(a,b). Eine weitere mathematische Funktion in Fortran führt eine Matrizenmultiplikation durch, matmul(a,b). Die Zahl 0.5d0 entspricht dem Wert 0.5 mit doppelter Genauigkeit. Diese Genauigkeit passt zu der Variablendeklaration REAL(8). 43 do i t e r =1, n i t e r 69 end do Mit dieser Anweisung wird eine Wiederholungsschleife erzeugt. Die Anweisungen zwischen diesen beiden Zeilen werden einmal durchgeführt und anschließend wird verglichen, ob die Variable iter den Wert von niter erreicht hat. Wenn nicht, wird iter um eins erhöht und die Schleife startet von vorn. Für iter=1 und niter=1 wird die Schleife genau einmal durchlaufen. Für niter=100 entsprechend 100 mal. 45!== b e r e c h n e p o t e n t i e l l e E n e r g i e und K r a e f t e ========== c a l l c a l c e p o t ( n, c, r0, epot, f ) Mit diesem Befehl wird ein Unterprogramm aufgerufen. Dabei werden die Werte der Variablen n,c,r0,epot und f zwischen dem Haupt- und dem Unterprogramm übergeben. Genau genommen wird jeweils nur ein Zeiger auf den Begin der Speicheradresse der Variable übergeben. Deshalb darf die Definition von Variablen im Unterprogramm nie

10 eine größere Bitlänge haben als im Hauptprogramm. Der Fachbegriff dafür heißt Call by Reference. 81 s u b r o u t i n e c a l c e p o t ( n, c, r0, epot, f ) 82 i m p l i c i t none 83 i n t e g e r ( 4 ), i n t e n t ( i n ) : : n 84 r e a l ( 8 ), i n t e n t ( i n ) : : c ( n, n ) 85 r e a l ( 8 ), i n t e n t ( i n ) : : r ( n ) 86 r e a l ( 8 ), i n t e n t ( out ) : : epot 87 r e a l ( 8 ), i n t e n t ( out ) : : f ( n ) 88 89! epot =0.5 d0 d o t p r o d u c t ( r, matmul ( c ( :, : ), r 0 ( : ) ) ) 92 f ( : )= matmul ( c ( :, : ), r 0 ( : ) ) 93 r e t u r n 94 end s u b r o u t i n e c a l c e p o t Ein Unterprogramm funktioniert genauso wie ein normales Programm. Das Hauptprogramm kann die Werte von Variablen beim Aufruf des Unterprogramms an das Unterprogramm weitergeben. Die mit intent(in) definierten Variablen werden mit diesen Werten belegt. Umgekehrt kann das Unterprogramm nach einer Berechnung Werte von anderen Variablen wieder an das Hauptprogramm zurückgeben. Diese Variablen sind mir intent(out) definiert. Es gibt auch den Parameter intent(inout). Er sollte aber vermieden werden. Zusätzlich gehört noch eine return Anweisung in das Unterprogramm, damit anschließend wieder in das Hauptprogramm zurückgesprungen wird. 49!== p r o p a g i e r e ======================================== a =0.5 d0 a l p h a dt /m 52 rp ( : )=r 0 ( : ) 2. d0/(1+a ) & 53 rm ( : ) (1 a ) /(1+a ) & 54 + f ( : ) dt 2/m/(1+a ) 55 56!== s c h r e i b e E n e r g i e und K o o r d i n a t e n ================== 57 v ( : ) =( rp ( : ) rm ( : ) ) / ( 2. d0 dt ) 58 e k i n =0.5 d0 m d o t p r o d u c t ( v, v ) 59 e t o t=e k i n+epot Ist eine Anweisung zu lang für eine Zeile oder unübersichtlich, kann sie mit dem UND- Zeichen & unterbrochen und in der nächsten Zeile fortgesetzt werden. Die angegebenen Formeln stellen sich in mathematischer Schreibweise folgendermaßen dar: a = 1 2 α m 2 r p = r a r 1 a m 1 + a + F 2 m(1 + a) v = r p r m 2 (1.10) (1.11) (1.12) E kin = 1 m ( v v) 2 (1.13) E tot = E kin + E pot (1.14)

11 60 w r i t e (, fmt = ( i t e r, i10, e t o t, e10. 5, e k i n & 61 &, e10. 5, epot, e10. 5 ) ) i t e r, e t o t, e k i n, epot Mit dem write Befehl können Inhalte von Variablen ausgegeben werden. In diesem Fall erfolgt die Ausgabe durch das * auf dem Standart Ausgabegerät, dem Monitor. Die fmt-anweisung gibt das Format der Ausgabe an. Die Zeichen zwischen den Anführungsstrichen werden direkt ausgegeben. Die anderen Anweisungen bezeichnen die Formate, in denen die Werte der Variablen dargestellt werden: i10 : Ein Integer, für den 10 Zeichen reserviert werden e10.5 : Eine Zahl in wissenschaftlicher Schreibweise. Zehn Zeichen werden reserviert, davon sind fünf Nachkommastellen. 3i10 : Bsp: Drei Integer mit jeweils 10 reservierten Zeichen. 62 w r i t e ( , ) r e a l ( i t e r, k i n d =8) dt, e t o t, e k i n, epot 63 w r i t e ( , ) r e a l ( i t e r, k i n d =8) dt, r 0 ( : ) Diese Anweisung ist ähnlich der vorherigen. Die Werte der Variablen werden jedoch nicht auf den Bildschirm geschrieben, sondern in die angegebene Datei (1001 und 1002). Der erste Wert ist eigentlich keine Variable sondern ein Ausdruck. Die Variable iter wird zunächst von Integer(4) in Real(8) umgewandelt und dann mit dt multipliziert. Das Ergebnis wird ausgegeben. 71!== nun s c h l i e s s e d i e D a t e i e n =========================== c l o s e (1000) 74 c l o s e (1001) 75 c l o s e (1002) 76 stop Der close Befehl ist das Gegenstück zum open Befehl. Er schließt die geöffneten Dateien wieder. Der Befehl stop beendet das Programm sofort unabhängig von noch nicht beendeten Schleifen, geöffneten Dateien oder Ähnlichem. Zusammenfassung Es werden kurz die wesentlichen Programmteile vorgestellt. Schlüsselwörter sind groß geschrieben. Text in eckigen Klammern ist optional. 1 PROGRAM Name 2 END [PROGRAM Name ] Kopf- und Fußdeklaration eines Programms. Zwischen dieses Zeilen befindet sich der Quellcode mit Ausnahme von Unterprogrammen. 1!== D e f i n i t i o n d e r V a r i a b l e n ============================

12 Kommentare beginnen mit einem Ausrufezeichen. Nachfolgender Text der gleichen Zeile wird nicht interpretiert. 1 INTEGER( 4 ),PARAMETER : : n=3! Kommentar 2 INTEGER( 4 ) : : i t e r! I n d e x des Z e i t s c h r i t t s 3 REAL( 8 ) : : f ( n )! K r a f t 4 REAL( 8 ) : : c ( n, n )! K r a f t k o n s t a n t e n Variablen und Konstanten können vom Typ INTEGER, REAL, COMPLEX, CHA- RACTER und LOGICAL sein. Im Beispiel ist n eine Ganzzahlkonstante, iter eine Ganzzahl, f(n) ein Vektor aus Gleitkommazahlen und c(n,n) eine Matrix aus Gleitkommazahlen. 1 OPEN( u n i t =1000, f i l e = i n. dat, form = f o r m a t t e d ) 2 CLOSE( 1000) Öffnet und schließt Dateien. 1 READ( , )m, alpha, c 2 WRITE(, fmt = ( i t e r, i10, e t o t, e10. 5, e k i n & 3 &, e10. 5, epot, e10. 5 ) ) i t e r, e t o t, e k i n, epot Liest Daten aus einer Datei ein und schreibt Daten in einem bestimmten Format in eine andere Datei. 1 DO i =1,n 2 [ Anweisungen ] 3 END DO Führt die Anweisungen n-mal hintereinander durch. 1 SUBROUTINE Unterprogramm ( parameter1, parameter2,... ) 2 [ Code ] 3 END Unterprogramm Erstellt ein benutzerdefiniertes Unterprogramm mit Parametern, die an das Unterprogramm übergeben werden. 1 CALL Unterprogramm ( parameter1, parameter2,... ) Ruft ein Unterprogramm mit Parametern auf. 1.4 Aufgaben 1. Verstehen Sie das Programm. 2. Variieren Sie die Eingabewerte und beobachten Sie die unterschiedlichen Ausgaben.