Java Hausaufgabe...

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • Java Hausaufgabe...

      Hallo Leute, ich muss momentan Java machen und komme bei meiner aktuellen Hausaufgabe nicht weiter, habe auch nicht viel Zeit momentan dazu, da ich in den nächsten 2 Wochen 5 große Prüfungen habe...

      Muss mich atm mehr auf die konzentrieren,mit Java lege ich mich dann ab dem 01.12 richtig an ;) leider haben wir ja Hausaufgaben auch zu erledigen, deswegen wollte ich Nachfragen, ob mir eventuell jemand von euch dabei bitte helfen kann / erstellen kann, würde dafür auch zahlen

      Bin echt grad an meiner aktuellen Aufgabe am verzweifeln und komme einfach nimmer weiter, sitze seit 6 Stunden dran und nügx...

      Ich poste mal die Aufgabe, wenn wer Lust hat, bitte einfach kurz melden und mir schreiben, was er dafür möchte :)

      Danke

      Aufgabe 05

      Implementieren Sie das Newtonsche Näherungsverfahren zum Auffinden aller Nullstellen der Funktion f(x) = x^3 - 6x^2 + 3x + 10 im Intervall [-10, 10]. Da das Verfahren für einen Startwert immer nur maximal eine Nullstelle liefert, durchlaufen Sie das Intervall mit einer Schrittweite STEP = 0.1. Falls eine Nullstelle gefunden wird, so geben Sie diese nur dann aus, wenn sie sich um mehr als EPSILON = 10^-6 von der letzten gefundenen Nullstelle unterscheidet (überlegen Sie warum).

      Das Verfahren ist iterativ und berechnet einen neuen Näherungswert xn+1 aus dem alten Wert xn wie folgt:
      xn+1 = xn - f(xn) / f'(xn)
      Eine Nullstelle gilt als gefunden, wenn innerhalb von MAX_ITERATIONS der Betrag |f(xn)| < EPSILON ist. Sehen Sie vor, dass MAX_ITERATIONS zu Beginn des Programms vom Benutzer eingegeben werden kann.

      Beispiel für eine Ein/Ausgabe (die Zahlen sind erfunden):

      MAX_ITERATIONS = ?
      7
      Zeros
      1.56
      2.456
      1.559998
      3.0001

      Implementieren Sie folgende Methoden in Ihrem Programm:

      public static double getZero(double x, double eps, int max)
      // berechnet eine Nullstelle mit dem Startwert x, einem EPSILON eps und MAX_ITERATIONS max
      // falls keine Nullstelle gefunden wird, wird Double.NaN zurückgegeben
      public static double getValue(double x)
      // return f(x)
      public static double getDerivative(double x)
      // return f'(x)



      Hinweis: Verwenden Sie die Methoden Math.abs() und Double.isNaN().


      PS: Obwohl meine Mathe Zeit schon lange zurück liegt, können es nicht maximal 3 0 Stellen sein?
    • Natürlich können als exakte Lösung nur 3 Nullstellen herauskommen. Dass 4 herauskommen bei dem Beispiel zeigt doch schon, dass es "zu wenig" Iterationen waren.
      Schau dir das Newton-Verfahren vielleicht nochmal an.
      Falls eine Nullstelle gefunden wird, so geben Sie diese nur dann aus, wenn sie sich um mehr als EPSILON = 10^-6 von der letzten gefundenen Nullstelle unterscheidet (überlegen Sie warum).


      Dann gehe wie folgt vor:
      -Programmiere die Ableitungsfunktion getDerivative (Wie war die Ableitung definiert?)
      -Programmiere getvalue
      -Programmiere getzero
      Die Aufgabenstellung gibt dir eigentlich schon einen Bauplan/eine Anleitung.

      Poste deinen Code / zeig ein paar Ideen falls du nicht weiter kommst :)

      Heinrich von Kleist schrieb:

      [...] [D]u hast an mir getan, [...] was in Kräften [...] eines Menschen stand, um mich zu retten: Die Wahrheit ist, daß mich auf Erden nicht zu helfen war.
    • Du musst nur die Formeln und Abbruchbedingungen die in der Aufgabe angegeben sind in Programmcode umwandeln. Dazu kommt dann noch 1x Rekursion und fertig ist das Programm.

      Da ist wirklich keine Schwierigkeit dabei. Wenn ich dir jetzt das Programm schreibe, lernste ja nix. Also zumindest nen Prototyp will ich sehen :P
    • Okay, habe doch ein Problem und krieg es nicht in den Griff

      Aufgabe lautet

      Quellcode

      1. Implementieren Sie das Newtonsche Näherungsverfahren zum Auffinden aller Nullstellen der Funktion f(x) = x^3 - 6x^2 + 3x + 10 im Intervall [-10, 10]. Da das Verfahren für einen Startwert immer nur maximal eine Nullstelle liefert, durchlaufen Sie das Intervall mit einer Schrittweite STEP = 0.1. Falls eine Nullstelle gefunden wird, so geben Sie diese nur dann aus, wenn sie sich um mehr als EPSILON = 10^-6 von der letzten gefundenen Nullstelle unterscheidet (überlegen Sie warum).
      2. Das Verfahren ist iterativ und berechnet einen neuen Näherungswert xn+1 aus dem alten Wert xn wie folgt:
      3. xn+1 = xn - f(xn) / f'(xn)
      4. Eine Nullstelle gilt als gefunden, wenn innerhalb von MAX_ITERATIONS der Betrag |f(xn)| < EPSILON ist. Sehen Sie vor, dass MAX_ITERATIONS zu Beginn des Programms vom Benutzer eingegeben werden kann.
      5. Beispiel für eine Ein/Ausgabe (die Zahlen sind erfunden):


      Quellcode

      1. MAX_ITERATIONS = ?
      2. 7
      3. Zeros
      4. 1.56
      5. 2.456
      6. 1.559998
      7. 3.0001
      8. Implementieren Sie folgende Methoden in Ihrem Programm:
      9. public static double getZero(double x, double eps, int max)
      10. // berechnet eine Nullstelle mit dem Startwert x, einem EPSILON eps und MAX_ITERATIONS max
      11. // falls keine Nullstelle gefunden wird, wird Double.NaN zurückgegeben
      12. public static double getValue(double x)
      13. // return f(x)
      14. public static double getDerivative(double x)
      15. // return f'(x)
      16. Hinweis: Verwenden Sie die Methoden Math.abs() und Double.isNaN().
      Alles anzeigen


      Meine Lösung

      Java-Quellcode

      1. import java.util.ArrayList;
      2. import java.util.Scanner;
      3. public class Main {
      4. public static double getZero(double x, double eps, int max) {
      5. double x_n = x;
      6. double delta = eps + 1;
      7. for (int i = 0; i < max; i++) {
      8. double x_n1 = x_n - getValue(x_n) / getDerivative(x_n);
      9. delta = Math.abs(x_n - x_n1);
      10. x_n = x_n1;
      11. }
      12. if (delta <= eps) return x_n;
      13. }
      14. public static double getValue(double x) {
      15. return x*x*x - 6*x*x + 3*x + 10;
      16. }
      17. public static double getDerivative(double x) {
      18. return 3*x*x - 12*x + 3;
      19. }
      20. public static void main (String [] args) {
      21. System.out.println("MAX_INTERATION = ?");
      22. Scanner scanner = new Scanner(System.in);
      23. int MAX_INTERATIONS = Integer.parseInt(scanner.nextLine());
      24. ArrayList<Double> nullstellen = new ArrayList<Double>();
      25. for (double x = -10; x <= 10; x+=0.1) {
      26. double aktuelleNST = getZero(x, 1e-6, MAX_INTERATIONS);
      27. if (Double.isNaN(aktuelleNST)) continue;
      28. boolean nullstelleSpeichern = true;
      29. for (Double d : nullstellen) {
      30. if (Math.abs(d - aktuelleNST) < 1e-6) {
      31. nullstelleSpeichern = false;
      32. }
      33. }
      34. if (nullstelleSpeichern) {
      35. nullstellen.add(aktuelleNST);
      36. System.out.println(String.valueOf(aktuelleNST));
      37. }
      38. }
      39. }
      40. }
      Alles anzeigen


      Dann erhalte ich folgende Fehlermeldung

      Quellcode

      1. [Ausführungsprotokoll gekürzt]
      2. -1.0
      3. 4.999999999999999
      4. 2.0
      5. MAX_INTERATION = ?
      6. -1.0
      7. 4.999999999999999
      8. Error in getZero-method! Wrong result!
      9. Input: x = -1.9000000000000195, eps = 1.0E-6, max = 5
      10. Your result: -1.0000000000000007
      11. Expected result: -1.0000000403355653
      12. Exception in thread "test" java.lang.Exception
      13. at test.testGetZero(test.java:124)
      14. at test.run(Unknown Source)
      Alles anzeigen


      Mach ich es so...

      Java-Quellcode

      1. import java.util.ArrayList;
      2. public class Bsp05 {
      3. public static double getZero(double x, double eps, int max) {
      4. double x_n = x; //Startwert fuer Iteration
      5. for (int i = 0; i < max; i++) {
      6. double x_n1 = x_n - getValue(x_n) / getDerivative(x_n);
      7. x_n = x_n1;
      8. if (Math.abs(getValue(x_n)) < eps)
      9. break;
      10. }
      11. if (Math.abs(getValue(x_n)) < eps)
      12. return x_n; //wenn nah genug an Nullstelle: Zahl ausgeben
      13. return Double.NaN;
      14. }
      15. public static double getValue(double x) {
      16. return x*x*x - 6*x*x + 3*x + 10; //f(x) fuer gegebenes Polynom
      17. }
      18. public static double getDerivative(double x) {
      19. return 3*x*x - 12*x + 3; //Ableitung von f(x)
      20. }
      21. public static void main (String [] args) {
      22. System.out.println("MAX_INTERATION = ?");
      23. int MAX_INTERATIONS = SavitchIn.readLineInt();
      24. ArrayList<Double> nullstellen = new ArrayList<Double>(); //bisherige Nullstellen muessen abgespeichert werden, um mit neuem Fund verglichen werden zu koennen (sonst wird eine Nullstelle moeglicherweise mehrfach gefunden und ausgegeben)
      25. for (double x = -10; x <= 10; x+=0.1) {
      26. double aktuelleNST = getZero(x, 1e-6, MAX_INTERATIONS);
      27. if (Double.isNaN(aktuelleNST))
      28. continue; //wenn kein Treffer, mache weiter mit naechstem x
      29. boolean nullstelleSpeichern = true; //diese Nullstelle ist neu und soll gespeichert werden (Variable kann spaeter noch ueberschrieben werden)
      30. for (Double d : nullstellen) { //gehe bisherige Nullstellen durch
      31. if (Math.abs(d - aktuelleNST) < 1e-6) { //wenn der aktuelle Fund fast einem bisherigen entspricht
      32. nullstelleSpeichern = false; //ist die Nullstelle doch nicht neu
      33. }
      34. }
      35. if (nullstelleSpeichern) {
      36. nullstellen.add(aktuelleNST);
      37. System.out.println(String.valueOf(aktuelleNST));
      38. }
      39. }
      40. }
      41. }
      Alles anzeigen


      erhalte ich

      Quellcode

      1. > java -classpath '/tmp/autoc-einfprog-0.5.5-15-g45fa094-plus/check-125-6-1416306128' -Duser.language=EN -Duser.region=US -Xmx512M Tester
      2. MAX_INTERATION = ?
      3. -1.0000000000000187
      4. 1.999999999999982
      5. 4.9999999999999805
      6. Wrong output! MAX_ITERATIONS: 0
      7. Output should be empty!
      8. Exception in thread "test" java.lang.Exception
      9. at test.testOutput(test.java:47)
      10. at test.run(Unknown Source)
      Alles anzeigen


      Feedback vom Prof beim ersten Bsp

      "Die max-iterations sind nur eine Obergrenze für den Algorithmus, wenn Sie schon vorher eine Nullstelle finden müssen Sie natürlich auch vorher abbrechen und nicht bis zu Max-Iterations durchlaufen."

      Jemand ne Idee? Danke
    • Also das Problem ist, dass er bis max_iterations durchläuft obwohl er vorher hätte rausspringen müssen?
      Hab noch nie mit break und continue gearbeitet aber sieht eigentlich gut aus würde ich sagen. Kanns auch jetzt nicht auf die Schnelle selbst testen, da ich nicht mit Java arbeite.
      Musste dir wohl mal alle Nullstellen ausgeben lassen (oder durch debuggern) um zu schauen wo er nicht abbricht obwohl er es sollte. Dann kommst du auf den Fehler.

      Die Java-Fehlermeldungen haben nichts damit zu tun oder?


      Ich hätte es mit Rekursion so gelöst:

      Quellcode

      1. public static double getZero(double x, double eps, int max) {
      2. double delta = math.abs(getValue(x))
      3. if (max > 0 && delta < eps) return x // evtl. (max > -1) weiss ich grad ausm kopf nicht, musste mal testen.
      4. if (max <= 0) return Double.NaN // evtl. (max <= -1) weiss ich grad ausm kopf nicht, musste mal testen.
      5. x_n = x - getValue(x) / getDerivative(x)
      6. return getZero(x_n, eps, max-1)
      7. }

      kannst ja das evtl. sonst mal testen.


      Und generell ruhig mal leerzeilen einbauen und dinger wie "x_n = x_n1;" weglassen. Ist scheiße zu lesen der quellcode.

      Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von Sweeper ()