Praktische Arbeitsmethoden Geodatenverarbeitung mit FORTRAN MT3

Der Weg vom Problem zur Executable: Programmier- sprache Problem Quelltext Compiler executable Es soll das Wort „Hallo“ auf den Bildschirm ge- schrieben werden Fortran90 Datei: hallo.f90: program main write(*,*)“hallo“ end program main gfortran hallo.f90 >./a.out >hallo · Die Datei „hallo.f90“ ist die sog. Quelltext-Datei (source code) Sie kann mit jedem x-beliebigen Editor geschrieben werden (pico, gedit, xemacs, etc.) Sie enthält Anweisungen in Fortran90-Syntax (die der Fortran-Compiler versteht) · Der Compiler „gfortran“ wird aufgerufen mit dem Namen der Quelltextdatei als Argument Er liest die Anweisungen in „hallo.f90“ der Reihe nach und produziert (wenn nichts anderes angeben ist) die executable „a.out“ · Die executable „a.out“ enthält den ausführbaren binärcode Sie kann als Befehl aufgerufen werden und führt die Anweisungen aus

Übung: Übungsaufgabe bis Sonntag vor nächster Sitzung (28.4.2012): fortran2013s_u01_<Benutzerkennung> Lassen Sie durch mehrere Anweisungen verschiedene Worte ausgeben. Benennen Sie den Quelltext: u01<Benutzerkennung>.f90 per e-mail an: a.philipp@geo.uni-augsburg.de Betreff: fortran2013s_u01_<Benutzerkennung> Anhang: die Quelltextdatei als u01<Benutzerkennung>.f90

Compilerbedienung Es gibt verschiedene Fortran-Compiler, u.a.: - gfortran (open source) - ifort (intel, persönliche Benutzung frei, schnell) - pgf90 (Portlandgroup compiler) Alle compiler wollen die Endung „.f90“ für Fortran90-Quelltexte Die zu erstellende executable kann statt „a.out“ auch anders benannt werden: Argument „-o <name>“ bei Aurfuf > gfortran -o hallo hallo.f90 > ./hallo hallo Weitere Optionen: > gfortran --help

Compilerbedienung (für gfortran) Optionen: -o <name> Name der zu erstellenden executable -static Binde eventuelle Bibliotheken mit ein -m32 Erstelle für 32-bit Betriebssystem -m64 Erstelle für 64-bit Betriebssystem -O3 starke Optimierung -Wextra -Wall -pedantic Warnungen -fbounds-check prüfe ob Feldgrenzen überschritten werden --version Version des Compilers (4.1.2) -ffree-line-length-0 Keine Beschränkung der Zeilenlänge (132)

Der Aufbau einer Quelltext-Datei - Header /Kopfzeile ..................... program main - Anweisungen: Deklarationen .... implicit none ausführbare A. ... write(*,*)“hallo“ - Ende ........................................... end program main Anweisungen - Deklarationen / nicht ausführbare Anweisungen: es werden Vereinbarungen festgelegt (Bsp. implicit none) - ausführbare Anweisungen: es werden Aktionen ausgeführt (Bsp. write(*,*)“hallo“)

Der Aufbau einer Quelltext-Datei Syntaxkonventionen: - in einer Zeile steht normalerweise nur eine Anweisung - Zeilenumbrüche werden mit & am Ende (und & am Anfang der Fortsetzungszeile) gekennzeichnet - nach einem ; kann in der selben Zeile eine 2. Anweisung stehen - Das ! leitet einen Kommentar für den Rest der Zeile ein: alles was in einer Zeile nach dem ! steht wird vom Compiler nicht beachtet (ist ein Kommentar)

Variablen Eine Variable ist ein Platzhalter in dem ein bestimmter Wert steht! (tatsächlich steht jede Variable für einen Teil des Arbeitsspeichers) Der Wert einer Variable kann verändert werden Eine Variable hat einen Namen Eine Variable muss am Anfang des Programms deklariert werden Einen Variable hat einen bestimmten Variablentyp: character: Textzeichen integer: Ganzzahlen real: Fließkommazahlen logical: logische Zustände: falsch (.false.) oder wahr (.true.)

Beispiel für Variablen program main implicit none character(len=10) :: textvar textvar=“hallo“ write(*,*)textvar end program main Header lasse nur vereinbarte Variablen zu deklariere eine Textvariable mit 10 Zeichen namens „textvar“ weise den Wert „hallo“ zu gebe den Wert der Variablen textvar aus Ende

Variablendeklaration implicit none bedeutet: falls im Programm ein Variablenname verwendet wird der nicht deklariert wurde (z.B. Tippfehler texvar), gib eine Fehlermelung aus! (ansonsten wird texvar als neue Variable angenommen) character(len=10) :: textvar <Variablentyp>(<Spezifikation>) :: <Variablenname> Beispiele für Variablendeklarationen (eine oder mehrere pro Zeile): character(len=10) :: textvar,zweitetextvar integer :: ganzzahl real :: bruchzahl logical :: stimmt

Variablendeklaration weitere Möglichkeiten bei der Deklaration: bei character: Anzahl der Zeichen (Länge des Wortes) character(len=5) :: name bei real: Genauigkeit, Bsp. doppelt genau (8 bytes), einfach (4 bytes) real(kind=8) :: doppelt bei integer, Bsp. kurze integer (1 byte), normal (4 bytes = 32bit) integer(kind=1) :: ishort Zahlenmodelle: bits können nur 1 (T, magnetisiert) oder 0 (F) sein! Jedes Muster aus 0 und 1 steht für eine Zahl: Bitmuster: 00000000 = 0 (das erste bit: 0=pos, 1=neg) 00000001 = 1 ... 11111111 =-1 => 28 = 256 Zahlen (-128 bis 127)

Regeln für Variablennamen Zulässig: - Großbuchstaben: A-Z - Kleinbuchstaben: a-z (groß/klein wird i.A. nicht unterschieden) - Ziffern: 0-9 (nicht am Anfang des Namens!) - Underline: _ Unzulässig: - Leerzeichen (blank) - Zeichen mit besonderer Bedeutung: ! & ( ) . :: , - Rechenoperatoren: = + - * / ** - logische Vergleichsoperatoren: == < > <= >= ! Wertzuweisung <variablenname> = <wert> textvar = „hallo“ ganzzahl = 1 zahl = 0.5 stimmt = .true.

Rechenanweisungen/Verknüpfung von Variablen: <Variablenname> = <Wert> <Operator> <Wert> <Wert> kann direkt angegeben werden oder mittels einer Variablen. Beispiele: zahl = 0.5 + 0.5 ganzzahl = 1 zahl = ganzahl + 0.5 zahl = 0.5 zahl = zahl + 0.5 Es wird immer erst die Seite rechts des = ausgewertet und dieser Wert anschließend in die Variable links des = geschrieben

Operatoren zur Verknüpfung zweier Werte: Verknüpfung von Zahlen: + := Addition - := Subtraktion * := Multiplikation / := Division ** := Potenzierung Verknüpfung von Textvariablen: // := Aneinanderketten von character-Variablen Verknüpfen von logischen Variablen: .and. := logisches „und“ (wahr falls beides wahr) .or. := logisches „oder“ (wahr falls eines wahr) .eqv. := wahr falls beide gleich .neqv.:= wahr falls unterschiedlich

Operatoren zur Verknüpfung zweier Werte: Auswertungshierarchie: 1.) () 2.) ** 3.) * / 4.) + - 5.) == /= > >= < <= 6.) .not. .and. .or. .eqv. .neqv.

Umwandlung von Werten unterschiedlicher Variablentypen - bei Operationen mit gleichartigen Variablentypen, liegt das Ergebnis als Wert gleichen Typs vor! Bsp.: integer <operator> integer => integer - Verknüpfung zwischen real und integer: real <operator> integer => real - Funtionen zur Umwandlung zwischen Variablentypen: <real(kind=4)> = FLOAT(integer) oder REAL(int) oder SNGL(int) <real(kind=8)> = DBLE(integer|real) <integer> = AINT(real) „abgehackt“ [auch DINT] <integer> = ANINT(real) „gerundet“ [auch DNINT]

Funktionen zur Verarbeitung von Werten: Funktionen für numerische Variablen: sin(var) := Sinus, var muss in Rad vorliegen cos(var) := Cosinus, - „ - sqrt(var) := Wurzel abs(var) := Absolutwert (ohne Vorzeichen) log10(var):= Logarithmus zur Basis 10 log(var) := natürlicher Logarithmus exp(var) := Exponentialfunktion zu e (2.718281) max(var,var[,...]) := Maximum der Argumente ... Funktionen für Textvariablen: trim(var) := schneidet bis zum ersten Zeichen ab len(var) := liefert Anzahl der Stellen

Exkurs: Zahlenmodelle im Dualsystem Kodierungskonventionen für character: American Standard Code for Information Interchange American National Standards Institute (nur Zeichen 32 bis 127 identisch) de Lange 2006

Exkurs: Zahlenmodelle im Dualsystem Kodierungskonvention für Integer: Dualsystem (statt Dezimalsystem) = Stellenwertsystem mit Basis 2 (statt 10): 12310 = 3*100 + 2*10¹ + 1*10³ (dezimal) 12310 = 1*20 + 1*2¹ + 0*2² + 1*2³ + 1*24 + 1*25 + 1*26 (binär/dual) 12310 = 11110112 → Bitmuster ist kürzer als 3 * 8 bits für char → schneller, weniger Speicher Paketweise Verarbeitung: 8 Bits = 1 Byte (1024 Bytes = 1Kb, ...): 000000002 = 010 000000012 = 110 000000112 = 310 011111112 = 12710 → signed Integer: erstes Bit = Vorzeichenbit

Exkurs: Zahlenmodelle im Dualsystem Kodierungskonvention für signed Integer: Dualsystem: = bit2·26 + bit3·25 + bit4·24 + bit5·23 + bit6·22 + bit7·21 + bit8·20 falls Vorzeichenbit (bit1) = 1 => (Komplement + 1) · (-1) “Zweierkomplement” Bsp.: -12710 = [10000001]2 => [1111110]2 + 1 · (-1) 1·26 = 64 1·25 = 32 1·24 = 16 1·23 = 8 1·22 = 4 1·21 = 2 0·20 = 0 = (126 + 1) · (-1) = -12710

Exkurs: Zahlenmodelle im Dualsystem Zahlenmodelle für Integer Integerzahlenmodell Byte: 1-byte-Werte Wertebereich: -127 - 128 (signed) oder 0 - 255 (unsigned) Integerzahlenmodell Short: 2-byte-Werte Wertebereich: -32768 - 32768 (signed) oder 0 - 65535 Integerzahlenmodell: 4-byte-Werte (standard) Wertebereich: -2,147,483,648 – 2,147,483,647 Integerzahlenmodell: Long: 8-byte-Zahlen Wertebereich: -9,223,372,036,854,775,808 - ...

Exkurs: Zahlenmodelle im Dualsystem Kodierungskonvention für Gleitkommazahlen / float / real: Standardnorm: IEEE 754 (Institute for Electrical and Electronics Engineers) Darstellung durch: Vorzeichen · Mantisse · (Basis=2) Exponent Mantisse und Exponent als binäre Integer Exponent: legt Zahlenbereich fest 4-byte +- 3403·1038 8-byte +- 1798·10308 Mantisse: legt Genauigkeit fest 4-byte: ca. 7-8 Stellen 8-byte: ca. 15-16 Stellen

Exkurs: Zahlenmodelle im Dualsystem Zahlenmodelle für Gleitkommazahlen: Realzahlenmodell: single precision (4byte) 1 bit für Vorzeichen, 8 bit für Exponenent (Bereich), 23 bit für Mantisse (Genauigkeit) => Bereich +- 3403·1038 Genauigkeit: 7-8 Stellen Realzahlenmodell: double precision (8byte) 1 bit für Vorzeichen, 11 bit für Exponenent (Bereich), 52 bit für Mantisse (Genauigkeit) => Bereich: +- 1798·10308 Genauigkeit: 15-16 Stellen