Cosinus mit Hilfe der Taylorreihe

Diskutiere Cosinus mit Hilfe der Taylorreihe im Java Basics - Anfänger-Themen Forum; 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....

  1. GETTINbaby
    GETTINbaby Neues Mitglied
    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 (Text):
    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
     
  2. Vielleicht hilft dir dieses Training hier weiter.
  3. GETTINbaby
    GETTINbaby Neues Mitglied
    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?
     
  4. GETTINbaby
    GETTINbaby Neues Mitglied
    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 (Text):
    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;
        }
    }
     
  5. Robat
    Robat Bekanntes Mitglied
    Deklarier die Variable außerhalb der Schleife und Weise ihr innerhalb der Schleife nur den Wert zu. Dann kannst du sie auch danach verwenden
     
    GETTINbaby gefällt das.
  6. fhoffmann
    fhoffmann Aktives Mitglied
    Uns schau dir mal die Fakultätsfunktion an. Hier berechnest du immer die Fakultät von 5.
     
    GETTINbaby gefällt das.
  7. GETTINbaby
    GETTINbaby Neues Mitglied
    Vielen Dank für die schnellen Antworten.
    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 ?

    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
     
  8. Robat
    Robat Bekanntes Mitglied
    Warum x? Der Parameter heißt doch a
     
  9. GETTINbaby
    GETTINbaby Neues Mitglied
    Oh, ja ich sehs. Dachte x, da ich x als Kommandozeilenargument eingespeichert habe. Danke !

    Und ich bin wieder auf ein Problem gestoßen. In der Taylorreihe wird abwechselnd - und + verwendet, das habe ich leider nicht beachtet. Wie könnte ich so was implementieren ?
     
  10. GETTINbaby
    GETTINbaby Neues Mitglied
    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 (Text):
    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;
        }
    }
     
  11. ocsme
    ocsme Mitglied
    Guten Abend,

    also bei uns würdest du dafür "erschossen" werden!
    Code (Java):
    wert = (Math.pow(x, a)/fakultaet(a)) * (-1);
    Das sollte eigentlich auch einfach so gehen:
    Code (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
    Code (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: 7. Dez. 2018
  12. Wenn du Java lernen möchtest, empfehlen wir dir dieses Online-Training hier
Passende Stellenanzeigen aus deiner Region:





Die Seite wird geladen...

Cosinus mit Hilfe der Taylorreihe - Ähnliche Themen

Hilfe bei der Cosinusapproximation
Hilfe bei der Cosinusapproximation im Forum Allgemeine Java-Themen
Hilfe bei Formel mit Cosinus
Hilfe bei Formel mit Cosinus im Forum Hausaufgaben
Cosinus einer Zahl
Cosinus einer Zahl im Forum Hausaufgaben
Fehleranalyse - Diskrete Cosinus Transformation + Inverse DCT
Fehleranalyse - Diskrete Cosinus Transformation + Inverse DCT im Forum Spiele- und Multimedia-Programmierung
Cosinus-Arcustangens
Cosinus-Arcustangens im Forum Java Basics - Anfänger-Themen
Thema: Cosinus mit Hilfe der Taylorreihe