einführung zu arrays geschrieben

einfuehrungen/einfuehrung_array.txt

+„auf dem Aufgabenblatt 6 werden arrays (dt. Felder) genutzt.
+Diese bieten die Möglichkeit mehrere (viele) Daten in einer Variablen zu speichern.
+
+Jedes array hat einen Datentyp, der angibt, welchen Typ die Elemente haben.
+Zusätzlich hat jedes Array eine Anzahl von Dimensionen (1 = ‚Liste’, 2 = ‚Matrix‘, genannt ‚rank‘) und eine Größe in jeder Dimension (‚shape‘).
+Die Deklaration gibt diese Informationen an mit der Größe im ‚DIMENSION‘-Attribut:
+für jede Dimension gibt man die Indexierung an mit startindex:endindex.
+Gibt man nur eine Zahl an, ist startindex 1“
+
+INTEGER, DIMENSION(3,-1:3) :: matrix  ! hat 3 * 5 = 15 Elemente
+
+„auf arrays kann auf verschiedene Weise zugegriffen werden.
+a) auf einzelne Elemente:
+Die Indexe beginnen bei 1:“
+
+matrix(1,2) = 5
+WRITE(*,*) matrix(1,2)  ! gibt 5 aus
+
+„b) auf Teilarrays:“
+
+matrix(1,2:) = matrix(2, 2:)
+
+„dabei muss für jede Dimension angegeben werden, welche Indeces genutzt werden. Jeweils gibt es die Möglichkeiten
+i) ein einzelner Index
+ii) ein Bereich anfang:ende:schrittweite wie bei Zählschleifen mit defaults kleinsterIndex:größterIndex:1 bei weggelassenen Angaben
+iii) ein eindimensionales INTEGER-array, in dem die gewünschten Indeces drinstehen
+iv) TODO: fällt jmd. noch etwas anderes ein?
+
+c) auf das Gesamtarray:”
+
+matrix = TRANSPOSE(matrix)
+
+„Um arrays mit Werten zu erstellen, gibt es die Schreibweise (/ Elemente /):“
+
+matrix(1,:) = (/2, 3, 4, 5, 9/)  # in der ersten Zeile stehen die Zahlen 2, 3, 4, 5, 9
+
+„Auf diese Art können nur eindimensionale arrays (‚Listen‘) erschaffen werden.
+Um mehrdimensionale arrays zu erstellen, nutze RESHAPE:“
+
+matrix = Reshape((/2,3,4,5,6,7,8,5,3,10,-2,39,0,1,2/), (/3,5/))
+
+„erstes Argument sind die Daten, das zweite Argument die Dimensionsgrößen“
+
+„Häufig kennt man die Größe eines arrays nicht beim Schreiben des Programms oder sie soll sich ändern.
+Daher gibt es „ALLOCATABLE“-arrays:“
+
+INTEGER, DIMENSION(:,:), ALLOCATABLE :: matrix  ! hat rank 2
+
+„diese Deklaration reserviert der Variablem matrix noch keinen Speicherplatz.
+Lesen und speichern mit ‚matrix‘ führt also zu unvorhersehbarem Verhalten oder Fehlern.
+Um Speicherplatz zu reservieren nutze ‚ALLOCATE‘:“
+
+ALLOCATE(matrix(2,3))
+matrix(1, :) = (/1, 2, 3/)
+matrix(2, :) = (/4, 5, 6/)
+
+„Wenn man das nicht mehr braucht
+(also insbesondere am Ende des Programms!)
+oder eine andere Größe braucht, gibt man den Speicherplatz wieder frei:“
+
+DEALLOCATE(matrix)
+
+„eine Vergrößerung eines arrays, bei dem die Daten erhalten bleiben, ist nicht möglich“
+
+„----------------
+Rechnen mit arrays
+-----------------
+In viele Fällen möchte man etwas mit allen Elementen eines arrays tun:“
+
+DO i = LBOUND(matrix, 1) : UBOUND(matrix, 1)
+  DO j = LBOUND(matrix, 2) : UBOUND(matrix, 2)
+    matrix (i, j) = i + 10 * j
+
+„sehr häufig kann man sich das aber sparen, wenn man geschickt die
+Fähigkeiten von Fortran in array-Manipulation nutzt.
+Die meisten Operationen für die Grundtypen können elementweise für arrays genutzt werden:“
+
+matrix = matrixA + matrixB  ! addiert elementweise, Größen müssen passen
+matrix = 0                  ! 
+matrix = matrix + 1         ! Zahlen werden behandelt wie ein array, in dem alle Einträge diese Zahl sind
+READ(*,*) matrix            ! liest size(matrix) viele Werte und schreibt sie spaltenweise in matrix
+logmatrix = matrixA == matrixB   ! logmatrix hat in jedem element stehen ob die entsprechenden Matrizeneinträge von matrixA und matrixB gleich sind
+„um zwei Matrizen auf Gleichheit zu überprüfen, brauchen wir also:“
+IF ALL( &
+    &  matrixA == matrixB .OR. ABS(matrixA - matrixB) > 10**(-4) &
+    & )
+  ! do something if matrixA and matrixB are almost equal
+
+„viele arithmetischen und logischen Funktionen, die man erwarten würde, existieren“
+MAXVAL (matrix)  ! gibt maximalen Wert
+MAXLOC (matrix)  ! gibt Indeces des maximalen Werts
+SUM (matrix)     ! summiert alle Werte von matrix
+MATMUL (matrixA, matrixB)   ! matrixA * matrixB ist elementweise Multiplikation, MATMUL ist Matrixmultiplikation
+DOT_PRODUCT (vecA, vecB)    ! für ein-dim. arrays ist das das Standardskalarprodukt
+
+„Beachte: all diese Funktionen haben viele Anpassungsfähigkeiten, schaut in die Dokumentation!
+Damit kann man die meisten Schleifen vermeiden.“
+
+„-----------------------------
+Arrays als Funktionsargumente
+------------------------------
+Um Funktionen nicht unnötig einzuschränken, will man selten die Größe von arrays
+in Argumenten von Unterprogrammmen fest vorgeben und stattdessen die Größe des Arguments übernehmen:“
+
+FUNCTION arrayFuellen(matrix)
+  INTEGER, DIMENSION(:, :), INTENT(INOUT) :: matrix
+  INTGER :: zeile
+  do spalte = LBOUND(matrix, 1), UBOUND(matrix, 1)
+    matrix(spalte, :) = (/ (2*i-1, i = 1, SIZE(matrix, 2), 1) /)
+
+    ! hier nutzen wir eine „implizite Zählschleife“
+
+„-------------------
+implizite Schleifen
+--------------------“
+„theoretisch sind implizite Zählschleifen unabhängig von arrays, aber sie sind oft zusammen praktisch:
+Syntax:
+(item1, item2, ..., itemN, i = start, end, step)
+ist äquivalent zu einer Liste von Komma-getrennten Werten. Es werden die itemI gelistet, wobei nacheinander
+i die Werte start, start + step, ..., end annimmt.
+
+Solch Komma-separierte Liste kann genutzt werden bei WRITE/ READ-Anweisungen und Arraykonstruktoren (/.../):“
+
+WRITE (*,*) (wow ** wow, vec(wow), wow = 1, 9, 2)
+
+„ist äquivalent zu“
+
+WRITE (*,*)  1, vec(1), 27, vec(3), 3125, vec(5), 823543, vec(7), 387420489, vec(9)
+
+