Fortran im Wandel der Zeit

Objektorientierung

Fortran entwickelt sich weiter

Beginnend mit dem Standard Fortran 90 bis zum aktuellen (Fortran 2008) hielten nach und nach Elemente der objektorientierten Programmierung Einzug in die Sprache. Um zu zeigen, was durch sie aktuell möglich ist, folgt die Beschreibung des Implementierens und Verwendens einer Klasse. In der Objektorientierung vereint eine Klasse Daten (Attribute) und Operationen (Methoden). In Fortran lässt sich das durch einen sogenannten Derived Type in einem Modul mit Funktionen und Subroutinen realisieren, die hinter einer contains-Anweisung stehen.

Weitere objektorientierte Konzepte können Entwickler umsetzen, wenn Zugriffsmodifikatoren zur Datenkapselung sowie Überladen von Funktionen und Operatoren dazu kommen. Listing 12 zeigt als Beispiel ein Modul mit der grundlegenden Struktur einer Klasse, mit der sich Brüche, also rationale Zahlen mit ganzzahligem Zähler und Nenner, darstellen und verrechnen lassen:

1   module RationalClass
2 implicit none
3
4 type, public :: Rational
5 private
6 integer num, den
7 end type Rational
8
9 interface Rational
10 module procedure construct
11 module procedure constructInteger
12 end interface
13
14 interface assignment(=)
15 module procedure assignInteger
16 end interface
17
18 interface operator(*)
19 module procedure times
20 module procedure timesRational
21 module procedure timesInteger
22 end interface
21
22 interface abs
23 module procedure absRational
24 end interface
25
26 interface writeRational
27 module procedure writeRationalScalar
28 end interface
29
30 contains
31
32 ! constructors:
33 elemental type(Rational) function construct(num, den)
34 integer, intent(in) :: num
35 integer, intent(in) :: den
36 construct%num = num
37 construct%den = den
38 end function
39
40 elemental type(Rational) function constructInteger(num)
41 integer, intent(in) :: num
42 constructInteger = construct(num, 1)
43 end function
44
45 ! getters:
46 elemental real(8) function getnum(r)
47 type(Rational), intent(in) :: r
48 getnum = r%num
49 end function
50
51 elemental real(8) function getden(r)
52 type(Rational), intent(in) :: r
53 getden = r%den
54 end function
55
56 ! setters:
57 elemental subroutine setnum(r,num)
58 type(Rational), intent(inout) :: r
59 integer, intent(in) :: num
60 r%num = num
61 end subroutine
62
63 elemental subroutine setden(r,den)
64 type(Rational), intent(inout) :: r
65 integer, intent(in) :: den
66 r%den = den
67 end subroutine
68
69 ! assignment operator:
70 elemental subroutine assignInteger(r, num)
71 type(Rational), intent(inout) :: r
72 integer, intent(in) :: num
73 r%num = num
74 r%den = 1
75 end subroutine
76
77 ! multiplication operators:
78 elemental type(Rational) function times(r1, r2)
79 type(Rational), intent(in) :: r1, r2
80 times%num = r1%num * r2%num
81 times%den = r1%den * r2%den
82 end function
83
84 elemental type(Rational) function timesRational(r, i)
85 type(Rational), intent(in) :: r
86 integer, intent(in) :: i
87 timesRational = times(r, Rational(i))
88 end function
89
90 elemental type(Rational) function timesInteger(i, r)
91 type(Rational), intent(in) :: r
92 integer, intent(in) :: i
93 timesInteger = times(Rational(i), r)
94 end function
95
96 ! abs function:
97 type(Rational) function absRational(r)
98 type(Rational), intent(in) :: r
99 absRational = Rational(abs(r%num),abs(r%den))
100 end function
101
102 ! output:
103 subroutine writeRationalScalar(r)
104 type(Rational), intent(in) :: r
105 write(*,*) 'Rational object: ', r%num, '/', r%den
106 end subroutine
107
108 end module RationalClass

Listing 12: Definition einer Klasse

Listing 13 enthält ein einfaches Hauptprogramm dazu. In Listing 12 erkennt man die Deklaration eines selbstdefinerten Datentyps in den Zeilen 4-7. Dort kommen die Zugriffsmodifikatoren public für den Typ selbst und private für die beiden Attribute num (für Numerator, Zähler) und den (für Denominator, Nenner) des Bruches zum Einsatz. Die Definition des Typs Rational erlaubt es nun, im Hauptprogramm (Listing 13, Zeile 5) Variablen dieses Typs anzulegen:

1  program RationalTest
2 use RationalClass
3 implicit none
4
5 type(Rational) :: r1, r2
6 type(Rational), allocatable :: r3(:)
7 integer :: i, n = 3
8
9 r1 = Rational(1, 2)
10 r2 = Rational(3)
11 call writeRational(r1)
12 call writeRational(r2)
13 r2 = r1*r2
14 call writeRational(r2)
15
16 allocate(r3(n))
17 r3 = Rational(0)
18 r3 = r3 * r3
19 do i=1,n
20 call writeRational(r3(i))
21 enddo
22 deallocate(r3)
23
24 end program

Listing 13: Benutzung der Klasse

Hinter der Typdefinition folgen im Modul nun diverse Interface-Blöcke. Im ersten (Zeilen 9-12) findet die Definition des Interface Rational mit zwei im Modul definierten Prozeduren statt. Der Begriff procedure steht an der Stelle für Fortran-Funktionen oder Subroutinen.

Ruft das Hauptprogramm (Listing 13, Zeilen 9, 10) Rational auf, wird in den im Interface-Block aufgeführten Modulprozeduren diejenige gesucht, die mit ihren Parametern passt. Im vorliegenden Fall ruft Zeile 9 des Hauptprogramms so über das Interface Rational die Funktion construct aus Zeile 35 des Moduls auf, die zwei Integer-Parameter bekommt. Zeile 10 des Hauptprogramms ruft dagegen diejenige mit nur einem Parameter auf (Zeile 42 im Modul). Auf völlig identische Weise lassen sich nun Funktionen und Operatoren, wie hier der Multiplikationsoperator, überladen. Bei den Prozeduren im Modul wurden zusätzlich die jeweiligen Parameter als intent(in) beziehungsweise out und inout gekennzeichnet. Der Compiler prüft diese in Fortran 90 eingeführte Spezifizierung, die einen zusätzlichen Schutzmechanismus darstellt.

Im Hauptprogramm lässt sich erkennen, dass es direkt ein Feld (Variable r3) des neuen Datentyps erzeugen, initialisieren und mit ihm rechnen konnte. Das kann funktionieren, wenn die entsprechenden Prozeduren wie im Modul als elemental gekennzeichnet sind. Das ermöglicht eigenen Datentypen und Klassen eine komfortable Syntax, die der für Felder primitiver Datentypen entspricht.

Auch Vererbung ist in Fortran möglich. Da man solche modernen Konstrukte in Legacy-Code eher nicht findet und auch die Bedeutung von Vererbung in numerischen Simulationscodes umstritten ist, wird hier allerdings nicht näher darauf eingegangen.

Eine sehr kompakte, aber dennoch umfassende Darstellung des modernen Fortran ist in [4] zu finden – nicht nur im Hinblick auf Klimamodelle, wie der Titel andeuten könnte. Daneben sei Interessierten das Buch "Modern Fortran Explained"[6] empfohlen, das weniger Lehrbuch als Nachschlagewerk zum jeweils aktuellen Sprachstandard ist. Die Autoren sind an dessen Gestaltung beteiligt. In "Computing for Scientists" [7] wird ein interessanter Vergleich zwischen Fortran 90 und C++ im Hinblick auf Objektorientierung gezogen, die beim Erscheinen des Buches in Fortran aber noch nicht vollständig realisiert wurde.