Cosinus mit Hilfe der Taylorreihe

Bitte aktiviere JavaScript!
Seid gegrüßt Freunde des guten Geschmacks.
Ich taste mich gerade an Java heran und würde gerne den Cosinus mit Hilfe der Taylorreihe berechnen. Mein Programm compiliert und spuckt mir auch ein Ergebnis aus, allerdings habe ich den Bereich auf max. 2*Math.PI begrenzt und das Ergebnis ist höher. Könntet Ihr mir vielleicht behilflich sein?

Code:
public class Cosinus {
    public static void main(String[] args) {
        double x = Double.parseDouble(args[0]);
        int a = 0;
        while (a <= (2 * Math.PI)){
            double cos = 1 - (Math.pow(x, a)/fakultaet(a));
            a++;
        }
        System.out.println("Der Cosinus betraegt: " + a);
    }

    private static int fakultaet(int a){
        int n = 5;
        int k = 1;
       
        for (int i = 1; i <= n; i++){
            k = k*i;
        }
        return k;
    }
}
Ich danke euch vielmals für die Hilfe
 
A

Anzeige




Vielleicht hilft dir unser Java-Tutorial hier weiter —> (hier klicken)
Okay, einen Fehler habe ich gefunden. Er spuckt mir durch die System.out.println() Zeile ja a aus und nicht cos. cos habe ich lediglich in der while schleife deklariert. Jetzt habe ich leider ein neues problem, wie kann ich dafür sorgen, dass cos ausgespuckt wird ? Kann ich den wert, der bei double cos ausgespuckt werden soll einfach nach der schleife noch mal "deklarieren"? Sprich: double cos = b und dann später einfach b ausgeben lassen?
 
Ich habe jetzt ein wenig rumprobiert und den Code etwas abgeändert, jetzt spuckt er mir akzeptable Ergebnisse aus. Ich weiß allerdings nicht, wie ich überprüfen kann, ob das das richtige Ergebnis ist, da ich die Taylorreihe nicht so ganz verstehe und nicht sonderlich sicher darin bin, diese werte selbst zu berechnen. Könntet ihr mir da bitte auch noch ein wenig helfen ? :D

Code:
public class Cosinus {
    public static void main(String[] args) {
        double x = Double.parseDouble(args[0]);
        int a = 0;
       
        while (a <= (2 * Math.PI)){
            double cos = 1 - (Math.pow(x, a)/fakultaet(a));
            a++;
            System.out.println("Der Cosinus betraegt: " + cos);
        }
    }

    private static int fakultaet(int a){
        int n = 5;
        int k = 1;
       
        for (int i = 1; i <= n; i++){
            k = k*i;
        }
        return k;
    }
}
 
Deklarier die Variable außerhalb der Schleife und Weise ihr innerhalb der Schleife nur den Wert zu. Dann kannst du sie auch danach verwenden
 
Vielen Dank für die schnellen Antworten.
Deklarier die Variable außerhalb der Schleife und Weise ihr innerhalb der Schleife nur den Wert zu. Dann kannst du sie auch danach verwenden
Ich habe das etwas anders gelöst, und zwar habe ich die System.out.println() Zeile in die Schleife gepackt, damit er mir nach jedem Durchlauf den Wert ausgibt. Das führt doch zum gleichen Ergebnis, oder ?

Uns schau dir mal die Fakultätsfunktion an. Hier berechnest du immer die Fakultät von 5.
Ja, habs jetzt auch bemerkt. Wollte das ursprünglich so lassen, damit der Wertebereich nicht zu groß wird, aber jetzt ist mir klar geworden, dass das Mumpitz ist.
Wie würde ich da vorgehen ? Wenn ich int n = x; deklariere, sagt mir die Konsole, dass x nicht deklariert wurde bzw. dass x nicht existiert
 
Ich denke, ich kam auf eine Lösung für das + - problem. Ich habe innerhalb der While Schleife if Bedingungen angeknüpft, je nach wert von a. Wäre das so richtig ? Gibt es angenehmere/praktikablere Lösungen ?

Ich weiß, ich könnte auch einfach nach einem fertigen code suchen und daraus lernen, allerdings denke ich nicht, dass mir damit geholfen ist.

Code:
public class Cosinus {
    public static void main(String[] args) {
        double x = Double.parseDouble(args[0]);
        int a = 0;
        double cos;
        double wert;
        while (a <= (2 * Math.PI)){
            if (a%2 == 0)
                wert = (Math.pow(x, a)/fakultaet(a)) * (-1);
            else
                wert = (Math.pow(x, a)/fakultaet(a));
           
            cos = 1 - wert;
            a++;
            System.out.println("Der Cosinus betraegt: " + cos);
        }
       
    }

    private static int fakultaet(int a){
        int n = a;
        int k = 1;
       
        for (int i = 1; i <= n; i++){
            k = k*i;
        }
        return k;
    }
}
 
Guten Abend,

also bei uns würdest du dafür "erschossen" werden!
Java:
wert = (Math.pow(x, a)/fakultaet(a)) * (-1);
Das sollte eigentlich auch einfach so gehen:
Java:
wert = -(Math.pow(x, a)/fakultaet(a));
Nicht getestet!

Da dein a aber eh nur 7x Läuft frage ich mich was das für eine Approximation vom Cosinus werden soll? Denn dann bist du ja erst bei
Der Cosinus betraegt: 1.0888888888888888
Vielleicht habe ich die Aufgabe auch nicht verstanden hier unten steht mal meine Lösung:

Das ganze würde Effizienter gehen wenn du dir die Cosinus Reihe anschaust und dir das a_(n+1)/a_n Glied berechnest.
Wenn du das berechnet hast ist es nur noch ein 11 Zeiler :D

Hier mal mein Cosinus nach diesem Prinzip
Java:
public static double cosinus(double x) {
    int n=0;
    double an=1;
    double sn=1;
    while(Math.abs(an)>EPSILON*Math.abs(sn)) {
        an *= -x/(2*n+1)*x/(2*n+2);
        sn += an;
        n++;
    }
        return sn;
    }
Sorry wegen dem Posten der Lösung aber musst Sie dir ja nicht anschauen wollte sie dir nur geben damit du später wenn du es so machen möchtest eine "Kontrolle" hast (Falls meiner auch nicht Falsch ist :D)
 
Zuletzt bearbeitet:
Vielen Dank für die Hilfe !
Ich verstehe nicht so genau, was der code wann macht, aber ich werde meine Zeit heute damit verbringen das zu verstehen ! :D
 
Hier steht die Potenzreihe des Cosinus:
https://de.wikipedia.org/wiki/Taylorreihe

Schreibe nun a_(n+1) / a_n auf und rechne es aus. Dann kommst du in meinem Code auf an. Das sind die Folgeglieder die später dann zu sn addiert werden!
Leider weiß ich nicht ob man hier Mathematische Funktionen oder der gleichen schreiben kann! Dann würde ich es dir so notieren :) Denke dann verstehst du es sicherlich ganz schnell.
Anderfalls könnte man es auch so weiter machen wie du angefangen hast.

LG
 
A

Anzeige




Hier lernst du alle wichtigen Java-Grundlagen.
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben