Sin(x) rekursiv lösen

[kilopack15]

Hallo Leute!
Ich habe ein Problem und zwar soll ich ein Programm schreiben, dass den Sinus(x) im Bogenmaß ausrechnet. Gegeben ist diese Formel zur Errechnung:

Ganz wichtig: Das ganze soll über Rekursion gelöst werden und abgebrochen wird die Methode, falls der Summand in der Klammer zwischen −1 ∗ 10^(−7) und 1 ∗ 10^(−7) liegt.

Meine (noch) falsche Lösung:

public class MathFormel {
    public static int i=0;
    public static double ergebnis = 0.0;
    //Fakultät
    public static double factorial(int fact){
        if(fact == 1){
            return 1.0;
        }
        else{
            return fact * (factorial(fact-1));
        }
    }
  
    //Term (-1)^i
    public static int termloeser1(int i){
        if((i % 2)==0){
            return 1;
        }else{
            return -1;
        }
    }
  
    //Term x^(2i+1)
    public static double termloeser2(double x, int i){
        double hilfe1 = x;
        for(int counter1 = 1; counter1 < ((2*i)+1); counter1++){
            x*=hilfe1;
        }
        return x;
    }
  
    public static boolean abbruchchecker(double x, int i){
        double abbruchraum = 0.0000001;
        double checkzahl = termloeser1(i) * ((termloeser2(x,i))/(factorial((2*i)+1)));
        if(checkzahl < abbruchraum && ((checkzahl * (-1)) > abbruchraum)){
            return false;
        }else{
            return true;
        }
    }
  
  
    public static double loeseRekursiv ( double x ) {
        ergebnis = termloeser1(i) * ((termloeser2(x,i))/(factorial((2*i)+1)));
        if(abbruchchecker(x,i)==false){
            return ergebnis;
        }else{
            i++;
            return ergebnis + loeseRekursiv(x);
        }
    }

Viel Code um nichts! Die ersten drei Methoden sind ganz einfach Termlöser und die 4. Methode ist für das Abbruchkriterium zuständig.
Das Problem: die methode loeseRekursiv(x) bricht nach dem zweiten Durchlauf ab und returned das Ergebnis, obwohl das Abbruchkriterium gar nicht erfüllt ist. Ich kann ums Verrecken den Fehler nicht finden. Findet ihr den Fehler und könnt mir helfen? 🙂
Vielen Dank im Voraus!

 

[neoexpert]

import java.util.*;

public class Main
{
    public static void main(String[] args)
    {
        System.out.println(sincos(Math.PI,1));
       
    }
    static double sincos(double x, int n){
        if(n>20)
            return 0.0;
       
        return sincos(x,n+2)+(Math.pow(-1,n/2)*Math.pow(x,n)/ fak(n));
    }
   
    static long fak(long n){
        if(n==1||n==0) return 1;
        return n*fak(n-1);
    }
}

 

[neoexpert]

Verbessert:

public class Main
{
    public static void main(String[] args)
    {
        System.out.println(sincos(Math.PI/2.0,1));
       
    }
    static double sincos(double x, int n){
        double term=Math.pow(-1,n/2)*Math.pow(x,n)/ fak(n);
        if(Math.abs(term)<Math.pow(10.0,-7))return 0.0;
        return sincos(x,n+2)+term;
    }
   
    static long fak(long n){
        if(n==1||n==0) return 1;
        return n*fak(n-1);
    }
}

 

[neoexpert]

Mehr von solchen Aufgaben bitte.
Übrigens: schreibt man in den zweiten Parameter eine 0, erhält man Cosinus

 

[InfectedBytes]

@neoexpert Dem TE bringt es nicht viel wenn du nen Code reinstellst, der nichts mehr mit seinem eigenen zu tun hat. Stattdessen wäre es hilfreicher wenn du auf seine Frage eingehen würdest etc.
Ansonsten solltest du nicht jedes mal Math.pow(10.0,-7) rechnen, sondern dass nur einmal machen.

@kilopack15 Wenn du schon mehrere Methoden nutzt, solltest du denen auch erstmal ordentliche Namen geben. Ansonsten wäre es gut wenn du deinen Code mal etwas aufräumst^^
Weiterhin solltest du keine statischen Variablen benutzen.
Ansonsten solltest du auch nicht immer alles doppelt berechnen. z.b. berechnest du den Summanden in der Klammer zweimal: einmal in löseRekursiv und einmal in abbruchchecker. Letzteress macht natürlich überhaupt keinen Sinn, dort solltest du nur prüfen ob der parameter (=der Summand) im entsprechenden Bereich liegt.

 

[kilopack15]

Danke für eure Hilfe! Ich habe vergessen zu sagen, dass ich die Math. Biblio von java nicht verwenden darf. Deshalb halt zwei Methoden mehr 😉 Statische Variablen sind nur vorübergehend zum Testen in der main da. Danke für die weiteren hilfreichen Tipps. Morgen habe ich sicher eine neue Sicht auf die Aufgabe. Mir fällt auch gerade auf, dass ich mir da einiges sparen könnte, aber so ist das nunmal am Anfang 🙂
Morgen werde ich nochmal meine verbesserte Lösung hereinstellen und ggf. Fragen stellen!

 

[kilopack15]

    public int i=0;
    public double ergebnis;
    public double abbruchraum = 0.0000001;
   
    //Fakultät
    public double factorial(int fact){
        if(fact == 1){
            return 1.0;
        }
        else{
            return fact * (factorial(fact-1));
        }
    }
   
    public double potenz(double basis, int exp){
        double h = basis;
        if(exp == 0){
            return 1;
        }
        for(int counter1 = 1; counter1 < exp;counter1++){
            h*=basis;
        }
        return h;
    }

    public double loeseRekursiv ( double x ) {
        ergebnis = potenz(-1.0,i) * potenz(x,(2*i+1))/factorial(2*i+1);
        if((ergebnis < 0.0000001) && (-0.0000001 < ergebnis)){
            return ergebnis;
        }else{
            i++;
            return ergebnis + loeseRekursiv(x);
        }
    }

Überarbeitet und Tests zufolge richtig! Gibts was zu korrigieren?

 

[InfectedBytes]

du definierst zwar abbruchraum, benutzt die variable aber nie.
Weder i, noch ergebnis sollten membervariablen sein. Das Ergebnis gibst du durch die Methode zurück, daher brauchst du es dir nicht separat merken. Die Laufvariable i solltest du einfach als extra parameter mitgeben und eben nicht als Objektvariable speichern.

 

[JStein52]

Ja, "loeseRekursiv()" würde ich dann sin(x) nennen. Dann weiss man auch was es tut

 

[kilopack15]

Okay. Danke habs soweit verbessert. Das Ding heißt loeseRekursiv, weil ich es noch auf einen anderen Weg lösen soll und zwar mit Schleifen und ohne Methodenaufrufe. Die entsprechende Methode loeseSchleife sieht bei mir bis jetzt so aus

int i=0;
double ergebnis=0.0;
public double loeseSchleife ( double x ) {
        int term1;
        double term2=1.0;
        double term3=1.0;
      
        do{
         //Potenz (-1)^i 
        if((i%2)==0){
            term1 = 1;
        }else{
            term1 = -1;
        }
      //Potenz Zähler
        for(int counter2=1;counter2<=(2*i+1);counter2++){
            term2*=x;
        }
      //Fakultät
        for(int h1 =(2*i+1);h1>1;h1--){
            term3*=h1;
        }

        ergebnis=ergebnis + term1*(term2/term3);
        i++;
        }while((ergebnis < 0.0000001) && (-0.0000001 < ergebnis));
        return ergebnis;
    }

Sie bricht aber nach dem ersten Durchlauf ab und ich erkenne den fehler nicht. Weiß jemand von euch, was ich falsch gemacht habe?

 

[InfectedBytes]

weil deine Bedingung nicht stimmt: ((ergebnis < 0.0000001) && (-0.0000001 < ergebnis));
Du lässt die Schleife momentan solange laufen wie ergebnis im Abbruchraum liegt.

Und auch hier hast du schon wieder Variablen unnötigerweise als Objektvariablen deklariert. Es macht überhaupt keinen Sinn das du i und ergebnis als Objektvariable speicherst!

 

[kilopack15]

Okay also einfach diese while-Bedingung negieren und die beiden Variablen in die Methode reinholen. Sieht dann bei mir folgendermaßen aus und liefert NaN beim Testen. Das verstehe ich nicht

    public double loeseSchleife ( double x ) {
        int term1;
        double term2=1.0;
        double term3=1.0;
        int i=0;
        double ergebnis=0.0;
      
        do{
          
        if((i%2)==0){
            term1 = 1;
        }else{
            term1 = -1;
        }
      
        for(int counter2=1;counter2<=(2*i+1);counter2++){
            term2*=x;
        }
      
        for(int h1 =(2*i+1);h1>1;h1--){
            term3*=h1;
        }

        ergebnis=ergebnis + term1*(term2/term3);
        i++;
        }while((ergebnis > 0.0000001) | (-0.0000001 > ergebnis));
        return ergebnis;
    }

Es dürfen übrigens keine weiteren Parameter zu der Methode mitgegeben werden.

 

[Flown]

Du kannst die Fakultät und die Potenz iterativ berechnen und musst dadurch diese nicht immer neu berechnen - gilt auch für deine rekursive Methode.

Tipp: Deine Abbruchbedingung kann man auch so schreiben:

do {
//...
} while(!(-1e-7 < step && step < 1e-7));

1e-7 == 1 * 10^-7 == 0.0000001

 

[Flown]

Also warum deine iterative Methode nicht funktioniert:
- Die Abbruchbedingung ist falsch (der aktuell Summand muss sich innerhalb von -1*10^-7 < summand < 1*10^-7 befinden, nicht die Summe)
- term2 & term3 werden außerhalb der Schleife deklariert, darum haben sie falsche Werte innerhalb der Schleife (also bitte die beiden Variablen in die Schleife ziehen)

 

[kilopack15]

Danke dir Flown. Hat mir enorm weitergeholfen 🙂

 

[Flown]

Funktionierts jetzt auch? Am besten du postest hier deine Lösung, damit andere auch noch Hilfe erwarten können.

 

[kilopack15]

Leider funktioniert es noch nicht. So sieht es bis jetzt aus

public static double loeseSchleife ( double x ) {
        double ergebnis= 0.0;
        double term3= 1.0;
        int term1;
        double term2 = 1.0;
        double abbruchzahl =5;
        for(int i=0;(!(-1e-7 < abbruchzahl && abbruchzahl < 1e-7));i++){
           
           
        if((i%2)==0){
            term1 = 1;
           
        }else{
            term1 = -1;
        }
       
       
   
        if(i == 0){
            term2=1;
        }
        for(int counter2=1;counter2 <= (2*i+1);counter2++){
            term2 = term2 *x;
           
        }
       
       
        for(int h1 =(2*i+1);h1>1;h1--){
           
            term3*= h1;
        }

        ergebnis+= term1*(term2/term3);
        abbruchzahl  = ergebnis;
       
        }
        return ergebnis;
       
    }

Beim Testen läuft es aber schon und gibt nicht wie vorher 0.0 aus. Allerdings läuft es minutenlang ohne Ergebnis. Was ist da los? Was kann ich korrgieren?

 

[Flown]

Schau her:
- Die Abbruchzahl ist ein Schritt und nicht das gesamte Ergebnis.
- Die Abbruchzahl sollte auch sinnvoll initialisiert werden (Tipp: x).
- Das Ergebnis sollte auch sinnvoll initialisiert werden (Tipp: .... rate mal?).
- Die Variablen - wie letztes mal auch schon - term1/2/3 sollen in die Schleife!