diff --git a/einfuehrungen/einfuehrung_array.txt b/einfuehrungen/einfuehrung_array.txt
deleted file mode 100644
index da81964a8245ac382e2059305940f6864019c200..0000000000000000000000000000000000000000
--- a/einfuehrungen/einfuehrung_array.txt
+++ /dev/null
@@ -1,137 +0,0 @@
-„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)
-
-„GANZ WICHTIG::
-man kann Indezes angeben, die außerhalb der Matrix liegen.
-Das wäre ein illegaler Zugriff und führt zu unvorhergesehenen Fehlern.
-Daher immer mit der Option -fcheck=all kompilieren:“
-
-f95 -fcheck=all -o myprog myprogram.f95
-
-„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)
-
-
diff --git a/einfuehrungen/einfuehrung_io.txt b/einfuehrungen/einfuehrung_io.txt
deleted file mode 100644
index 98c7dcd771aad45e855d0ed8bcdccd5e4351c14c..0000000000000000000000000000000000000000
--- a/einfuehrungen/einfuehrung_io.txt
+++ /dev/null
@@ -1,72 +0,0 @@
-„Zu dieser Übersicht gibt es das Beispielprogramm in hilfsprogramme/io-example.f95“
-„in Aufgabe 14 sehen wir zum ersten Mal lesen aus und schreiben in Dateien.
-In Fortran gibt es keinen prinzipiellen Unterschied zwischen IO (input/ output)
-von der Kommandozeile und Dateien. D.h. wir benutzen READ und WRITE
-
-Um eine Datei zu lesen/ schreiben, müssen wir sie öffnen:“
-
-INTEGER :: err
-
-OPEN(NAME = "../input.dat", UNIT = 20, ACTION = "READ", IOSTAT = err)
-OPEN(NAME = "output.dat", UNIT = 21, ACTION = "WRITE", IOSTAT = err)
-
-„was passiert hier?
-NAME = gibt den Dateipfad vom aktuellen Verzeichnis aus an (meist nur Dateiname)
-UNIT = vergibt eine programminterne Nummer mit der diese Datei später referenziert wird
- nutze nur Zahlen ab 20, da die kleineren tw. für bestimmte Dinge reserviert sind
-ACTION = "READ"/ "WRITE"/ "READWRITE" -> gibt an, was man mit der Datei tun möchte
- nur lesen/ nur schreiben (Inhalt wird überschrieben!) / lesen und schreiben möglich
-IOSTAT = wenn ein Fehler auftritt (z.B. keine Lese/ Schreibrechte für die Datei oder
- Datei existiert nicht bei ACTION = "READ"
-Bei jeder Datei - IO muss man mit Fehlern rechnen und diese abfangen! (siehe io-example.f95)
-
-Jede Datei hat einen ‚curser position‘. Am Anfang steht dieser am Anfang der
-Datei. Mit jedem READ/ WRITE bewegt sich der curser.
-
-Wir möchten von der zu lesenden Datei lesen mit READ: genauso wie von der Standardeingabe“
-
-READ(20, *) norden ! 20 als Ersatz für *: die UNIT-Nr von der Datei
-! READ(UNIT = 20, FORMAT = *) ! * für das FORMAT
-
-„Genauso schreiben wir:“
-
-WRITE(21, *) norden
-
-„Wenn wir mit den Dateien fertig sind, schließe sie ordnungsgemäß:
-(mit UNIT-Nr Angabe)
-wie beim ALLOCATABLE Arrays: schließen sobald die Dateien nicht mehr benötigt werden“
-CLOSE(20, 21)
-
-„theoretisch kann man damit alles machen, aber mit Arrays und selbstdefinierten Typen kann man vieles vereinfachen:“
-
-INTEGER, DIMENSION(4) :: zahlen
-CHARACTER(len = 1) :: text
-READ(20, *) text, zahlen ! liest ein Zeichen und 4 INTEGER ein
-„Arrays auf einmal einlesen ist häufig einfacher als mit Schleifen alle Elemente einzeln einzulesen“
-
-TYPE datensammlung
- CHARACTER :: text
- INTEGER :: norden, osten, sueden, westen
-END TYPE
-
-TYPE(datensammlung) :: zeile1, zeile2
-READ(20, *) zeile1, zeile2
-
-„in einen komplexen Datentyp schreiben ist wie schreiben in alle Bestandteile.
-Daher ist es praktisch, wenn man die Bestandteile der Datentypen ordnet wie in Eingabedateien“
-
-„Meist weiß man nicht, wie lang die Eingabedatei ist. Daher muss man irgendwie ein Dateiende
-erkennen:“
-
-DO
- READ(20, *, iostat = err) text
- IF (err < 0) THEN
- ! Datei zu Ende
- EXIT
- ELSE IF (err > 0) THEN
- ! Fehler
- WRITE(*,*) "Lesefehler, z.B. konnte Eingabe nicht als INTEGER verstanden werden"
- ELSE
- WRITE(*, "(A)", ADVANCE = "NO") text
- END IF
-END DO
diff --git a/einfuehrungen/einfuehrung_mod.txt b/einfuehrungen/einfuehrung_mod.txt
deleted file mode 100644
index 9d0ae843819249aacda66faf2d3a4ad737525f5b..0000000000000000000000000000000000000000
--- a/einfuehrungen/einfuehrung_mod.txt
+++ /dev/null
@@ -1,142 +0,0 @@
-„in Blatt 5 werden Module um weitere Features ergänzt
-
-Typen: wir wissen: Variablen haben Typen, z.B. INTEGER, REAL, CHARACTER, LOGICAL
-neu: wir können eigene Typen deklarieren. Variablen von selbstdefinierten Typen
-bestehen aus mehreren Werten, z.B.“
-
-MODULE quaternionen
-
- IMPLICIT NONE
-
- TYPE quat ! Quaternionen, sowas aehnliches wie komplexe Zahlen mit 4 Dimensionen
- REAL :: reell, imag, jmag, kmag
- END TYPE
-
-CONTAINS
-
-END MODULE
-
-„um eine Variable von diesem Typ zu deklarieren, nutze TYPE(quaternionen),
-z.B. für Modulvariablen
-Um ein Objekt von diesem Typ zu erstellen, nutze den Konstruktor mit dem Namen
-des Typs und als Argumente die Werte der Bestandteile“
-
-MODULE quaternionen
-
- ...
-
- TYPE (quat), PARAMETER :: eins = quat(1, 0, 0, 0)
- TYPE (quat), PARAMETER :: i = quat(0, 1, 0, 0)
- TYPE (quat), PARAMETER :: j = quat(0, 0, 1, 0)
- TYPE (quat), PARAMETER :: k = quat(0, 0, 0, 1)
-
-CONTAINS
-
-END MODULE
-
-„Quaternionen sind ein Körper, die man addieren und multiplizieren können möchte
-
-Um auf Bestandteile von selbstdefinierten Typen zurückzugreifen, nutze %“
-
-MODULE quaternionen
- ...
-
-CONTAINS
-
- FUNCTION add(a, b)
- TYPE(quaternionen), INTENT(IN) :: a, b
- TYPE(quaternionen) :: add
- add%reell = a%reell + b%reell
- add%imag = a%imag + b%imag
- add%jmag = a%jmag + b%jmag
- add%kmag = a%kmag + b%kmag
- END FUNCTION
-
-END MODULE
-
-„Interfaces
-Im Hauptprogramm kann man nun schreiben: q = ADD(eins, i) und erhält (1.0, 1.0, 0.0, 0.0)
-aber man möchte eher q = eins + i schreiben.
-Dafür kann man ein INTERFACE nutzen, eine Art "zweiter Name", ein Alias:“
-
-MODULE quaternionen
-...
- INTERFACE OPERATOR (+)
- MODULE PROCEDURE add
- END INTERFACE
-
-CONTAINS
-
- FUNCTION add(a, b)
- ...
-
-END MODULE
-
-„Interfaces können auch aliase für mehrere Funktionen sein, solange deren
-Argumenttypen sich unterscheiden.
-Z.B. sollte Skalarmultiplikation (also REAL * quat) und Multiplikation von Quaternionen
-Dann wird immer die passende Funktion ausgewählt“
-
-MODULE quaternionen
-...
- INTERFACE OPERATOR (*)
- MODULE PROCEDURE mul, realmul, intmul
- END INTERFACE
-...
-CONTAINS
- FUNCTION mul(a, b)
-... ! komplette Variante in quaternionen.f95 zu finden
- FUNCTION realmul(skalar, a)
-...
- FUNCTION intmul(skalar, a)
-...
-END MODULE
-
-„wir haben schon Modulvariablen (in diesem Fall Konstanten) gesehen.
-Eine häufige sinnvolle Anwendung sind die kind-Konstanten. Diese können
-dann einheitlich im ganzen Modul UND im Hauptprogramm nutzen.
-Damit umgeht man Probleme mit nicht zusammen passenden Typen.“
-
-MODULE quaternionen
- IMPLICIT NONE
-...
- INTEGER, PARAMETER :: pr = SELECTED_REAL_KIND(P = 15, R=307)
- INTEGER, PARAMETER :: intsize = SELECTED_INT_KIND(20)
-
- TYPE quat
- REAL (kind = pr) :: reell, imag, jmag, kmag
- END TYPE
-...
-END MODULE
-
-„Standardmäßig kann ein Nutzer eines Moduls alles aus einem genutzten Modul sehen, d.h. nutzen.
-Das ist häufig unangebracht, z.B. sollte ein Benutzer nicht zwischen den verschiedenen Multiplikationen
-für Quaternionen unterscheiden können. Unterprogramme, die man zur besseren Strukturierung
-komplexer Funktionen schreibt, sollten nicht von außen direkt benutzt werden können, etc.
-Deshalb kann (und sollte) man Bestandteile von Modulen standardmäßig "private" (außerhalb des Moduls
-unsichtbar) setzen und alles, was außerhalb genutzt werden soll, explizit "public" setzen:“
-
-MODULE quaternionen
- IMPLICIT NONE
- PRIVATE
- PUBLIC :: pr, intsize, quat, OPERATOR (+), OPERATOR (*), eins, i, j, k
-
-...
-END MODULE
-
-„Jetzt kann man bei einem Quaternion immer noch alle Einträge "per Hand" mit q%reell lesen und
-schreiben. Das ist bei vielen selbstdefinierten Typen
-schlecht, da oft viele Variablenbelegungen ungültig sind (welche wären das bei Intervallen und Trilog)
-und der Benutzer eines Moduls nicht
-wissen müssen sollte, wie etwas intern implementiert ist (Quaternionen können über eine Polardarstellung
-gespeichert werden, für den Benutzer wäre das egal.) Daher sollten in den meisten Fällen die
-Bestandteile von selbstdefinierten Typen privat sein:“
-
-MODULE quaternionen
-...
- TYPE quat
- PRIVATE
- REAL (kind = pr) :: reell, imag, jmag, kmag
- END TYPE
-...
-END MODULE
diff --git a/einfuehrungen/einfuehrung_pointer.txt b/einfuehrungen/einfuehrung_pointer.txt
deleted file mode 100644
index 16033445780fa0bd74419f0778cb43948516f1f9..0000000000000000000000000000000000000000
--- a/einfuehrungen/einfuehrung_pointer.txt
+++ /dev/null
@@ -1,70 +0,0 @@
-Ab Blatt 2 dieses Semesters werden wir uns mit Pointern beschaeftigen.
-Pointer: Referenz auf ein Objekt (von best. Objekttyp). In FTN nur Attribut fuer Variable
-
-Vorteile: - Pointer koennen die komplexitaet des Codes stark reduzieren
- - Pointer koennen Speicher im Heap dynamisch zur Laufzeit allokieren (aehnlich zu ALLOCATE) und
- - der Heap ist betraechtlich groesser als der Stack (gilt nicht fuer Variablen mit TARGET-Attribut)
- - Das verwenden von z.B. Listen ist von Vorteil, wenn Daten oft in die Mitte der Liste eingefuegt werden muessen
- (Arrays hier eher unpraktisch)
- - Pointer sind noetig, um kompliziertere Datenstrukturen (z.B. trees) ordentlich zu implementieren
-
-In FTN werden Pointer ausser bei der "=>" Zuweisung automatisch dereferenziert.
-
-Syntax:
-
- PROGRAM testprog
-
- IMPLICIT NONE
- INTEGER, POINTER :: ptr
- ...
-
- END PROGRAM
-
-
-Wichtige Funktionen sind:
-
- NULLIFY(ptr) !! ptr zeigt nun auf NULL
-
- ALLOCATE(ptr) !! erzeugt (in unserem Fall) Integer Objekt im Heap
-
- DEALLOCATE(ptr) !! loescht diese Element im Heap
-
- ASSOCIATED(ptr) !! schaut, ob ptr nicht auf NULL zeigt
-
- ASSOCIATED(ptr1, ptr2) !! schaut, ob ptr und ptr2 auf das selbe El. zeigen
-
-
-Pointer Zuweisungen: "=>"
- - ptr => tgt !! assoziiert Pointer mit Target tgt (tgt Variable mit TARGET-Attribut)
- - ptr1 => ptr2 !! kopiert Pointerreferenz von ptr2 auf ptr1
-
- PROGRAM testprog
- IMPLICIT NONE
- INTEGER, POINTER :: ptr, q
- INTEGER, TARGET :: n, m
-
- n = 1
- m = 4
-
- ptr => n !! ptr zeigt auf n
- q => ptr !! q zeigt auf n
- ptr => m !! ptr zeigt auf m
- ptr = q + n !! nun ist m == 2 !! Hier sieht man gut die automatische Deref.
- END PROGRAM
-
-
-Gefahren beim Umgang mit Pointern:
- - Verwendung/Deref. eines nicht initialisierten/definierten Pointers
- - "Dangling Pointer" : q => n
- ptr => q
- DEALLOCATE(q) !! ptr nun undefiniert
- - memory leaks : nichterreichbare Objekte im Heap (z.B. wenn man DEALLOCATE vergisst)
- - ASSOCIATED abfrage auf einen undef. Pointer
-
-
-Anzeige von
- - Zugriff auf dangling pointer (error) und
- - memory leaks (leak summary - definitely lost)
-nach Ausführung des Programms:
- f95 testprog.f95 -o testprog -g
- valgrind ./testprog
diff --git a/einfuehrungen/einfuehrung_sub_fun.txt b/einfuehrungen/einfuehrung_sub_fun.txt
deleted file mode 100644
index dc23974bbc76dcabad28ac0222add7875246d9d5..0000000000000000000000000000000000000000
--- a/einfuehrungen/einfuehrung_sub_fun.txt
+++ /dev/null
@@ -1,144 +0,0 @@
-„in Blatt 4 werden Module, Funktionen und Subroutinen genutzt
-Subroutinen: Programmteile, die man wiederverwenden kann
- Vorteil: Sachen nicht mehrmals schreiben (Code-Dopplung vermeiden!)
- mehr Übersicht, wenn man ignoriert, wie das im Detail passiert und das Hauptprogramm übersichtlich wird
-Syntax:“
-
-PROGRAM testprog
- ! Hauptprogramm
-
-CONTAINS
-
- SUBROUTINE ausgabe(myname)
- CHARACTER(len = 5), INTENT(IN) :: myname ! INTENT(IN): ist input, kann nicht verändert werden
-
- WRITE(*,*) "Hallo, mein Name ist ", myname, ". Bitte sprich mit mir."
- READ(*,*) ! unnuetze Eingabe
- END SUBROUTINE
-
-END PROGRAM
-
-„Dann im HP aufrufen:“
-ergänze im obigen Programm:
-
-PROGRAM testprog
- IMPLICIT NONE
-
- CALL ausgabe("Dummy")
-
-CONTAINS
- ...
-END PROGRAM
-
-„oft: Eingabe mit Überprüfung auf Sinnhaftigkeit
-Nach Ausführung des Unterprogramms soll berechneter (eingegebener) Wert im Hauptprogramm genutzt werden.
-Option 1 mit subroutine:“
-
-PROGRAM
- SUBROUTINE anzahleingabe(eingabeaufforderung, benutzereingabe)
- CHARACTER(len = *), INTENT(IN) :: eingabeaufforderung ! len = * -> übernommene Länge
- INTEGER, INTENT(OUT) :: benutzereingabe ! voriger Wert des Arguments wird ignoriert
-
- DO
- WRITE(*,*) eingabeaufforderung
- READ (*,*) benutzereingabe
- IF (benutzereingabe > 0) THEN
- EXIT
- ELSE
- WRITE(*,*) "Eingabe fehlerhaft. Bitte nochmal."
- END IF
- END DO
- END SUBROUTINE
-
-„also: Variable außen wird verändert, wenn sie innen neu gesetzt wird
--> darauf immer aufpassen, kann mit INTENT(IN/OUT/INOUT) gut geprüft werden
-Alternative: FUNCTION: "wie in der Mathematik" (aber nur, wenn INTENT(IN) angegeben ist,
-andernfalls koennen die Eingabeparameter veraendert werden!):
-man gibt Argumente rein, bekommt Ergebnis raus
-damit kann man weiterrechnen, z.B. mittelwert = REAL(summe)/n (in Zyklus Programm)
-Das Ergebnis nennt man "Rückgabewert"“
-
- FUNCTION anzahleingabe(eingabeaufforderung)
- CHARACTER(len = *), INTENT(IN) :: eingabeaufforderung ! len = * -> übernommene Länge
- INTEGER :: anzahleingabe ! innerhalb der Funktion ist eingabe eine
- ! normal nutzbare Variable, bekommt einen Typ
-
- DO
- WRITE(*,*) eingabeaufforderung
- READ (*,*) anzahleingabe
- IF (anzahleingabe > 0) THEN
- EXIT
- ELSE
- WRITE(*,*) "Eingabe fehlerhaft. Bitte nochmal."
- END IF
- END DO
- END FUNCTION
-
-„um rekursive Funktionen zu schreiben, muss "namenseingabe" als Funktion zur Verfügung stehen.
-Dafür muss die Variable, die den Rückgabewert enthält anders heißen:â€
-
- RECURSIVE FUNCTION add(a, n) RESULT(sum)
- ! returns a + n in convoluted method
- INTEGER :: a, n, sum
-
- IF (n == 0) THEN
- sum = a
- ELSE (n < 0) THEN
- sum = add(a - 1, n + 1) ! rekursiver Aufruf, liefert (a - 1) + (n + 1)
- ELSE
- sum = add(a + 1, n - 1) ! auch rekursiver Aufruf
- END IF
- END FUNCTION
-
-„RESULT kann man immer benutzen, wenn man den Funktionsnamen nicht als Variable in der Funktion nutzen möchte
-
-Um dem Projekt mehr Struktur zu geben, sammelt man Subroutinen, Funktionen, Konstantendeklarationen
-in sogenannten Modulen.
-Module sind unabhängig von Programmen und können in verschiedenen Programmen wiederverwendet werden.
-Z.B. werden wir ein Modul von Prof. Walter für Intervallarithmetik in Kürze sehenâ€
-
-MODULE simpleIO
- IMPLICIT NONE
-
- ! VOR dem "CONTAINS" statement werden hier KIND parameter definiert, die von
- ! allen Funktionen/Subroutinen verwendet werden koennen (KIND Parameter
- ! koennen nicht implizit uebernommen werden)
-
- INTEGER, PARAMETER :: realkind = SELECTED_REAL_KIND(p = 15, r = 100)
- INTEGER, PARAMETER :: intkind = SELECTED_INT_KIND(i = 20)
- ! i = 20 bedeutet Zahlen von -10^i bis 10^i können dargestellt werden
-
-CONTAINS
-
- FUNCTION anzahleingabe(eingabeaufforderung)
- CHARACTER(len = *), INTENT(IN) :: eingabeaufforderung ! len = * -> übernommene Länge
- INTEGER, (KIND=intkind) :: anzahleingabe ! innerhalb der Funktion ist anzahleingabe eine
- ! normal nutzbare Variable, bekommt einen Typ
-
- DO
- WRITE(*,*) eingabeaufforderung
- READ (*,*) anzahleingabe
- IF (anzahleingabe > 0) THEN
- EXIT
- ELSE
- WRITE(*,*) "Eingabe fehlerhaft. Bitte nochmal."
- END IF
- END DO
- END FUNCTION
-
-END MODULE
-
-„um das zu nutzen, muss es im Hauptprogramm importiert werden mit USE:“
-
-PROGRAM testprog
- USE simpleIO
- IMPLICIT NONE
-
- INTEGER :: n
-
- n = anzahleingabe("Hallo, gib eine Zahl ein.")
-END PROGRAM
-
-„beim Kompilieren muss beides kompiliert werden, das Modul allerdings
-zuerst:
-f95 simpleIO.f95 testprog.f95 -o testprog“
diff --git a/einfuehrungen/einfuehrung_verzweigung_if.txt b/einfuehrungen/einfuehrung_verzweigung_if.txt
deleted file mode 100644
index 6869e305504ebdedf5f0795694fe9993a7c05cd4..0000000000000000000000000000000000000000
--- a/einfuehrungen/einfuehrung_verzweigung_if.txt
+++ /dev/null
@@ -1,58 +0,0 @@
-3. Ãœbungsblatt
-
-„3. Übungsblatt fordert, dass man unterschiedlich reagiert, abhängig von der Benutzereingabe
-Dafür gibt es Verzweigungen, schon kurz in e^x-Programm gesehen“
-
-INTEGER :: alter
-READ (*,*) alter
-IF (ALTER < 0) THEN
- WRITE(*,*) "Du wirst in der Zukunft geboren."
-END IF
-WRITE(*,*) "In 5 Jahren wirst du", alter + 5, "Jahre alt sein."
-
-„in den Klammern steht eine Bedingung, die wahr oder
-falsch sein kann. Ist sie .TRUE., wird der Block zwischen
-THEN und END IF ausgeführt.“
-„Manchmal möchte man auch im anderen Fall etwas tun. Dafür gibt es ELSE“
-
-IF (alter < -5) THEN
- WRITE(*,*) "Geduld"
-ELSE IF(alter < 0) THEN
- WRITE(*,*) "Geburt in < 5 Jr."
-ELSE
- WRITE(*,*) "In 5 Jahren wirst du", alter + 5, "Jahre alt sein."
-END IF
-
-„ELSE passiert, wenn keiner der IF Zweige eintritt.“
-
-LOGICAL :: verbose
-READ(*,*) verbose
-! kann T (-> .TRUE.) oder F (-> .FALSE.) sein
-IF (verbose) THEN
- WRITE(*,*) "Das Programm endet."
-END IF
-
-„LOGICAL ist ein Datentyp, der nur wahr (.TRUE.) oder falsch (.FALSE.) sein kann
-Man sieht: Bedingung in IF-Bedingung kann beliebiger Ausdruck sein, der
-wahr oder falsch sein kann. (z.B. keine Zahl)“
-
-------------------
-
-spiel: DO
- WRITE(*,*) "Hi, spiele mit mir!"
- DO
- WRITE(*,*) "spielzug"
- READ(*,*) zug
- IF (zug == "doof") THEN
- EXIT spiel ! beendet äußere Schleife
- ! geht also zu END DO spiel
- ELSE IF (zug == "nein") THEN
- EXIT ! beendet innere Schleife
- END IF
- END DO
-END DO spiel
-
-„Wenn man EXIT nutzt, verlässt man die innerste Schleife.
-Um eine äußere Schleife zu verlassen, muss sie einen Namen haben.“
-
-„Außerdem: Terminalhilfe zu pipes“
diff --git a/einfuehrungen/einfuehrung_verzweigung_schleifen.txt b/einfuehrungen/einfuehrung_verzweigung_schleifen.txt
deleted file mode 100644
index 523fb80fd61d2eb86fce4bfd3800d279f36ed1ef..0000000000000000000000000000000000000000
--- a/einfuehrungen/einfuehrung_verzweigung_schleifen.txt
+++ /dev/null
@@ -1,58 +0,0 @@
-2. Ãœbungsblatt Aufgabe 3 fordert 2 Schleifen
-
-„bisher: Befehle nacheinander ausgeführt
-häufig: sehr ähnliche Arbeit soll häufig ausgeführt werden
-häufig: man weiß als Programmierer nicht wie häufig
--> man braucht Schleifen
--> in Fortran gibt es nur eine Schleife in 2 Varianten“
-
-DO
- WRITE(*,*) 'Hallo Welt'
-END DO
-
-f95 -> Ausführen
-
-Abbrechen mit Strg+C
-(„Cancel“)
-„Man kann Endlosschleifen bauen.
-Keine gute Idee.
--> man muss dem Computer sagen, wann er abbrechen soll.“
-
-DO
- WRITE(*,*) 'Hallo Welt'
- EXIT
-END DO
-
--> f95 -> Ausführen ->
-„Beim ersten Mal abgebrochen. Schleife nutzlos.
-Bedingung nötig.“
-
-CHARACTER(len = 2) :: answer
-DO
- WRITE(*,*) 'Hallo Welt. Schreibe "ja"'
- READ(*,*) answer
- IF (answer == 'ja') THEN
- EXIT
- END IF
-END DO
-
-„mit if kann eine Verzweigung (Bedingung) programmiert werden.
-In die Klammern kommt ein LOGICAL-Wert, z.B.
-das Ergebnis eines Vergleiches.
-
-EXIT wird nun nur ausgeführt, wenn die Bedingung .TRUE. ist“
-
-f95 -> Ausführen
-
-„sehr häufig: man braucht einen Wert, der sich bei jedem Schleifendurchlauf
-ändert. Dafür Zählschleife:“
-
-INTEGER :: klasse
-
-DO klasse = 0,10,1
- WRITE(*,*) 'Hallo Klasse', klasse, 'a.'
-END DO
-
-„man sieht: bei jedem Durchlauf wird der Wert von 'klasse' um 1 erhöht
-der 3. Wert ist die Schrittweite, kann bei 1 weggelassen werden“
-
diff --git a/einfuehrungen/klausur-tipps.txt b/einfuehrungen/klausur-tipps.txt
deleted file mode 100644
index 081c62c9cf8413036d559493ccab118a7e80b9a7..0000000000000000000000000000000000000000
--- a/einfuehrungen/klausur-tipps.txt
+++ /dev/null
@@ -1,46 +0,0 @@
-Gedanken zur PROG Klausur -- Diese Datei ist wie üblich auch online!
-Diese Liste ist äußert unvollständig!
-
-denke an:
-• Lies jede Aufgabe mehrmals konzentriert (= langsam) und achte auf alle Details.
-• Lies die Aufgabe nochmal nachdem du ein generelles Konzept hast.
-• Lies jeden Aufgabeteil nochmal durch bevor du ihn bearbeitest.
-• Lies die Aufgabe nochmal, wenn du fertig bist.
-
-• PUBLIC/ PRIVATE: setze alles auf privat und dann einzeln die für ein Hauptprogramm relevanten Unterprogrammen, Konstanten und Interfaces auf public
- - wenn es sinnvoll ist (häufig) setze Typ-Komponenten selbstdefinierter Datentypen auf private:
- TYPE(CMPX)
- PRIVATE
- REAL :: eins, imag
- END TYPE
-
-• INTENT(IN): bei allen Argumenten von Unterprogrammen gib INTENT(IN/OUT/INOUT) an. Ist Punkte wert.
-
-• KIND bei Konstanten: wenn man hard-coded Zahlen im Programm hat, bspw.
- INTEGER, PARAMETER :: pr = SELECTED_REAL_KIND(32, 10)
- REAL (pr), PARAMETER :: euler = 2.718281828459045235360287471352
-
- muss man darauf achten, dass Zahlen (REAL oder INTEGER) erstmal den Standard-KIND-Wert haben.
- Das heißt im obigen Beispiel wird von 2.718... ein großer Teil beim Reduzieren auf einfache Genauigkeit
- verloren und dann wieder in eine Zahl mit hoher Genauigkeit gewandelt, die dann falsch ist.
- Daher bei konstanten Zahlen im Code die Genauigkeit mit angeben:
-
- REAL (pr), PARAMETER :: euler = 2.718281828459045235360287471352_pr ! achte auf _pr am Ende!
-
-• schaue dir die Syntax von TYPE-Deklarationen an
-
-• END DO, DEALLOCATE (bei ALLOCATABLE arrays/pointern), CLOSE (bei Dateien)
-
-• Bei der Klausur nach dem 2. Semester werden auch theoretische Fragen kommen (Aufteilung ca. 50/50).
-
-
-Empfehlungen:
-• Variablennamenlänge: finde einen sinnvoller Kompromiss zwischen Lesbarkeit und Schreibgeschwindigkeit. I.d.R. sollte man mit 3 bis 5 Buchstaben gut merkbare Abkürzungen hinkriegen
- - mit unleserlichem Code nervt ihr Korrektoren - keine gute Idee
-• es ist kein Problem, wenn man nicht mit allem fertig wird. Darauf ist die Klausur nicht ausgelegt.
-
-Resourcen:
-• die Dateien in einführungen (stura.link/progmaterial bzw. https://gitlab.math.tu-dresden.de/wwalter/PROG-material-public wenn ihr das repo clonen wollt)
-• github.com/linfelix/sonderuebung -> das Material von Felix für die Sonderübung
-• die Dateien auf OPAL - diese dürfen auch in der Klausur genutzt werden
-• das Fortran Nachschlagewerk - dieses darf auch in der Klausur genutzt werden (um sich damit vertraut zu machen, sollte man darin vorher gelesen haben - besonders hilfreich bei theoretischen Fragen zu pointern)
diff --git a/hilfsprogramme/io_example.f95 b/hilfsprogramme/io_example.f95
deleted file mode 100644
index 11be03d4e9c5da9e88f7c3881aedde1f00e863d6..0000000000000000000000000000000000000000
--- a/hilfsprogramme/io_example.f95
+++ /dev/null
@@ -1,68 +0,0 @@
-PROGRAM io_example
- IMPLICIT NONE
- ! dieses Beispielprogramm arbeitet mit Daten, die vom Programm puzzleschreiben.f95 erzeugt werden,
- ! bspw. durch die Aufrufe
- ! frun puzzleschreiben
- ! Eingabe 3, 2, blabli
- ! mv puzzle1.puz input.dat
-
- TYPE datensammlung
- INTEGER :: norden, osten, sueden, westen
- CHARACTER :: text
- END TYPE
-
- INTEGER :: err, norden
- INTEGER, DIMENSION(4) :: zahlen
- CHARACTER (len = 5) :: text
- TYPE (datensammlung) :: zeile
-
- OPEN(FILE = "input.dat", UNIT = 20, ACTION = "READ", IOSTAT = err)
- IF (err /= 0) THEN
- ! bedeutet irgendeinen Fehler beim Öffnen der Datei
- STOP "Konnte Lesedatei nicht öffnen!"
- ! irgendwie sinnvollere Fehlerbehandlung
- END IF
- OPEN(FILE = "output.dat", UNIT = 21, ACTION = "WRITE", IOSTAT = err)
- IF (err /= 0) THEN
- ! bedeutet irgendeinen Fehler beim Öffnen der Datei
- STOP "Konnte Schreibdatei nicht öffnen!"
- END IF
-
- READ(20, *) norden ! liest die erste Zahl in 'norden' ein
- WRITE(*, *) "Die erste gespeicherte Zahl:", norden ! testweise ausgeben
-
- WRITE(21, *) "Eine eingelesene Zahl wird gespeichert:"
- WRITE(21, *) norden
- WRITE(21, *) ! leere Zeile
-
- READ(20, *) zahlen, text
- WRITE(21, *) "Die folgende Zeile ist aus der Eingabedatei, aber anders herum:"
- WRITE(21, *) text, zahlen(4:1:-1) ! Zeile in umgekehrter Reihenfolge wieder abspeichern
- WRITE(21, *) ! leere Zeile
-
-
- READ(20, *) zeile
- WRITE(21, *) "Selbstdef. Typ Ausgabe:"
- WRITE(21, *) "text:", zeile%text, " N:", zeile%norden, "O:", zeile%osten, &
- & "S:", zeile%sueden, "W:", zeile%westen
- WRITE(21, *) ! leere Zeile
-
- CLOSE(21) ! schließen sobald nicht mehr gebrauch
-
- WRITE(*, *) "Die restlichen Texte:"
- DO
- READ(20, *, iostat = err) zahlen, text ! setzt den Curser mindestens auf nächste Zeile
- IF (err < 0) THEN
- ! Datei zu Ende
- EXIT
- ELSE IF (err > 0) THEN
- ! Fehler
- WRITE(*,*) "Lesefehler, z.B. konnte Eingabe nicht als INTEGER verstanden werden"
- ELSE
- WRITE(*, "(A)", ADVANCE = "NO") text
- END IF
- END DO
- WRITE(*,*) ! leere Zeile
-
- CLOSE(20) ! schließen sobald nicht mehr gebrauch
-END PROGRAM
diff --git a/hilfsprogramme/operation_priority.f95 b/hilfsprogramme/operation_priority.f95
deleted file mode 100644
index 3951f5f0b6f268d960e72d630305c26bd0af60d8..0000000000000000000000000000000000000000
--- a/hilfsprogramme/operation_priority.f95
+++ /dev/null
@@ -1,71 +0,0 @@
-module int_type
- implicit none
- private
-
- public :: inte, operator(**), operator(-), operator(+), operator(.e.), operator(.p.), operator(.n.)
-
- type inte
- integer :: i
- end type inte
-
- interface operator(**)
- module procedure exp2
- end interface
- interface operator(+)
- module procedure plus
- end interface
- interface operator(-)
- module procedure neg
- end interface
- interface operator(.e.)
- module procedure exp2
- end interface
- interface operator(.p.)
- module procedure plus
- end interface
- interface operator(.n.)
- module procedure neg
- end interface
-
-contains
-
- function exp2(e,x)
- type(inte), intent(in) :: e,x
- type(inte) :: exp2
- exp2%i=e%i**x%i
- end function exp2
-
- function plus(e,x)
- type(inte), intent(in) :: e,x
- type(inte) :: plus
- plus%i=e%i+x%i
- end function plus
-
- function neg(x)
- type(inte) :: neg
- type(inte), intent(in) :: x
- neg%i = -x%i
- end function neg
-end module int_type
-
-program operation_priority
- use int_type
- implicit none
- type(inte) :: a, b
- a%i = 2; b%i=0
- write(*,*) "a**a**b ", a**a**b ! rechts nach links wie nächste Zeile
- write(*,*) "a**(a**b) ", a**(a**b) ! 2**2**0 = 2**1 = 2
- write(*,*) "(a**a)**b ", (a**a)**b ! (2**2)**0 = 4**0 = 1
- write(*,*) "a.e.a.e.b ", a.e.a.e.b ! eigener Operator: links nach rechts: = 1
-
- write(*,*) "a+a**a ", a+a**a ! exp vor +
- write(*,*) "a**a+a ", a**a+a ! exp vor + : 2**2+2=4+2=6
- write(*,*) "a.p.a.e.a ", a.p.a.e.a ! eigener Operator: links nach rechts (2+2)**2=16
- write(*,*) "a.e.a.p.a ", a.e.a.p.a ! eigener Operator: links nach rechts 2**2+2=6
-
-
- write(*,*) "a+a.e.a ", a+a.e.a ! + vor eigener Operator (binär) (2+2)**2=16
-
- write(*,*) "-a**a ", -a**a ! exp vor -: -2**2=-4
- write(*,*) ".n.a**a ", .n.a**a ! eigener Operator (unär) vor exp: (-2)**2=4
-end program operation_priority
diff --git a/hilfsprogramme/puzzleschreiben.f95 b/hilfsprogramme/puzzleschreiben.f95
deleted file mode 100644
index e3dd63ad16bbacb9d440ddd1b095a4066472d17e..0000000000000000000000000000000000000000
--- a/hilfsprogramme/puzzleschreiben.f95
+++ /dev/null
@@ -1,196 +0,0 @@
-PROGRAM puzzleschreiben
- ! Dieses Programm schreibt ein Puzzle in eine Datei.
- ! Diese Puzzle können von Programmen für die Aufgabe 17 von Blatt 8
- ! Nummerierung vom SoSe 2016) gelöst werden.
- ! Das Programm nimmt drei Argumente:
- ! 1) Die Breite des Puzzles
- ! 2) Die Höhe des Puzzles
- ! 3) Die Beschriftung des Puzzles (wenn es zu wenig Zeichen sind, werden die restlichen mit Leerzeichen aufgefüllt)
- ! wenn das Puzzle mehr als 1000 Teile hat und mehr als 1000 Zeichen angegeben werden, werden trotzdem nur 1000 Teile beschriftet. Euren nächsten Roman könnt ihr hier also nicht verewigen. Sorry. (Bei Bedarf ersetze 1000 unten durch einen größeren Wert.)
- ! Also eine beispielhafte Nutzung ist
- ! f95 puzzleerzeugen.f96 -o pe
- ! ./pe 5 3 "Puzzle sindTOLL"
-
- IMPLICIT NONE
-
- TYPE teil
- ! ein Puzzleteil
- ! oben, rechts, unten, links
- INTEGER, DIMENSION(4) :: seiten = 0
- CHARACTER :: beschriftung = " "
- END TYPE
-
- INTEGER, PARAMETER :: NORTH = 4, EAST = 1, WEST = 3, SOUTH = 2, unitnr = 30, zufaellig = 30
- INTEGER :: pmEins, spalte, zeile, error
- INTEGER :: width = 0, heigth = 0
- INTEGER, DIMENSION(:,:), ALLOCATABLE :: zeilenbuchten, spaltenbuchten
- INTEGER, DIMENSION(:), ALLOCATABLE :: buchtenliste
- TYPE(teil), DIMENSION(:,:), ALLOCATABLE :: teile
- CHARACTER(len=20) :: format
- CHARACTER, DIMENSION(:), ALLOCATABLE :: puzzletext
- CHARACTER(len=1000) :: text
- ! bei einer Zeichenkette wüsste ich nicht wie ich einzelne Zeichen ansprechen könnte
-
- ! Höhe und Breite einlesen, falls nicht als Argumente gegeben
- if (COMMAND_ARGUMENT_COUNT() < 3) then
- WRITE(*,*) "Du kannst die Breite, Höhe und Beschriftung des Puzzles&
- & einfach hinter den Programmaufruf schreiben. Gib jetzt die Höhe ein:"
- READ(*,*, iostat = error) heigth
- if (error /= 0 .OR. heigth < 1) then
- STOP "Höhenangabe konnte nicht als natürliche Zahl geparst werden."
- endif
- WRITE(*,*) "Breite:"
- READ(*,*, iostat = error) width
- if (error /= 0 .OR. width < 1) then
- STOP "Breitenangabe konnte nicht als natürliche Zahl geparst werden."
- endif
- WRITE(*,*) "Text, der auf dem Puzzle steht (wenn Leerzeichen enthalten sind umrahme den Text mit Anführungszeichen):"
- READ(*,*, iostat = error) text
- else
- CALL GETARG(2, text)
- READ(UNIT=text, FMT=*, iostat = error) heigth
- if (error /= 0 .OR. heigth < 1) THEN
- STOP "Höhenangabe konnte nicht als natürliche Zahl geparst werden."
- ELSE
- WRITE(*,*) "Höhe", heigth
- END IF
-
- CALL GETARG(1, text)
- READ(UNIT=text, FMT=*, iostat = error) width
- if (error /= 0 .OR. width < 1) THEN
- STOP "Breitenangabe konnte nicht als natürliche Zahl geparst werden."
- ELSE
- WRITE (*,*) "Breite", width
- END IF
-
- CALL GETARG(3, text)
- endif
-
- ALLOCATE(zeilenbuchten(width-1, heigth))
- ALLOCATE(spaltenbuchten(width, heigth-1))
- ALLOCATE(buchtenliste(SIZE(zeilenbuchten) + SIZE(spaltenbuchten)))
- ALLOCATE(teile(width, heigth))
- ALLOCATE(puzzletext(width*heigth))
-
- ! jedes Zeichen wird einzeln gelesen und in ein Element geschrieben
- WRITE(format, "(A,I0,A)") "(", width*heigth, "(A1))"
- ! WRITE(*,"(A,I0,A)") "Beschriftung des Puzzles (", width*heigth, " Zeichen inkl. Leerzeichen)"
- READ(text,format) teile%beschriftung
-
- ! rechteckig ausgeben
- WRITE(*,*) "Das Puzzle wird mit folgendem Text beschrieben:"
- WRITE(format, "(A,I0,A)") "(", width, "A)"
- WRITE(*,format) teile%beschriftung
-
- buchtenliste = permutation(SIZE(buchtenliste))
- ! zwischenspeichern, damit alle Nummern über alle Buchten verteilt werden
- ! und es keine getrennte Nummerierung für senkrechte und waagerechte Buchten gibt
- zeilenbuchten = reshape(buchtenliste(:SIZE(zeilenbuchten)), SHAPE(zeilenbuchten))
- spaltenbuchten = reshape(buchtenliste(SIZE(zeilenbuchten) + 1:), SHAPE(spaltenbuchten))
- WRITE(format, "(A,I0,A)") "(", width-1, "(I3))"
- WRITE(*,*) "Zeilenbuchten"
- WRITE(*, format) zeilenbuchten
- WRITE(*,*) "Spaltenbuchten"
- WRITE(format, "(A,I0,A)") "(", width, "(I3))"
- WRITE(*, format) spaltenbuchten
-
- ! -------------
- ! die Buchten in die Teile schreiben.
- ! erst für die waagerechten Buchten, dann die senkrechten
- ! -------------
- DO spalte = 1, width-1
- DO zeile = 1, heigth
- pmEins = INT(RAND()*2) *2-1
- teile(spalte, zeile)%seiten(EAST) = pmEins*zeilenbuchten(spalte, zeile)
- teile(spalte + 1, zeile)%seiten(WEST) = - pmEins*zeilenbuchten(spalte, zeile)
- END DO
- END DO
- DO spalte = 1, width
- DO zeile = 1, heigth-1
- pmEins = INT(RAND()*2) *2-1
- teile(spalte, zeile)%seiten(SOUTH) = pmEins*spaltenbuchten(spalte, zeile)
- teile(spalte, zeile + 1)%seiten(NORTH) = - pmEins*spaltenbuchten(spalte, zeile)
- END DO
- END DO
-
- WRITE(*,*) "Teile vor dem Verdrehen"
- CALL putTeile()
-
- ! drehe Teile zufaellig
- ! schreibe Text auf die Teile
- WRITE(*,*)
- do zeile = 1, width
- do spalte = 1, heigth
- ! Eckteile werden nicht gedreht:
- if (.NOT. ((zeile == 1 .OR. zeile == width) .AND. (spalte == 1 .OR. spalte == heigth))) then
- ! zufaellig 0 bis 4 Seiten weit rotiert
- teile(zeile, spalte)%seiten = CSHIFT(teile(zeile, spalte)%seiten, INT(RAND()*4))
- end if
- ! teile(zeile, spalte)%beschriftung =
- END DO
- END DO
-
- WRITE(*,*) "Teile nach dem Verdrehen"
- CALL putTeile()
-
- ! schreibe Teile in zufaelliger Reihenfolge in eine Datei
- DO pmEins = 1, 30 ! pmEins und format hier missbraucht
- WRITE(format, "(A,I0,A)") "puzzle", pmEins, ".puz"
- WRITE(*,*) format
- OPEN(UNIT=unitnr, file=format, status="NEW", iostat=error, action="WRITE")
- IF (error == 0) EXIT
- IF (pmEins == 30) error = 1 ! I know, bad code, make it better
- ! otherwise try next file
- END DO
-
- IF (error == 0) THEN
- ! Breite und Hoehe in die Datei schreiben
- WRITE(unitnr, *) heigth, width
- buchtenliste = permutation(SIZE(teile))
- DO pmEins = 1, SIZE(buchtenliste)
- ! zeilenweise nummerieren
- CALL saveTeil(teile(&
- & MOD(buchtenliste(pmEins)-1, width) + 1, &
- & (buchtenliste(pmEins)-1)/width + 1 ) )
- END DO
- ELSE
- WRITE(*,*) "Konnte keine Datei öffnen. Überprüfe, ob es eine der &
- & Dateien puzzle1-30.puz noch nicht gibt und ich Schreibrechte habe."
- END IF
- CLOSE(unitnr)
-
-CONTAINS
-
- FUNCTION permutation(groesse)
- INTEGER :: groesse, i, index, tauscher, tauschwert
- INTEGER, DIMENSION(groesse) :: permutation
- INTEGER, DIMENSION(8) :: time
- CALL DATE_AND_TIME(VALUES=time)
- ! Pseudozufall mithilfe der aktuellen Uhrzeit
- tauscher = RAND(SUM(time))
- ! permutation = (i = 1, groesse)
- permutation = (/ (i, i = 1, groesse) /)
- DO i=1, zufaellig ! so viele Durchgaenge an Vertauschungen
- DO index = 1, groesse ! jede Position mal vertauschen
- tauscher = 1 + groesse * RAND()
- ! WRITE(*,*) tauscher
- tauschwert = permutation(tauscher)
- permutation(tauscher) = permutation(index)
- permutation(index) = tauschwert
- END DO
- END DO
- END FUNCTION
-
- SUBROUTINE putTeile()
- WRITE(format, "(A,I0,A)") "(", width, "(4(I3),1X,A,2X))"
- WRITE(*,*) "Teile"
- WRITE(*, format) teile
- END SUBROUTINE
-
- SUBROUTINE saveTeil(puzzleteil)
- TYPE(teil) :: puzzleteil
- WRITE(unitnr, ("(4(I6,1X),A,A,A)")) puzzleteil%seiten, '"', &
- & puzzleteil%beschriftung, '"'
- END SUBROUTINE
-
-END PROGRAM
diff --git a/hilfsprogramme/quaternionen.f95 b/hilfsprogramme/quaternionen.f95
deleted file mode 100644
index d5b8bdcf438700c3d8440eef94e2c244a83d567d..0000000000000000000000000000000000000000
--- a/hilfsprogramme/quaternionen.f95
+++ /dev/null
@@ -1,93 +0,0 @@
-MODULE quaternionen_mod
- IMPLICIT NONE
-
- PRIVATE
- PUBLIC :: pr, intsize, quat, OPERATOR (+), OPERATOR (*), eins, i, j, k, put
-
- INTEGER, PARAMETER :: pr = SELECTED_REAL_KIND(P = 15, R=307)
- INTEGER, PARAMETER :: intsize = SELECTED_INT_KIND(20)
-
- TYPE quat
- PRIVATE
- REAL (kind = pr) :: reell, imag, jmag, kmag
- END TYPE
-
- INTERFACE OPERATOR (+)
- MODULE PROCEDURE add
- END INTERFACE
-
- INTERFACE OPERATOR (*)
- MODULE PROCEDURE mul, realmul, intmul
- END INTERFACE
-
- TYPE (quat), PARAMETER :: eins = quat(1, 0, 0, 0)
- TYPE (quat), PARAMETER :: i = quat(0, 1, 0, 0)
- TYPE (quat), PARAMETER :: j = quat(0, 0, 1, 0)
- TYPE (quat), PARAMETER :: k = quat(0, 0, 0, 1)
-
-CONTAINS
-
- FUNCTION add(a, b)
- TYPE(quat), INTENT(IN) :: a, b
- TYPE(quat) :: add
- add%reell = a%reell + b%reell
- add%imag = a%imag + b%imag
- add%jmag = a%jmag + b%jmag
- add%kmag = a%kmag + b%kmag
- END FUNCTION
-
- FUNCTION mul(a, b)
- TYPE(quat), INTENT(IN) :: a, b
- TYPE(quat) :: mul
- mul%reell = a%reell * b%reell &
- & - a%imag * b%imag &
- & - a%jmag * b%jmag &
- & - a%kmag * b%kmag
- mul%imag = a%reell * b%imag &
- & + a%imag * b%reell &
- & + a%jmag * b%kmag &
- & - a%kmag * b%jmag
- mul%jmag = a%reell * b%jmag &
- & - a%imag * b%kmag &
- & + a%jmag * b%reell &
- & + a%kmag * b%imag
- mul%kmag = a%reell * b%kmag &
- & + a%imag * b%jmag &
- & - a%jmag * b%imag &
- & + a%kmag * b%reell
- END FUNCTION
-
- FUNCTION realmul(skalar, a)
- REAL (kind = pr), INTENT(IN) :: skalar
- TYPE(quat), INTENT(IN) :: a
- TYPE(quat) :: realmul
- realmul = quat(skalar * a%reell, skalar * a%imag, skalar * a%jmag, skalar * a%kmag)
- END FUNCTION
-
- FUNCTION intmul(skalar, a)
- INTEGER (kind = intsize), INTENT(IN) :: skalar
- TYPE(quat), INTENT(IN) :: a
- TYPE(quat) :: intmul
- intmul = quat(skalar * a%reell, skalar * a%imag, skalar * a%jmag, skalar * a%kmag)
- END FUNCTION
-
- SUBROUTINE put(a)
- TYPE(quat), INTENT(IN) :: a
- WRITE(*,*) a%reell, " + ", a%imag, "i + ", a%jmag, "j + ", a%kmag, "k"
- END SUBROUTINE
-END MODULE
-
-PROGRAM quaternionen
- USE quaternionen_mod
- IMPLICIT NONE
-
- TYPE(quat) :: q
- ! q = add(eins,i) ! Fehler, add nicht public
- ! WRITE(*,*) q ! Fehler, Komponenten von q sind private
-
- q = eins + i
- call put(q)
-
- q = 3.0_pr*eins + 5_intsize*i ! _pr und _intsize muss angefuegt werden, damit die Typen in realmul und intmul passen
- call put(q)
-END PROGRAM
diff --git a/hilfsprogramme/random.f95 b/hilfsprogramme/random.f95
deleted file mode 100644
index 17959f2f355f8b9652c11257efdb5d9c52e163fa..0000000000000000000000000000000000000000
--- a/hilfsprogramme/random.f95
+++ /dev/null
@@ -1,25 +0,0 @@
-! benutze random_init um eine neue Peudozufallsfolge für random_number zu erzeugen
-module random
- implicit none
- private
- public random_init
-contains
- subroutine random_init()
- integer :: n, unit_nr = 101, stat, clock, i
- integer, dimension(:), allocatable :: seed
- call random_seed(size=n)
- allocate(seed(n))
- open(unit=unit_nr,file="/dev/urandom",status="old",access="stream",action="read", iostat=stat)
- if( stat /= 0 ) then
- write(*,*) "Warning can't open /dev/urandom, use system time instead"
- call system_clock(count=clock)
- seed = clock + 41 * (/ (i, i = 1, n) /)
- call random_seed(put=seed)
- else
- read(unit_nr) seed
- call random_seed(put=seed)
- close(unit_nr)
- end if
- deallocate(seed)
- end subroutine random_init
-end module random