Taylor-Reihe in Java

[rosima26]

public class COS {

    public static double fakultät(int i) {
        double fakultaet = 1;
        for (int k = 1; k <=i ; k++) {
            fakultaet *= k;

        }
        return fakultaet;
    }

    public static double cos(double x) {

        double cos = 0;
        for (int i = 0; ((Math.pow(-1, i) * ((Math.pow(x, 2 * i) / COS.fakultät(2*i)))) > 0.001
                | (Math.pow(-1, i) * (((Math.pow(x, 2 * i) / COS.fakultät(2*i))))) < -0.001); i++) {

            cos += (Math.pow(-1, i) * (((Math.pow(x, 2 * i) / COS.fakultät(2*i)))));
            

        }

        return cos;
    }

}

Moin, muss den Cosinus mithilfe der Taylorreihe berechnen. Soweit so gut, mein Code liefert nur leider immer falsche Ergebnisse. Hat jemand Tipps? Komme einfach nicht weiter..

 

[Staarfightaar]

*sarkasmus an*
wegen der übersichtlichkeit würde ich den cos wert in der for schleife direkt erhöhen

    for (int i = 0; ((Math.pow(-1, i) * ((Math.pow(x, 2 * i) / COS.fakultät(2*i)))) > 0.001  | (Math.pow(-1, i) * (((Math.pow(x, 2 * i) /COS.fakultät(2*i))))) < -0.001); cos += (Math.pow(-1, i++) * (((Math.pow(x, 2 * i) / COS.fakultät(2*i))))));

*sarkasmus aus*
es muss doch nicht sein ...

 

[m1234]

Suchst du vielleicht das hier?

public class SpassMitTaylor {
    public static double fac(int n) {
        double f = 1;
        for (int i = 2; i <= n; i++) {
            f *= i;
        }
        return f;
    }

    public static double sin(double x, int n) {
        double sum = 0;
        for (int i = 0; i < n; i++) {
            double summand = Math.pow(-1, i) * (Math.pow(x, 2 * i + 1) / fac(2 * i + 1));
            sum += summand;
        }
        return sum;
    }

    public static double cos(double x, int n) {
        double sum = 0;
        for (int i = 0; i < n; i++) {
            double summand = Math.pow(-1, i) * (Math.pow(x, 2 * i) / fac(2 * i));
            sum += summand;
        }
        return sum;
    }

    public static void main(String[] args) {
        for (int i = 0; i <= 10; i++) {
            double x = Math.PI / 10 * i;
            System.out.println(Math.sin(x));
            System.out.println(sin(x, 5));
            System.out.printf("Fehler: %.20f%n", Math.abs(Math.sin(x) - sin(x, 5)));
            System.out.println();
        }
        System.out.println();
        for (int i = 0; i <= 10; i++) {
            double x = Math.PI / 10 * i;
            System.out.println(Math.cos(x));
            System.out.println(cos(x, 5));
            System.out.printf("Fehler: %.20f%n", Math.abs(Math.cos(x) - cos(x, 5)));
            System.out.println();
        }
    }
}

 

[rosima26]

Danke erstmal, denke aber nicht dass das dem entspricht was ich suche. Im Anhang ist mal die Aufgabenstellung

 

[KonradN]

Vermutlich wird es am int in der Schleife hängen.

Berechnungen mit Integer Zahlen bleiben Integer und du hast dann ein Integer Ergebnis.

Bei der Division eins der Zwischenergebnisse zu einer Fliesskommazahl casten könnte helfen.

Weiterhin macht es Sinn, den || Operator zu nutzen, damit der zweite Check nicht errechnet werden muss, wenn der erste schon true ergeben hat.

 

[m1234]

Danke erstmal, denke aber nicht dass das dem entspricht was ich suche

Woher sollte ich denn deine Anforderungen kennen? Du solltest in der Lage sein die zweite Anforderung eigenständig zu implementieren. Wenn nicht, Pech.

 

[rosima26]

Danke dir @KonradN , tatsächlich ist der Code so völlig funktionsfähig und korrekt. Mein Fehler war, dass ich die Ergebnisse mit einem Rechner überprüft hatte der auf Gradmaß eingestellt war. Danke trotzdem an alle!!

 

[KonradN]

Danke dir @KonradN , tatsächlich ist der Code so völlig funktionsfähig und korrekt. Mein Fehler war, dass ich die Ergebnisse mit einem Rechner überprüft hatte der auf Gradmaß eingestellt war. Danke trotzdem an alle!!

Ja, hatte übersehen, dass fakultät ja einen double zurück gibt. Das machte die angesprochene Berechnung natürlich korrekt.

Wenn Du noch etwas optimieren willst: Du musst das (Math.pow(-1, i) * (((Math.pow(x, 2 * i) / COS.fakultät(2*i))))) natürlich nur einmal berechnen und in einer Variablen speichern. Also z.B. in einer do while Schleife.

 

[rosima26]

Das wäre dann wohl effizienter, werde ich probieren. Danke dir!

 

[Blender3D]

Das wäre dann wohl effizienter, werde ich probieren. Danke dir!

Ich hatte das damals so gemacht.
[CODE lang="java" title="StartTaylor"]public class StartTaylor {
private final static double PRECISION_LIMIT = 0.001;

public static void main(String[] args) {
System.out.println(" Taylor Math ");
System.out.println("--------------------------------");
for (int angle = 0; angle <= 90; angle += 10) {
double cosTaylor = cos(angle);
double cosMath = Math.cos(Math.toRadians(angle));
System.out.println(String.format("cos(%d)\t %f\t %f", angle, cosTaylor, cosMath));
}
}

/**
* Calculates cosine of an angle using Taylor series limited by precision.
*
* cos(x) = 1 - x^2/fac(2) + x^4/fac(4) - x^6/fac(6) ...
*
* @param angle
* Angle in degree
* @return double
*/
public static double cos(double angle) {
angle = Math.toRadians(angle % 360); // transform degree to radian
double cosine = 1;
int sign = -1;
double add = 0;
int i = 0;
do {
add = getAddCos(angle, i);
cosine += sign * add;
sign = -sign;
i++;
} while (add > PRECISION_LIMIT);
return cosine;
}

public static long fac(int n) {
long val = 1;
for (int i = 2; i <= n; i++)
val *= i;
return val;
}

private static double getAddCos(double x, int n) {
int pot = 2 * (n + 1);
return Math.pow(x, pot) / fac(pot);
}

}[/CODE]

 

[rosima26]

Hättet ihr ne Idee wie ich das ohne Math.pow und ohne die Fakultätsmethode lösen könnte? Also praktisch nur eine Methode und keine Funktionen aus irgendwelchen Bibliotheken?

 

[MarvinsDepression]

Hier hätte ich auch noch eine Anmerkung. Der Vorteil der Taylorreihen ist doch, das sich alle Folgeglieder aus den vorangegangen entwickeln. Dadurch konnten sich die Anwender zu Vorcomputerzeiten viel Rechenarbeit sparen.
[CODE lang="java" title="Maclaurin-Reihe for den Cosinus" highlight="13-15"]double cosinus(final double x) {
final double epsilon = 0.0001;
double cos = 1.0;

int vorzeichen = 1;
double zaehler = 1;
double nenner = 1;

int index = 0;
double glied;
do {
index++;
vorzeichen *= -1;
zaehler *= x * x;
nenner *= (2 * index - 1) * (2 * index);

glied = vorzeichen * zaehler / nenner;
cos += glied;

System.out.println(glied + " " + cos);
} while (Math.abs(glied) >= epsilon);

return cos;
}[/CODE]
So musste nicht für jedes Folgeglied erneut die gesamte Fakultät oder die n-te Potenz berechnet werden. Man verwendete die Zwischenergebnisse der vorhergehenden Rechenschritte.
Das läßt sich auch Programiertechnisch umsetzen und kommt womöglich der Aufgabenstellung auch noch ein Stückchen näher.

 

[rosima26]

Hab das auch mal versucht, allerdings liefert der mir wieder falsche Ergebnisse. Tipps?

    public static double sin(double x, double eps) {

        double vorzeichen = 1;
        double zaehler = 1;
        double nenner = 1;
        double ausdruck = 1;
        double sin = 0;

        for (int i = 1; (ausdruck >= eps || ausdruck <= -eps); i++) {

            zaehler *= x * x + x;
            nenner *= (2 * i + 1) * (2 * i);

            ausdruck = vorzeichen * zaehler / nenner;

            sin += ausdruck;

            vorzeichen *= 1;

        }

        return sin;
    }

}

 

[KonradN]

vorzeichen *= 1;

Da dürfte das - bei der 1 fehlen.

 

[rosima26]

Ja stimmt, danke. Zudem liegt das Problem glaub ich hier: zaehler *= x * x + x;
Hat jemand ne Idee wie sich ungerade Exponenten als geometrische Reihe darstellen lassen? x*x ist ja immer doppelt und x*x*x ist dreifach aber was ist ungerade?!

 

[Jw456]

x*x ist x^2
x*x*x ist x^3
x*x*x*x*x ist x^5

 

[rosima26]

ja genau. Und was ist x^(2n+1)?
also sozusagen x^3, x^5, x^7, x^9 usw

 

[KonradN]

Das Problem hier ist doch, dass Du x^(2n+1) berechnen musst.
Und nun willst Du dies mit dem vorherigen Wert ausdrücken - das ist ja x^(2(n-1) + 1)

Oder anders ausgedrückt: Du hast für ein n den Wert x^(2n+1) und willst nun den wert für x^(2(n+1)+1)

Betrachten wir nur das 2(n+1)+1 = 2n+2+1 = (2n+1) + 2

x^(a+b) = x^a * x^b

x^((2n+1)+2) = x^(2n+1) * x^2 = x^(2n+1) * x * x

Den Folgewert bekommst Du also durch multiplikation mit x * x.

Oder anders betrachtet: das +1 spielt keine Rolle. Du hast halt ^1, ^3, ^5 - es kommen immer 2 dazu - ebenso wie bei ^0, ^2, ^4, ....

 

[KonradN]

Oder um es konkret zu machen: Es ändert sich sozusagen durch das +1 nur, dass enmal ein x mehr da sein muss. Der startwert ändert sich also von 1 hin zu 1*x.

 

[rosima26]

Ja das stimmt wohl, hatte ich auch schon probiert. Aber irgendwie ist da der Wurm drin. Ich komm einfach verdammt nochmal nicht auf das richtige Ergebnis, es ist zum verrückt werden

 

[rosima26]

Edit: Habs geschafft, musste Nenner und Zähler natürlich unter Ausdruck und Sin packen, sonst funktioniert das natürlich nicht.
Vielen Dank nochmal!!