Fortran: Datentypen und formatierte Ausgabe

Kurz: print *, i, gross print *, einfach print *, doppelt print *, abs(z), real(z), aimag(z), z * z print *, ok, .not. ok, ok .and. .false., ok .or. .false.

Teil des Kurses Fortran

Kapitel 2 von 8 im Kurs Fortran. Mit Fortschritt, Quiz und Zertifikat auf der Lernseite.

Die Datentypen

Typ	Beispiel	Hinweis
integer	42	Ganzzahl (meist 32 Bit)
real	3.14	einfache Genauigkeit (32 Bit)
double precision / real(kind=8)	3.14d0	doppelte Genauigkeit (64 Bit)
complex	(1.0, 2.0)	komplexe Zahl
logical	.true., .false.	Wahrheitswert
character	"Text"	Zeichenkette fester Länge

program typen
  use, intrinsic :: iso_fortran_env, only: int64, real32, real64
  implicit none
  integer :: i = 42
  integer(int64) :: gross = 9000000000_int64
  real(real32) :: einfach = 1.0_real32 / 3.0_real32
  real(real64) :: doppelt = 1.0_real64 / 3.0_real64
  complex :: z = (3.0, 4.0)
  logical :: ok = .true.
  character(len=10) :: s = "Fortran"
  character(len=:), allocatable :: dyn
 
  print *, i, gross
  print *, einfach
  print *, doppelt
  print *, abs(z), real(z), aimag(z), z * z
  print *, ok, .not. ok, ok .and. .false., ok .or. .false.
  print *, "[", s, "] [", trim(s), "] len=", len(s), " len_trim=", len_trim(s)
  dyn = "dynamisch"
  print *, dyn, len(dyn)
  print *, huge(i), huge(gross), digits(einfach), digits(doppelt)
  print *, kind(1.0), kind(1.0d0), kind(i), kind(gross)
  print *, 0.1_real64 + 0.2_real64 == 0.3_real64
  print *, abs(0.1_real64 + 0.2_real64 - 0.3_real64) < epsilon(1.0_real64)
end program typen

Ausgabe:

42           9000000000
  0.333333343
  0.33333333333333331
   5.00000000       3.00000000       4.00000000                (-7.00000000,24.0000000)
 T F F T
 [Fortran   ] [Fortran] len=          10  len_trim=           7
 dynamisch           9
  2147483647  9223372036854775807          24          53
           4           8           4           8
 F
 T

Hinweis

Rechne wissenschaftlich fast immer in doppelter Genauigkeit (real64). Literale mit _real64 erzwingen den Typ; 3.14 ist nur real (einfach).

Strings

program texte
  implicit none
  character(len=30) :: s
  character(len=:), allocatable :: t
  integer :: pos, n
 
  s = "Hallo Welt"
  print *, len(s), len_trim(s)
  print "(a)", s(1:5)                       ! Teilstring
  print "(a)", trim(s) // "!"              ! Verkettung
  pos = index(s, "Welt")
  print *, pos
  print "(a)", adjustl("   links")
  print *, scan("abc.def", "."), verify("123x", "0123456789")
  print *, repeat("ab", 3)
  t = "Fortran"
  do pos = len(t), 1, -1                      ! rückwärts ausgeben
    write(*, "(a)", advance="no") t(pos:pos)
  end do
  print *
  print *, lge("b", "a"), llt("a", "b")
  n = 0
  do pos = 1, len_trim(s)
    if (s(pos:pos) == "l") n = n + 1
  end do
  print *, "Anzahl l:", n
 
  write(s, "(a, i0, a, f0.2)") "Wert=", 42, " Preis=", 3.5
  print "(a)", trim(s)
  read(s(6:7), *) n                           ! aus dem Text lesen
  print *, n + 1
  print "(a)", merge("ja  ", "nein", n > 10)
end program texte

Ausgabe:

30          10
Hallo
Hallo Welt!
           7
links
           4           4
 ababab
nartroF
 T T
 Anzahl l:           3
Wert=42 Preis=3.50
          43
ja

Formatierte Ausgabe

print * gibt Werte mit Standardformat aus. Mit einer Formatangabe kontrollierst du jede Spalte:

Format	Bedeutung
i5 / i0	Ganzzahl in 5 Stellen / so kurz wie möglich
f8.3 / f0.2	Festkomma: 8 Stellen, 3 Nachkommastellen
es12.4 / e12.4	wissenschaftlich
a / a10	Text
l1	logical
x / 3x	Leerzeichen
/	neue Zeile
2(i3) / *(i3)	Wiederholung

program format_demo
  implicit none
  integer :: i
  real :: pi_ = 3.14159265
  print "(i5)", 42
  print "(i0)", 42
  print "(f8.3)", pi_
  print "(f0.2)", pi_
  print "(es12.4)", 12345.678
  print "(a, i3, a)", "[", 7, "]"
  print "(3(i4))", 1, 2, 3
  print "(a10, '|', a)", "rechts", "links"
  print "(2f6.1, /, 2f6.1)", 1.0, 2.0, 3.0, 4.0
  print "(*(i3))", (i * i, i = 1, 8)
  print "('Summe: ', f6.2)", 1.5 + 2.25
  write(*, "(a)", advance="no") "ohne Umbruch, "
  write(*, "(a)") "weiter"
  print "(i0.3)", 7
  print "(l1, 1x, l1)", .true., .false.
  print "(a)", "Zeile1" // new_line("a") // "Zeile2"
end program format_demo

Ausgabe:

42
42
   3.142
3.14
  1.2346E+04
[  7]
   1   2   3
    rechts|links
   1.0   2.0
   3.0   4.0
  1  4  9 16 25 36 49 64
Summe:   3.75
ohne Umbruch, weiter
007
T F
Zeile1
Zeile2

Merke

• Typen: integer, real, double precision/real(real64), complex, logical, character
• kind legt die Genauigkeit fest: use iso_fortran_env liefert int64, real64
• Strings sind fest lang: trim, len_trim, //, index, Teilstrings s(1:5)
• Formatierte Ausgabe mit (i5, f8.3, a, ...); i0/f0.2 für kompakte Zahlen

Übungsaufgabe

Gib eine kleine Tabelle der Quadratzahlen von 1 bis 5 mit rechtsbündigen Spalten aus.

Quiz zur Selbstkontrolle

Welcher Typ ist für wissenschaftliche Rechnungen üblich?

• Doppelte Genauigkeit (real64) (richtig)
• integer
• character
• logical

Was bedeutet das Format f8.3?

• Zahl in 8 Stellen mit 3 Nachkommastellen (richtig)
• 8 Nachkommastellen
• Text mit 8 Zeichen
• Dezimal mit 3 Stellen insgesamt

Wie verkettet man Zeichenketten?

• Mit // (richtig)
• Mit +
• Mit &
• Mit ,

Weiter im Kurs

Zurück: Einführung und erstes Programm

Weiter: Verzweigungen und Schleifen

Alle Kapitel: Fortran im Überblick