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, Fortran 90, Fortran 95, Fortran 2003, Fortran 2008 und Fortran 2018. Ab FORTRAN 66 ist Fortran durch die ISO standardisiert. Die Fortschreibung der Standards ist ein komplizierter Prozess, der oft wesentlich länger dauert als zunächst angestrebt: Der Nachfolger des 1978 erschienenen Standards FORTRAN 77, der als Fortran 8x bezeichnet wurde, war ursprünglich für das Jahr 1982 geplant, später dann für das Jahr 1985, und wurde schließlich unter der Bezeichnung Fortran 90 erst am 11. April 1991 als neuer Standard und Nachfolger von FORTRAN 77 angenommen. 2018 wurde Fortran 2018 freigegeben. Es wurden die Interoperabilität mit C und Funktionen bezüglich der Parallelprogrammierung verbessert. Weitere Neuerungen betreffen die Gleitkommaarithmetik auf Mikroprozessoren und die Ein- und Ausgabe von Hexadezimalzahlen.

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

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')

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

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(3:12)   ! Deklariere zwei Arrays der Länge 10
  read (*,*) a             ! Lies 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)

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

implicit none

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

call drucke_zahl(3.14)
! ...
subroutine drucke_zahl(meine_zahl)

program bsp_bar
    call bar(4)
    print *, 4
end program bsp_bar

subroutine bar(i)
    i = 42
end subroutine bar

subroutine bar(i)
  integer, intent(in) :: i
  ! ...
end subroutine bar

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

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

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(:,:)

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

type(element_t), pointer, save :: liste => null()
type(element_t), 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
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

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.

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.

Mathematische Bibliotheken

Die Referenz-Implementierung der BLAS-Bibliothek, die Grundoperationen der linearen Algebra zur Verfügung stellt, ist in Fortran geschrieben und verwendet die API von Fortran, ebenso wie die auf BLAS aufsetzende LAPACK-Bibliothek.

Zahlreiche der bei Netlib verfügbaren Algorithmen sind in Fortran geschrieben, typischerweise in älteren Dialekten.

Programmbeispiele

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