Finish Übungstest 6

angabe/Aufgabenblatt8.md

@@ -0,0 +1,152 @@
+# Aufgabenblatt 8
+
+## Allgemeine Anmerkungen
+Ihre Lösung für dieses Aufgabenblatt ist bis Dienstag, 13.6., 11h durch `git commit` und `git push` 
+abzugeben.
+Wenn Sie zusätzlich zu den gefragten Klassen und Interfaces weitere Klassen oder 
+Interfaces definieren, achten Sie darauf, dass die Klassennamen mit `My` beginnen, um Konflikte 
+mit späteren Aufgabenblättern zu vermeiden.
+
+Weiters werden die Dateien `StateFileNotFoundException.java`, 
+`StateFileFormatException.java`, `ReadDataUtil.java`, `Simulation8.java`, `Simulation9.java`,
+ `Aufgabe8Test.java` und das Verzeichnis `states` mit `txt`-Dateien mitgeliefert. 
+
+## Ziel
+Ziel der Aufgabe ist das Verständnis und die Anwendung der Konzepte: Java-Collections, Eingabe mit 
+Validierung, Exceptions (S. 110-123).
+
+## Beschreibung der gegebenen Dateien
+
+- [states](../states) ist ein Verzeichnis, in dem mehrere Dateien mit der Endung `.txt` 
+ mitgeliefert werden. Diese enthalten Daten von je einem Himmelskörper sowie dessen Positionen und
+ Geschwindigkeitsvektoren für alle Tage der Jahre 2019-2021. Die Angaben sind wie gewohnt in 
+ kartesischen Koordinaten, wobei die Sonne den Urspung des Koordinatensystems bildet und die 
+ Ekliptik die x-y-Ebene darstellt. Die Daten stammen von [https://ssd.jpl.nasa.gov/horizons.cgi#top](https://ssd.jpl.nasa.gov/horizons.cgi#top). 
+   
+    **ACHTUNG**: Die Werte sind in km bzw. km/sec angegeben! 
+                      
+- [StateFileNotFoundException](../src/StateFileNotFoundException.java) enthält die Definition
+der Klasse `StateFileNotFoundException`. Diese sollen Sie vervollständigen.
+- [StateFileFormatException](../src/StateFileFormatException.java) enthält die Definition
+der Klasse `StateFileFormatException`. Diese sollen Sie vervollständigen.
+- [ReadDataUtil](../src/ReadDataUtil.java) ist eine Klasse mit einer statischen Methode zum
+Einlesen von Position- und Bewegungsvektoren von Himmelskörpern aus Dateien. 
+Diese sollen Sie vervollständigen.
+- [Simulation8](../src/Simulation8.java) ist ein Gerüst für eine ausführbare Klasse. Hier soll
+die Simulation analog zur Klasse `Simulation` implementiert werden (damit Sie Ihre [ursprüngliche
+ Datei](../src/Simulation.java) nicht überschreiben müssen).
+- [Simulation9](../src/Simulation9.java) ist eine leere Datei. Hier soll eine weitere Simulation
+implementiert werden, die so wie `Simulation8` funktioniert, mit dem Unterschied, dass anstelle 
+der selbst implementierten Datenstrukturen nur vorgefertigte Klassen aus dem 
+Java-Collection-Framework benutzt werden sollen.
+- [Aufgabe8Test](../src/Aufgabe8Test.java) ist eine vorgegebene Klasse, die Sie zum Testen Ihrer
+Implementierung verwenden sollten. Bei einer fehlerfreien Implementierung sollten bei der
+Ausführung dieser Klasse keine Exceptions geworfen werden und alle Tests als erfolgreich ("successful")
+ausgegeben werden. Entfernen Sie die Kommentarzeichen, um diese Klasse verwenden zu können. Sie
+müssen diese Klasse nicht weiter verändern, können aber eigene Testfälle hinzufügen.
+
+
+## Aufgaben
+
+1. Ändern Sie Ihre Implementierung, sodass ein `MassiveIterator` eine Exception 
+    vom Typ `java.util.NoSuchElementException` wirft, falls `next()` aufgerufen wird,
+    jedoch der Iterator keine weitere Iteration hat (`hasNext()` liefert `false`).
+    
+2. Ändern Sie den Iterator von der von `getKeys()` zurückgelieferten 
+    Sichtweise auf `MassiveForceTreeMap` so, dass `remove()` überschrieben wird 
+    ([siehe API Dokumentation](https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html#remove--)), 
+    sodass der Iterator Einträge in Objekten von `MassiveForceTreeMap` löschen kann. Achten Sie 
+    darauf, dass hier in bestimmten Fällen eine `java.lang.IllegalStateException` geworfen werden
+    soll. Der Iterator von `HierarchicalSystem` muss nicht geändert werden.
+
+3. Validierung von Eingabedaten:
+    - Implementieren Sie in der Klasse `ReadDataUtil.java` die Methode `readConfiguration`.
+    Es soll ein gepufferter Stream zum Einlesen genutzt werden (siehe Skriptum Seite 128). 
+    Erstellen Sie zum Testen auch Varianten der txt-Dateien mit Formatfehlern.
+    - Fügen Sie der Klasse `NamedBody` bei Bedarf 
+    eine Methode `setState(Vector3 position, Vector3 velocity)` zum Setzen der Position 
+    und des Geschwindigkeitsvektors des Himmelskörpers hinzu. 
+    - Definieren Sie die beiden angegebenen Exceptionklassen in den entsprechenden 
+    mitgelieferten Dateien.
+  
+4. Ausnahmebehandlung:
+    In der Klasse `Simulation8` sollen nun die Himmelskörper mit Daten aus den gegebenen 
+    txt-Dateien initialisiert werden. Dabei sollen zumindest die Sonne sowie die 
+    inneren Planeten
+    Merkur, Venus, Erde und Mars vorkommen. Sie können weitere Himmelskörper (siehe txt-Dateien) 
+    hinzufügen. Nutzen Sie die Klasse `MassiveForceTreeMap` und ihre Iteratoren, um die 
+    Himmelskörper der Simulation zu verwalten. (Kollisionen von Himmelskörpern müssen nicht 
+    berücksichtigt werden.)
+    Ändern Sie die Klasse `Simulation8` so, dass sie zwei Kommandozeilenargumente verarbeitet. 
+    Das erste Argument ist ein String mit der Angabe des Pfades zum Verzeichnis, wo die 
+    entsprechenden txt-Dateien (z.B. `Venus.txt`,`Mercury.txt`,`Earth.txt`) mit den Konfigurationen 
+    der Himmelskörper zu finden sind. Die Dateien haben die Namen der Himmelskörper mit Endung `
+    .txt`. Für die Sonne gibt es keine txt-Datei (es wird die Position (0,0,0) angenommen).
+    Das zweite Argument ist ein String mit einer Datumsangabe der Form YYYY-MMM-DD, also z.B. 
+    2020-Dec-04, die den Tag der auszulesenden Position und Bewegungsvektor bestimmt. Die Klasse 
+    soll beim Auftreten von Problemen bei der Ausführung entsprechende Fehlermeldungen ausgeben und
+    die Ausführung in bestimmten Fällen beenden. Beispiele für Aufrufe im Kommandozeileninterpreter 
+    mit entsprechenden Fehlermeldungen (Sie können zum Ausführen das Terminal in IntelliJ nutzen
+    oder die Programmargumente unter `Edit Configurations` angeben):
+    ```
+         $ javac Simulation8.java
+         $ java Simulation8 ../states 2021-May-28
+         Running simulation ...
+         $ java Simulation8 ../states
+         Error: wrong number of arguments.
+         $ java Simulation8 ../states 2025-Dec-12
+         Warning: State not available for Earth.
+         Running simulation without Earth.
+         Warning: State not available for Venus.
+         Running simulation without Venus.
+         ...
+         $ java Simulation8 ../states-altered 2021-May-28
+         Warning: File ../states-altered/Venus.txt does not have required format. 
+         Running simulation without Venus.
+         Warning: File ../states-altered/Mars.txt not found. 
+         Running simulation without Mars.
+         Running simulation ...
+         $ java Simulation8 ../states -17
+         Error: State has wrong format (requires YYYY-MM-DD), aborting. 
+         $ java Simulation8 blah 2021-May-28
+         Warning: File blah/Earth.txt not found. 
+         Running simulation without Earth.
+         Warning: File blah/Venus.txt not found. 
+         Running simulation without Venus.
+         ...
+    ```
+
+5. Kopieren Sie den Inhalt der Datei `Simulation8.java` in die Datei `Simulation9.java` und bauen
+    Sie `Simulation9` so um, dass anstelle der selbst implementierten Datenstrukturen nur 
+    vorgefertigte Klassen aus dem Java-Collection-Framework benutzt werden.
+    
+6. Freiwillige Zusatzaufgabe (ohne Bewertung):
+    Ändern Sie die Klasse `Simulation8` so um, dass ein drittes optionales Kommandozeilenargument
+    verarbeitet werden kann. Dieses gibt an, wieviele Tage simuliert werden sollen. Beispielsweise
+    kann eine zweite Datumsangabe möglich sein, oder die Anzahl an Tagen. 
+    Sobald dieser Zeitpunkt in der Simulation erreicht wurde, können die aktuellen Positionen der
+    Himmelskörper mit den in den txt-Dateien angegebenen Positionen verglichen werden (z.B. 
+    durch erneutem Aufruf von `readConfiguration` und `draw`). Wie groß sind die Abweichungen 
+    der von NASA errechneten Positionen zu den Positionen, die Ihre Simulation liefert?
+
+### Denkanstöße (ohne Bewertung)
+
+1. Haben Sie die remove-Methode des Iterators so implementiert, dass der Aufruf keine 
+zusätzliche Suche nach dem zu löschenden Eintrag benötigt?
+2. Wie verhalten sich die von der Methode `toList()` der Klasse `MassiveForceTreeMap` 
+zurückgelieferten Listen, wenn deren enthaltene Himmelskörper durch `setState` verändert werden? 
+Werden dadurch die Himmelskörper der ursprünglichen `MassiveForceTreeMap`-Objekte auch geändert? 
+(Anmerkung: diesbezüglich gibt es im Aufgabenblatt 6 keine Vorgaben).
+3. Wie verhalten sich Ihre Iteratoren, wenn Objekte geändert werden?
+4. Wie kann man durch Einfügen von Zeichen `,` und newlines (`\n`) aus den `txt`-Dateien eine 
+"fehlerhafte" Datei machen, die trotzdem von der Methode akzeptiert wird? Kann man solche Probleme 
+verhindern?
+
+#### _Punkteaufteilung_
+
+- Änderung von `next()` von `MassiveIterator`: 0.5 Punkte
+- Implementierung der Methode `remove()` im Iterator der `MassiveSet`-Sichtweise  
+  von `MassiveForceTreeMap`: 2 Punkte
+- Implementierung der Exceptionklassen und Implementierung von `readConfiguration` 
+  in `ReadDataUtil`: 1.5 Punkte
+- Implementierung von `Simulation8` und `Simulation9`: 1 Punkt

src/Aufgabe6Test.java

@@ -113,4 +113,21 @@ public class Aufgabe6Test {
         }
         assertEquals(12, count);
     }
+
+    @Test
+    public void testIterator() {
+        NamedBody sun1, mercury1, venus1;
+        sun1 = new NamedBody(SolSystem4.SUN_NAMED);
+        mercury1 = new NamedBody(SolSystem4.MERCURY_NAMED);
+        venus1 = new NamedBody(SolSystem4.VENUS_NAMED);
+
+        MassiveForceTreeMap map = new MassiveForceTreeMap();
+
+        map.put(sun1, new Vector3());
+        map.put(mercury1, new Vector3());
+        map.put(venus1, new Vector3());
+        for (Massive m : map.getKeys().toList()) {
+            System.out.println(m);
+        }
+    }
 }

src/Aufgabe8Test.java

@@ -0,0 +1,100 @@
+
+import java.util.HashSet;
+import java.util.NoSuchElementException;
+
+public class Aufgabe8Test {
+
+    public static void main(String[] args) {
+
+        /* //TODO: uncomment for testing
+
+        MassiveForceTreeMap map = new MassiveForceTreeMap();
+        NamedBody mars;
+
+        map.put(new NamedBody("Oumuamua", 8e6, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Earth", 5.972E24, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Moon", 7.349E22, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(mars = new NamedBody("Mars", 6.41712E23, new Vector3(0, 0, 0),
+                        new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Deimos", 1.8E20, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Phobos", 1.08E20, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Mercury", 3.301E23, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Venus", 4.86747E24, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Vesta", 2.5908E20, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Pallas", 2.14E20, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Hygiea", 8.32E19, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Ceres", 9.394E20, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+
+
+        System.out.println("Test1:");
+        MassiveIterator iterator = map.getKeys().iterator();
+        int count = 0;
+        while(iterator.hasNext()) {
+            if (iterator.next().equals(mars)) {
+                iterator.remove();
+            }
+            count++;
+        }
+        testValue(count, 12);
+        testValue(map.getKeys().size(), 11);
+        testValue(map.getKeys().contains(mars), false);
+
+        System.out.println("Test2:");
+        try {
+            iterator.next();
+            // this statement must not be reached
+            testValue(true, false);
+        } catch (NoSuchElementException e) {
+            testValue(true, true);
+        }
+
+        System.out.println("Test3:");
+        iterator = map.getKeys().iterator();
+        while(iterator.hasNext()) {
+            iterator.next();
+            iterator.remove();
+        }
+        testValue(map.getKeys().size(),0);
+
+        */ //TODO: uncomment
+    }
+
+    public static void testComparison(Object first, Object second, boolean expected) {
+        boolean real = first == second;
+
+        if (real == expected) {
+            System.out.println("Successful comparison");
+        } else {
+            System.out.println("Comparison NOT successful! Expected value: " + expected + " / Given value: " + real);
+        }
+    }
+
+    public static void testValue(Object given, Object expected) {
+        if (given == expected) {
+            System.out.println("Successful test");
+        } else {
+            System.out.println("Test NOT successful! Expected value: " + expected + " / Given value: " + given);
+        }
+    }
+
+    public static void testValue(double given, double expected) {
+        if (given < expected + (expected + 1) / 1e12 && given > expected - (expected + 1) / 1e12) {
+            System.out.println("Successful test");
+        } else {
+            System.out.println("Test NOT successful! Expected value: " + expected + " / Given value: " + given);
+        }
+    }
+
+}

src/HierarchicalSystem.java

@@ -138,15 +138,13 @@ public class HierarchicalSystem implements CosmicSystem, MassiveIterable {
             public Massive next() {
                 if (cur != null && cur.hasNext()) return cur.next();
 
-                for (; i < all.length; i++) {
-                    CosmicSystem sys = all[i];
+                while (i < all.length) {
+                    CosmicSystem sys = all[i++];
                     if (sys instanceof NamedBodyForcePair m) {
-                        i++;
                         return m.getBody();
                     } else if (sys instanceof HierarchicalSystem hs) {
                         cur = hs.iterator();
                         if (cur.hasNext()) {
-                            i++;
                             return cur.next();
                         }
                     }
@@ -159,14 +157,14 @@ public class HierarchicalSystem implements CosmicSystem, MassiveIterable {
             public boolean hasNext() {
                 if (cur != null && cur.hasNext()) return true;
 
-                for (; i < all.length; i++) {
+                while (i < all.length) {
                     CosmicSystem sys = all[i];
-                    if (sys instanceof NamedBodyForcePair) {
-                        return true;
-                    } else if (sys instanceof HierarchicalSystem hs) {
+                    if (sys instanceof NamedBodyForcePair) return true;
+                    i++;
+
+                    if (sys instanceof HierarchicalSystem hs) {
                         cur = hs.iterator();
                         if (cur.hasNext()) {
-                            i++;
                             return true;
                         }
                     }

src/MassiveLinkedList.java

@@ -4,7 +4,7 @@ import java.util.Iterator;
  * A list of massive objects implemented as a linked list.
  * The number of elements of the list is not limited.
  */
-public class MassiveLinkedList implements Iterable<Massive> {
+public class MassiveLinkedList implements MassiveIterable {
     private int size = 0;
     private Item first;
     private Item last;
@@ -172,8 +172,8 @@ public class MassiveLinkedList implements Iterable<Massive> {
     }
 
     @Override
-    public Iterator<Massive> iterator() {
-        return new Iterator<>() {
+    public MassiveIterator iterator() {
+        return new MassiveIterator() {
             Item ptr = first;
             boolean yieldedFirst = false;
 

src/ReadDataUtil.java

@@ -0,0 +1,27 @@
+import java.io.*;
+
+public class ReadDataUtil {
+
+    // Reads the position and velocity vector on the specified 'day' from the file with the
+    // specified 'path', and sets position and current velocity of 'b' accordingly. If
+    // successful the method returns 'true'. If the specified 'day' was not found in the file,
+    // 'b' is unchanged and the method returns 'false'.
+    // The file format is validated before reading the state.
+    // Lines before the line "$$SOE" and after the line "$$EOE" the are ignored. Each line of the
+    // file between the line "$$SOE" and the line "$$EOE" is required to have the following format:
+    // JDTDB, TIME, X, Y, Z, VX, VY, VZ
+    // where JDTDB is interpretable as a 'double' value, TIME is a string and X, Y, Z, VX, VY and
+    // VZ are interpretable as 'double' values. JDTDB can be ignored. The character ',' must only
+    // be used as field separator. If the file is not found, an exception of the class
+    // 'StateFileNotFoundException' is thrown. If it does not comply with the format described
+    // above, the method throws an exception of the class 'StateFileFormatException'. Both
+    // exceptions are subtypes of 'IOException'.
+    // Precondition: b != null, path != null, day != null and has the format YYYY-MM-DD.
+    public static boolean readConfiguration(NamedBody b, String path, String day)
+            throws IOException {
+
+            // TODO: implement this method.
+            return false;
+        }
+    }
+

src/Simulation8.java

@@ -0,0 +1,60 @@
+import codedraw.CodeDraw;
+
+// Simulates the solar system.
+//
+public class Simulation8 {
+
+    // gravitational constant
+    public static final double G = 6.6743e-11;
+
+    // one astronomical unit (AU) is the average distance of earth to the sun.
+    public static final double AU = 150e9; // meters
+
+    // set some system parameters
+    public static final double SECTION_SIZE = 10 * AU; // the size of the square region in space
+
+    // all quantities are based on units of kilogram respectively second and meter.
+
+    // The main simulation method using instances of other classes.
+    public static void main(String[] args) {
+
+        // simulation
+        CodeDraw cd = new CodeDraw();
+
+        // create solar system with 13 bodies
+        MassiveForceTreeMap map = new MassiveForceTreeMap();
+
+        map.put(new NamedBody("Oumuamua", 8e6, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Earth", 5.972E24, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Moon", 7.349E22, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Mars1", 6.41712E23, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Deimos", 1.8E20, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Phobos", 1.08E20, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Mercury", 3.301E23, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Venus", 4.86747E24, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Vesta", 2.5908E20, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Pallas", 2.14E20, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Hygiea", 8.32E19, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+        map.put(new NamedBody("Ceres1", 9.394E20, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+
+
+        //TODO: implementation of this method according to 'Aufgabenblatt8.md'.
+
+        // add sun after states have been read from files.
+        map.put(new NamedBody("Sun", 1.989E30, new Vector3(0, 0, 0), new Vector3(0, 0, 0)),
+                new Vector3(0, 0, 0));
+
+    }
+}

src/Simulation9.java

@@ -0,0 +1,7 @@
+// Simulates the solar system.
+//
+public class Simulation9 {
+
+    // TODO: Implement the simulation using the Java-Collections framework.
+
+}

src/StateFileFormatException.java

@@ -0,0 +1,7 @@
+import java.io.IOException;
+
+public class StateFileFormatException extends IOException {
+
+    // TODO: implement class
+
+}

src/StateFileNotFoundException.java

@@ -0,0 +1,7 @@
+import java.io.IOException;
+
+public class StateFileNotFoundException extends IOException {
+
+    // TODO: implement class
+
+}