FORTRAN

Transcription

FORTRAN

Ausarbeitung
FORTRAN
im Rahmen des Seminars „Programmiersprachen“
Swetlana Konovalov
Themensteller: Prof. Dr. Herbert Kuchen
Betreuer: Susanne Gruttmann
Institut für Wirtschaftsinformatik
Praktische Informatik in der Wirtschaft
Inhaltsverzeichnis
1
Einleitung ................................................................................................................... 3
2
Historische Entwicklung der Sprache Fortran ........................................................... 4
3
Charakteristika der Sprache ....................................................................................... 6
4
3.1
Alphabet und die Grundlage des Syntax ............................................................ 6
3.2
FORTRAN - Programmformular ....................................................................... 7
3.3
Programmstruktur .............................................................................................. 8
FORTRAN - Sprachelemente .................................................................................. 12
4.1
Konstanten, Variablen und Felder.................................................................... 12
4.2
Standardtypen ................................................................................................... 15
4.3
Elementare Anweisungen................................................................................. 17
4.3.1
4.3.2
4.3.3
4.3.4
4.4
IF- Anweisung .......................................................................................... 17
Ein- /Ausgabeanweisungen....................................................................... 18
FORMAT- Anweisung ............................................................................. 19
DO -Schleif ............................................................................................... 21
Unterprogramme .............................................................................................. 22
5
SEND - MORE – MONEY ..................................................................................... 24
6
Zusammenfassung ................................................................................................... 27
A
SEND – MORE – MONEY - Code ......................................................................... 28
Literaturverzeichnis ........................................................................................................ 29
Kapitel 1: Einleitung
1 Einleitung
In dieser Arbeit wird die erste hohe Programmiersprache FORTRAN vorgestellt. Die
imperative Programmiersprache wurde in den 50er Jahren für naturwissenschaftliche
und ingenieurmäßige Anwendungen entwickelt.
Die historische Entwicklung der Sprache, ab den 50er Jahren bis heute, wird in Kapitel
2 beschrieben.
Die Charakteristik der Sprache wird in Kapitel 3 wiedergegeben. Dabei wird die Syntax
FORTRAN beschrieben. Es wird drauf eingegangen wie ein FORTRAN Programm
strukturiert werden kann.
Die Sprachelemente von FORTRAN, welche für die Gestaltung eines Programms
wichtig
sind,
werden
im
Kapitel
4
beschrieben.
Nach
Erklärung
der
Datenobjektdefinition und des Typsystems, wird die Benutzung der grundlegenden
Programmstrukturen FORTRANs dargestellt. Desweiteren wird auf den Aufbau von
Unterprogrammen eingegangen.
In Kapitel 5 wird die Benutzung der vorgestellten Sprachelemente an einem
Praxisbeispiel demonstriert. Es wird gezeigt, wie das berühmte SEND-MORE-MONEY
Rätsel mit FORTRAN gelöst werden kann. Der zugehörige Programmcode ist in
Anhang A zu finden.
Die Ausarbeitung schließt mit einer Zusammenfassung in Kapitel 6.
3
Kapitel 2: Historische Entwicklung der Sprache Fortran
2 Historische Entwicklung der Sprache Fortran
Der Name FORTRAN wurde von FORmula TRANslation abgeleitet und wie der Name
schon verrät, sollte die Sprache der Übersetzung von Formeln bei nummerischen
Anwendungen
dienen.
Daher
kommt
diese
Sprache
oft
in
natur-
oder
ingenieurwissenschaftlichen Bereichen zum Einsatz. [Sc90, S.1ff]
Im Jahr 1953 begann bei der International Business Machines Corporation (IBM) unter
der Leitung von John W. Backus die Entwicklung der Sprache FORTRAN. Bis dahin
erfolgte
die
Programmierung
ausschließlich
in
Assemblersprachen.
Um
naturwissenschaftliche Problemstellungen lösen zu können, galt es nun, diese Sprachen
um Algebra-Ausdrücke zu erweitern. Bereits nach einem Jahr konnte der erste Entwurf
der Sprache FORTRAN vorgestellt werden.
Die Herausgabe der Sprachbeschreibung folgte im Jahr 1956. Ein Jahr später war der
erste
FORTRAN-Compiler
FORTRAN
I,
welcher
auf
Grundlage
dieser
Sprachbeschreibung entwickelt wurde, einsatzbereit. Dieser Compiler bestand aus
25.000 Zeilen Code und wurde mit jedem IBM-704-System ausgeliefert.
Das wirklich neue an Programmiersprache FORTRAN war nun, dass durch sie zum
ersten
Mal
die
Möglichkeit
bestand
Programme
ohne
die
aufwändige
Maschinenprogrammierung zu beschreiben. Dies war für Entwickler deutlich einfacher
und
außerdem
war
die
Sprache
leichter
zu
erlernen,
da
sie
geringere
Programmierfähigkeiten benötigte.
Eine überarbeitete und erweiterte Version FORTRAN II wurde von IBM im Jahr 1958
herausgebracht, die u.a. auch die Unterprogrammtechnik zuließ. Noch im selben Jahr
wurde auch FORTRAN III entwickelt, das Assemblercode im FORTRAN-Code
erlaubte, aber diese Version wurde nie als Produkt veröffentlicht.
FORTRAN IV, das 1962 erschien, führte logische Vergleiche und boolesche Ausdrücke
ein, während maschinenabhängige Teile wie Anweisungen zum Lesen von
Eingabebändern aus FORTRAN II herausgenommen wurden.
Nach ihrer rasanten Ausbreitung entstanden diverse Dialekte der Sprache FORTRAN.
Um den Programmeaustausch zu erleichtern, veröffentlichte im Jahr 1966 das American
National Standard Institute (ANSI) den ersten Standard für eine Programmiersprache 4
Kapitel 2: Historische Entwicklung der Sprache Fortran
FORTRAN 66, das auf FOTRAN IV basierte. Im Laufe der Zeit entsprach aber
FORTRAN 66 nicht mehr den Ansprüchen vieler Benutzer. Es entstanden wieder viele
Dialekte der Sprache, die alle auf FORTRAN 66 basierten aber mit einander nicht
kompatibel waren.
Als Folge davon wurde die Einführung eines neuen Standards
notwendig.
1978 wurde der Standard FORTRAN 66 durch FORTRAN 77 abgelöst. Diese neue
FOTRAN Version, war ein wichtiger Schritt in der Entwicklung der Sprache, wobei
aber keine grundlegenden Änderungen an der Sprache vorgenommen wurden. In der
Normung ANSI X3.9-1978 wurde die Spracherweiterung, die von den Computerfirmen
bzw. Compilerautoren
vorgenommen worden, aufgenommen. Diese sollten das
Programmieren vereinfachen. Der Standard blieb jahrelang unverändert.
Erst im Jahr 1992 wurde ein neuer Standard „FORTRAN 90“ verabschiedet, der fast
vollständig FORTRAN 77 enthält. Im Gegensatz zu FORTRAN 77 sind im Standard
FORTRAN 90 nicht nur die in verschiedenen Realisierungen entstandenen
Erweiterungen aufgenommen worden, sondern es sind auch ganz neue Elemente
aufgetaucht. Im neuen Standard sind Konzepte eingeführt worden, die die Entwicklung
der Programme erleichtern und die Benutzung neuer Technologien der Programmierung
möglich machen. Dabei wurde die Abwärtskompatibilität beibehalten. FORTRAN 90 war
auch der erste Standard, der die parallele Programmierung unterstützt hat.
Im Jahr 1997 entstand ein neuer internationaler Sprachstandard – FORTRAN 95. Im
Vergleich zu FORTRAN 90, sind in FORTRAN 95 verhältnismäßig wenige
Neuerungen dazugekommen. Die Meisten dienten der Optimierung der Parallelität und
sind auf die Nutzung von High Performance FORTRAN (HPF) ausgerichtet.
Der nächste wichtige Schritt in der Entwicklung der Sprache war die Umsetzung des
Standards FORTRAN 2003. Die wesentlichen Neuerungen sind die Unterstützung der
objektorientierten Programmierung und die Interoperabilität mit der Sprache C.
Außerdem wurde die Verarbeitung von Fleißkommazahlen und die Ein-/Ausgabe
verbessert.
Es wurde bis jetzt nicht aufgehört die Sprache zu verbessern. Fortran 2008 ist weiterhin
in Entwicklung und soll bis 2010 fertig sein.
Diese Arbeit konzentriert sich auf Version FORTRAN 77.
5
Kapitel 3: Charakteristika der Sprache
3 Charakteristika der Sprache
3.1 Alphabet und die Grundlage des Syntax
Die
Syntax
bezeichnet
die
nach
bestimmten
Regeln
festgelegten
Verknüpfungsmöglichkeiten von Zeichen und Befehlen aus dem Zeichen- und
Befehlsvorrat einer Programmiersprache. Sie regelt, welche Symbolfolgen des
zugrundegelegten Vokabulars (Alphabets) zulässige „Sätze“ der Sprache bilden und legt
gleichzeitig zu jeder solchen Symbolfolge eine grammatikalische Struktur fest.
Ein Buchstabe oder eine Zahl ist ein alphanumerisches Symbol und wie auch in anderen
Sprachen sind in FORTRAN 77 nicht alle Symbole oder Symbolfolgen erlaubt.
Für die Darstellung einer Anweisung werden folgende Grundsymbole [Sc90, S.17]
benutzt:
1. 26 Buchstaben: A, B … Z (a, b … z)
2. 10 Ziffern: 0, 1 … 9
3. 13 Sonderzeichen: = + - * / ( ) , . $ ‘ : und das Leerzeichen
Dabei sind im FORTRAN 77 Standard nur die Großbuchstaben als gültige
Grundsymbole aufgeführt. Es hat sich aber im Laufe der Zeit durchgesetzt, auch
Kleinbuchstaben zu benutzen, wobei vor der Kompilierung einer Quellcodedatei, alle
Kleinbuchstaben in Großbuchstaben umgewandelt werden. Seit dem darauf folgenden
Standard FORTRAN 90, sind auch Kleinbuchstaben erlaubt, wobei Klein- und
Großbuchstaben dieselbe Bedeutung haben.
In Abhängigkeit davon für welche Anweisungen sie benutzt werden, können die
Symbole für verschiedene Zwecke eingesetzt werden.
Aus den Grundsymbolen der Sprache lassen sich Wortsymbole bilden, die bspw.
Variablennamen oder Funktionen bezeichnen können.
Ein Wortsymbol kann aus Buchstaben und Ziffern bestehen, aber mit der
Einschränkung, dass das erste Zeichen ein Buchstabe sein muss. Die Länge eines
Wortsymbols ist in FORTRAN 77 auf sechs Zeichen begrenzt. Auch die von
FORTRAN 77 reservierten Wortsymbole (wie z. B. die Funktionen SIN oder COS)
dürfen überschrieben werden. In diesem Fall verlieren sie aber die ursprüngliche
6
Bedeutung. Um Missverständnisse zu vermeiden, soll diese Möglichkeit aber nur in
zwingenden Ausnahmefällen genutzt werden.[Sc90, S.18]
3.2 FORTRAN - Programmformular
Bis in die 70er Jahre des 20. Jahrhunderts war die Lochkarte das beherrschende
Speichermedium der elektronischen Datenverarbeitung. (Merten, 1988 S. 10) Sowohl
FORTRAN 77 als auch die älteren Versionen von FORTRAN sind an der
Spaltenaufteilung einer Lochkarte orientiert. Zwar erfolgt jetzt die Eingabe unmittelbar
über eine Tastatur, die jeweiligen Eingabezeilen entsprechen dabei in ihrem Aufbau
aber den früher benutzen Lochkarten. Da Programme zu der Zeit einerseits noch recht
überschaubar waren und man sich das Schreiben von Programmen erleichtern wollte,
wurden früher sogenannte FORTRAN- Kodierformular benutzt. [FT73, S.21f]
Abbildung 1: FORTRAN- Kodierformular [FT73, S.22]
Eine Eingabezeile setzt sich aus 80 Positionen bzw. Spalten zusammen und entspricht
im Aufbau der einer Lochkarte. Die ersten 72 Spalten stehen für die Kodierung zur
Verfügung. In den letzten 8 Spalten können Zeichen kodiert werden, die nicht zum
Programm gehören. Beispielsweise kann das Durchnummerieren der Zeilen in diesem
Spalten erfolgen.
Steht in der ersten Spalte einer Zeile ein „C“ oder ein „*“,
wird diese Zeile als
Kommentar interpretiert. Das gleiche gilt für eine leere Zeile. Ansonsten kann in den
Spalten 1-5 einer Programmzeile bei Bedarf eine Anweisungsnummer eingetragen
werden.
Mit
Hilfe der Anweisungsnummer
können
Anweisungen
eindeutig
7
gekennzeichnet werden. Als Symbole für die Anweisungsnummer sind ausschließlich
Ziffern zugelassen. Die 6. Spalte beherbergt das Feld für die Folgezeilenkennzeichnung.
Eine Anweisungszeile kann in der nächsten Zeile fortgesetzt werden. Dazu muss in der
Spalte 6 der nächsten Zeile, ein beliebiges Zeichen mit Ausnahme eines Leerzeichens
oder einer „0“ stehen. In FORTRAN 77 sind 19 Fortsetzungszeilen für eine Anweisung
erlaubt. Der wichtigste Bereich einer Zeile liegt zwischen den Spalten 7 und 72. In
diesen Spalten kann die FORTRAN Anweisung stehen. Die Anweisung darf nicht über
Spalte 72 hinausgehen, da alle Zeichen danach abgeschnitten und als Kommentar
gewertet werden. Somit bieten die Spalten 73-80 eine weitere Möglichkeit das
Programm zu kommentieren. Diese Spalten können aber auch frei bleiben oder z.B. zur
Nummerierung der Programmzeilen genutzt werden. [FT73, S.21ff]
Die Arten von Zeilen, die FORTRAN unterscheidet, lassen sich in der folgenden
Tabelle entnehmen. [Sc90, S.20]
Anweisungszeile
Spalte 1 - 5
Spalte 6
Spalte 7 - 72
Leerzeichen oder
Leerzeichen oder eine Null
Anweisung
Vereinbarung
Anweisungsnummer
Leerzeichen oder
Vereinbarungszeile
Anweisungsnummer
Formatzeile
Anweisungsnummer
Leerzeichen
Formatanweisung
Fortsetzungszeile
Leerzeichen
Beliebige Zeichen außer
Fortsetzung der
Anweisung
Kommentarzeile
In der Spalte 1:
Ab Spalte 2 das gewünschte Kommentar
C oder *
END – Zeile
Leerzeichen
Leerzeichen
END
Tabelle 1: Zeilenarten von Fortran
3.3 Programmstruktur
FORTRAN ist die erste imperative Programmiersprache. Bei dem imperativen
Programmierparadigma wird ein Programm als Abfolge von Anweisungen aufgefasst,
die an einen Rechner
übergeben werden und mit denen ein bestimmter Prozess
durchgeführt werden soll.
8
Jedes FORTRAN Programm, wird zunächst in Form von Text in einer algorithmischen
Sprache geschrieben. Danach wird es mit Hilfe eines Programmcompilers in einen
Maschinencode übersetzt und wird so in die Form einer ausführbaren Datei überführt,
mit der das Programm gestartet werden kann. Der Text eines FORTRAN Programms
kann mit Hilfe eines beliebigen Texteditors erstellt werden.
Wenn ein einfaches Programm in FORTRAN geschrieben wird, sollten die
Anweisungen in folgender Reihenfolge geschrieben werden:
1. Die Beschreibungsanweisungen;
2. Bestimmung der Funktionsanweisungen;
3. Ausführbare Anweisungen;
4. Die END- Anweisung.
Desweiteren können mehrere Unterprogramme im Anschluss folgen. Ein FORTRAN
Programm hat dann folgenden Aufbau [Sc90, S.19]:
PROGRAM <Programmname>
<Vereinbarungsteil>
<Anweisungsteil>
END
<Unterprogramm1>
…
<Unterprogramm2>
Tabelle 2: Programmaufbau von Fortran
Das „Program“-Statement ist dafür da, um dem Programm einen Namen zu geben.
Diese Zeile ist optional und kann weggelassen werden. Am Ende eines Programms
muss immer eine „END“-Anweisung stehen.
Im Vereinbarungsteil werden die nicht ausführbaren Anweisungen angegeben und
somit die von der Programmeinheit benutzen Konstanten, Variablen, Felder und
Unterprogramme definiert.
Die ausführbaren Anweisungen, werden in dem Anweisungsteil formuliert. Somit stellt
der
Anweisungsteil
den
eigentlichen
Programmkörper
da,
in
dem
der
Programmalgorithmus realisiert wird.
Ein FORTRAN Programm ist eine Aufzeichnung der Lösung des gestellten Problems
und stellt eine Abfolge von Anweisungen und Kommentaren dar.
9
Die Kommentare dienen dabei dem besseren Verständnis des Programms und
gewährleisten die verbale Beschreibung seiner Logik. Gewöhnlich wird der Anfang
eines Programms mit einführenden Kommentaren versehen – sowie jeder Abschnitt, der
die abschließende Logik enthält. In den einführenden Kommentaren werden der Name,
sowie der Zweck des Programms angegeben. Die wichtigsten Variablen und ihre
Funktionen können in den einführenden Kommentaren aufgezählt und erläutert werden.
Die Kommentarzeilen beginnen mit * oder dem Buchstaben C in der ersten Spalte und
sind nur für die menschlichen Leser des Programms gedacht. Für den Compiler sind sie
bedeutungslos. Auch Leerzeichen und leeren Zeilen werden ähnlich wie Kommentare
behandelt. Sie dienen dazu, das Programm für den Menschen lesbarer zu machen und
dürfen überall eingefügt werden. [Ma80, S.29f]
Die Anweisungen sind die Hauptelemente einer Programmiersprache. Sie schreiben die
Ausführung der Vorschriften vor, die für die Realisierung des Algorithmus notwendig
sind, beschreiben die verwendeten Daten und bestimmen die Struktur des Programms.
Alle Anweisungen in FORTRAN werden in ausführbare und nicht ausführbare
Anweisungen unterschieden.
Die nicht ausführbaren Anweisungen dienen dazu, die Eigenschaften der Daten zu
beschreiben. Dazu zählen: Typbeschreibungsanweisungen, Anweisungen, welche die
Dimensionen von Arrays beschreiben, Anweisungen, welche die Anfangsbedeutung der
Daten bestimmen, Anweisungen die die Form der Ein- und Ausgabedaten bestimmen
und einige mehr. Demzufolge gehören zu den nicht ausführbaren Anweisungen die
Formatangaben (FORMAT), die Deklarationen (z.B. INTEGER, REAL, DIMENSION,
DATA) und die Endanweisung (END).
Die ausführbaren Anweisungen bestimmen die Handlungen, die ausgeführt werden
sollen. Beispielsweise die Ausführung mathematischer Operationen oder die Auslösung
einer Ausgabe. Zu den ausführbaren Anweisungen gehören die Rechenbefehle (z.B.
A=B+C),
die
Ein-/Ausgabeanweisungen
(z.B.
READ,
WRITE)
und
die
Steueranweisungen (z.B. GO TO, IF, DO, STOP).
Alle ausführbaren Anweisungen werden in der Reihenfolge im Programm angeordnet,
in der sie entsprechend dem Lösungsalgorithmus der Aufgabe ausgeführt werden sollen.
10
Für die Beendigung eines Programms werden die Anweisungen STOP und END
verwendet.
Die END Anweisung kennzeichnet das Ende eines Programms. Diese Anweisung ist
nicht ausführbar und sie löst keine Handlung des Rechners aus. Steht die Anweisung
END irgendwo im Programm, wird die Ausführung des Programms sofort gestoppt.
Deswegen sollte die END Anweisung immer die letzte Anweisung im Programm sein.
Steht die END Anweisung am Ende eines Unterprogramms, so bewirkt sie einen Sprung
zur aufrufenden Programmeinheit.
Eine andere Möglichkeit ein Programm zu beenden ist die STOP Anweisung. Mit ihr
wird das Programm beendet, wenn alle notwendigen Berechnungen durchgeführt
wurden. Sie stellt eine ausführbare Anweisung dar und kann sich an beliebiger Stelle im
Programm befinden. Die Syntax der Anweisung lautet:
STOP <TEXT>
Vor Beendigung des Programms wird die Zeichenkette <TEXT> ausgegeben.
Außerdem kann das Programm mit der Anweisung PAUSE angehalten werden.
PAUSE <TEXT>
Die Ausführung des Programms wird damit unterbrochen. Dabei wird die Nachricht
<TEXT> ausgegeben. Durch eine spezielle Nutzerhandlung wird die Abarbeitung des
Programms mit der Anweisung fortgesetzt, die auf die PAUSE Anweisung folgt.
11
Kapitel 4: FORTRAN - Sprachelemente
4 FORTRAN - Sprachelemente
4.1 Konstanten, Variablen und Felder
In einem FORTRAN Programm werden Daten verarbeitet. Die Daten können in Form
von Konstanten oder Variablen gegeben sein. Die Datenobjekte werden durch einen
Name, Typ und weitere Eigenschaften gekennzeichnet.
Konstanten
Eine Konstante wird vor der Programmausführung definiert, womit auch der nötige
Speicherbedarf festgelegt wird. Während der Programmausführung kann der Wert und
somit auch der Speicherbereich einer Konstante nicht mehr verändert werden. In
FORTRAN gibt es die Möglichkeit einer Konstanten einen Namen zuzuweisen. Dieser
Name wird bei der Konstantendefinition festgelegt und kann innerhalb einer
Programmeinheit nicht mehr verändert werden. Wenn einer Konstanten ein Datentyp
zugewiesen werden soll, muss die Deklaration vor der Konstantendefinition erfolgen.
Konstanten außerdem können zur Beschreibung anderer Konstanten genutzt werden.
Um die Definition von Konstanten zu vereinfachen wurde in FORTRAN 77 die
Anweisung PARAMETER eingeführt. Die Syntax dieser Anweisung lautet:
PARAMETER ( <PAR1>=<WERT1>, <PAR2>=<WERT2>, … )
Wenn Konstanten ohne die Anweisung PARAMETER definiert werden, besteht die
Gefahr, dass sie während der Ausführung des Programms überschrieben werden.
Konstanten, die durch eine PARAMETER Anweisung beschrieben wurden, werden
symbolische Konstanten genannt und dürfen nie auf der linken Seite einer Zuweisung
stehen. Als Folge davon können sie auch nicht überschrieben werden. Der Name einer
so definierten Konstante, ist ein symbolischer Name und darf als Variablenname im
selben Programmteil nicht mehr benutzt werden. Ansonsten können sie aber ohne
weitere Einschränkungen wie normale Konstanten benutzt werden.
Wenn eine symbolische Konstante „A“ mit Hilfe einer anderen symbolischen Konstante
„P“ definiert werden soll, muss die Konstante „P“ vor der Konstanten „A“ mit Hilfe
12
einer PARAMETER Anweisung oder vor der Kostanten „A“ in derselben Anweisung
definiert worden sein.
Die PARAMETER Anweisung ist ein wichtiges Hilfsmittel zur Definition von
Konstanten. Mit ihr können Konstanten vor Überschreibungen geschützt und
Programme außerdem sicherer modifiziert werden.
Variablen
Ein Datenobjekt, dessen Wert im Gegensatz zu einer Konstante verändert werden kann,
wird Variable genannt. Im Vereinbarungsteil können Namen als Variablen vereinbart
werden. Die Variablen werden dann über den entsprechenden Namen im Programm
angesprochen.
Wie zuvor bereits erläutert, sollte zur Initialisierung von Konstanten die PARAMETER
Anweisung genutzt werden. Für die Initialisierung von Variablen und Arrays wird die
Anweisung DATA genutzt Mit dem Begriff Initialisierung ist die erstmalige
Wertzuweisung gemeint. Eine DATA Anweisung setzt sich wie folgt zusammen:
DATA <VAR1>, <VAR2>, …, <VARN> / <WERT1>, <WERT2>, …, <WERTN> /
Dabei stehen <VAR1>, <VAR2>, …, <VARN> für die Namen der Variablen und
<WERT1>, <WERT2>, …, <WERTN> für die Werte, die diese Variablen aufnehmen
sollen. Diese Werte werden einmalig zu Beginn der Programmausführung den
Variablen zugewiesen.
Es müssen dabei immer genau so viele <VAR> Elemente
existieren wie <WERT> Elemente.
Es besteht auch die Möglichkeit einen Wiederholungsfaktor einzuführen, um die
Aufzählung von mehrmals auftretenden Werten zu vereinfachen. Eine ebensolche
Anweisung kann folgendermaßen aussehen:
DATA A, B, C, D / 4*5 /
Hierbei nehmen die Variablen A – D alle den Wert 5 an. Die Variablen dürfen je
Programmeinheit nur einmal durch eine DATA Anweisung initialisiert werden. Die
Variablen, bei denen kein Anfangswert verlangt wird, müssen nicht initialisiert werden.
Wenn mehrere Variablennamen für ein denselben Speicherplatz benutzt werden dürfen,
soll die Anweisung EQUIVALENCE benutzt werden. Syntax der Anweisung ist:
13
EQUIVALENCE (N1, N2, … )
Dabei sind N1 und N2 die Namen der Variablen, die sich auf denselben Speicherplatz
beziehen sollen. In der Klammer müssen mindestens zwei Namen aufgeführt werden.
Die Variablen N1 und N2 haben zu jedem Zeitpunkt im Programm denselben Wert.
Dies kann zu mehreren Zwecken genutzt werden. Beispielswiese kann diese Anweisung
bei der Fehlerkorrektur von Programmen helfen. So braucht man bei einem
Programmierfehler nicht jede Variable einzeln zu verbessern, wenn sich z.B. mehrere
Variablen auf denselben Speicherplatz beziehen. Außerdem kann speicherplatzsparend
programmiert werden. Wenn zwei Variablen nicht gleichzeitig sondern nacheinander
benutzt werden, können diese Variablen denselben Speicherplatz nutzen und somit
effizienter den Speicher nutzen. Während die Speicherplatzeinsparung bei einfachen
Speicherplätzen noch sehr gering ist, kann sie bei größeren Feldern beachtlich sein. Die
Struktur
einer
auf
Felder
angewandten
EQUIVALENCE
Anweisung
sieht
folgendermaßen aus (gleiche Felddimensionen vorausgesetzt):
EQUIVALENCE (N1(i,j), N2(i,j), … )
Zusätzlich kann die EQUIVALE- Anweisung der Einsparung von Rechenzeit dienen.
Besonders bei mehrdimensionalen Feldern ist die Zeiteinsparung erheblich.
Felder
Während des Programmierens wird oft nicht nur eine Variable benötigt, sondern es soll
eine Menge zusammengehöriger Daten verarbeitet werden. Solche Variablen lassen sich
zu einem Feld (Array) zusammenfassen. Ein FORTRAN Feld ist eine Gruppe von
Variablen gleichen Typs, die im Speicher einen zusammenhängenden Bereich
einnehmen und die in FORTRAN unter einem gemeinsamen Namen ansprechbar sind.
Jedes Element des Feldes wird durch den Namen des Feldes und seine Platznummer
eindeutig bestimmt. Ein Feld lässt sich mit der Anweisung DIMENSION vereinbaren.
Diese Anweisung ist eine nicht ausführbare Anweisung und dient nur dazu, die Größe
der benötigten Felder anzugeben. FORTRAN 77 kennt Felder mit bis zu sieben
Dimensionen. Die Syntax dieser Anweisung lautet:
DIMENSION N1(V11, V12), N2(V21, V22), …
14
Dabei stellen N1 und N2 die Namen der Felder dar, die durch diese Anweisung
dimensioniert werden sollen. V11 und V12 sind natürliche Zahlen, welche die Größe
des Feldes angeben. Diese Werte müssen hinter dem Namen des Feldes in Klammern
und durch Kommata getrennt angegeben werden. Der Typ des Feldes kann entweder
explizit oder implizit vereinbart werden. Bei der expliziten Typvereinbarung können
auch direkt die Feldgrenzen angegeben werden.
Beispiel:
Erst wird der Typ der Matrizen M1, M2 und des Vektors M3 bestimmt. Die Größe der
Felder wird ausschließlich mit der DIMENSION Anweisung bestimmt.
DOUBLE PRECISION M1, M2, M3
DIMENSION M1(3, 3), M2(10, 10), M3(6)
Alternativ dazu können die Grenzen der Felder sofort bei der Typvereinbarung mit
angegeben werden.
DOUBLE PRECISION M1(3, 3), M2(10, 10), M3(6)
Die Spezifikationsanweisungen der Felder sind für das ganze Programm gültig und
müssen vor Benutzung der Variablen in der Liste angegeben werden. Sollten Variablen
benutzt werden, deren Indizes größer als vereinbart ausfallen, führt dies zu
Rechenfehlern, die nicht angezeigt werden. [Dr70, S. 28]
4.2 Standardtypen
Um festzulegen wie viel Speicherplatz für ein angegebenes Datenobjekt reserviert
werden muss und um seinen Wertebereich festzulegen, muss schon bei der Deklaration
festgelegt werden, welchen Datentypen diese Datenobjekte angehören sollen. Die
allgemeine Form einer Datenobjektvereinbarung lautet:
<Typ> <Liste von Namen>.
Die Namen in der Liste werden durch Kommata getrennt. Die Reihenfolge ist dabei
beliebig.
Jedes Datenobjekt, ob Konstante oder Variable, sollte mit einem Datentyp deklariert
werden. Die von FORTRAN 77 unterstützten Standardtypen, sind in folgender Tabelle
zu sehen:
15
Wortsymbol
INTENGER
REAL
DOUBLE PRECISION
COMPLEX
LOGICAL
CHARACTER
Entspricht
Z, ganze Zahlen
R, reelle Zahlen
R, reelle Zahlen
C, komplexe Zahlen
B, logische Werte
Bel. Zeichen
Beispiel
-4 10 1 +2
1.3 1.23e-1 -1.E-6 -.98
(1.0,2.e-3)
.TRUE. .FALSE.
‚Name‘ „Zahl“ ‚Hälfte‘
Tabelle 3: Datentypen von FORTRAN 77
Es ist vorteilhaft, Datenobjekte vor ihrer Verwendung zu deklarieren. Deswegen sollte
die Variablendeklaration am Anfang des Programms vorgenommen werden. Der Typ
eines Datenobjektes, kann nach Ausführung des Programms nicht mehr verändert
werden. Wird ein Objekt ausdrücklich einem Datentyp zugewiesen, spricht man von
einer expliziten Typvereinbarung.
Wenn einem Datenobjekt kein Datentyp zugewiesen wurde, wird dieses Objekt nach
folgenden Regeln einem von zwei Datentypen (INTEGER oder REAL) zugeordnet:
beginnt der Name dieses Objektes mit dem Buchstaben I, J, K, L, M, N, wird dieses
Datenobjekt dem INTEGER Typ zugewiesen. Steht ein beliebiger anderer Buchstabe
am Namensanfang so wird dieses Objekt dem REAL Typ zugewiesen. Diese
Typbeschreibung wird unter dem Namen implizite Typvereinbarung in der Literatur
beschrieben. [Dr70, S.22f]
Außerdem gibt es die Möglichkeit die implizite Typvereinbarung mittels der Anweisung
IMPLICIT zu erweitern bzw. zu überschreiben. Mit dieser Anweisung können
Buchstaben einem bestimmten Datentyp zugeordnet werden. Die Objekte die mit
diesem Buchstaben beginnen, werden automatisch diesem Typ zugewiesen.
Eine
beispielhafte IMPLICIT Anweisung sieht folgendermaßen aus:
IMPLICIT COMPLEX (K, T)
Das bedeutet, die Variablen deren Name mit K und T beginnen, werden dem Datentyp
COMPLEX zugerodet.
Mit der Anweisung IMPLICIT NONE kann die implizite Typvereinbarung aufgehoben
werden. [La87, S. 35] Damit kann die Fehlersuche nach nicht deklarierten Bezeichnern
vereinfacht werden.
Bei der expliziten und impliziten Deklaration gelten folgende Rangfolgen:
16
1. Die explizite Deklaration wird der impliziten vorgezogen. Sie hebt alle anderen
Deklarationen auf.
2. Wenn eine Variable nicht explizit deklariert wurde, greift die IMPLICIT
Anweisung und der Typ wird nach dem Anfangsbuchstaben bestimmt.
3. Falls keine explizite Deklaration und keine IMPLICIT Anweisung gegeben ist,
gelten die Regeln der impliziten Typvereinbarung.
Eine explizite Typvereinbarung ist immer der impliziten vorzuziehen, da die implizite
Vereinbarung oftmals zu Fehlern führt. Bei der expliziten Typvereinbarung sind
desweiteren alle Variablen am Programmanfang aufgelistet wodurch auch eine
Typänderung einfacher vorzunehmen ist.
4.3 Elementare Anweisungen
4.3.1 IF- Anweisung
Seit FORTRAN 77 wurde die Nutzung der bedingten Anweisung in FORTRAN
möglich. Es kam die logische IF Anweisung hinzu. In den früheren Versionen musste
für solche Abfragen mindestens eine GOTO Anweisung verwendet werden. Die IF
Anweisung ist die einzige Anweisung, bei der eine zweite Anweisung in der gleichen
Programmzeile angegeben wird. [Sc90, S.59]
Soll der Programmablauf von einem Wert oder logischen Ausdruck abhängig sein, kann
die IF Anweisung genutzt werden. Die allgemeine Form einer logischen IF- Anweisung
ist:
IF (<LA>) <A>
Ob die Anweisung <A> ausgeführt wird, hängt vom Ergebnis der Auswertung des
logischen Ausdrucks <LA> ab. Wenn der logische Ausdruck wahr ist, wird die
Anweisung ausgeführt.
Es können auch mehrere IF Blöcke in einem IF Block geschachtelt werden. [Sc90,
S.60f] Diese Art von Anweisung wird BLOCK-IF Anweisung genannt und hat folgende
Syntax:
17
IF (<LA1>) THEN
<A1>
ELSE IF (<LA2>) THEN
<A2>
…
ELSE (<LA>)
<A>
END IF
Eine spezielle Form eines logischen Ausdrucks ist der Vergleichsausdruck. Eine
allgemeine Form des Vergleichs sieht folgendermaßen aus:
<A1> <VERGELICHSOPERATOR> <A2>
Da die Entwicklung von FORTRAN zu der Zeit stattfand als Programme noch auf
Lochkarten gestanzt wurden, musste mit einem sehr eingeschränkten Zeichenvorrat
gearbeitet werden. Die entsprechenden Eingabegeräte verfügten nur über eine sehr
begrenzte Anzahl an Zeichen, bei denen die Vergleichsoperatoren nicht enthalten
waren. Daher werden die Vergleichsoperatoren durch eine Folge von Buchstaben
dargestellt. Die Schreibweise hat sich in FORTRAN bis heute gehalten. Die sechs
Vergleichsoperatoren, die FORTRAN unterscheidet sind in der folgenden Tabelle zu
entnehmen. [Me88, S.41]
Vergleichsoperator
.EQ.
.NE.
.GT.
.GE.
.LT.
.LE.
Bedeutung
EQual
Not Equal
Greater Than
Greater than or Equal
Less Than
Less than or Equal
Math. Symbol
=
≠
>
≥
<
≤
Tabelle 4: Vergleichsoperatoren in FORTRAN 77
4.3.2 Ein- /Ausgabeanweisungen
Nachdem das FORTRAN Programm eine Berechnung durchgeführt hat, sollen die
Ergebnisse auf einem Medium angezeigt werden. Zur Anzeige auf dem Bildschirm wird
der Ausgabebefehl WRITE verwendet. Zum Einlesen dient die Anweisung READ.
[Sc90, S. 67]
18
Die allgemeine Form der READ Anweisung lautet:
READ*, <VAR1>, <VAR2>, …
oder
READ(*,*) <VAR1>, <VAR2>, …
Durch diesen Befehl können beliebig viele Variablen z. B. per Tastatur eingegeben und
von FORTRAN eingelesen werden. Dabei steht (*,*) als Platzhalter für eine
Zeichenkombination. Die erste Stelle gibt die Verbindung zu einer Datei an, die zweite
bestimmt das Ausgabeformat.
Der entsprechende WRITE Befehl sieht folgendermaßen aus: [Sc90, S. 68]
WRITE(*,*) <VAR1>, <VAR2>, …
Für die Wildcard (*,*) muss analog zur READ Anweisung, an erster Stelle die
Zuweisungsnummer für das Medium und an zweiter Stelle die Anweisungsnummer für
das Format angegeben werden. Steht an erster Stelle statt einer Zahl ein „*“ Zeichen,
wird das Standard Eingabemedium des jeweiligen Rechners angesprochen.
Außerdem gibt es bei FORTRAN, als vereinfachte Form der WRITE Anweisung, die
PRINT Anweisung. [Sc90, S. 68f] Durch die PRINT Anweisung wird immer das
Standard Ausgabemedium angesprochen. Die Syntax dazu ist:
PRINT* <VAR1>, <VAR2>, …
Dies entspricht der folgenden WRITE Anweisung:
WRITE (*,f) <VAR1>, <VAR2>, …
Zu beachten ist, dass es hierbei keine Möglichkeit gibt, das Datenausgabeformat
festzulegen.
4.3.3 FORMAT- Anweisung
Um anzugeben in welchem Format eine Information
auf einem Daten-
Aufzeichnungsmedium erscheinen soll, wird die FORMAT- Anweisung benutzt. [La87,
S.38f]
19
Mehrere verschiedene Ein- und Ausgabeanweisungen können eine FORMAT- Anweisung
zur Verarbeitung von Variablen verschiedenen Namens, aber gleichen Typs benutzt
werden. Die allgemeine Form der FORMAT- Anweisung lautet:
N FORMAT (<A1>, <A2>,…, <AN>)
N ist dabei die Nummer der FORMAT- Anweisung, die dann auch in den Ein- und
Ausgabeanweisungen an entsprechender Stelle benutzt wird. <A1>, <A2>,…, <AN>
stehen für die Formatbezeichner. Die Form der Formatbezeichner hängt von dem Typ
der Variablen, die zu formatieren sind ab.
Für die Variablen von Typ INTEGER sieht der Formatbezeichner folgendermaßen aus:
I<ANZ> oder I<ANZ>.<STEL>
An der Stelle <ANZ> wird die Anzahl der maximal auszugebenen Stelle angegeben.
<STEL> darf nicht größer als <ANZ> sein, da <STEL> die Anzahl der mindestens
auszugebenden Stellen darstellen soll, wobei fehlende Stellen mit einer Null aufgefüllt
werden.
Wie die Formatbeschreiben für andere Datentypen aussehen, wird in der nachfolgenden
Tabelle veranschaulicht.[Sc90, 103ff]
Beschreiber
Bedeutung
F<ANZ>.<NACH>
Festpunktdarstellung mit <NACH> Nachkommastellen für REAL und
DOUBLE PRECISION- Zahlen
E<ANZ>.<NACH>
Gleitpunktdarstellung mit <NACH> Stellen nach dem Dezimal für
REAL- Zahlen
D<ANZ>.<NACH> Gleitpunktdarstellung mit <NACH> Stellen nach dem Dezimal für
DOUBLE PRECISION- Zahlen
L<ANZ>
Darstellung boolescher Variablen bei Ein- und Ausgabe
Tabelle 5: Bedeutung der Formatbeschreibungen
Sollten Druckpositionen übersprungen werden, kann die Spezifikation X benutzt
werden. Es werden so viele Positionen freigelassen wie vor dem X stehen wird. Z. B.
mit 1X wird eine leere Stelle veranlasst. [Ma80, S.152]
Außerdem kann mit / (Slash) angegeben werden, dass die grade gedruckte Zeile nicht
weiter beschrieben wird und die Ausgabe der nächsten Zeile anfangen kann. Sollten in
einer FORMANT- Anweisungen N hintereinander folgende / - Zeichen stehen, werden N20
1 Leerzeilen zwischen zwei aufeinanderfolgenden geduckten Zeilen geschaltet. Dies
gilt nur wenn die N Schrägstriche nicht am Anfang oder Ende der FORMAT- Anweisung
stehen. [DR70, S.106]
Eine FORMAT- Anweisung kann an beliebiger Stelle im Programm geschrieben
werden. Um das Programm übersichtlicher zu gestalten, wird empfohlen alle
FORMAT- Anweisungen am Anfang oder am Ende eines Programms aufzuführen.
4.3.4 DO -Schleif
FORTRAN 77 bietet nur eine Art der direkten Schleifenprogrammierung – die
sogenannte DO Schleife. Die DO Anweisung ist die wichtigste FORTRAN Anweisung.
Mit deren Hilfe kann ein kompletter Programmabschnitt mehrfach wiederholt werden.
Wie oft der Abschnitt wiederholt wird, wird von einer Laufvariablen bestimmt, deren
Erhöhung vom Programm automatisch durchgeführt wird. Der Anfangswert dieser
Variablen wird festgelegt. Der maximale Wert, den die Laufvariable annehmen kann
muss ebenfalls im Voraus bestimmt werden. [Sc90, S.69] Die Form der DO Schleife
lautet:
DO <LABEL> <LV> = <AW>, <EW>, <ST>
Mit <LABEL> wird die letzte auszuführende Zeile des Schleifenbereiches angegeben.
Das <LV> steht für Laufvariable, <AW> für Anfangswert, <EW> für Endwert und
<ST> für Schrittweite.
Um das Ende einer DO Schleife zu bezeichnen wurde die leere Anweisung CONTINUE
eingeführt. Vor der Anweisung muss eine Zahl als LABEL stehen, welche identisch mit
der Zahl sein muss, die direkt hinter der DO Anweisung steht. [Sc90, S. 70] Dies sieht
allgemein folgendermaßen aus:
<LABEL> CONTINUE
Die CONTINUE Anweisung kann aber auch unabhängig davon bei der Strukturierung
von Programmen sehr häufig eingesetzt werden.
21
4.4 Unterprogramme
Eine Problemstellung lässt sich meistens in einem Hauptprogramm lösen. Es empfiehlt
sich oft aber die Unterprogrammtechnik zu nutzen. Die Zusammenfassung von
Programmteilen zu Unterprogrammen macht das gesamte Programm übersichtlicher.
Desweiteren lässt sich ein mit Unterprogrammen strukturiertes Programm schneller
testen. Außerdem werden viele Programmteile mehrfach genutzt. Diese Programmteile
lassen sich zu Unterprogrammen zusammenfassen, und können auf diese Weise leichter
wiederverwendet werden. In FORTRAN werden zwei Arten von Unterprogrammen
unterschieden: FUNCTION und SUBROUTINE.
FUNCTION
FUNCTION
bezeichnet
eine
von
einem
Hauptprogramm
unabhängige
Programmeinheit. Die Ausführung eines FUNCTION Unterprogramms, kann entweder
aus einem Haupt- oder aber aus einem anderen Unterprogramm heraus durchgeführt
werden. [Sc90, S.87] Die erste Zeile eines solchen Unterprogramms kann
folgendermaßen aussehen:
FUNCTION NAME (P1, …, PN)
oder
<TYP> FUNCTION NAME * LÄNGE (P1, …, PN).
Da es bei FORTRAN 77 keine globalen Variablen gibt, müssen Variablen stets an
Unterprogramme übergeben werden. P1, …, PN sind die übergebende Argumente. Die
Liste der Argumente darf nicht länger als 15 Werte enthalten, es muss aber mindestens
ein Wert angegeben werden.
In einer FUNCTION dürfen alle in FORTRAN 77 zugelassenen Anweisungen
verwendet werden – mit Ausnahme von FUNCTION, SUBROUTINE und
BLOCKDATA Anweisungen sowie Ein- und Ausgabeanweisungen.
SUBROUTINE
Die FUNCTION Unterprogramme können nur einen Wert, den Funktionswert,
berechnen. Die SUBROUTINE Unterprogramme dagegen können alle Anweisungen
22
enthalten, die auch Hauptprogramme enthalten dürfen. [Ma80, S. 60] Ein
SUBROUTINE Unterprogramm wird aufgerufen durch:
CALL SUBROUTINE NAME(P1, …, PN)
Der Rücksprung in das aufrufende Programm erfolgt bei beiden Unterprogrammen mit
der Anweisung RETURN. Das physische Ende wird durch die Anweisung END
festgelegt.
COMMON
Bis jetzt wurden die Parameter, die bei einem Unterprogramm nötig sind, immer in der
Klammer
hinter
dem
Unterprogrammnamen
eingeschlossen
und
so
dem
Unterprogramm übergeben. Eine andere Möglichkeit ist die Definition eines
gemeinsamen Speicherbereichs, auf den sowohl das Hauptprogramm als auch die
Unterprogramme zugreifen können. Dies kann mit der nicht ausführbaren Anweisung
COMMON geschehen [La87, S.89ff], deren Syntax wie folgt aussieht:
COMMON / <NAME> / <VAR1>, <VAR2>, … , <VARN>
Mit <NAME> wird der COMMON Block benannt. Diese Angabe ist optional und kann
weggelassen werden. In diesem Fall kann aber nur ein unbenannter COMMON Block
verwendet werden.
BLOCK DATA
Wurden Variablen in einem COMMON Block aufgeführt, können diese nicht mit einer
DATA Anweisung initialisiert werden. Um die Variablen dennoch initialisieren zu
können, muss eine eigene Programmeinheit - BLOCK DATA - bereitgestellt werden.
[Sc90, S.121f] Die Syntax lautet:
BLOCK DATA <NAME>
…
END
Wobei NAME die Bezeichnung der BLOCK DATA Programmeinheit ist. In der
Programmeinheit können außer den Typvereinbarungen folgende Anweisungen
enthalten sein: PARAMETER, DIMENSION, COMMON, EQUIVALENCE, SAVE,
IMPLICIT, und DATA.
23
Kapitel 5: SEND - MORE – MONEY
5 SEND - MORE – MONEY
Für den praktischen Teil dieser Seminararbeit, stand die Aufgabe, das sogenannte
SEND-MORE-MONEY Rätsel zu lösen. Einer Legende zufolge, ist das erste Rätsel
dieser Art durch ein Telegramm entstanden, welches ein Sohn hat der finanzielle
Schwierigkeiten hatte an seinen Vater geschickt hatte. Um den genau benötigten Betrag
zu errechnen, sollte jedem Buchstaben eine Ziffer zwischen 0 und 9 zugeordnet werden.
Dadurch sollte der Ausdruck korrekt gelöst werden. Dabei durfte den führenden
Buchstaben (also S und M) keine Null zugeordnet werden.
SEND
+ MORE
-----MONEY
FORTRAN ist wahrscheinlich nicht die erste Programmiersprache, die gewählt wurde,
um diese Art von Aufgabe zu lösen. Nichtsdestotrotz ist es aber auch mit FORTRAN
möglich eine Lösung dieser Aufgabenstellung zu finden.
Zunächst wird dem Programm der Name „Rebus“ zugewiesen.
PROGRAM REBUS
Da die Buchstaben A bis Z eine ganze Zahl annehmen können sollen, werden sie mit
dem Datentyp INTEGER initialisiert.
IMPLICIT INTEGER (A-Z)
Die eigentliche Aufgabe, die Zuordnung von Zahlen zu Buchstaben, wird mit
geschachtelten DO Schleifen und IF Anweisungen gelöst. Da in der Aufgabe nur 8
verschiedene Buchstaben enthalten sind, werden im Programm acht DO Schleifen
benötigt.
Die erste DO Schleife sieht folgendermaßen aus:
DO 220 S=1,9
…
220 CONTINUE
Dies bedeutet, dass der Buchstabe S mit dem Anfangswert 1 initialisiert wird und die
Schleife so oft wiederholt werden kann, bis S maximal den Wert 9 angenommen hat.
Nach der zweiten DO Schleife folgt die erste IF- Abfrage:
24
DO 219 E=0,9
IF (E.EQ.S) GOTO 219
…
219 CONTINUE
Da E kein führender Buchstabe in der Aufgabe ist, darf er auch den Wert Null
annehmen. Daher bekommt E als Anfangswert die Zahl 0 zugewiesen. In der IFAnweisung wird überprüft ob E und S den gleichen Wert angenommen haben. Wenn
das der Fall sein sollte, soll die zweite DO Schleife mit der Nummer 219 noch einmal
ausgeführt werden. Dies wird mit der GOTO Anweisung veranlasst. Auch die zweite
DO Schleife kann so oft wiederholt werden, bis der Buchstabe E maximal den Wert 9
angenommen hat.
In dieser Art folgen noch mehrere DO Schleifen und IF Anweisungen. Bis der Wert des
letzten Buchstaben bestimmt werden soll.
DO 213 Y=0,9
IF (Y.EQ.S.OR.Y.EQ.E.OR.Y.EQ.N.OR.Y.EQ.D.OR.Y.EQ.M.OR.Y.EQ.O
& .OR.Y.EQ.R) GOTO 213
…
213 CONTINUE
Die DO Anweisung sieht bei dem letzten Buchstaben Y genauso aus, wie bei dem
Buchstaben E. Nur in der IF Anweisung ist der Wert des Buchstaben Y mit allen
anderen Buchstaben zu überprüfen. Sollte der Wert mit nur einem Wert der anderen
sieben Buchstaben übereinstimmen, muss die DO Schleife 213 wiederholt ausgeführt
werden.
Als nächstes werden die Wörter SEND, MORE und MONEY definiert. Da die Werte
der Buchstaben
nur eine ganze Zahl zwischen 0 und 9 darstellen, müssen einige
Buchstaben mit jeweils 10, 100, 1000 oder 10000 multipliziert werden.
SEND = D+10*N+100*E+1000*S
MORE = E+10*R+100*O+1000*M
MONEY = Y+10*E+100*N+1000*O+10000*M
Anschließend kann überprüft werden ob die Lösung korrekt ist. Wenn nicht, muss in die
letzte DO Schleife gesprungen werden.
IF(SEND+MORE.NE.MONEY) GOTO 213
An dieser Stelle kann die Lösung ausgegeben werden. Dazu wird die WRITE
Anweisung benutzt.
25
WRITE(*,300) S,E,N,D,M,O,R,E,M,O,N,E,Y
Nachdem
alle
DO
Schleifen
mit
den
jeweiligen
CONTINUE-Anweisungen
abgeschlossen wurden, wird das Ausgabeformat mit der Nummer 300 bestimmt.
300 FORMAT(1X,' SEND
&
',4I1,/,1X,'+MORE
',4I1,
/,1X,'----- ',/,1X,'MONEY ',5I1,/)
Wie bei jedem FORTRAN Programm, muss auch hier END die letzte Anweisung des
Programms sein.
Das Programm läuft alle möglichen Alternativen durch bis es eine gültige Lösung
gefunden hat.
Als Fazit lässt sich sagen, dass FORTRAN einen Vorteil bei der Lösung
mathematischer Aufgaben besitzt. Demzufolge ist FORTRAN weniger für die
Entwicklung von System- bzw. Businesscode und objektorientierte Programmierung
geeignet.
26
Kapitel 6: Zusammenfassung
6 Zusammenfassung
Die Programmiersprache FORTRAN wurde für die Lösung mathematischer Probleme
im naturwissenschaftlichen und ingenieurmäßigen Bereich konzipiert. Die Sprache hat
sich in der Zeit sehr entwickelt und kann in verschiedenen Gebieten eingesetzt werden.
Jedoch für die Lösung systemnaher Problemstellung ist FORTRAN nicht vorgesehen.
Die aktuellen Versionen von FORTRAN lassen jedoch die Einbindung von
anderssprachigen Prozeduren, z.B. C, über die Zugriffe aus Systemressourcen möglich
sind.
In der vorliegenden Arbeit wurde ein Einblick in die Programmiersprache FORTRAN
gewährt. Von der historischen Entwicklung, über zugelassene Symbole, bis wichtige
Anweisungen der Sprache wurde in den vorrangehenden Kapiteln behandelt.
Da FORTRAN zu der Zeiten der Lochkarten entwickelt wurde, ist die Länger und
Struktur jeder Zeile am Aufbau einer 80-spaltige Lochkarte orientiert. Die genauere
Aufteilung der Zeilen wurde im Kapitel 3.2 erklärt.
Im Kapitel 5 wurden die vorgestellten Sprachelemente zur Lösung des SEND-MOREMONEY Rätsels genutzt.
Der grundsätzliche Nachteil von FORTRAN ist, dass in dieser Sprache sehr
unübersichtlicher Programme erstellt werden können. Trotzdessen wird die Sprache
immer noch im wissenschaftlichen und kaufmännischen Bereich verwendet.
Es wird weiterhin an der Entwicklung von FORTRAN gearbeitet. Ein weiter Standard
ist geplant und wird, mit weiterer Verbesserung der Sprache, folgen.
27
Anhang A: Titel von Anhang 1
A SEND – MORE – MONEY - Code
PROGRAM REBUS
IMPLICIT INTEGER (A-Z)
* S E N D M O R E M O N E Y
* S E N D M O R Y
* M and S start with 1 because they are leading
DO 220 S=1,9
DO 219 E=0,9
IF (E.EQ.S) GOTO 219
DO 218 N=0,9
IF (N.EQ.S.OR.N.EQ.E) GOTO 218
DO 217 D=0,9
IF (D.EQ.S.OR.D.EQ.E.OR.D.EQ.N) GOTO 217
DO 216 M=1,9
IF (M.EQ.S.OR.M.EQ.E.OR.M.EQ.N.OR.M.EQ.D) GOTO 216
DO 215 O=0,9
IF (O.EQ.S.OR.O.EQ.E.OR.O.EQ.N.OR.O.EQ.D.OR.O.EQ.M) GOTO 215
DO 214 R=0,9
IF (R.EQ.S.OR.R.EQ.E.OR.R.EQ.N.OR.R.EQ.D.OR.R.EQ.M.OR.R.EQ.O)
& GOTO 214
DO 213 Y=0,9
IF (Y.EQ.S.OR.Y.EQ.E.OR.Y.EQ.N.OR.Y.EQ.D.OR.Y.EQ.M.OR.Y.EQ.O
& .OR.Y.EQ.R) GOTO 213
SEND = D+10*N+100*E+1000*S
MORE = E+10*R+100*O+1000*M
MONEY = Y+10*E+100*N+1000*O+10000*M
IF(SEND+MORE.NE.MONEY) GOTO 213
WRITE(*,300) S,E,N,D,M,O,R,E,M,O,N,E,Y
213 CONTINUE
214 CONTINUE
215 CONTINUE
216 CONTINUE
217 CONTINUE
218 CONTINUE
219 CONTINUE
220 CONTINUE
300 FORMAT(1X,' SEND ',4I1,/,1X,'+MORE ',4I1,
&
/,1X,'----- ',/,1X,'MONEY ',5I1,/)
END
28
Literaturverzeichnis
Literaturverzeichnis
[Al95]
Alt, Walter. Programmieren mit FORTRAN 77. Jena : Walter Alt, 1995.
[CS06]
Chivers, Ian D. und Sleightholme, Jane. Introduction to Programming
with Fortran. London : Springer-Verlag, 2006.
[Dr70]
Dreyfus, Michel. Anleitung zum praktischen Gebrauch von FORTRAN
IV. München : R. Oldenbourg, 1970.
[Ge91]
Gehrke, Wilhelm. FORTRAN 90: Referenz-Handbuch. Der neue
FORTRAn-Standard. München, Wien : Carl Hanser, 1991.
[He81]
Herschel, Rudolf. FORTRAN: Systematische Darstellug für den
Anwender, 2. verb. Aufl. München : R. Oldenbourg , 1981.
[KKU80]
Kaucher, Edgar, Klatte, Rudi und Ullrich, Christian.
Programmiersprachen im Griff. Band 1: FORTRAN. Mannheim :
Bibliographisches Institut AG, 1980.
[La87]
Lamprecht, Günther. Einführung in die Programmiersprache
FORTRAN 77. Braunschweig : Friedr. Vieweg Sohn Verlagsgesellschaft,
1987.
[Ma80]
May, Gerd. Strukturiertes Programmieren mit FORTRAN . München,
Wien : Carl Hanser, 1980.
[Me88]
Merten, Klaus. FORTRAN 77. Eine Einführung zum Selbststudium.
3. Aufl. . Stuttgart : Gustav Fischer Verlag , 1988.
[Me85]
Metcalf, Michael. Effective Fortran 77. Oxford : Clarendon Press, 1985.
[Sc90]
Schwinn, Walter. FORTRAN 77: Einführung und praktische Beispiele.
Düsseldorf : VDI-Verlag GmbH, 1990.
[Th73]
Thull, Karl-Heinz. Problemorientiert mit FORTRAN. Köln-Braunsfeld :
Verlangsgesellschaft Rudolf Müller, 1973.
[ÜBM93]
Überhuber, Christoph, Berhuber, Christoph und Meditz, Peter.
Software- Entwicklung in Fortran 90. Wien, New York : Springer, 1993.
29
Hinweis: Die unten angeführte Erklärung wird nur bei Bachelor- oder Diplomarbeiten
benötigt, nicht jedoch bei Seminarausarbeitungen. Bei Bachelorarbeiten ist
darauf zu achten, dass das Wort „Diplomhausarbeit“ durch „BachelorAbschlussarbeit“ ersetzt wird.
Ich versichere hiermit, dass ich meine Diplomhausarbeit <Titel der Arbeit>
selbstständig und ohne fremde Hilfe angefertigt habe, und dass ich alle von anderen
Autoren wörtlich übernommenen Stellen wie auch die sich an die Gedankengänge
anderer Autoren eng anlegenden Ausführungen meiner Arbeit besonders gekennzeichnet und die Quellen zitiert habe.
Münster, __________
_____________________________

FORTRAN

Transcription

Documents pareils

Höllische Programmiersprachen: FORTRAN77

B Notizen zu Fortran 90/95

npd-nrw.de • /npdnrw Zensur bei KAUFLAND - Meinungs

Formelinterpreter für die Bildverarbeitung

„Übersetzung“ von Struktogrammen nach VBA

Farbig bemalte Buchstaben mit Glitzer

Programmierung JavaScript - CIP

Programmierkurs Python I - Universität des Saarlandes

Zur Person - Galas Industrielle Software

Mind Maps

Jubilums-Sudoku (DIE ZEIT 42/2010)