Fortran

Fortran ⓘ
Paradigma	Multi-Paradigma: strukturiert, imperativ (prozedural, objektorientiert), generisch, Array
Entworfen von	John Backus
Entwickler	John Backus und IBM
Erstes Erscheinen	1957; vor 66 Jahren
Stabile Version	Fortran 2018 (ISO/IEC 1539-1:2018) / 28. November 2018; vor 4 Jahren
Disziplin der Typisierung	stark, statisch, manifest
Dateinamen-Erweiterungen	.f, .for, .f90
Wichtigste Implementierungen
	Absoft, Cray, GFortran, G95, IBM XL Fortran, Intel, Hitachi, Lahey/Fujitsu, Numerical Algorithms Group, Open Watcom, PathScale, PGI, Silverfrost, Oracle Solaris Studio, andere
Beeinflusst durch
	Schnellcodierung
Beeinflusst
	ALGOL 58, BASIC, C, Chapel, CMS-2, DOPE, Fortress, PL/I, PACT I, MUMPS, IDL, Ratfor

Fortran (/ˈfɔːrtræn/; früher FORTRAN) ist eine kompilierte, imperative Allzweckprogrammiersprache, die sich besonders für numerische und wissenschaftliche Berechnungen eignet. ⓘ

Ursprünglich wurde Fortran in den 1950er Jahren von IBM für wissenschaftliche und technische Anwendungen entwickelt und dominierte später das wissenschaftliche Rechnen. Es wird seit über sechs Jahrzehnten in rechenintensiven Bereichen wie der numerischen Wettervorhersage, der Finite-Elemente-Analyse, der rechnergestützten Strömungsmechanik, der Geophysik, der rechnergestützten Physik, der Kristallographie und der rechnergestützten Chemie eingesetzt. Sie ist eine beliebte Sprache für Hochleistungsrechner und wird für Programme verwendet, mit denen die schnellsten Supercomputer der Welt bewertet und eingestuft werden. ⓘ

Der IBM Blue Gene/P Supercomputer wurde 2007 in der Argonne Leadership Angela Yang Computing Facility im Argonne National Laboratory in Lemont, Illinois, USA, installiert. ⓘ

Von Fortran gibt es zahlreiche Versionen, die jeweils um Erweiterungen ergänzt wurden, wobei die Kompatibilität mit den Vorgängerversionen weitgehend erhalten blieb. Nachfolgende Versionen unterstützten die strukturierte Programmierung und die Verarbeitung zeichenbasierter Daten (FORTRAN 77), die Array-Programmierung, die modulare Programmierung und die generische Programmierung (Fortran 90), das Hochleistungs-Fortran (Fortran 95), die objektorientierte Programmierung (Fortran 2003), die gleichzeitige Programmierung (Fortran 2008) und native parallele Rechenfunktionen (Coarray Fortran 2008/2018). ⓘ

Das Design von Fortran war die Grundlage für viele andere Programmiersprachen. Zu den bekanntesten gehört BASIC, das auf FORTRAN II basiert, mit einer Reihe von Syntaxbereinigungen, insbesondere besseren logischen Strukturen, und anderen Änderungen, um die Arbeit in einer interaktiven Umgebung zu erleichtern. ⓘ

Im August 2021 lag Fortran im TIOBE-Index, einem Maß für die Belieb^theit von Programmiersprachen, auf Platz 13 und verbesserte sich damit um 29 Plätze gegenüber Platz 42 im August 2020. ⓘ

Fortran ist eine prozedurale, seit 2003 auch eine objektorientierte Programmiersprache, die insbesondere für numerische Berechnungen in Wissenschaft, Technik und Forschung eingesetzt wird. Der Name entstand aus FORmula TRANslation und wurde bis zur Version FORTRAN 77 mit Großbuchstaben geschrieben. ⓘ

Namensgebung

Das erste Handbuch für FORTRAN beschreibt es als Formula Translating System und druckt den Namen mit Kapitälchen, FORTRAN. Andere Quellen legen nahe, dass der Name für Formula Translator oder Formula Translation steht. Die frühen IBM-Computer unterstützten keine Kleinbuchstaben, und die Namen der Versionen der Sprache bis FORTRAN 77 wurden in der Regel in Großbuchstaben geschrieben (FORTRAN 77 war die letzte Version, in der der Fortran-Zeichensatz nur Großbuchstaben enthielt). In den offiziellen Sprachstandards für Fortran wird die Sprache seit Fortran 90 als "Fortran" mit Großbuchstaben bezeichnet. ⓘ

Ursprünge

Ein IBM 704 Großrechner ⓘ

Ende 1953 unterbreitete John W. Backus seinen Vorgesetzten bei IBM den Vorschlag, eine praktischere Alternative zur Assemblersprache für die Programmierung des IBM 704 Großrechners zu entwickeln. Backus' historisches FORTRAN-Team bestand aus den Programmierern Richard Goldberg, Sheldon F. Best, Harlan Herrick, Peter Sheridan, Roy Nutt, Robert Nelson, Irving Ziller, Harold Stern, Lois Haibt und David Sayre. Zu seinen Konzepten gehörte die einfachere Eingabe von Gleichungen in einen Computer, eine Idee, die von J. Halcombe Laning entwickelt und im Laning- und Zierler-System von 1952 demonstriert wurde. ⓘ

The Fortran Automatic Coding System for the IBM 704 (15. Oktober 1956), das erste Referenzhandbuch für Programmierer von Fortran ⓘ

Der Entwurf einer Spezifikation für das IBM Mathematical Formula Translating System wurde im November 1954 fertiggestellt. Das erste Handbuch für FORTRAN erschien im Oktober 1956, und der erste FORTRAN-Compiler wurde im April 1957 ausgeliefert. Es handelte sich um den ersten optimierenden Compiler, denn die Kunden zögerten, eine Hochsprache zu verwenden, wenn der Compiler nicht in der Lage war, einen Code zu erzeugen, der annähernd so leistungsfähig war wie ein von Hand geschriebener Assembler. ⓘ

Die Community war zwar skeptisch, dass diese neue Methode die Handcodierung übertreffen könnte, aber sie reduzierte die Anzahl der Programmieranweisungen, die zum Betrieb einer Maschine notwendig waren, um den Faktor 20 und setzte sich schnell durch. John Backus sagte 1979 in einem Interview mit Think, dem IBM-Mitarbeitermagazin: "Ein großer Teil meiner Arbeit ist aus Faulheit entstanden. Ich mochte es nicht, Programme zu schreiben, und so begann ich, als ich an der IBM 701 arbeitete und Programme zur Berechnung von Raketenflugbahnen schrieb, mit der Arbeit an einem Programmiersystem, das das Schreiben von Programmen erleichtern sollte." ⓘ

Die Sprache wurde von vielen Wissenschaftlern zum Schreiben numerisch intensiver Programme verwendet, was die Compiler-Autoren ermutigte, Compiler zu entwickeln, die schnelleren und effizienteren Code erzeugen konnten. Die Aufnahme eines Datentyps für komplexe Zahlen in die Sprache machte Fortran besonders geeignet für technische Anwendungen wie die Elektrotechnik. ⓘ

Bis 1960 waren Versionen von FORTRAN für die IBM-Computer 709, 650, 1620 und 7090 verfügbar. Die zunehmende Popularität von FORTRAN veranlasste konkurrierende Computerhersteller, FORTRAN-Compiler für ihre Maschinen anzubieten, so dass 1963 bereits über 40 FORTRAN-Compiler existierten. Aus diesen Gründen gilt FORTRAN als die erste weit verbreitete plattformübergreifende Programmiersprache. ⓘ

Die Entwicklung von Fortran verlief parallel zur frühen Entwicklung der Compilertechnologie, und viele Fortschritte in der Theorie und im Design von Compilern wurden speziell durch die Notwendigkeit motiviert, effizienten Code für Fortran-Programme zu erzeugen. ⓘ

FORTRAN

Die erste Version von FORTRAN für die IBM 704 enthielt 32 Anweisungen, darunter:

DIMENSION und EQUIVALENCE Anweisungen
Zuweisungsanweisungen
Dreifach-Arithmetik IF Anweisung, die die Kontrolle an eine von drei Stellen im Programm weitergibt, je nachdem, ob das Ergebnis der arithmetischen Anweisung negativ, null oder positiv ist
IF Anweisungen zur Überprüfung von Ausnahmen (ÜBERLAUF DES AKKUMULATORS, QUOTIENTENÜBERLAUFund DIVIDE CHECK); und IF Anweisungen zur Manipulation von Sensorschaltern und Sensorleuchten
GO TO, berechnete GO TO, ASSIGN, und zugewiesene GO TO
DO Schleifen
Formatierte E/A: FORMAT, LESEN, EINGABEBAND LESEN, SCHREIBEN, AUSGABEBAND SCHREIBEN, DRUCKENund PUNCH
Unformatierte E/A: TAPE LESEN, LESEN TROMMEL, TAPE SCHREIBENund SCHREIBEN TROMMEL
Andere E/A: ENDE DATEI, ZURÜCKSPULENund ZURÜCK SPRINGEN
PAUSE, STOPPund FORTSETZEN
FREQUENCY Anweisung (um dem Compiler Hinweise zur Optimierung zu geben). ⓘ

Die arithmetische IF Anweisung erinnerte an einen Drei-Wege-Vergleichsbefehl (CAS-Compare Accumulator with Storage), der auf der 704 verfügbar war (aber nicht ohne weiteres implementiert werden konnte). Die Anweisung bot die einzige Möglichkeit, Zahlen zu vergleichen, indem man ihre Differenz testete, was die Gefahr eines Überlaufs mit sich brachte. Diese Unzulänglichkeit wurde später durch die in FORTRAN IV eingeführten "logischen" Möglichkeiten überwunden. ⓘ

Die Anweisung FREQUENCY Anweisung wurde ursprünglich (und optional) verwendet, um Verzweigungswahrscheinlichkeiten für die drei Verzweigungsfälle der arithmetischen IF-Anweisung anzugeben. Der erste FORTRAN-Compiler nutzte diese Gewichtung, um zur Kompilierzeit eine Monte-Carlo-Simulation des generierten Codes durchzuführen, deren Ergebnisse zur Optimierung der Platzierung von Basisblöcken im Speicher verwendet wurden - eine für die damalige Zeit sehr anspruchsvolle Optimierung. Die Monte-Carlo-Technik ist in Backus et al.'s Arbeit über diese ursprüngliche Implementierung, The FORTRAN Automatic Coding System, dokumentiert:

Die grundlegende Einheit eines Programms ist der Basissatz; ein Basissatz ist ein Programmabschnitt, der einen Einstiegspunkt und einen Ausstiegspunkt hat. Der Zweck von Abschnitt 4 besteht darin, für Abschnitt 5 eine Vorgängertabelle (PRED-Tabelle) vorzubereiten, die die Basissätze aufzählt und für jeden Basissatz jeden Basissatz auflistet, der sein unmittelbarer Vorgänger im Ablauf sein kann, zusammen mit der absoluten Häufigkeit jeder solchen Basissatzverbindung. Diese Tabelle erhält man, indem man das Programm einmal in Monte-Carlo-Manier durchlaufen lässt, wobei das Ergebnis der bedingten Übertragungen, die sich aus IF-Anweisungen und berechneten GO TO's ergeben, durch einen Zufallszahlengenerator bestimmt wird, der entsprechend den gegebenen FREQUENCY-Anweisungen gewichtet wird. ⓘ

Viele Jahre später hatte die FREQUENCY Anweisung keine Auswirkung auf den Code und wurde als Kommentaranweisung behandelt, da die Compiler diese Art der Kompilierzeitsimulation nicht mehr durchführten. Ein ähnliches Schicksal ereilte Compiler-Hinweise in mehreren anderen Programmiersprachen, z. B. die Register Schlüsselwort in C. ⓘ

Der erste FORTRAN-Compiler meldete Diagnoseinformationen, indem er das Programm anhielt, wenn ein Fehler gefunden wurde, und einen Fehlercode auf seiner Konsole ausgab. Dieser Code konnte vom Programmierer in einer Fehlermeldungstabelle im Benutzerhandbuch nachgeschlagen werden und lieferte ihm eine kurze Beschreibung des Problems. Später wurde ein von der NASA entwickeltes Unterprogramm zur Behandlung von Benutzerfehlern wie der Division durch Null integriert, das dem Benutzer mitteilte, in welcher Codezeile der Fehler aufgetreten war. ⓘ

Festes Layout und Lochkarten

FORTRAN-Code auf einer Lochkarte, der die spezielle Verwendung der Spalten 1-5, 6 und 73-80 zeigt ⓘ

Eine Reproduktion eines FORTRAN-Codierformulars, das auf Papier gedruckt wurde und von Programmierern zur Vorbereitung von Programmen auf Lochkarten verwendet werden sollte. Jetzt veraltet. ⓘ

Vor der Entwicklung von Plattendateien, Texteditoren und Terminals wurden Programme meist über eine Tastatur auf 80-spaltigen Lochkarten eingegeben, eine Zeile pro Karte. Der resultierende Kartenstapel wurde in ein Kartenlesegerät eingelegt, um kompiliert zu werden. Die Lochkartencodes enthielten keine Kleinbuchstaben oder viele Sonderzeichen, und es wurden spezielle Versionen der IBM 026-Tastatur angeboten, die die in FORTRAN verwendeten Sonderzeichen korrekt drucken konnten. ⓘ

Entsprechend der Praxis der Lochkarteneingabe wurden Fortran-Programme ursprünglich in einem festen Spaltenformat geschrieben, wobei die ersten 72 Spalten in zwölf 36-Bit-Worten gelesen wurden. ⓘ

Ein Buchstabe "C" in Spalte 1 führte dazu, dass die gesamte Karte als Kommentar behandelt und vom Compiler ignoriert wurde. Ansonsten waren die Spalten der Karte in vier Felder unterteilt:

1 bis 5 waren das Bezeichnungsfeld: Eine Ziffernfolge wurde hier als Bezeichnung für die Verwendung in DO- oder Kontrollanweisungen wie GO TO und IF oder zur Kennzeichnung einer FORMAT-Anweisung, auf die in einer WRITE- oder READ-Anweisung Bezug genommen wurde, verwendet. Führende Nullen werden ignoriert, und 0 ist keine gültige Labelnummer.
6 war ein Fortsetzungsfeld: Ein anderes Zeichen als ein Leerzeichen oder eine Null bewirkte, dass die Karte als Fortsetzung der Anweisung auf der vorherigen Karte betrachtet wurde. Die Fortsetzungskarten waren in der Regel mit 1, 2 usw. nummeriert, so dass die Anfangskarte in ihrer Fortsetzungsspalte eine Null haben konnte - was keine Fortsetzung der vorangegangenen Karte war.
7 bis 72 dienten als Anweisungsfeld.
73 bis 80 wurden ignoriert (der Kartenleser des IBM 704 verwendete nur 72 Spalten). ⓘ

Die Spalten 73 bis 80 konnten daher für Identifizierungsinformationen verwendet werden, wie z. B. das Stanzen einer Sequenznummer oder eines Textes, der dazu verwendet werden konnte, Karten neu zu ordnen, wenn ein Kartenstapel heruntergefallen war; in der Praxis war dies jedoch stabilen Produktionsprogrammen vorbehalten. Ein IBM 519 konnte zum Kopieren eines Programmstapels und zum Hinzufügen von Sequenznummern verwendet werden. Einige frühe Compiler, z. B. der IBM 650, wiesen aufgrund der Beschränkungen ihrer Kartenleser zusätzliche Einschränkungen auf. Tastaturstempel konnten so programmiert werden, dass sie in Spalte 7 einen Tabulator setzen und nach Spalte 72 aussetzen. Spätere Compiler lockerten die meisten Beschränkungen für feste Formate, und die Anforderung wurde im Fortran-90-Standard abgeschafft. ⓘ

Innerhalb des Anweisungsfeldes wurden Leerzeichen außerhalb eines Textliterales ignoriert. Dies ermöglichte es, Leerzeichen zwischen Token wegzulassen, um sich kurz zu fassen, oder Leerzeichen innerhalb von Bezeichnern einzufügen, um Klarheit zu schaffen. Zum Beispiel, AVG VON X ein gültiger Bezeichner, gleichbedeutend mit AVGOFXund 101010DO101I=1,101 war eine gültige Anweisung, äquivalent zu 10101 DO 101 I = 1, 101 weil die Null in Spalte 6 so behandelt wird, als wäre sie ein Leerzeichen (!), während 101010DO101I=1,101 stattdessen war 10101 DO101I = 1,101die Zuweisung von 1.101 an eine Variable namens DO101I. Man beachte den leichten visuellen Unterschied zwischen einem Komma und einem Punkt. ⓘ

Hollerith-Zeichenketten, die ursprünglich nur in FORMAT- und DATA-Anweisungen zulässig waren, wurden durch eine Zeichenzahl und den Buchstaben H eingeleitet (z. B., 26HDIES SIND ALPHANUMERISCHE DATEN.), wodurch Leerzeichen innerhalb der Zeichenkette beibehalten werden konnten. Fehlzählungen waren ein Problem. ⓘ

Entwicklung

FORTRAN II

IBMs FORTRAN II erschien 1958. Die wichtigste Neuerung war die Unterstützung der prozeduralen Programmierung, indem es vom Benutzer geschriebene Unterprogramme und Funktionen ermöglichte, die Werte mit per Referenz übergebenen Parametern zurückgaben. Die Anweisung COMMON ermöglichte es Unterprogrammen, auf gemeinsame (oder globale) Variablen zuzugreifen. Sechs neue Anweisungen wurden eingeführt:

SUBROUTINE, FUNCTIONund END
CALL und RETURN
GEMEINSAM [https://en.wikipedia.org/wiki/Fortran#FORTRAN_II ⓘ]

In den nächsten Jahren sollte FORTRAN II auch die Unterstützung für die DOPPELTE GENAUIGKEIT und COMPLEX Datentypen. ⓘ

Frühe FORTRAN-Compiler unterstützten keine Rekursion in Unterroutinen. Frühe Computerarchitekturen unterstützten kein Konzept eines Stacks, und wenn sie Unterprogrammaufrufe direkt unterstützten, wurde die Rücksprungstelle oft an einer festen Stelle neben dem Unterprogrammcode (z. B. IBM 1130) oder in einem bestimmten Maschinenregister (IBM 360 usw.) gespeichert, was eine Rekursion nur zulässt, wenn ein Stack von der Software verwaltet wird und die Rücksprungadresse vor dem Aufruf auf dem Stack gespeichert und nach der Rückkehr des Aufrufs wiederhergestellt wird. Obwohl in FORTRAN 77 nicht spezifiziert, unterstützten viele F77-Compiler die Rekursion als Option, und die Burroughs-Mainframes, die mit eingebauter Rekursion entwickelt wurden, taten dies standardmäßig. In Fortran 90 wurde sie durch das neue Schlüsselwort RECURSIVE zum Standard. ⓘ

Einfaches FORTRAN II-Programm

Dieses Programm für die Heron-Formel liest Daten von einer Bandspule mit drei 5-stelligen Ganzzahlen A, B und C als Eingabe. Es sind keine "Typ"-Deklarationen vorhanden: Variablen, deren Name mit I, J, K, L, M oder N beginnt, sind "Festkomma" (d.h. Ganzzahlen), ansonsten Gleitkomma. Da in diesem Beispiel Ganzzahlen verarbeitet werden sollen, beginnen die Namen der Variablen mit dem Buchstaben "I". Der Name einer Variablen muss mit einem Buchstaben beginnen und kann sowohl mit Buchstaben als auch mit Ziffern fortgesetzt werden, bis zu einer Grenze von sechs Zeichen in FORTRAN II. Wenn A, B und C nicht die Seiten eines Dreiecks in der ebenen Geometrie darstellen können, wird die Ausführung des Programms mit dem Fehlercode "STOP 1" beendet. Andernfalls wird eine Ausgabezeile mit den Eingabewerten für A, B und C ausgegeben, gefolgt von der berechneten Fläche des Dreiecks als Fließkommazahl, die zehn Stellen entlang der Ausgabezeile einnimmt und zwei Nachkommastellen aufweist, die .2 in F10.2 der FORMAT-Anweisung mit der Bezeichnung 601. ⓘ

C FLÄCHE EINES DREIECKS MIT EINER STANDARD-QUADRATWURZELFUNKTION
C EINGABE - BANDLESEGERÄT 5, GANZZAHLIGE EINGABE
C AUSGABE - ZEILENDRUCKER EINHEIT 6, REELLE AUSGABE
C INPUT ERROR ANZEIGE DES FEHLERAUSGABECODES 1 IN DER AUFLISTUNG DER AUFTRAGSSTEUERUNG
      EINGABEBAND 5, 501, IA, IB, IC LESEN
  FORMAT 501 (3I5)
C IA, IB UND IC DÜRFEN NICHT NEGATIV ODER NULL SEIN
C AUSSERDEM MUSS DIE SUMME VON ZWEI SEITEN EINES DREIECKS
C MUSS GRÖSSER SEIN ALS DIE DRITTE SEITE, ALSO PRÜFEN WIR AUCH DAS
      WENN (IA) 777, 777, 701
  701 WENN (IB) 777, 777, 702
  702 WENN (IC) 777, 777, 703
  703 WENN (IA+IB-IC) 777, 777, 704
  704 WENN (IA+IC-IB) 777, 777, 705
  705 WENN (IB+IC-IA) 777, 777, 799
  777 STOPP 1
C MIT HILFE DER HERONSCHEN FORMEL BERECHNEN WIR DIE
C FLÄCHE DES DREIECKS
  799 S = FLOATF (IA + IB + IC) / 2.0
      FLÄCHE = SQRTF( S * (S - FLOATF(IA)) * (S - FLOATF(IB)) *
     + (S - FLOATF(IC)))
      SCHREIBE AUSGABEBAND 6, 601, IA, IB, IC, FLÄCHE
  601 FORMAT (4H A= ,I5,5H B= ,I5,5H C= ,I5,8H AREA= ,F10.2,
     + 13H QUADRATEINHEITEN)
      STOP
      ENDE <span title="Aus: Englische Wikipedia, Abschnitt &quot;Simple FORTRAN II program&quot;" class="plainlinks">[https://en.wikipedia.org/wiki/Fortran#Simple_FORTRAN_II_program <span style="color:#dddddd">ⓘ</span>]</span>

FORTRAN III

IBM entwickelte 1958 auch ein FORTRAN III, das unter anderem Inline-Assembler-Code ermöglichte; diese Version wurde jedoch nie als Produkt veröffentlicht. Wie FORTRAN 704 und FORTRAN II enthielt auch FORTRAN III maschinenabhängige Funktionen, die es unmöglich machten, den in FORTRAN III geschriebenen Code von Maschine zu Maschine zu übertragen. Frühe Versionen von FORTRAN, die von anderen Herstellern angeboten wurden, litten unter demselben Nachteil. ⓘ

IBM 1401 FORTRAN

FORTRAN wurde für den IBM 1401-Computer durch einen innovativen 63-Phasen-Compiler bereitgestellt, der vollständig in seinem Kernspeicher von nur 8000 (6-Bit) Zeichen lief. Der Compiler konnte vom Band oder von einem 2200er-Kartendeck aus gestartet werden; er benötigte keinen weiteren Band- oder Plattenspeicher. Er behielt das Programm im Speicher und lud Overlays, die es nach und nach in eine ausführbare Form umwandelten, wie von Haines beschrieben. Dieser Artikel wurde in beiden Ausgaben von Anatomy of a Compiler und im IBM-Handbuch "Fortran Specifications and Operating Procedures, IBM 1401" in bearbeiteter Form nachgedruckt. Die ausführbare Form war nicht vollständig Maschinensprache; vielmehr wurden Gleitkommaarithmetik, Subskription, Ein-/Ausgabe und Funktionsreferenzen interpretiert, was dem UCSD Pascal P-Code um zwei Jahrzehnte vorausging. ⓘ

IBM stellte später einen FORTRAN IV-Compiler für die 1400er-Reihe zur Verfügung. ⓘ

FORTRAN IV

IBM begann 1961 mit der Entwicklung von FORTRAN IV, das auf Kundenwünsche zurückging. FORTRAN IV entfernte die maschinenabhängigen Funktionen von FORTRAN II (wie z. B. EINGABEBAND LESEN) und fügte neue Funktionen hinzu, wie z. B. eine LOGISCH Datentyp, logische boolesche Ausdrücke und die logische IF-Anweisung als Alternative zur arithmetischen IF-Anweisung. FORTRAN IV wurde schließlich 1962 veröffentlicht, zunächst für den IBM 7030 ("Stretch") Computer, gefolgt von Versionen für den IBM 7090, IBM 7094 und später für den IBM 1401 im Jahr 1966. ⓘ

Ab 1965 sollte FORTRAN IV mit dem von der American Standards Association X3.4.3 FORTRAN Working Group entwickelten Standard konform sein. ⓘ

Zwischen 1966 und 1968 bot IBM mehrere FORTRAN-IV-Compiler für sein System/360 an, die jeweils mit Buchstaben benannt waren, die die Mindestmenge an Speicher angaben, die der Compiler zur Ausführung benötigte. ⓘ

Die Buchstaben (F, G, H) entsprachen den Codes, die bei den System/360-Modellnummern zur Angabe der Speichergröße verwendet wurden, wobei jeder Buchstabenschritt um einen Faktor zwei größer war:

1966 : FORTRAN IV F für DOS/360 (64K Bytes)
1966 : FORTRAN IV G für OS/360 (128K Bytes)
1968 : FORTRAN IV H für OS/360 (256K Bytes) ⓘ

Digital Equipment Corporation pflegte DECSYSTEM-10 Fortran IV (F40) für PDP-10 von 1967 bis 1975 ⓘ

Ungefähr zu dieser Zeit begann FORTRAN IV, ein wichtiges Werkzeug für die Ausbildung zu werden, und Implementierungen wie WATFOR und WATFIV der University of Waterloo wurden geschaffen, um die komplexen Kompilier- und Verknüpfungsprozesse der früheren Compiler zu vereinfachen. ⓘ

FORTRAN 66

Die vielleicht bedeutendste Entwicklung in der frühen Geschichte von FORTRAN war die Entscheidung der American Standards Association (heute American National Standards Institute (ANSI)), ein von der BEMA, der Business Equipment Manufacturers Association, gesponsertes Komitee zur Entwicklung eines American Standard Fortran zu bilden. Die beiden daraus resultierenden Normen, die im März 1966 verabschiedet wurden, definierten zwei Sprachen, FORTRAN (basierend auf FORTRAN IV, das als De-facto-Standard diente) und Basic FORTRAN (basierend auf FORTRAN II, aber ohne dessen maschinenabhängige Funktionen). Das durch den ersten Standard definierte FORTRAN, das offiziell als X3.9-1966 bezeichnet wurde, wurde als FORTRAN 66 bekannt (obwohl viele es weiterhin als FORTRAN IV bezeichneten, die Sprache, auf der der Standard weitgehend basierte). FORTRAN 66 wurde tatsächlich die erste Industriestandardversion von FORTRAN. FORTRAN 66 enthielt:

Hauptprogramm, SUBROUTINE, FUNCTIONund BLOCKDATEN Programmeinheiten
INTEGER, REAL, DOPPELTE GENAUIGKEIT, COMPLEXund LOGISCH Datentypen
GEMEINSAM, DIMENSIONund EQUIVALENCE Anweisungen
DATA Anweisung zur Angabe von Anfangswerten
Intrinsisch und EXTERN (z.B. Bibliotheks-) Funktionen
Zuweisungsanweisung
GO TO, berechnete GO TO, zugewiesen GO TOund ASSIGN Anweisungen
Logisch IF und arithmetische (dreifache) IF Anweisungen
DO Schleifenanweisung
LESEN, SCHREIBEN, ZURÜCK SPRINGEN, ZURÜCKSPULENund ENDFILE Anweisungen für sequentielle E/A
FORMAT Anweisung und zugewiesenes Format
CALL, RETURN, PAUSEund STOPP Anweisungen
Hollerith-Konstanten in DATA und FORMAT Anweisungen und als Argumente für Prozeduren
Bezeichner mit einer Länge von bis zu sechs Zeichen
Kommentarzeilen
END Zeile ⓘ

FORTRAN 77

FORTRAN-77-Programm mit Compiler-Ausgabe, geschrieben auf einem CDC 175 an der RWTH Aachen, Deutschland, 1987 ⓘ

4.3 BSD für die Digital Equipment Corporation (DEC) VAX, zeigt das Handbuch für den FORTRAN 77 (f77) Compiler an ⓘ

Nach der Veröffentlichung des FORTRAN 66-Standards führten Compiler-Hersteller mehrere Erweiterungen des Standard-Fortran ein, was das ANSI-Komitee X3J3 1969 dazu veranlasste, unter der Schirmherrschaft der CBEMA, der Computer Business Equipment Manufacturers Association (früher BEMA), mit der Überarbeitung des Standards von 1966 zu beginnen. Die endgültigen Entwürfe dieses überarbeiteten Standards wurden 1977 in Umlauf gebracht, was zur offiziellen Annahme des neuen FORTRAN-Standards im April 1978 führte. Der neue Standard, FORTRAN 77 genannt und offiziell als X3.9-1978 bezeichnet, fügte eine Reihe wichtiger Funktionen hinzu, um viele der Unzulänglichkeiten von FORTRAN 66 zu beheben:

Block . IF und END IF Anweisungen, mit optionalen ELSE und ELSE IF Klauseln, um eine verbesserte Sprachunterstützung für strukturierte Programmierung zu bieten
DO Schleifenerweiterungen, einschließlich Parameterausdrücke, negative Inkremente und Null-Auslöserzählungen
ÖFFNEN, SCHLIESSENund INQUIRE Anweisungen für verbesserte E/A-Fähigkeit
Direktzugriff auf Datei-E/A
IMPLICIT Anweisung, um die implizite Konvention außer Kraft zu setzen, dass nicht deklarierte Variablen INTEGER sind, wenn ihr Name mit I, J, K, L, M oder N beginnt (und ansonsten REAL)
CHARAKTER Datentyp, der Hollerith-Strings durch erheblich erweiterte Möglichkeiten zur Zeicheneingabe und -ausgabe sowie zur Verarbeitung zeichenbasierter Daten ersetzt
PARAMETER Anweisung zur Angabe von Konstanten
SAVE Anweisung für persistente lokale Variablen
Generische Namen für intrinsische Funktionen (z.B. SQRT akzeptiert auch Argumente anderer Typen, wie COMPLEX oder REAL*16).
Eine Reihe von intrinsischen Funktionen (LGE, LGT, LLE, LLT) für den lexikalischen Vergleich von Zeichenketten, basierend auf der ASCII-Kollationierungssequenz. (Diese ASCII-Funktionen wurden vom US-Verteidigungsministerium in seinem bedingten Genehmigungsvotum gefordert.) ⓘ

Bei dieser Überarbeitung des Standards wurde eine Reihe von Funktionen entfernt oder in einer Weise geändert, die zuvor standardkonforme Programme ungültig machen könnte. (Die Entfernung war damals die einzige zulässige Alternative zu X3J3, da das Konzept der "Verwerfung" für ANSI-Normen noch nicht zur Verfügung stand.) Während die meisten der 24 Punkte in der Konfliktliste (siehe Anhang A2 von X3.9-1978) Schlupflöcher oder pathologische Fälle betrafen, die in der vorherigen Norm erlaubt waren, aber nur selten verwendet wurden, wurde eine kleine Anzahl spezifischer Fähigkeiten absichtlich entfernt, wie z. B.:

Hollerith-Konstanten und Hollerith-Daten, wie z. B. GRÜSSEN = 12HHALLO!
Einlesen eines H-Edit (Hollerith-Feld)-Deskriptors in einer FORMAT-Spezifikation
Überindizierung von Array-Grenzen durch tiefgestellte Indizes
```
      DIMENSION A(10,5)
      Y= A(11,1)
```
Übertragung der Kontrolle aus dem und zurück in den Bereich einer DO-Schleife (auch bekannt als "Extended Range") ⓘ

Übergang zum ANSI-Standard Fortran

Die Entwicklung eines überarbeiteten Standards als Nachfolger von FORTRAN 77 wurde immer wieder verschoben, da der Standardisierungsprozess mit den raschen Veränderungen in der Computer- und Programmierpraxis nicht Schritt halten konnte. In der Zwischenzeit wurde FORTRAN 77 als "Standard FORTRAN" für fast fünfzehn Jahre zum historisch wichtigsten Dialekt. ⓘ

Eine wichtige praktische Erweiterung von FORTRAN 77 war die Veröffentlichung von MIL-STD-1753 im Jahr 1978. Diese vom US-Verteidigungsministerium entwickelte Spezifikation standardisierte eine Reihe von Funktionen, die von den meisten FORTRAN 77-Compilern implementiert, aber nicht in den ANSI FORTRAN 77-Standard aufgenommen wurden. Diese Funktionen wurden schließlich in den Fortran 90-Standard aufgenommen. ⓘ

DO WHILE, EXIT, CYCLEund END DO Anweisungen
INCLUDE Anweisung
IMPLICIT NONE Variante der IMPLICIT Anweisung
Bitmanipulations-Eigenfunktionen, die auf ähnlichen Funktionen in Industrial Real-Time Fortran (ANSI/ISA S61.1 (1976)) basieren. ⓘ

Der IEEE 1003.9 POSIX-Standard, der 1991 veröffentlicht wurde, bot FORTRAN 77-Programmierern eine einfache Möglichkeit, POSIX-Systemaufrufe zu tätigen. In dem Dokument wurden über 100 Aufrufe definiert, die einen portablen Zugriff auf POSIX-kompatible Prozesssteuerung, Signalverarbeitung, Dateisystemsteuerung, Gerätesteuerung, Prozedurenzuweisung und Stream I/O ermöglichen. ⓘ

Fortran 90

Der lange verzögerte Nachfolger von FORTRAN 77, der informell als Fortran 90 (und davor als Fortran 8X) bekannt ist, wurde schließlich 1991 als ISO/IEC-Standard 1539:1991 und 1992 als ANSI-Standard veröffentlicht. Neben der Änderung der offiziellen Schreibweise von FORTRAN zu Fortran wurden bei dieser umfassenden Überarbeitung viele neue Funktionen hinzugefügt, um den bedeutenden Änderungen in der Programmierpraxis Rechnung zu tragen, die sich seit dem Standard von 1978 entwickelt hatten:

Bei der Eingabe von Quelltexten in freier Form mussten die ersten sechs Zeichenpositionen vor der Eingabe von Anweisungen nicht mehr übersprungen werden.
Fortran-Schlüsselwörter in Kleinbuchstaben
Bezeichner mit einer Länge von bis zu 31 Zeichen (im vorherigen Standard waren es nur sechs Zeichen).
Inline-Kommentare
Die Möglichkeit, auf Arrays (oder Array-Abschnitten) als Ganzes zu operieren, was mathematische und technische Berechnungen erheblich vereinfacht.
- Ganze, partielle und maskierte Array-Zuweisungsanweisungen und Array-Ausdrücke, wie z. B. X(1:N)=R(1:N)*COS(A(1:N))
- WHERE Anweisung für selektive Array-Zuweisung
- Array-bewertete Konstanten und Ausdrücke,
- benutzerdefinierte array-bewertete Funktionen und Array-Konstruktoren.
RECURSIVE Prozeduren
Module, um zusammengehörige Prozeduren und Daten zu gruppieren und sie anderen Programmeinheiten zur Verfügung zu stellen, einschließlich der Möglichkeit, den Zugriff auf nur bestimmte Teile des Moduls zu beschränken.
Ein stark verbesserter Mechanismus für die Weitergabe von Argumenten, der es ermöglicht, Schnittstellen zur Kompilierzeit zu überprüfen
Benutzerdefinierte Schnittstellen für generische Prozeduren
Überladen von Operatoren
Abgeleitete (strukturierte) Datentypen
Neue Syntax für die Deklaration von Datentypen, um den Datentyp und andere Attribute von Variablen anzugeben
Dynamische Speicherzuweisung mit Hilfe der ALLOCATABLE Attributs und des ALLOCATE und DEALLOCATE Anweisungen
POINTER Attribut, Zeigerzuweisung und NULLIFY Anweisung zur Erleichterung der Erstellung und Manipulation von dynamischen Datenstrukturen
Strukturierte Schleifenkonstrukte, mit einer END DO Anweisung für die Beendigung von Schleifen und EXIT und CYCLE Anweisungen zur Beendigung normaler DO Schleifeniterationen in geordneter Weise
SELECT . . . CASE Konstrukt für die mehrstufige Auswahl
Portable Spezifikation der numerischen Genauigkeit unter der Kontrolle des Benutzers
Neue und verbesserte intrinsische Prozeduren. ⓘ

Veralterung und Streichungen

Anders als bei der vorherigen Revision wurden in Fortran 90 keine Funktionen entfernt. Jedes standardkonforme FORTRAN 77-Programm war auch unter Fortran 90 standardkonform, und beide Standards hätten zur Definition des Verhaltens verwendet werden können. ⓘ

Eine kleine Anzahl von Funktionen wurde als "veraltet" eingestuft und sollte in einem zukünftigen Standard entfernt werden. Alle Funktionalitäten dieser frühen Versionen können von neueren Fortran-Funktionen übernommen werden. Einige werden beibehalten, um die Portierung alter Programme zu vereinfachen, aber viele wurden in Fortran 95 gestrichen. ⓘ

Obsoleszenz und Löschungen ⓘ
Veraltetes Merkmal	Aktueller Status
Arithmetische IF-Anweisung	Gelöscht
Nicht-ganzzahlige DO-Parameter oder Kontrollvariablen	Gelöscht
Gemeinsame Beendigung der DO-Schleife oder Beendigung mit einer anderen Anweisung als END DO oder CONTINUE	Gelöscht
Verzweigung zu END IF von außerhalb eines Blocks	Gelöscht
Alternativer Rücksprung	Veraltet
PAUSE-Anweisung	Gelöscht
ASSIGN-Anweisung und zugewiesene GO TO-Anweisung	Gelöscht
Zugewiesene Anweisungsnummern und FORMAT-Spezifizierer	Gelöscht
H Edit-Deskriptoren	Gelöscht
Berechnete GO TO-Anweisung	Veraltet
Anweisungsfunktionen	Veraltet
DATA-Anweisungen zwischen ausführbaren Anweisungen	Veraltet
CHARACTER*-Form der CHARACTER-Deklaration	Veraltet
Angenommene Zeichenlängenfunktionen	Veraltet
Quellcode in fester Form	Veraltet

"Beispiel "Hallo, Welt!

Programm helloworld
     print *, "Hallo, Welt!"
Ende Programm helloworld <span title="Aus: Englische Wikipedia, Abschnitt &quot;&quot;Hello, World!&quot; example&quot;" class="plainlinks">[https://en.wikipedia.org/wiki/Fortran#&quot;Hello,_World!&quot;_example <span style="color:#dddddd">ⓘ</span>]</span>

Fortran 95

Fortran 95, das offiziell als ISO/IEC 1539-1:1997 veröffentlicht wurde, war eine geringfügige Überarbeitung, die hauptsächlich darauf abzielte, einige noch offene Probleme des Fortran 90-Standards zu lösen. Dennoch fügte Fortran 95 auch eine Reihe von Erweiterungen hinzu, insbesondere aus der High Performance Fortran Spezifikation:

FORALL und verschachtelte WHERE Konstrukte zur Unterstützung der Vektorisierung
Benutzerdefinierte PURE und ELEMENTAL Prozeduren
Standardinitialisierung von abgeleiteten Typkomponenten, einschließlich Zeigerinitialisierung
Erweiterung der Möglichkeit, Initialisierungsausdrücke für Datenobjekte zu verwenden
Initialisierung von Zeigern auf NULL()
Eindeutige Definition, dass ALLOCATABLE Arrays automatisch deallokiert werden, wenn sie aus dem Anwendungsbereich herausgehen. ⓘ

Eine Reihe von intrinsischen Funktionen wurde erweitert (zum Beispiel eine dim Argument zu der Funktion maxloc hinzugefügt). ⓘ

Mehrere Funktionen, die in Fortran 90 als "veraltet" bezeichnet wurden, wurden in Fortran 95 entfernt:

DO Anweisungen, die REAL und DOPPELTE GENAUIGKEIT Index-Variablen
Verzweigung zu einer END IF Anweisung von außerhalb ihres Blocks
PAUSE Anweisung
ASSIGN und zugewiesene GO TO Anweisung und zugewiesene Formatspezifizierer
H Hollerith Edit Deskriptor. ⓘ

Eine wichtige Ergänzung zu Fortran 95 war der ISO Technical Report TR-15581: Enhanced Data Type Facilities, informell bekannt als Allocatable TR. Diese Spezifikation definierte die erweiterte Verwendung von ALLOCATABLE Arrays, noch bevor Fortran 2003-kompatible Fortran-Compiler verfügbar waren. Solche Verwendungen umfassen ALLOCATABLE Arrays als abgeleitete Typkomponenten, in Prozedur-Dummy-Argumentlisten und als Funktionsrückgabewerte. (ALLOCATABLE Arrays sind vorzuziehen gegenüber POINTER-basierten Arrays vorzuziehen, da ALLOCATABLE Arrays von Fortran 95 garantiert werden, dass sie automatisch freigegeben werden, wenn sie den Gültigkeitsbereich verlassen, wodurch die Möglichkeit von Speicherverlusten ausgeschlossen wird. Darüber hinaus sind die Elemente von zuweisbaren Arrays zusammenhängend, und Aliasing ist kein Problem für die Optimierung von Array-Referenzen, so dass Compiler schnelleren Code erzeugen können als im Fall von Zeigern). ⓘ

Eine weitere wichtige Ergänzung zu Fortran 95 war der ISO Technical Report TR-15580: Floating-point exception handling, informell bekannt als IEEE TR. Diese Spezifikation definierte die Unterstützung für die IEEE-Gleitkomma-Arithmetik und die Behandlung von Gleitkomma-Ausnahmen. ⓘ

Bedingte Kompilierung und Strings unterschiedlicher Länge

Neben der obligatorischen "Basissprache" (definiert in ISO/IEC 1539-1 : 1997) enthält die Sprache Fortran 95 auch zwei optionale Module:

Zeichenketten mit variabler Länge (ISO/IEC 1539-2 : 2000)
Bedingte Kompilierung (ISO/IEC 1539-3 : 1998)

die zusammen den mehrteiligen internationalen Standard (ISO/IEC 1539) bilden. ⓘ

Den Entwicklern der Norm zufolge "beschreiben die optionalen Teile in sich geschlossene Funktionen, die von einer beträchtlichen Anzahl von Anwendern und/oder Implementierern gefordert wurden, die aber nicht als so allgemein angesehen werden, dass sie in allen standardkonformen Fortran-Compilern erforderlich sind." Wenn jedoch ein standardkonformer Fortran-Compiler solche Optionen bereitstellt, dann "müssen sie in Übereinstimmung mit der Beschreibung dieser Einrichtungen im entsprechenden Teil des Standards bereitgestellt werden". ⓘ

Modernes Fortran

Jahrhundert definierte Sprache, insbesondere wegen der Einbeziehung der objektorientierten Programmierung und später des Coarray Fortran, wird oft als "Modern Fortran" bezeichnet, und der Begriff wird in der Literatur zunehmend verwendet. ⓘ

Fortran 2003

Fortran 2003, offiziell veröffentlicht als ISO/IEC 1539-1:2004, ist eine umfassende Überarbeitung, die viele neue Funktionen einführt. Eine umfassende Zusammenfassung der neuen Funktionen von Fortran 2003 ist auf der offiziellen Website der Fortran Working Group (ISO/IEC JTC1/SC22/WG5) verfügbar. ⓘ

Aus diesem Artikel geht hervor, dass die wichtigsten Verbesserungen in dieser Revision folgende sind:

Verbesserungen bei abgeleiteten Typen: parametrisierte abgeleitete Typen, verbesserte Kontrolle der Zugänglichkeit, verbesserte Strukturkonstruktoren und Finalisierer
Unterstützung der objektorientierten Programmierung: Typerweiterung und Vererbung, Polymorphismus, dynamische Typzuweisung und typgebundene Prozeduren, die eine vollständige Unterstützung für abstrakte Datentypen bieten
Verbesserungen bei der Datenmanipulation: zuweisbare Komponenten (unter Einbeziehung von TR 15581), verzögerte Typparameter, VOLATILE Attribut, explizite Typspezifikation in Array-Konstruktoren und allocate-Anweisungen, Zeigerverbesserungen, erweiterte Initialisierungsausdrücke und verbesserte intrinsische Prozeduren
Verbesserungen bei der Ein-/Ausgabe: asynchrone Übertragung, Stream-Zugriff, benutzerspezifische Übertragungsoperationen für abgeleitete Typen, benutzerspezifische Kontrolle der Rundung bei Formatkonvertierungen, benannte Konstanten für vorverbundene Einheiten, die FLUSH Anweisung, Regularisierung von Schlüsselwörtern und Zugriff auf Fehlermeldungen
Prozedur-Zeiger
Unterstützung für IEEE-Gleitkomma-Arithmetik und Behandlung von Gleitkomma-Ausnahmen (unter Einbeziehung von TR 15580)
Interoperabilität mit der Programmiersprache C
Unterstützung für internationale Verwendung: Zugriff auf ISO 10646 4-Byte-Zeichen und Wahl zwischen Dezimalzeichen und Komma bei numerisch formatierter Ein-/Ausgabe
Verbesserte Integration mit dem Host-Betriebssystem: Zugriff auf Befehlszeilenargumente, Umgebungsvariablen und Prozessorfehlermeldungen ⓘ

Eine wichtige Ergänzung zu Fortran 2003 war der ISO Technical Report TR-19767: Enhanced module facilities in Fortran. Dieser Bericht stellte Untermodule zur Verfügung, die Fortran-Module den Modula-2-Modulen ähnlicher machen. Sie sind vergleichbar mit den privaten Untereinheiten von Ada. Dies ermöglicht es, die Spezifikation und Implementierung eines Moduls in separaten Programmeinheiten auszudrücken, was die Paketierung großer Bibliotheken verbessert, die Wahrung von Geschäftsgeheimnissen bei gleichzeitiger Veröffentlichung endgültiger Schnittstellen ermöglicht und Kompilierungskaskaden verhindert. ⓘ

Fortran 2008

ISO/IEC 1539-1:2010, informell bekannt als Fortran 2008, wurde im September 2010 verabschiedet. Wie bei Fortran 95 handelt es sich um eine geringfügige Aktualisierung, die Klarstellungen und Korrekturen zu Fortran 2003 enthält sowie einige neue Funktionen einführt. Zu den neuen Funktionen gehören:

Sub-Module - zusätzliche Strukturierungsmöglichkeiten für Module; ersetzt ISO/IEC TR 19767:2005
Coarray Fortran - ein paralleles Ausführungsmodell
Das DO CONCURRENT-Konstrukt - für Schleifenwiederholungen ohne Abhängigkeiten
Das CONTIGUOUS-Attribut - zur Angabe von Speicherlayout-Beschränkungen
Das BLOCK-Konstrukt - kann Deklarationen von Objekten mit Konstruktionsumfang enthalten
Rekursive zuweisbare Komponenten - als Alternative zu rekursiven Zeigern in abgeleiteten Typen ⓘ

Der Final Draft International Standard (FDIS) ist als Dokument N1830 verfügbar. ⓘ

Eine Ergänzung zu Fortran 2008 ist die International Organization for Standardization (ISO) Technical Specification (TS) 29113 on Further Interoperability of Fortran with C, die der ISO im Mai 2012 zur Genehmigung vorgelegt wurde. Die Spezifikation fügt Unterstützung für den Zugriff auf den Array-Deskriptor von C aus hinzu und ermöglicht das Ignorieren von Typ und Rang der Argumente. ⓘ

Fortran 2018

Die neueste Revision der Sprache (Fortran 2018) wurde früher als Fortran 2015 bezeichnet. Sie ist eine bedeutende Überarbeitung und wurde am 28. November 2018 veröffentlicht. ⓘ

Fortran 2018 enthält zwei zuvor veröffentlichte Technische Spezifikationen:

ISO/IEC TS 29113:2012 Weitere Interoperabilität mit C
ISO/IEC TS 18508:2015 Zusätzliche parallele Funktionen in Fortran ⓘ

Zu den zusätzlichen Änderungen und neuen Funktionen gehören die Unterstützung von ISO/IEC/IEEE 60559:2011 (die Version des IEEE-Fließkommastandards vor der neuesten Nebenrevision IEEE 754-2019), hexadezimale Ein-/Ausgabe, IMPLICIT NONE-Erweiterungen und andere Änderungen. ⓘ

Sprachfunktionen

Eine ausführliche Beschreibung der mit Fortran 95 eingeführten Fortran-Sprachfunktionen finden Sie im zugehörigen Artikel Fortran 95 Sprachfunktionen. Die durch spätere Standards definierten Sprachversionen werden oft als "Modern Fortran" bezeichnet und sind in der Literatur beschrieben. ⓘ

Wissenschaft und Technik

Allgemeine relativistische magnetohydrodynamische Fortran-Simulation der Akkretion von Schwarzen Löchern unter Verwendung des BHAC-Codes mit kartesischem adaptivem Netz (www.bhac.science). ⓘ

Geschwindigkeit und Meeresoberflächentemperatur in den Ozeanen, berechnet mit dem Fortran-Code NEMO (Nucleus for European Modelling of the Ocean, https://www.nemo-ocean.eu) im Barcelona Supercomputing Center (2020). ⓘ

Obwohl FORTRAN bereits 1968 in einem Zeitschriftenartikel der BASIC-Autoren als "altmodisch" bezeichnet wurde, werden ab 2022 seit mehr als sechs Jahrzehnten Programme in Fortran geschrieben, und es gibt eine große Anzahl von Fortran-Software, die täglich in wissenschaftlichen und technischen Kreisen verwendet wird. Jay Pasachoff schrieb 1984, dass "Physik- und Astronomiestudenten einfach FORTRAN lernen müssen. Es gibt so viel in FORTRAN, dass es unwahrscheinlich erscheint, dass Wissenschaftler zu Pascal, Modula-2 oder was auch immer wechseln werden." 1993 bezeichnete Cecil E. Leith FORTRAN als "Muttersprache des wissenschaftlichen Rechnens" und fügte hinzu, dass seine Ersetzung durch eine andere mögliche Sprache "eine vergebliche Hoffnung" bleiben könnte. ⓘ

FORTRAN ist die primäre Sprache für einige der intensivsten Supercomputing-Aufgaben, z. B. in der Astronomie, der Klimamodellierung, der computergestützten Chemie, der computergestützten Wirtschaft, der computergestützten Strömungsdynamik, der computergestützten Physik, der Datenanalyse, der hydrologischen Modellierung, der numerischen linearen Algebra und der numerischen Bibliotheken (LAPACK, IMSL und NAG), der Optimierung, der Satellitensimulation, dem Bauwesen und der Wettervorhersage. Viele der Fließkomma-Benchmarks, mit denen die Leistung neuer Computerprozessoren gemessen wird, wie z. B. die Fließkomma-Komponenten der SPEC-Benchmarks (z. B. CFP2006, CFP2017), sind in Fortran geschrieben. Die mathematischen Algorithmen sind in Numerical Recipes gut dokumentiert. ⓘ

Abgesehen davon verwenden modernere Codes in den Computerwissenschaften in der Regel große Programmbibliotheken wie METIS für die Graphenpartitionierung, PETSc oder Trilinos für lineare Algebra-Funktionen, deal.II oder FEniCS für die Unterstützung von Gitternetzen und finiten Elementen sowie andere generische Bibliotheken. Seit Anfang der 2000er Jahre sind viele der weit verbreiteten Bibliotheken auch in C und neuerdings auch in C++ implementiert worden. Andererseits haben sich Hochsprachen wie MATLAB, Python und R in bestimmten Bereichen der Computerwissenschaften durchgesetzt. Folglich wird ein wachsender Anteil wissenschaftlicher Programme auch in solchen höheren Skriptsprachen geschrieben. Aus diesem Grund wurden in Fortran 2003 Möglichkeiten zur Zusammenarbeit mit C hinzugefügt und durch die technische Spezifikation ISO/IEC 29113 erweitert, die in Fortran 2018 aufgenommen wurde, um eine flexiblere Zusammenarbeit mit anderen Programmiersprachen zu ermöglichen. ⓘ

Die Software für die NASA-Sonden Voyager 1 und Voyager 2 wurde ursprünglich in FORTRAN 5 geschrieben und später auf FORTRAN 77 portiert. Seit dem 25. September 2013 ist ein Teil der Software immer noch in Fortran geschrieben und ein Teil wurde nach C portiert. ⓘ

Portabilität

Die Portabilität war in den Anfängen ein Problem, da es keinen einheitlichen Standard gab - nicht einmal das Referenzhandbuch von IBM - und die Computerfirmen darum wetteiferten, ihre Angebote durch inkompatible Funktionen von anderen zu unterscheiden. Standards haben die Portabilität verbessert. Die Norm von 1966 enthielt eine Referenzsyntax und -semantik, aber die Anbieter boten weiterhin inkompatible Erweiterungen an. Obwohl vorsichtige Programmierer erkannten, dass die Verwendung inkompatibler Erweiterungen teure Portabilitätsprobleme verursachte, und deshalb Programme wie The PFORT Verifier einsetzten, wurden erst nach dem Standard von 1977, als das National Bureau of Standards (jetzt NIST) FIPS PUB 69 veröffentlichte, Prozessoren, die von der US-Regierung gekauft wurden, verpflichtet, Erweiterungen des Standards zu diagnostizieren. Anstatt zwei Prozessoren anzubieten, verfügte schließlich praktisch jeder Compiler zumindest über eine Option zur Diagnose von Erweiterungen. ⓘ

Inkompatible Erweiterungen waren nicht das einzige Portabilitätsproblem. Bei numerischen Berechnungen ist es wichtig, die Eigenschaften der Arithmetik zu berücksichtigen. Dies wurde von Fox et al. im Zusammenhang mit dem Standard von 1966 durch die PORT-Bibliothek in Angriff genommen. Die darin enthaltenen Ideen fanden weite Verbreitung und wurden schließlich in die Norm von 1990 in Form von intrinsischen Abfragefunktionen aufgenommen. Die weit verbreitete (und inzwischen fast universelle) Annahme des IEEE 754-Standards für binäre Gleitkomma-Arithmetik hat dieses Problem im Wesentlichen beseitigt. ⓘ

Der Zugriff auf die Computerumgebung (z. B. die Befehlszeile des Programms, Umgebungsvariablen, textuelle Erklärungen von Fehlerzuständen) blieb ein Problem, bis es in der Norm von 2003 gelöst wurde. ⓘ

Große Sammlungen von Bibliothekssoftware, die man als lose verwandt mit technischen und wissenschaftlichen Berechnungen bezeichnen könnte, wie z. B. Grafikbibliotheken, wurden in C geschrieben, so dass der Zugang zu ihnen ein Portabilitätsproblem darstellte. Diesem Problem wurde durch die Aufnahme der C-Interoperabilität in die Norm 2003 begegnet. ⓘ

Es ist nun möglich (und relativ einfach), ein vollständig portierbares Programm in Fortran zu schreiben, sogar ohne Rückgriff auf einen Präprozessor. ⓘ

Veraltete Varianten

Bis zur Entwicklung des Fortran 66-Standards unterstützte jeder Compiler seine eigene Variante von Fortran. Einige davon wichen stärker vom Mainstream ab als andere. ⓘ

Der erste Fortran-Compiler setzte einen hohen Standard für die Effizienz des kompilierten Codes. Dieses Ziel machte es schwierig, einen Compiler zu entwickeln, so dass dies in der Regel von den Computerherstellern übernommen wurde, um den Verkauf der Hardware zu unterstützen. So blieb eine wichtige Nische übrig: Compiler, die schnell waren und dem Programmierer (oft einem Studenten) gute Diagnosen boten. Beispiele hierfür sind Watfor, Watfiv, PUFFT und in kleinerem Maßstab FORGO, Wits Fortran und Kingston Fortran 2. ⓘ

Fortran 5 wurde von der Data General Corp. in den späten 1970er und frühen 1980er Jahren für die Nova-, Eclipse- und MV-Reihe von Computern vermarktet. Sie verfügte über einen optimierenden Compiler, der für damalige Minicomputer recht gut war. Die Sprache ähnelt am ehesten FORTRAN 66. ⓘ

FORTRAN V wurde 1968 von der Control Data Corporation für die CDC 6600-Serie vertrieben. Die Sprache basierte auf FORTRAN IV. ⓘ

Univac bot auch einen Compiler für die 1100er Serie an, der als FORTRAN V bekannt war. Ein Ableger von Univac Fortran V war Athena FORTRAN. ⓘ

Spezielle Varianten, die von den Anbietern wissenschaftlicher Hochleistungsrechner (z. B. Burroughs, Control Data Corporation (CDC), Cray, Honeywell, IBM, Texas Instruments und UNIVAC) produziert wurden, erweiterten Fortran, um spezielle Hardwarefunktionen wie Befehlscache, CPU-Pipelines und Vektorarrays zu nutzen. So verfügte beispielsweise einer der FORTRAN-Compiler von IBM (H Extended IUP) über eine Optimierungsstufe, die die Maschinencode-Anweisungen neu ordnete, um mehrere interne Recheneinheiten gleichzeitig zu beschäftigen. Ein weiteres Beispiel ist CFD, eine spezielle Variante von FORTRAN, die speziell für den Supercomputer ILLIAC IV im Ames Research Center der NASA entwickelt wurde. IBM Research Labs entwickelte auch eine erweiterte FORTRAN-basierte Sprache namens VECTRAN für die Verarbeitung von Vektoren und Matrizen. ⓘ

Object-Oriented Fortran war eine objektorientierte Erweiterung von Fortran, in der Daten in Objekten gruppiert werden können, die instanziiert und parallel ausgeführt werden können. Sie war für Sun, Iris, iPSC und nCUBE verfügbar, wird aber nicht mehr unterstützt. ⓘ

Solche maschinenspezifischen Erweiterungen sind entweder im Laufe der Zeit verschwunden oder es wurden Elemente in die Hauptstandards aufgenommen. Die wichtigste verbleibende Erweiterung ist OpenMP, eine plattformübergreifende Erweiterung für die Programmierung mit gemeinsamem Speicher. Eine neue Erweiterung, Coarray Fortran, ist für die Unterstützung der parallelen Programmierung gedacht. ⓘ

FOR TRANSIT war der Name einer reduzierten Version der IBM 704 FORTRAN-Sprache, die mit Hilfe eines in Carnegie Ende der 1950er Jahre entwickelten Übersetzungsprogramms für die IBM 650 implementiert wurde. in den späten 1950er Jahren in Carnegie entwickelt wurde. Der folgende Kommentar erscheint im IBM-Referenzhandbuch (FOR TRANSIT Automatic Coding System C28-4038, Copyright 1957, 1959 by IBM):

Das FORTRAN-System wurde für eine komplexere Maschine als die 650 entwickelt, und folglich sind einige der 32 Anweisungen, die im FORTRAN Programmer's Reference Manual zu finden sind, für das FOR TRANSIT-System nicht akzeptabel. Darüber hinaus wurden bestimmte Einschränkungen der FORTRAN-Sprache hinzugefügt. Keine dieser Einschränkungen führt jedoch dazu, dass ein für FOR TRANSIT geschriebenes Quellprogramm nicht mit dem FORTRAN-System für die 704 kompatibel ist. ⓘ

Die zulässigen Anweisungen waren:

Arithmetische Zuweisungsanweisungen, z.B. a = b
GO bis n
GO TO (n₁, n₂, ..., n_m), i
IF (a) n₁, n₂, n₃
PAUSE
STOPP
DO n i = m1, m2
FORTSETZEN
END
READ n, Liste
PUNCH n, Liste
DIMENSION V, V, V, ...
EQUIVALENZ (a,b,c), (d,c), ... [https://en.wikipedia.org/wiki/Fortran#Obsolete_variants ⓘ]

Es konnten bis zu zehn Unterprogramme in einem Programm verwendet werden. ⓘ

FOR TRANSIT-Anweisungen waren nur auf die Spalten 7 bis 56 beschränkt. Für die Eingabe und Ausgabe auf der IBM 650 wurden Lochkarten verwendet. Es waren drei Durchgänge erforderlich, um den Quellcode in die "IT"-Sprache zu übersetzen, dann die IT-Anweisungen in SOAP-Assemblersprache zu kompilieren und schließlich das Objektprogramm zu erstellen, das dann in die Maschine geladen werden konnte, um das Programm auszuführen (unter Verwendung von Lochkarten für die Dateneingabe und die Ausgabe der Ergebnisse auf Lochkarten). ⓘ

Für den 650s mit 2000-Wort-Speichertrommel gab es zwei Versionen: FOR TRANSIT I (S) und FOR TRANSIT II, letztere für Maschinen, die mit Indexierungsregistern und automatischer Gleitkomma-Dezimalarithmetik (bi-quinär) ausgestattet waren. Anhang A des Handbuchs enthielt Schaltpläne für das Bedienfeld des Kartenlesers/Stanzers IBM 533. ⓘ

Fortran-basierte Sprachen

Vor FORTRAN 77 wurden üblicherweise eine Reihe von Präprozessoren verwendet, um eine benutzerfreundlichere Sprache zu schaffen, mit dem Vorteil, dass der vorverarbeitete Code auf jeder Maschine mit einem Standard-FORTRAN-Compiler kompiliert werden konnte. Diese Präprozessoren unterstützen in der Regel strukturierte Programmierung, Variablennamen mit mehr als sechs Zeichen, zusätzliche Datentypen, bedingte Kompilierung und sogar Makrofunktionen. Beliebte Präprozessoren waren FLECS, iftran, MORTRAN, SFtran, S-Fortran, Ratfor und Ratfiv. Ratfor und Ratfiv zum Beispiel implementierten eine C-ähnliche Sprache, die vorverarbeiteten Code im Standard FORTRAN 66 ausgab. Trotz der Fortschritte in der Fortran-Sprache werden Präprozessoren weiterhin für die bedingte Kompilierung und Makro-Substitution verwendet. ⓘ

Eine der frühesten Versionen von FORTRAN, die in den 60er Jahren eingeführt wurde, wurde häufig an Hochschulen und Universitäten verwendet. WATFOR wurde von der University of Waterloo entwickelt, unterstützt und vertrieben und basierte weitgehend auf FORTRAN IV. Ein Student, der WATFOR benutzte, konnte seine FORTRAN-Stapelverarbeitung einreichen, und wenn keine Syntaxfehler auftraten, wurde das Programm direkt ausgeführt. Diese Vereinfachung ermöglichte es den Studenten, sich auf die Syntax und Semantik ihres Programms oder den logischen Ablauf der Ausführung zu konzentrieren, anstatt sich mit der Job Control Language (JCL), den aufeinanderfolgenden Prozessen Kompilieren/Link-Editieren/Ausführen oder anderen komplexen Aspekten der Mainframe-/Minicomputer-Umgebung zu beschäftigen. Ein Nachteil dieser vereinfachten Umgebung war, dass WATFOR keine gute Wahl für Programmierer war, die die erweiterten Fähigkeiten ihrer Host-Prozessoren benötigten, z. B. hatte WATFOR typischerweise nur sehr begrenzten Zugriff auf E/A-Geräte. WATFOR wurde durch WATFIV und seine späteren Versionen abgelöst. ⓘ

program; s=0 i=1,n; s=s+1; stop i; s='s' Stop

(Zeilenprogrammierung) ⓘ

LRLTRAN wurde am Lawrence Radiation Laboratory entwickelt, um neben anderen Erweiterungen zur Unterstützung der Systemprogrammierung auch Vektorarithmetik und dynamische Speicherung zu ermöglichen. Die Distribution enthielt das LTSS-Betriebssystem. ⓘ

Der Fortran-95-Standard enthält einen optionalen Teil 3, der eine optionale Fähigkeit zur bedingten Kompilierung definiert. Diese Fähigkeit wird oft als "CoCo" bezeichnet. ⓘ

Viele Fortran-Compiler haben Teilmengen des C-Präprozessors in ihre Systeme integriert. ⓘ

SIMSCRIPT ist ein anwendungsspezifischer Fortran-Präprozessor für die Modellierung und Simulation großer diskreter Systeme. ⓘ

Die F-Programmiersprache wurde als saubere Untermenge von Fortran 95 entwickelt, die versucht, die redundanten, unstrukturierten und veralteten Funktionen von Fortran zu entfernen, wie z. B. die EQUIVALENCE Anweisung. F behält die in Fortran 90 hinzugefügten Array-Funktionen bei und entfernt Steueranweisungen, die durch strukturierte Programmierkonstrukte, die sowohl in FORTRAN 77 als auch in Fortran 90 hinzugefügt wurden, obsolet wurden. F wird von seinen Schöpfern als "eine kompilierte, strukturierte Array-Programmiersprache, die sich besonders gut für die Ausbildung und das wissenschaftliche Rechnen eignet" beschrieben. Essential Lahey Fortran 90 (ELF90) war eine ähnliche Untermenge. ⓘ

Lahey und Fujitsu haben sich zusammengetan, um Fortran für das Microsoft .NET Framework zu entwickeln. Silverfrost FTN95 ist ebenfalls in der Lage, .NET-Code zu erstellen. ⓘ

Code-Beispiele

Das folgende Programm veranschaulicht die dynamische Speicherzuweisung und array-basierte Operationen, zwei Funktionen, die mit Fortran 90 eingeführt wurden. Besonders erwähnenswert ist das Fehlen von DO Schleifen und IF/DANN Anweisungen bei der Manipulation des Arrays; mathematische Operationen werden auf das Array als Ganzes angewendet. Auffällig ist auch die Verwendung von beschreibenden Variablennamen und die allgemeine Formatierung des Codes, die dem heutigen Programmierstil entsprechen. In diesem Beispiel wird ein Durchschnitt über interaktiv eingegebene Daten berechnet. ⓘ

Programm Durchschnitt <span title="Aus: Englische Wikipedia, Abschnitt &quot;Code examples&quot;" class="plainlinks">[https://en.wikipedia.org/wiki/Fortran#Code_examples <span style="color:#dddddd">ⓘ</span>]</span>

  ! Lesen Sie einige Zahlen ein und bilden Sie den Durchschnitt
  ! Wie geschrieben, wenn es keine Datenpunkte gibt, wird ein Durchschnitt von Null zurückgegeben
  ! Dies ist zwar nicht unbedingt erwünscht, aber das Beispiel ist dadurch einfach <span title="Aus: Englische Wikipedia, Abschnitt &quot;Code examples&quot;" class="plainlinks">[https://en.wikipedia.org/wiki/Fortran#Code_examples <span style="color:#dddddd">ⓘ</span>]</span>

  implizit keine <span title="Aus: Englische Wikipedia, Abschnitt &quot;Code examples&quot;" class="plainlinks">[https://en.wikipedia.org/wiki/Fortran#Code_examples <span style="color:#dddddd">ⓘ</span>]</span>

  real, dimension(:), allocatable :: Punkte
  integer :: anzahl_der_punkte
  real :: Durchschnitt_Punkte, positiver_Durchschnitt, negativer_Durchschnitt
  durchschnittliche_Punkte = 0.0
  positiver_Durchschnitt = 0,0
  negativer_Durchschnitt = 0,0
  write (*,*) "Eingabe der Anzahl der zu mittelnden Punkte:"
  read (*,*) anzahl_der_punkte <span title="Aus: Englische Wikipedia, Abschnitt &quot;Code examples&quot;" class="plainlinks">[https://en.wikipedia.org/wiki/Fortran#Code_examples <span style="color:#dddddd">ⓘ</span>]</span>

  allocate (Punkte(anzahl_der_punkte)) <span title="Aus: Englische Wikipedia, Abschnitt &quot;Code examples&quot;" class="plainlinks">[https://en.wikipedia.org/wiki/Fortran#Code_examples <span style="color:#dddddd">ⓘ</span>]</span>

  write (*,*) "Geben Sie die zu mittelnden Punkte ein:"
  read (*,*) points <span title="Aus: Englische Wikipedia, Abschnitt &quot;Code examples&quot;" class="plainlinks">[https://en.wikipedia.org/wiki/Fortran#Code_examples <span style="color:#dddddd">ⓘ</span>]</span>

  ! Berechne den Durchschnitt, indem du die Punkte addierst und durch die Anzahl der Punkte dividierst
  if (anzahl_der_punkte > 0) mittelwert_punkte = summe(punkte) / anzahl_der_punkte <span title="Aus: Englische Wikipedia, Abschnitt &quot;Code examples&quot;" class="plainlinks">[https://en.wikipedia.org/wiki/Fortran#Code_examples <span style="color:#dddddd">ⓘ</span>]</span>

  ! Bilden Sie nun den Durchschnitt nur über positive und negative Punkte
  if (count(points > 0.) > 0) positiver_durchschnitt = sum(points, points > 0.) / count(points > 0.)
  if (count(points < 0.) > 0) negative_average = sum(points, points < 0.) / count(points < 0.) <span title="Aus: Englische Wikipedia, Abschnitt &quot;Code examples&quot;" class="plainlinks">[https://en.wikipedia.org/wiki/Fortran#Code_examples <span style="color:#dddddd">ⓘ</span>]</span>

  ! Ergebnis auf Terminal stdout unit 6 ausgeben
  write (*,'(a,g12.4)') 'Mittelwert = ', mittelwert_punkte
  write (*,'(a,g12.4)') 'Durchschnitt der positiven Punkte = ', positiver_durchschnitt
  write (*,'(a,g12.4)') 'Durchschnitt der negativen Punkte = ', negative_average
  deallocate (Punkte) ! Speicher freigeben
Programm beenden Durchschnitt

ⓘ

Humor

Während der gleichen Sitzung des FORTRAN-Standardisierungskomitees, auf der der Name "FORTRAN 77" gewählt wurde, wurde ein satirischer technischer Vorschlag mit dem Titel "Letter O Considered Harmful" in die offizielle Verteilung aufgenommen. Dieser Vorschlag zielte darauf ab, die Verwirrung zu beseitigen, die manchmal zwischen dem Buchstaben "O" und der Zahl Null entsteht, indem der Buchstabe aus den zulässigen Variablennamen entfernt wird. Die vorgeschlagene Methode bestand jedoch darin, den Buchstaben ganz aus dem Zeichensatz zu streichen (und damit 48 als Anzahl der lexikalischen Zeichen beizubehalten, die durch den Doppelpunkt auf 49 erhöht wurde). Dies wurde insofern als vorteilhaft angesehen, als es die strukturierte Programmierung fördern würde, indem es unmöglich gemacht würde, die berüchtigte GO TO Anweisung wie zuvor zu verwenden. (Lästige FORMAT Anweisungen würden ebenfalls eliminiert werden.) Es wurde angemerkt, dass dies "einige bestehende Programme ungültig machen könnte", aber dass die meisten von ihnen "wahrscheinlich ohnehin nicht konform waren". ⓘ

Als X3J3 darüber debattierte, ob die Mindestanzahl von Auslösungen für eine DO-Schleife in Fortran 77 null oder eins sein sollte, schlug Loren Meissner eine Mindestanzahl von zwei Auslösungen vor - mit der augenzwinkernden Begründung, dass es keinen Grund für eine Schleife gäbe, wenn sie weniger als zwei betragen würde! ⓘ

Als Arrays mit angenommener Länge hinzugefügt wurden, gab es einen Streit über das geeignete Zeichen zur Trennung von Ober- und Untergrenze. In einem Kommentar, der diese Argumente untersuchte, schrieb Dr. Walt Brainerd einen Artikel mit dem Titel "Astronomie vs. Gastroenterologie", weil einige Befürworter die Verwendung des Sterns oder Sternchens ("*") vorgeschlagen hatten, während andere den Doppelpunkt (":") bevorzugten. ⓘ

Variablennamen, die mit den Buchstaben I-N beginnen, haben standardmäßig den Typ "Integer", während Variablen, die mit anderen Buchstaben beginnen, standardmäßig den Typ "Real" haben, obwohl Programmierer die Standardwerte durch eine explizite Deklaration außer Kraft setzen können. Dies führte zu dem Witz: "In FORTRAN ist GOTT REAL (sofern nicht als INTEGER deklariert)." ⓘ

Sprachelemente

Im Laufe dieser Erweiterungen wurden zahlreiche Sprachelemente aus später entstandenen Programmiersprachen übernommen. Frühe FORTRAN-Versionen bis Version 4 hatten als Flusskontrollstruktur nur zwei verschiedene Goto-Anweisungen und den Aufruf von Unterprogrammen. Strukturierte Programmierung mit Schleifen wurde mit FORTRAN 77 möglich. Mit Fortran 90 wurde neben dem aus der Lochkartenzeit stammenden festen Zeilenformat ein von späteren Programmiersprachen verwendetes freieres Format erlaubt. Ab Fortran 90 werden Elemente eingeführt, die auch beispielsweise in Ada vorhanden sind, beispielsweise optionale Parameter und die Möglichkeit, Prozedurparameter nicht nur über die Position in der Parameterliste zu identifizieren, sondern auch über ihren Namen. Seit Fortran 2003 werden auch polymorphe Datentypen und Vererbung unterstützt, so dass man objektorientiert programmieren kann. Seit Fortran 2008 ist mit Coarray Fortran eine Parallelisierung in die Sprache eingebaut, die dem PGAS-Schema folgt. ⓘ

Beispiel:

subroutine test(argument1, argument2, argument3)
    real,             intent(in)           :: argument1
    character(len=*), intent(in)           :: argument2
    integer,          intent(in), optional :: argument3
    ! Hier etwas Sinnvolles ...
end subroutine test <span title="Aus: Deutsche Wikipedia, Abschnitt &quot;Sprachelemente&quot;" class="plainlinks">[https://de.wikipedia.org/wiki/Fortran#Sprachelemente <span style="color:#dddddd">ⓘ</span>]</span>

Mögliche Aufrufe sind dann z. B.:

call test(1.0, 'Tach')
call test(argument1=1.0, argument2='Tach auch')
call test(argument2='Tach Auch', argument1=1.0)
call test(argument3=3, argument1=1.0, argument2='Tach auch') <span title="Aus: Deutsche Wikipedia, Abschnitt &quot;Sprachelemente&quot;" class="plainlinks">[https://de.wikipedia.org/wiki/Fortran#Sprachelemente <span style="color:#dddddd">ⓘ</span>]</span>

Während beim ersten Aufruf die Parameterassoziation über die Reihenfolge der Parameter erfolgt, so werden bei den anderen Beispielen die Parameter mittels der Namen identifiziert. Bei letzteren spielt die Reihenfolge dann keine Rolle mehr. ⓘ

Varianten

Einige von Fortran abgeleitete Programmiersprachen sind Ratfor, F und HPF (High Performance Fortran). ⓘ

Eigenschaften

Arrays in Zuweisungen und Ausdrücken und intrinsische Array-Funktionen

Arrays mit gleicher Zahl von Elementen und gleichem Rang können in Ausdrücken und Zuweisungen verwendet werden, auch gemischt mit Skalaren.

  real :: a(10), b(2:12)   ! Deklariere zwei Arrays der Länge 10
  read (*,*) a             ! Lese a ein
  b = 2.*a + 3./a          ! Elementweise Zuweisung
  write (*,*) b            ! Ausgabe von b

Verschiedene Array-Funktionen werden durch die Sprachnorm vordefiniert. So gibt beispielsweise die Funktion MAXVAL den maximalen Wert eines Arrays zurück und MAXLOC den Index des maximalen Wertes. Die intrinsischen Funktionen DOT_PRODUCT und MATMUL liefern das Skalarprodukt und die Matrixmultiplikation. ⓘ

Implizite Variablendeklaration

In Anlehnung an mathematischen Notationsgebrauch sind Variablen in Fortran ohne Deklaration ü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 Gleitkommazahlen. Diese implizite Typenvereinbarung von Variablen kann durch die Deklaration einzelner Variablen überschrieben werden, sie kann durch eine Zeile wie ⓘ

! Alle nichtdeklarierten Bezeichner, deren erster Buchstabe c oder z ist,
! bezeichnen komplexe Zahlen.
implicit complex(c, z) <span title="Aus: Deutsche Wikipedia, Abschnitt &quot;Implizite Variablendeklaration&quot;" class="plainlinks">[https://de.wikipedia.org/wiki/Fortran#Implizite_Variablendeklaration <span style="color:#dddddd">ⓘ</span>]</span>

verändert werden, und die implizite Vereinbarung kann durch den Befehl ⓘ

implicit none <span title="Aus: Deutsche Wikipedia, Abschnitt &quot;Implizite Variablendeklaration&quot;" class="plainlinks">[https://de.wikipedia.org/wiki/Fortran#Implizite_Variablendeklaration <span style="color:#dddddd">ⓘ</span>]</span>

ganz aufgehoben werden, was für alle neuen Programme empfohlen wird. In diesem Fall löst die Verwendung eines nichtdeklarierten Bezeichners einen Fehler während der Übersetzung aus. Dadurch vereinfacht sich die Fehlersuche erheblich. ⓘ

Übergabe von Argumenten

Bis FORTRAN 77

Bis einschließlich FORTRAN 77 konnten Unterprogramme vor ihrer Verwendung nicht deklariert werden. Es konnte durch eine Deklaration nur der Typ des Rückgabewerts einer Funktion festgelegt werden. Der Compiler überprüfte normalerweise nicht, ob ein Unterprogrammaufruf mit typrichtigen Argumenten erfolgt. Die Übergabe von Argumenten an Unterprogramme (subroutine oder function) erfolgt üblicherweise per Adresse. Eine automatische Typumwandlung findet nicht statt. ⓘ

Die meisten Fortran-Systeme führen auch keine Typüberprüfung zur Laufzeit durch. Das ist bei der Verwendung dieses veralteten Programmierstils eine häufige Fehlerquelle. ⓘ

Programmbeispiel 1:

call drucke_zahl(3.14)
! ...
subroutine drucke_zahl(meine_zahl) <span title="Aus: Deutsche Wikipedia, Abschnitt &quot;Bis FORTRAN 77&quot;" class="plainlinks">[https://de.wikipedia.org/wiki/Fortran#Bis_FORTRAN_77 <span style="color:#dddddd">ⓘ</span>]</span>

Im Unterprogramm drucke_zahl() ist meine_zahl, weil mit m beginnend, implizit als Integer deklariert. Zur Laufzeit erfolgt ein Aufruf mit dem real-Argument 3.14. Dann wird die Integer-Variable meine_zahl mit den Bits der Gleitkommadarstellung von 3.14 aufgefüllt – was auf beliebig abwegige numerische Ergebnisse führt. ⓘ

Viele Fortran-Compiler übergeben Parameter per Referenz. Das führt teilweise zu nicht beabsichtigten Ergebnissen, beispielsweise folgendes Programmbeispiel 2:

program bsp_bar
    call bar(4)
    print *, 4
end program bsp_bar <span title="Aus: Deutsche Wikipedia, Abschnitt &quot;Bis FORTRAN 77&quot;" class="plainlinks">[https://de.wikipedia.org/wiki/Fortran#Bis_FORTRAN_77 <span style="color:#dddddd">ⓘ</span>]</span>

subroutine bar(i)
    i = 42
end subroutine bar

ⓘ

Dieses würde bei manchen Compilern die Zahl 42 ausgeben. Das Programm ist allerdings so nicht korrekt. ⓘ

Programmierwerkzeuge wie „ftnchek“ ermöglichen eine separate Prüfung der Übereinstimmung von Argumentlisten und würden in diesen Fällen warnen. Aktuelle Compiler führen ebenfalls solche Überprüfungen durch oder erzeugen einen Laufzeitfehler bei der Zuweisung eines Wertes an eine Konstante; diese beiden Prüfungen waren schon seit 1970 am Rechner TR 440 verfügbar. ⓘ

Modernes Fortran

In Fortran 90 und nachfolgenden Versionen besteht die Möglichkeit, die Parametertypen der Unterprogramme anhand von Schnittstellen (interface) und Modulen (module) zu definieren. Der Compiler kann somit überprüfen, ob der übergebene Parametertyp und der erwartete Typ übereinstimmen. Diese Bekanntgabe ist allerdings nicht zwingend, wie das in anderen Programmiersprachen – beispielsweise Ada – der Fall ist. Die von Fortran 95 abgeleitete Programmiersprache F erzwingt dieses; in F sind nur Aufrufe von Unterprogrammen erlaubt, deren Parameterliste beispielsweise durch use-Anweisungen bekannt gemacht sind. In einem Unterprogramm kann auch festgelegt werden, ob ein Parameter Eingabeparameter (intent(in)), Ausgabeparameter (intent(out)) oder beides (intent(in out)) ist. In Fortran 90 deklariert man das Unterprogramm bar folgendermaßen:

subroutine bar(i)
  integer, intent(in) :: i
  ! ...
end subroutine bar <span title="Aus: Deutsche Wikipedia, Abschnitt &quot;Modernes Fortran&quot;" class="plainlinks">[https://de.wikipedia.org/wiki/Fortran#Modernes_Fortran <span style="color:#dddddd">ⓘ</span>]</span>

Falls das Unterprogramm versuchen sollte, den Wert des Aktualparameter i zu verändern, würde der Compiler einen Fehler anzeigen. ⓘ

Weitherhin kann Fortran 90 Arrays einschließlich ihrer Größen übergeben, diese können dann im Unterprogramm verwendet werden:

subroutine foo(x)
  integer, intent(in), dimension(:) :: x
  !
  print *,size(x) ! Gebe die Größe von x aus
end subroutine foo

Es dann können auch Teile von Arrays übergeben werden, z. B. mit

program main
  integer, dimension(20) :: x
  call foo(x(1:10:2)
end program main

Dies übergibt einen Array mit den Elementen x(1), x(3), x(5), x(7), x(9) an foo. ⓘ

Dynamische Speicherallokation

Unter dynamischer Speicherallokation versteht man die Möglichkeit, Speicher (insbesondere für Felder wie z. B. für Matrizen) erst zur Laufzeit des Programms anzufordern, das heißt, dass die Größe von Arrays nicht bereits zum Zeitpunkt des Übersetzens des Programms festgelegt zu sein braucht. Ein einfaches Beispiel:

real, allocatable :: a(:,:) <span title="Aus: Deutsche Wikipedia, Abschnitt &quot;Dynamische Speicherallokation&quot;" class="plainlinks">[https://de.wikipedia.org/wiki/Fortran#Dynamische_Speicherallokation <span style="color:#dddddd">ⓘ</span>]</span>

print *, 'Zeilen- und Spaltenzahl eingeben'
read (*, *) m, n
allocate(a(m, n))
! ...
deallocate(a)

ⓘ

Bis FORTRAN 77 ist eine dynamische Speicherallokation nicht oder nur über nicht standardisierte Erweiterungen der Compilerhersteller möglich. Ab Fortran 90 ist die dynamische Speicherverwaltung im Sprachstandard enthalten. ⓘ

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

type element_t
    type(element_t), pointer :: naechstes
    real                     :: datum
end type element_t <span title="Aus: Deutsche Wikipedia, Abschnitt &quot;Dynamische Speicherallokation&quot;" class="plainlinks">[https://de.wikipedia.org/wiki/Fortran#Dynamische_Speicherallokation <span style="color:#dddddd">ⓘ</span>]</span>

type(element_t), pointer, save :: liste => null()
type(element_t), pointer       :: element <span title="Aus: Deutsche Wikipedia, Abschnitt &quot;Dynamische Speicherallokation&quot;" class="plainlinks">[https://de.wikipedia.org/wiki/Fortran#Dynamische_Speicherallokation <span style="color:#dddddd">ⓘ</span>]</span>

! Anlegen eines Elements und Eintragen am Anfang der Liste
allocate(element) <span title="Aus: Deutsche Wikipedia, Abschnitt &quot;Dynamische Speicherallokation&quot;" class="plainlinks">[https://de.wikipedia.org/wiki/Fortran#Dynamische_Speicherallokation <span style="color:#dddddd">ⓘ</span>]</span>

element%datum = 4711.0
element%naechstes => liste
liste => element <span title="Aus: Deutsche Wikipedia, Abschnitt &quot;Dynamische Speicherallokation&quot;" class="plainlinks">[https://de.wikipedia.org/wiki/Fortran#Dynamische_Speicherallokation <span style="color:#dddddd">ⓘ</span>]</span>

! Durchlaufen der Liste:
element => liste <span title="Aus: Deutsche Wikipedia, Abschnitt &quot;Dynamische Speicherallokation&quot;" class="plainlinks">[https://de.wikipedia.org/wiki/Fortran#Dynamische_Speicherallokation <span style="color:#dddddd">ⓘ</span>]</span>

do while (associated(element))
    call bearbeiten(element%datum)
    element => element%naechstes
end do

ⓘ

Coarrays

Fortran unterstützt seit der Sprachversion Fortran 2008 Coarrays. Ein Programm läuft in unterschiedlichen Instanzen, die als „images“ bezeichnet werden. Jede Instanz kann auf lokale Variablen zugreifen. Zugriff auf Variablen auf anderen Images wird über Coarrays realisiert, die wie ein normaler Array mit einem bestimmten Cosubscript angesprochen werden. Bevor der Wert einer Variable verwendet werden kann, der von einem anderen Image geschrieben wurde, muss synchronisiert werden, dies geschieht am einfachsten durch einen SYNC ALL-Befehl. Ein einfaches Beispiel:

! In diesem Programm schreibt jedes Image eine Nachricht in das
! Element eines anderen Images.
program main
  implicit none
  character (len=30) :: greetings[*]
  integer :: me, n, you
  me = this_image()
  n = num_images()
  if (me /= n) then
     you = me + 1
  else
     you = 1
  end if
  write (unit=greetings[you],fmt='(A,I0,A,I0)') &
       "Gruesse von ", me, " an ", you
  sync all
  write (*,'(A)') trim(greetings)
end program main

was dann mit vier Images beispielsweise die Ausgabe

 Gruesse von 3 an 4
 Gruesse von 1 an 2
 Gruesse von 2 an 3
 Gruesse von 4 an 1

erzeugt. ⓘ

Objektorientierung

Vererbung wird in Fortran durch Erweiterung von Typen realisiert. In Fortran kann ein Pointer oder ein Argument eines Unterprogrammes ein CLASS-Argument sein. Falls erforderlich, kann der Typ durch SELECT TYPE unterschieden werden.

  type t1
    integer :: i1
  end type t1
  type, extends (t1) :: t2
    real :: r1
  end type t2
!...
  subroutine foo(a)
    class (t1), intent(in) :: a
    select type(a)
    type is (t1)
      print *,"Type ist t1, Wert ist", a%i1
    type is (t2)
      print *,"Type ist t2, Werte sind", a%i1, a%r1
    class default
      print *,"Das ist ein anderer Wert."
    end select <span title="Aus: Deutsche Wikipedia, Abschnitt &quot;Objektorientierung&quot;" class="plainlinks">[https://de.wikipedia.org/wiki/Fortran#Objektorientierung <span style="color:#dddddd">ⓘ</span>]</span>

Methoden werden in Fortran als „Type-bound procedures“ bezeichnet:

  type foo
    integer, private :: i
  contains
    procedure :: add => int_add
    procedure :: subtract => int_subtract
    procedure :: get_val => int_read
  end type foo

Ein Benutzer, der eine Variable x vom Typ oder der Klasse foo verwendet, kann dann die Routinen foo%add, foo%subtract und foo%get_val aufrufen, der direkte Zugriff auf foo%i ist durch das Schlüsselwort private nicht möglich. ⓘ

Compiler

UCSD Fortran ⓘ

Fortran-Compiler gibt es für praktisch alle Computer, von Arbeitsplatzrechnern bis zu Supercomputern. ⓘ

Proprietäre Software

Kommerzielle Anbieter von Fortran-Compilern sind entweder Computerhersteller wie z. B. IBM, SUN, HP, Intel oder spezialisierte Softwarehersteller wie Absoft, NAG, Lahey, Salford. Reine FORTRAN-77-Compiler werden heute zumeist nicht mehr hergestellt, da FORTRAN 77 fast vollständig im Sprachstandard Fortran 95 enthalten ist (nur DO-Schleifen mit REAL-Iterationsvariablen und Hollerith-Edit-Deskriptoren sind in Fortran 95 und später nicht mehr vorhanden). ⓘ

Einige der oben genannten Compiler sind für Privatanwender bzw. nichtkommerzielle Nutzung unentgeltlich, zum Beispiel die Linux-Variante des Intel-Fortran-Compilers, Sun Studio Express (mit Fortran-, C- und C++-Compilern für Linux und Solaris), für Microsoft Windows der Compiler von Salford und DEC Fortran für OpenVMS. ⓘ

Freie Software

Ab Version 4.0 enthält die praktisch für alle Plattformen verfügbare GNU Compiler Collection (GCC) einen Compiler für Fortran 95 (GNU Fortran). Ältere Versionen von GCC enthalten noch den FORTRAN-77-Compiler g77. An dem freien Compiler G95 wurden die Arbeiten 2012 eingestellt, er ist allerdings weiterhin verfügbar. Aus diesem ging 2003 gfortran als neuer GNU-Fortran-Compiler hervor. ⓘ

Ab Version 4.4 „Luna“ existiert eine integrierte Entwicklungsumgebung für Eclipse. ⓘ

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

Transcompiler

Es gibt Transcompiler, wie beispielsweise f2c, zur automatischen Übersetzung von Fortran-77 in C. Der daraus erzeugte Quelltext ist allerdings kaum für den Menschen lesbar. Auch der NAG-Compiler verwendet als Zwischensprache C; allerdings ist die nötige Laufzeitbibliothek nicht im Quelltext erhältlich. ⓘ

Sprachunterstützung

Die meisten aktuellen Compiler unterstützen den 2008- oder 2018-Standard. ⓘ

Verfügbare Software und Programmbeispiele

Programmbeispiele

Zahlreiche Programmbeispiele finden sich bei den Webseiten „Programming Idioms“ und bei Rosetta Code. ⓘ

Literatur zur Geschichte von Fortran

Annals of History of Computing. Vol. 6, No. 1, 1984, ISSN 0164-1239.
- John C. McPherson: Early Computers and Computing Institutions. S. 15–16. doi:10.1109/MAHC.1984.10005
- Herbert S. Bright: Early Fortran User Experience. S. 28–30. doi:10.1109/MAHC.1984.10011
- Daniel N. Leeson: IBM Fortran Exhibit and Film. S. 41–48. doi:10.1109/MAHC.1984.10000
- J. A. N. Lee: An Annotated Bibliography of Fortran. S. 49–58. doi:10.1109/MAHC.1984.10003
„History of FORTRAN and FORTRAN II“ Sammlung präsentiert vom Computer History Museum (englisch)
Saul Rosen (Hrsg.): Programming Systems and Languages. McGraw-Hill, New York NY u. a. 1967.
Richard L. Wexelblat (Hrsg.): History of Programming Languages. Academic Press, New York NY u. a. 1981, ISBN 0-12-745040-8, S. 25–74.
FORTRAN-Fachwörterbuch. In: Blätter der Deutschen Gesellschaft für Versicherungsmathematik. Bd. 8, H. 3, Oktober 1967, S. 499–520. ⓘ

Literatur zu Fortran

Stephen J. Chapman: Fortran 90/95 for Scientists and Engineers. 2. Auflage. McGraw Hill Higher Education, Boston MA u. a. 2004, ISBN 0-07-123233-8.
Thomas Kühme, Peter Witschital: Die FORTRAN-Fibel. Strukturierte Programmierung mit FORTRAN 77. Lehr- und Arbeitsbuch für Anfänger. 3., durchgesehene Auflage. Oldenbourg, München u. a. 1991, ISBN 3-486-22016-0.
Michael Metcalf, John Reid, Malcolm Cohen: Fortran 95/2003 Explained. Oxford University Press, Oxford u. a. 2004, ISBN 0-19-852693-8.
Michael Metcalf, John Reid, Malcolm Cohen: Modern Fortran explained. Oxford University Press, Oxford u. a. 2011, ISBN 978-0-19-960142-4.
William H. Press, Saul A. Teukolsky, William T. Vetterling, Brian P. Flannery: Numerical recipes in Fortran 77. The Art of Scientific Computing. (= Numerical recipes in Fortran. Vol. 1). 2. Auflage. Cambridge University Press, Cambridge u. a. 1992, ISBN 0-521-43064-X (2., korr. Auflage. ebenda 2003).
William H. Press, Saul A. Teukolsky, William T. Vetterling, Brian P. Flannery: Numerical Recipes in Fortran 90. The Art of Parallel Scientific Computing. (= Numerical recipes in Fortran. Vol. 2). 2. Auflage. Cambridge University Press, Cambridge u. a. 1996, ISBN 0-521-57439-0 (2., korr. Auflage. ebenda 1999).
Günter Schmitt: Fortran-90-Kurs technisch orientiert. Einführung in die Programmierung mit Fortran 90. Oldenbourg, München u. a. 1996, ISBN 3-486-23896-5.
Dragos Chirila, Gerrit Lohmann: Introduction to Modern Fortran for Earth System Sciences. Springer, Berlin/ Heidelberg 2015, ISBN 978-3-642-37008-3. ⓘ