Fortran

Related Topics:
Fortran :: Fortran_77 :: Fortran_90 :: Fortran_95 :: Fortran_90_and_95

Fortran ist eine Programmiersprache, die insbesondere für numerische Berechnungen eingesetzt wird. Der Name entstand aus FORmula TRANslation und wurde bis zur Version FORTRAN 77 mit Großbuchstaben geschrieben.

Geschichte

Fortran gilt als die erste jemals tatsächlich realisierte höhere Programmiersprache. Sie geht zurück auf einen Vorschlag, den John W. Backus, Programmierer bei IBM, 1953 seinen Vorgesetzten unterbreitete.

Dem Entwurf der Sprache folgte die Entwicklung eines Compilers durch ein IBM-Team unter Leitung von John W. Backus. Das Projekt begann 1954 und war ursprünglich auf sechs Monate ausgelegt. Tatsächlich konnte Harlan Herrick, der Erfinder der später heftig kritisierten Goto-Anweisung, am 20. September 1954 das erste Fortran-Programm ausführen. Doch erst 1957 wurde der Compiler für marktreif befunden und mit jedem IBM 704-System ausgeliefert. Backus hatte darauf bestanden, den Compiler von Anfang an mit der Fähigkeit zu Optimierungen auszustatten: er sah voraus, dass sich Fortran nur dann durchsetzen würde, wenn ähnliche Ausführungsgeschwindigkeiten wie mit bisherigen Assembler-Programmen erzielt würden.

Versionen

Fortran wurde mehrmals erweitert. Viele neue Sprachelemente wurden zunächst von einem einzelnen Hersteller eingeführt und später in den internationalen Standard übernommen. Als Versionen folgten aufeinander FORTRAN I, FORTRAN II, FORTRAN IV, FORTRAN-66, FORTRAN-77, Fortran90, Fortran95 und zuletzt Fortran2003. Ab FORTRAN-66 ist Fortran von einer internationalen Organisation standardisiert. Die Fortschreibung der Standards ist ein komplizierter Prozess, der oft wesentlich länger dauert als zunächst angestrebt: so war Fortran90 ursprünglich für 1988 angekündigt, erschien aber erst 1990.

Im Laufe dieser Erweiterungen wurden zahlreiche Sprachelemente aus neueren Programmiersprachen übernommen. Beruhte früher Fortran-Stil noch ganz auf Goto-Anweisungen, kann man seit FORTRAN 77 uneingeschränkt strukturiert programmieren. Mit Fortran90 wurde das aus der Lochkartenzeit stammende Zeilenformat freigegeben. Ab Fortran 90 werden interessante Elemente eingeführt, die auch z.B. in Ada vorhanden sind, beispielsweise optionale Parameter und die Möglichkeit, Prozedurparameter nicht nur über die Position in der Parameterliste zu identifizieren, sondern über ihren Namen.

Beispiel:

SUBROUTINE Bla( Argument1, Argument2, Argument3 ) REAL, INTENT(IN) :: Argument1 CHARACTER(LEN= *), INTENT(IN) :: Argument2 INTEGER, INTENT(IN), OPTIONAL :: Argument3 ! Hier was sinnvolles. END SUBROUTINE

Mögliche Aufrufe sind dann z.B.: CALL Bla( 1.0, 'Tach' ) ! Parameterassoziation ueber die Reihenfolge CALL Bla( Argument1= 1.0, Argument2= 'Tach auch' ) ! Identifikation ueber Namen der Formalparameter CALL Bla( Argument2= 'Tach Auch', Argument1= 1.0 ) ! Identifikation ueber Formalparameter CALL Bla( Argument3= 3, Argument1= 1.0, Argument2= 'Tach auch' )

Varianten

Einige von Fortran abgeleitete Programmiersprachen sind Ratfor, F und HPF (High Performance Fortran). Auf Fortran aufgesetzt ist das Finite-Elemente-Programmpaket Nastran.

Eigenschaften

Fortran war und ist für numerische Berechnungen vorgesehen und optimiert. Von Anfang an hatte Fortran den Potenz-Operator ** – der in vielen anderen Hochsprachen nicht vorhanden ist – und einen Datentyp für komplexe Zahlen. Mit Fortran90 wurden Vektor- und Matrix-Operationen standardisiert. Ein Fortran-Programm kann leichter optimiert werden als z.B. ein C-Programm, da Fortran restriktiver ist. Beispielsweise ist es nicht erlaubt, innerhalb einer Iterationsschleife die Iterationsvariable zu verändern. Unter anderem deshalb ist beim Eintritt in die Schleife die Maximalzahl der Durchläufe bekannt.

! iFunc() sei eine Funktion, die einen INTEGER Wert berechnet. ! Der Compiler muss nur einen Aufruf von iFunc erzeugen. DO i= 1, iFunc(4711) !.. sinnvolles hier. ! Innerhalb dieser Schleife darf i nicht veraendert werden. ENDDO

In C sähe eine solche Iteration vielleicht so aus: for (i=1; i<=ifunc(4711); i++) { /* Sinnvolles hier */ /* Es ist hier erlaubt, i zu veraendern */ } Der C-Compiler muss Code erzeugen, der in jedem Durchlauf wieder die Funktion iFunc aufruft.

Insbesondere für wissenschaftliche und numerische Berechnungen gibt es in FORTRAN umfangreiche Bibliotheken, die immer noch weit verbreitet sind, auch wenn eine zunehmende Menge an Routinen inzwischen nach C und C++ portiert wurde.

Implizite Variablendeklaration

In Anlehnung an mathematischen Notationsgebrauch sind Variablen in Fortran standardmäßig über ihren Anfangsbuchstaben deklariert: Bezeichner, die mit einem der Buchstaben i, j, k, l, m, n beginnen, stehen für eine INTEGER-Variable oder einen INTEGER-Funktionswert, alle übrigen Bezeichner stehen für REAL-Werte. Dieser Default kann durch die Deklaration einzelner Variablen überschrieben werden, er kann durch einen Befehl wie IMPLICIT (c) COMPLEX überschrieben werden, und er kann durch den Befehl IMPLICIT NONE ganz aufgehoben werden, in welchem Fall jeder nichtdeklarierte Bezeichner einen Fehler während des Compilerlaufs auslöst. Dies vereinfacht die Fehlersuche.

Übergabe von Parametern

In alten Versionen von Fortran (FORTRAN 77 und früher) mussten Unterprogramme vor ihrer Verwendung nicht deklariert werden. Es konnte durch eine Deklaration allenfalls der Typ des Rückgabewerts festgelegt werden. Der Compiler überprüfte normalerweise nicht, ob ein Unterprogrammaufruf mit typrichtigen Parametern erfolgt. Die Übergabe von Parametern an Unterprogramme (SUBROUTINE oder FUNCTION) erfolgt üblicherweise per Adresse. Vor Fortran-90 konnten grundsätzlich alle Aktualparameter von einer SUBROUTINE oder FUNCTION verändert werden. Deshalb müssen alle Parameter z.B. durch Adressübergabe übergeben werden. Eine automatische Typumwandlung kann deshalb auch nicht stattfinden.

Die meisten Fortran Systeme führen auch keine Typüberprüfung zur Laufzeit durch.

Das ist eine häufige Fehlerquelle. Programmbeispiel 1: ... CALL DruckeZahl(3.14) ... SUBROUTINE DruckeZahl(meineZahl) ... Im Unterprogramm DruckeZahl ist ,,meineZahl (natürlich würde kein Fortran-Programmierer so explizite Variablennamen wählen, und zwischen Groß- und Kleinschreibung unterscheidet ein Fortran-Compiler auch nicht), weil mit ,,m beginnend, implizit als INTEGER deklariert. Zur Laufzeit erfolgt ein Aufruf mit dem REAL Argument 3.14. Dann wird die INTEGER-Variable ,,meineZahl'' mit den Bits der Gleitkommadarstellung von 3.14 aufgefüllt – was auf beliebig abwegige numerische Ergebnisse führt.

Viele Fortran-Compiler arbeiten mit Zeigern zur Übergabe von Parametern. Das führt zu teilweise amüsanten Ergebnissen, z.B. folgendes Programmbeispiel 2:

call bar(3) print *,3 end subroutine bar(i) i=42 end

was bei bestimmten Compilern die Zahl 42 ausgeben würde. Das Programm ist allerdings so nicht korrekt.

Programmierwerkzeuge wie ftnchek ermöglichen allerdings eine separate Prüfung der Übereinstimmung von Argumentlisten und würden in diesen Fällen warnen.

In Fortran 90 und nachfolgenden Versionen besteht die Möglichkeit, die Parametertypen der Unterprogramme anhand von Schnittstellen (INTERFACE) und Module (MODULE) zu definieren. Der Compiler kann somit überprüfen, ob der übergebene Parametertyp und der erwartete Typ übereinstimmt, so wie es in anderen Programmiersprachen, beispielsweise ISO-C und Pascal der Fall ist. In einem Unterprogramm kann auch festgelegt werden, ob ein Parameter Eingabeparameter (INTENT(IN)), Ausgabeparameter (INTENT(OUT)) oder beides (INTENT(INOUT)) ist. In Fortran 90 deklariert man das Unterprogramm bar folgendermaßen:

subroutine bar(i) integer, intent(in):: i ^* end subroutine

Falls das Unterprogram versuchen sollte den Wert des Parameter i zu setzen, würde der Compiler eine Fehlermeldung anzeigen.

Dynamische Speicherallokation

Unter dynamischer Speicherallokation versteht man die Möglichkeit, Speicher (insbesondere für Arrays wie z.B. für Matrizen) erst zur Laufzeit des Programms anzufordern, das heißt, dass die Größe von Arrays nicht bereits vor dem Kompilieren des Programms festgelegt werden muss. Bis Fortran 77 ist eine dynamische Speicherallokation nicht oder nur über nicht standardisierte Erweiterungen der Compilerhersteller möglich. Ab Fortran 90 ist dynamische Speicherverwaltung im Sprachstandard enthalten.

Ein Beispiel für dynamische Speicherreservierung: Anlegen und Bearbeiten einer verketteten Liste:

TYPE tElement TYPE (tElement), POINTER :: Naechstes REAL :: Datum END TYPE tElement TYPE (tElement), POINTER, SAVE :: Liste=> NULL();

TYPE (tElement), POINTER :: Element

! Anlegen eines Elements und Eintragen am Anfang der Liste ALLOCATE( Element ) Element% Datum= 4711.0 Element% Naechstes=> Liste Liste=> Element

! Durchlaufen der Liste: Element=> Liste DO WHILE (ASSOCIATED(Element)) CALL Bearbeiten( Element% Datum ) Element=> Element% Naechstes ENDDO

Compiler

Bis zum heutigen Zeitpunkt (Februar 2006) gibt es keinen Compiler, der den aktuellen Fortran-Standard von 2003 unterstützt.

Kommerzielle Software

F95-Compiler gibt es für praktisch alle Computer, von Arbeitsplatzrechnern bis zu Supercomputern. Hersteller hierfür sind entweder die Computerhersteller wie z.B. IBM, SUN, HP, Intel oder aber spezialisierte Softwarehersteller wie z.B. Absoft, PGI, NAG, Lahey, Salford. Reine F77-Compiler werden heute zumeist nicht mehr hergestellt, da Fortran77 fast vollständig im Sprachstandard Fortran95 enthalten ist (Nur DO Loops mit REAL Iterationsvariablen sind verschwunden).

Manche der oben genannten Compiler sind für Privatanwender bzw. nichtkommerzielle Nutzung kostenlos, zum Beispiel die Linux-Variante des Intel-Fortran-Compilers (aktuelle Version 9.0) oder für Microsoft-Windows der Compiler von Salford.

Freie Software

Seit Version 4.0 der GNU Compiler Collection (GCC), die praktisch für alle Plattformen vorhanden ist, enthält diese einen Fortran 95 Frontend (gfortran). Ältere Versionen von GCC enthalten noch den FORTRAN 77 Frontend g77. Außerdem existiert mit G95 ein weiterer freier Fortran 95 Compiler (aus diesem ging 2003 gfortran hervor).

Auch die OpenWatcom-Entwicklersuite verfügt über einen FORTRAN 77-Compiler.

Übersetzer

Es gibt Programme, wie z.B. f2c, zur automatischen Übersetzung von Fortran in (allerdings kaum lesbares) C.

Literatur zur Geschichte von Fortran

Annals of History of Computing, 6, 1, Jan. 1984.
S. Rosen (Hrsg.): Programming Systems and Languages, McGraw Hill, 1967.
R. L. Wexelblat (Hrsg.): History of Programmining Languages. Academic Press, 1981, S. 25–74.

Weblinks

Fortran.de Links und Informationen
Fortran Store Umfangreiche Informationen inkl. Historischem und Standards (engl.)
Einführung in Fortran90/95
Einführung in Fortran90/95
Einführung FORTRAN77

Programmiersprache

Gourt Home::Gourt :: Fortran