====== Variablen in Fortran ======

In diesem Kapitel geht es um die Verwendung von Variablen in Fortran. 

===== Datentypen =====

In Fortran existieren folgende Datentypen:

  * INTEGER (Ganzzahlen)
  * REAL (Fließkommazahlen)
  * DOUBLEPRECISION (Fließkommazahlen doppelter Genauigkeit (mehr dazu unten))
  * COMPLEX (komplexe Zahlen)
  * LOGICAL (logische Werte (.TRUE., .FALSE.))
  * CHARACTER (mehr dazu im Kapitel [[string|Zeichenketten]])

===== Implizite Variablendefinition =====

Fortran entscheidet anhand des Namen der Variablen, welchen Datentyp eine Variable hat. Das wird implizite Typzuweisung genannt. Dabei wird der Datentyp anhand des ersten Buchstabend gewählt, anhand folgender Tabelle:

^ Anfangsbuchstabe ^ Datentyp ^
| A bis L | Real |
| I bis N | **In**teger |
| M bis Z | Real |

Dh. verwenden wir eine Variable in unserem Programmcode, die nicht explizit definiert wurde, erhält sie vom Fortran Compiler automatisch einen Datentyp zugewiesen. Beachtet man das nicht, können schnell Rundungsfehler auftreten, wenn ungünstige Variablennamen verwendet werden. Man kann das auch umbdefinieren:

<code fortran>
PROGRAM main
  IMPLICIT LOGICAL (a-d)
  ! ...
  write (*,*) a * 0.3
  ! ..
  end PROGRAM
</code>

Dieser Programmcode wird durch den Compiler nicht übersetzt, weil die Variable a eine ''LOGICAL''-Variable ist, und versucht wird eine ''LOGICAL''-Variable mit einem ''REAL''-Wert zu multiplizieren. 

**Empfehlung** schalten Sie bei jedem Programmstück die implizite Typzuweisung aus. So erhalten Sie bei jeder nicht definierten Variable eine Fehlermeldung des Compilers (und finden damit Programmierfehler schneller). 

<code fortran>
PROGRAM main
  IMPLICIT NONE
       
  !  ...
end PROGRAMM
</code>

===== Variablendefinition =====

==== in Fortran 77 ====

Fortran fordert die Variablendefinition als erste Codezeilen in einem (Unter-)Programm. Wollen wir eine Integer-Variable (Ganzzahl) definieren, geschieht das wie folgt:

<code fortran>
      PROGRAM main
        IMPLICIT NONE
        INTEGER myvar
        
c       ...
      END PROGRAM
</code>

Es ist nicht möglich im Programmcode Variablen anzulegen, da das immer zu Beginn geschehen muss. Wollen Sie mehrere Variablen des gleichen Typs definieren, schreiben Sie einfach mehrere Variablennamen mit Komma getrennt hinter den Variablennamen:

<code fortran>
      PROGRAM main
        IMPLICIT NONE
        INTEGER var1, var2, var3
        REAL var4, var5, var6
        
c       ...
      END PROGRAM
</code>

==== in Fortran 90 ====

Fortran 90 hat einige Neuerungen bei der Variablendefinition gebracht. Es können nun Attribute an die Variablendefinition gestellt werden. Hier sei nur die allgemeine Syntax beschrieben:

<code>
<datentyp> [(KIND=...)[, <attribute>] ::] <variable>, ..
</code>

Wichtig ist also zunächst, dass zwei Doppelpunkte vor dem ersten Variablennamen stehen soll. Ein Fortran 90 Compiler lässt aber auch die Fortran 77 Variante durchgehen. Es ist nun möglich weitere Attribute anzugeben, bspw. die Länge des Datentyps, Dimensionen des Feldes (siehe [[array|Felder]]),... Mögliche Attribute sind:

  * PARAMETER
  * DIMENSION(dim1,...,dimn) -> (erzeugt ein n-dimensionales Feld mit den Dimensionen dim1 bis dimn; siehe [[array|Felder]]))
  * ALLOCATABLE -> (markiert eine Variable als alloziierbar, dh. es kann dynamisch Speicher geholt werden (siehe [[pointer|Zeiger]]))
  * POINTER -> (markiert eine Variable als Pointer, siehe [[pointer|Zeiger]])
  * TARGET -> (markiert eine Variable als Ziel eines Pointer)
  * INTENT -> (markiert eine Variable als Eingabevariable (verhindert Schreiben auf diese Variable))
  * EXTERNAL

===== Auswahl anderer Wortbreiten für Datentypen =====

Manchmal ist es notwendig einen kleineren oder größeren Ganzzahldatentyp zu verwenden (also bspw. einen 16 Bit oder 64 Bit Integer). Dazu kann in Fortran 77 mit einem Stern am Datentyp die Breite des Datentyps angegeben werden:

<code fortran>
  integer*2 var16bit
  integer*4 var32bit
  integer*8 var64bit
</code>

In Fortran 90 sieht das wie folgt aus:

<code fortran>
  integer (KIND=2) :: var16bit
  integer (4) :: var32bit
  integer (8) :: var64bit
</code>

Der Selektor ''KIND'' kann angegeben werden, muss aber nicht. 

Der Datentyp ''DOUBLEPRECISION'' stellt einen besonderen Datentyp dar, weil er eine Sonderform von ''REAL'' ist. Double-Zahlen sind i.d.R. 64 Bit lang, dh. folgende Codezeilen sind quasi äquivalent:

<code fortran>
  REAL*8 a
  DOUBLE PRECISION b
</code>

===== Verwendung von Variablen =====

Variablen werden durch die Verwendung des Namens im Programmcode verwendet:

<code fortran>
PROGRAM main
  INTEGER :: a,b
  REAL :: c,d
        
  a = 12
  b = 42
  c = 0.3
  d = a + b * c
  write (*,*) d
END PROGRAM
</code>

===== Anfangswertzuweisung =====

Es kann sinnvoll sein Variablen einen Anfangswert zuzuweisen, dafür gibt es verschiedene Methoden in Fortran.

==== DATA (Fortan 77) ====

In Fortran 77 ist es üblich das DATA-Statement zu verwenden um Variablen einen Anfangswert zuzuweisen:

<code fortran>
  DOUBLE PRECISION pi, e
  DATA pi /3.14159d0/
  DATA e /2.718281d0/
</code>

Zunächst legen wir die Variablen an, dann wird mittels ''DATA'' angekündigt, dass der nachfolgenden Variablen der folgende Wert zugewiesen werden soll. Dabei ist der Wert in Schrägstriche zu klammern. 

Auch möglich ist folgendes:

<code fortran>
  DOUBLE PRECISION pi /3.141d0/
  DOUBLE PRECISION e /2.7162d0/
</code>

==== Fortran 90 ====

In Fortran 90 kann die Anfangswertzuweisung direkt bei der Definition des Variablen geschehen:

<code fortran>
  DOUBLE PRECISION :: pi = 3.14159d0 
  DOUBLE PRECISION :: e = 2.718281d0
</code>

===== Benannte Konstanten =====

Es kann nützlich sein Konstanten zu benennen, bspw. wenn ein Wert im Programm verwendet werden soll, aber nicht verändert - so kann der Wert einmal oben definiert werden und im eigentlichen Code dann mit seinem Namen angesprochen werden. Das kann vor allem dann nützlich sein, wenn der Wert oft gebraucht wird, und bspw. zum Testen mit unterschiedlichen Werten übersetzt werden soll (während des Programmlaufs aber konstant bleiben soll). 

Dafür gibt es die Anweisung ''PARAMETER'', der in Klammern der Konstantenname und der Wert folgt. Die Konstante wird zuvor wie eine normale Variable erstellt:

<code fortran>
  REAL*8 pi, e
  PARAMETER (pi=3.14159d0, e=2.718281d0)
  INTEGER testvar
  PARAMETER (testvar=100)
</code>

bzw. in Fortran 90:

<code fortran>
  REAL*8,PARAMETER :: pi=3.14159d0, e=2.718281d0
  INTEGER,PARAMETER :: testvar=100
</code>