Fortran: Spickzettel

Die älteste Hochsprache, bis heute König der Zahlen

Ausführen: Datei hallo.f90 speichern, mit gfortran hallo.f90 -o hallo übersetzen und ./hallo starten (GNU Fortran, z. B. über sudo apt install gfortran).

gfortran hallo.f90 -o hallo     # übersetzen (GNU Fortran)
./hallo                         # starten
gfortran -O2 -Wall -fcheck=all -std=f2018 hallo.f90   # Warnungen, Laufzeitprüfungen

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

program verzweigungen
  implicit none
  integer :: punkte, tag
  punkte = 78
  if (punkte >= 90) then
    print *, "sehr gut"
  else if (punkte >= 75) then
    print *, "gut"
  else
    print *, "weiter üben"
  end if
  if (punkte > 50) print *, "bestanden"           ! einzeiliges if

  tag = 3
  select case (tag)
  case (1)
    print *, "Montag"
  case (2, 3, 4)
    print *, "Mitte der Woche"
  case (6:7)
    print *, "Wochenende"
  case default
    print *, "anderer Tag"
  end select

  print *, punkte > 70 .and. punkte < 90, punkte < 0 .or. punkte == 78, .not. (punkte == 0)
  print *, merge("ja  ", "nein", punkte >= 50)     ! Ausdruck wie ein ternärer Operator
end program verzweigungen

program arrays1
  implicit none
  integer, parameter :: n = 5
  real :: v(n), w(n)
  integer :: i, a(3) = [10, 20, 30]

  v = [1.0, 2.0, 3.0, 4.0, 5.0]
  w = 2.0
  print *, v
  print *, v + w                  ! elementweise
  print *, v * v
  print *, sqrt(v)
  print *, sum(v), product(v), maxval(v), minval(v)
  print *, maxloc(v), minloc(v)
  print *, size(v), shape(v)
  print *, v(2:4)                 ! Ausschnitt
  print *, v(5:1:-2)              ! mit Schrittweite
  print *, a(1), a(size(a))
  v(2:3) = 0.0
  print *, v
  print *, dot_product([1, 2, 3], [4, 5, 6])
  print *, any(v > 4), all(v >= 0), count(v > 0)
  print *, pack(v, v > 0)         ! nur positive Elemente
  where (v == 0.0) v = -1.0       ! Bedingte Zuweisung
  print *, v
  print *, [(i * i, i = 1, 6)]    ! Array-Konstruktor mit implizierter Schleife
  print *, cshift([1, 2, 3, 4], 1), eoshift([1, 2, 3, 4], 1)
end program arrays1

program unterprogramme
  implicit none
  print *, quadrat(7.0)
  print *, fakultaet(10)
  print *, istgerade(4), istgerade(7)

  block
    real :: mittel, abw
    call statistik([2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0], mittel, abw)
    print "(a, f6.2, a, f6.2)", "Mittel ", mittel, " Abweichung ", abw
  end block

  block
    integer :: a, b
    a = 3; b = 8
    call tausche(a, b)
    print *, a, b
  end block

contains

  real function quadrat(x)
    real, intent(in) :: x
    quadrat = x * x
  end function quadrat

  recursive function fakultaet(n) result(r)
    integer, intent(in) :: n
    integer(kind=8) :: r
    if (n <= 1) then
      r = 1
    else
      r = n * fakultaet(n - 1)
    end if
  end function fakultaet

  logical function istgerade(n)
    integer, intent(in) :: n
    istgerade = mod(n, 2) == 0
  end function istgerade

  subroutine statistik(v, mittel, abw)
    real, intent(in) :: v(:)
    real, intent(out) :: mittel, abw
    mittel = sum(v) / size(v)
    abw = sqrt(sum((v - mittel)**2) / size(v))
  end subroutine statistik

  subroutine tausche(a, b)
    integer, intent(inout) :: a, b
    integer :: t
    t = a; a = b; b = t
  end subroutine tausche

end program unterprogramme

program typen
  implicit none

  type :: punkt
    real :: x = 0.0, y = 0.0
  end type punkt

  type :: person
    character(len=20) :: name
    integer :: alter
    type(punkt) :: ort
  end type person

  type(punkt) :: p
  type(person) :: leute(3)
  integer :: i

  p = punkt(3.0, 4.0)
  print *, p%x, p%y, sqrt(p%x**2 + p%y**2)

  leute(1) = person("Mia", 17, punkt(1.0, 2.0))
  leute(2) = person("Tom", 25, punkt(0.0, 0.0))
  leute(3) = person("Zoe", 31, punkt(5.5, 1.0))
  do i = 1, size(leute)
    print "(a6, i4, 2f7.1)", leute(i)%name, leute(i)%alter, leute(i)%ort%x, leute(i)%ort%y
  end do
  print *, sum(leute%alter) / size(leute)
  print *, maxval(leute%alter), leute(maxloc(leute%alter, dim=1))%name
  leute(2)%alter = leute(2)%alter + 1
  print *, leute(2)%alter
end program typen

program numerik
  use, intrinsic :: iso_fortran_env, only: dp => real64
  implicit none
  integer, parameter :: n = 1000
  real(dp) :: h, summe, x, pi_naehrung
  integer :: i

  ! Trapezregel: Integral von sin(x) von 0 bis pi
  h = acos(-1.0_dp) / n
  summe = 0.5_dp * (sin(0.0_dp) + sin(n * h))
  do i = 1, n - 1
    summe = summe + sin(i * h)
  end do
  print "(a, f10.6)", "Integral sin(x) = ", summe * h

  ! Leibniz-Reihe: pi/4 = 1 - 1/3 + 1/5 - ...
  summe = 0.0_dp
  do i = 0, 999999
    summe = summe + (-1.0_dp)**i / (2 * i + 1)
  end do
  pi_naehrung = 4.0_dp * summe
  print "(a, f12.8)", "pi ~ ", pi_naehrung

  ! Newton-Verfahren: sqrt(2)
  x = 1.0_dp
  do i = 1, 6
    x = x - (x * x - 2.0_dp) / (2.0_dp * x)
  end do
  print "(a, f12.10, a, es9.2)", "sqrt(2) ~ ", x, "   Fehler ", abs(x - sqrt(2.0_dp))
end program numerik

module name
  implicit none
  private
  public :: funktion
contains
  function funktion(x) result(r)
    real, intent(in) :: x
    real :: r
    r = x * 2
  end function
end module name

program haupt
  use name
  implicit none
  real :: y
  y = funktion(3.0)
  print *, y
end program haupt