Java rechnet falsch?

[minos5000]

Hi,
ich muss gerade einige mathemtische Berechnungen in Java realisieren und benutze Maple um die Ergebnisse zu verifizieren und mir ist verschiedentlich aufgefallen, daß Java falsche Ergebnisse liefert.

int x1 = 23; int y1 = 15;
int x2 = 17; int y2 = 37;
double s = Math.hypot(x1-x2, y1-y2);

double result = ( (12*x2*x2*y2*y2*x1*x1) + (2*x2*x2*y2*y2*s*s)
+ (8*x1*x1*x1*x2*y2*y2) + (8*x2*x2*x2*y1*y1*x1)-(12*x2*x2*y1*y1*x1*x1) );

Java liefert mir als result den Wert "-3.611018656E9" was völlig daneben liegt, denn sowohl mein Taschenrechner als auch Maple bekommen "4978915936" als Ergebnis raus.

Wie kann das sein und wie bekomme ich Java dazu, die korrekten Ergebnisse zu liefern?

thx,
minos

 

[abollm]

Mach das mal so:

public class FalschRichtigRechnen {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub


		double x1 = 23.0; double y1 = 15.0;
		double x2 = 17.0; double y2 = 37.0;
		double s = Math.hypot(x1-x2, y1-y2);

		double result = ( (12*x2*x2*y2*y2*x1*x1) + (2*x2*x2*y2*y2*s*s)
		+ (8*x1*x1*x1*x2*y2*y2) + (8*x2*x2*x2*y1*y1*x1)-(12*x2*x2*y1*y1*x1*x1) );

		System.out.println ("Ergebnis result: " + result);

	}

}

Irgendwo steht das auch, dass man bei Berechungen, bei denen z.B. double das Ergebnis ist, nicht den elementaren Datentyp int für interne Variablenwerte nehmen soll.

 

[minos5000]

Vielen Dank für den Tipp.

Es überrascht mich aber doch, wie stark sich die Verwendung von int auf das Ergebnis auswirken kann.

 

[Ark]

Zunächst würde ich noch mal überprüfen, ob die hier eingesetzte Formel tatsächlich stimmt! Wenn ja, sollte das meines Erachtens vereinfacht werden, so sollte es auch schneller sein:

int x1 = 23; int y1 = 15;
int x2 = 17; int y2 = 37;
double s = Math.hypot(x1-x2, y1-y2);
int x12 = x1 * x1;
int y12 = y1 * y1;
int x22 = x2 * x2;
int y22 = y2 * y2;

double result = (12 * x22 * y22 * x12)
              + (8  * x12*x1 * x2 * y22)
              + (8 *  x22*x2 * y12 * x1)
              - (12 * x22 * y12 * x12)
              + (2 * x22 * y22 * s*s); // double-Operanden als letztes

Wenn der Wertebereich von int nicht ausreicht, solltest du auf long umsteigen.

Hinzu kommt noch, dass s gerade eine Wurzel aus einer Zahl ist, das macht die Sache noch viel einfacher:

s = Math.hypot(x1-x2, y1-y2)
s*s = (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2)
s*s = x12+x22-2*x1*x2 + y12+y22-2*y1*y2

Das kannst du dann in den nun letzten Summanden von result einsetzen und da vielleicht auch wieder etwas vereinfachen. So wird ein double hinfällig, und ganze Zahlen reichen aus.

Ark

 

[minos5000]

Tja, ich würde gern noch weiter vereinfachen, abe was ich gepostet habe war nur ein Beispiel. Die eigentlichen Rechnungen sehen so aus:

double sqrt_x1_1 = -8*x1*x1*x1*x2*s*s-Math.pow(y1,4)*x2*x2+4*y2*y1*y1*y1*x1*x1+4*y1*y1*y1*x2*x2*y2-8*x1*x2*x2*x2*s*s-
                Math.pow(y1,4)*x1*x1-8*y1*y1*y1*x1*x2*y2+2*Math.pow(y1,4)*x1*x2-Math.pow(y2,4)*x2*x2-Math.pow(y2,4)*x1*x1-2*
                Math.pow(x2,4)*y2*y2-2*Math.pow(x2,4)*y1*y1-2*y1*y1*Math.pow(x1,4)+20*x1*x1*x1*x2*x2*x2-15*x1*x1*Math.pow(x2,4)+6*
                Math.pow(x1,5)*x2+6*x1*Math.pow(x2,5)-15*Math.pow(x1,4)*x2*x2+2*Math.pow(x2,4)*s*s-x2*x2*Math.pow(s,4)+4*
                Math.pow(x2,4)*d*d+2*Math.pow(x1,4)*s*s-x1*x1*Math.pow(s,4)+4*Math.pow(x1,4)*d*d+8*s*s*y1*x1*x2*y2+2*s*s*y1*y1*x2*x2+4*y2*y2*y2*y1*x2*x2-6*y2*y2*y1*y1*x2*x2+4*y2*y2*y2*y1*x1*x1-6*y2*y2*y1*y1*x1*x1+2*s*s*y1*y1*x1*x1+2*
                Math.pow(y2,4)*x1*x2+8*x2*x2*x2*y2*y2*x1+4*Math.pow(x2,4)*y2*y1-12*x2*x2*y2*y2*x1*x1+2*x2*x2*y2*y2*s*s+8*x1*x1*x1*x2*y2*y2+8*x2*x2*x2*y1*y1*x1-12*x2*x2*y1*y1*x1*x1+4*y2*
                Math.pow(x1,4)*y1+2*y2*y2*x1*x1*s*s+8*x1*x1*x1*x2*y1*y1+12*x1*x1*x2*x2*s*s+2*x1*x2*Math.pow(s,4)+24*x1*x1*x2*x2*d*d-16*x1*x2*x2*x2*d*d-16*x1*x1*x1*x2*d*d+4*y2*y2*d*d*x2*x2+4*y2*y2*d*d*x1*x1-8*y2*y2*y2*y1*x1*x2+8*x2*x2*y2*y1*s*d+8*x1*x2*y2*y2*s*d-16*x1*x2*y2*y1*s*d-2*y2*y2*
                Math.pow(x1,4)+16*y2*y1*d*d*x2*x1-8*y2*y2*d*d*x2*x1-8*y1*y1*d*d*x2*x1+8*y2*x1*x1*y1*s*d+8*y1*y1*s*d*x1*x2-4*y1*y1*s*d*x1*x1-8*x1*x2*s*s*s*d+8*x1*x2*s*s*d*d+16*x1*x1*x1*x2*s*d+16*x1*x2*x2*x2*s*d-24*x1*x1*x2*x2*s*d-8*y2*y1*d*d*x2*x2-8*y2*y1*d*d*x1*x1-
                Math.pow(x2,6)-Math.pow(x1,6)+12*y2*y2*y1*y1*x1*x2-4*s*s*y1*x2*x2*y2-4*s*s*y1*y2*x1*x1-4*s*s*y1*y1*x1*x2-16*x2*x2*x2*y2*x1*y1-4*x2*x2*y2*y2*s*d+24*x2*x2*y2*y1*x1*x1-16*x1*x1*x1*x2*y2*y1-4*x1*x2*y2*y2*s*s-4*x2*x2*y1*y1*s*d-4*y2*y2*x1*x1*s*d+4*y1*y1*d*d*x2*x2+4*y1*y1*d*d*x1*x1+4*x2*x2*s*s*s*d-4*x2*x2*s*s*d*d-4*
                Math.pow(x2,4)*s*d+4*x1*x1*s*s*s*d-4*x1*x1*s*s*d*d-4*Math.pow(x1,4)*s*d;

double sqrt_x1_2 = -8*x1*x1*x1*x2*s*s-Math.pow(y1,4)*x2*x2+4*y2*y1*y1*y1*x1*x1+4*y1*y1*y1*x2*x2*y2-8*x1*x2*x2*x2*s*s-
                Math.pow(y1,4)*x1*x1-8*y1*y1*y1*x1*x2*y2+2*Math.pow(y1,4)*x1*x2-Math.pow(y2,4)*x2*x2-Math.pow(y2,4)*x1*x1-2*
                Math.pow(x2,4)*y2*y2-2*Math.pow(x2,4)*y1*y1-2*y1*y1*Math.pow(x1,4)+20*x1*x1*x1*x2*x2*x2-15*x1*x1*Math.pow(x2,4)+6*
                Math.pow(x1,5)*x2+6*x1*Math.pow(x2,5)-15*Math.pow(x1,4)*x2*x2+2*Math.pow(x2,4)*s*s-x2*x2*Math.pow(s,4)+4*
                Math.pow(x2,4)*d*d+2*Math.pow(x1,4)*s*s-x1*x1*Math.pow(s,4)+4*Math.pow(x1,4)*d*d+8*s*s*y1*x1*x2*y2+2*s*s*y1*y1*x2*x2+4*y2*y2*y2*y1*x2*x2-6*y2*y2*y1*y1*x2*x2+4*y2*y2*y2*y1*x1*x1-6*y2*y2*y1*y1*x1*x1+2*s*s*y1*y1*x1*x1+2*
                Math.pow(y2,4)*x1*x2+8*x2*x2*x2*y2*y2*x1+4*Math.pow(x2,4)*y2*y1-12*x2*x2*y2*y2*x1*x1+2*x2*x2*y2*y2*s*s+8*x1*x1*x1*x2*y2*y2+8*x2*x2*x2*y1*y1*x1-12*x2*x2*y1*y1*x1*x1+4*y2*Math.pow(x1,4)*y1+2*y2*y2*x1*x1*s*s+8*x1*x1*x1*x2*y1*y1+12*x1*x1*x2*x2*s*s+2*x1*x2*
                Math.pow(s,4)+24*x1*x1*x2*x2*d*d-16*x1*x2*x2*x2*d*d-16*x1*x1*x1*x2*d*d+4*y2*y2*d*d*x2*x2+4*y2*y2*d*d*x1*x1-8*y2*y2*y2*y1*x1*x2+8*x2*x2*y2*y1*s*d+8*x1*x2*y2*y2*s*d-16*x1*x2*y2*y1*s*d-2*y2*y2*
                Math.pow(x1,4)+16*y2*y1*d*d*x2*x1-8*y2*y2*d*d*x2*x1-8*y1*y1*d*d*x2*x1+8*y2*x1*x1*y1*s*d+8*y1*y1*s*d*x1*x2-4*y1*y1*s*d*x1*x1-8*x1*x2*s*s*s*d+8*x1*x2*s*s*d*d+16*x1*x1*x1*x2*s*d+16*x1*x2*x2*x2*s*d-24*x1*x1*x2*x2*s*d-8*y2*y1*d*d*x2*x2-8*y2*y1*d*d*x1*x1-
                Math.pow(x2,6)-Math.pow(x1,6)+12*y2*y2*y1*y1*x1*x2-4*s*s*y1*x2*x2*y2-4*s*s*y1*y2*x1*x1-4*s*s*y1*y1*x1*x2-16*x2*x2*x2*y2*x1*y1-4*x2*x2*y2*y2*s*d+24*x2*x2*y2*y1*x1*x1-16*x1*x1*x1*x2*y2*y1-4*x1*x2*y2*y2*s*s-4*x2*x2*y1*y1*s*d-4*y2*y2*x1*x1*s*d+4*y1*y1*d*d*x2*x2+4*y1*y1*d*d*x1*x1+4*x2*x2*s*s*s*d-4*x2*x2*s*s*d*d-4*
                Math.pow(x2,4)*s*d+4*x1*x1*s*s*s*d-4*x1*x1*s*s*d*d-4*Math.pow(x1,4)*s*d;
double x_1 = (-0.5)*(-1/(-8*x1*x2-8*y2*y1+4*y2*y2+4*y1*y1+4*x2*x2+4*x1*x1)*(-4*y2*y2*y1+4*y1*y1*y1+4*s*s*y1+4*y2*y2*y2+4*x2*x2*y2-
                8*x1*x2*y2+4*x2*x2*y1-4*y2*y1*y1+4*y2*x1*x1-8*y1*s*d-8*x1*x2*y1+8*y2*s*d+4*y1*x1*x1-4*s*s*y2+4*Math.sqrt(sqrt_x1_1))*y2+1/
                (-8*x1*x2-8*y2*y1+4*y2*y2+4*y1*y1+4*x2*x2+4*x1*x1)*(-4*y2*y2*y1+4*y1*y1*y1+4*s*s*y1+4*y2*y2*y2+4*x2*x2*y2-8*x1*x2*y2+4*x2*x2*y1-
                4*y2*y1*y1+4*y2*x1*x1-8*y1*s*d-8*x1*x2*y1+8*y2*s*d+4*y1*x1*x1-4*s*s*y2+4*Math.sqrt(sqrt_x1_2))*y1+y2*y2+x2*x2-s*s+2*s*d-x1*x1-y1*y1)/(-x2+x1);

Der Zahlenwußt stammt direkt aus Maple was leider auch bedeutet, daß sich nichts weiter vereinfachen lässt.

 

[Marco13]

:autsch: Und WIE man das Vereinfachen kann!!!

double sqrt_x1_1 = -8*x1*x1*x1*x2*s*s-Math.pow(y1,4)*x2*x2+4*y2*y1*y1*y1*x1*x1+4*y1*y1*y1*x2*x2*y2-8*x1*x2*x2*x2*s*s-
                Math.pow(y1,4)*x1*x1-8*y1*y1*y1*x1*x2*y2+2*Math.pow(y1,4)*x1*x2-Math.pow(y2,4)*x2*x2-Math.pow(y2,4)*x1*x1-2*...

->

double x1p2 = x1*x1;
double x2p2 = x2*x2;
double y1p2 = y1*y1;
double sp2 = s*s;
double y2p4 = Math.pow(y2,4);
double y1p4 = Math.pow(y1,4);
double f01 = 8*x1*x2;
double f02 = 4*y2*y1*y1p2;
double f03 = f02*sp2;

double sqrt_x1_1 = -f03*x1p2-f03*x2p2-f01*y1p2*y1*y2+f02*x1p2+f02*x2p2-2*y1p4*x1*x2-y1p4*x2p2+y1p4*x1p2-y2p4*x2p2-x2p4*x1p2-2* ...

....

 

[minos5000]

Ok, so gesehen geht's natürlich noch einfacher. Ich meinte im Hinblick auf Zusammenfassen von Termen.

Aber da die Operation eh nicht zeikritisch ist erspar ich es mir vorerst lieber, die Berechnungen nach gleichen Ausdrücken abzugrasen.

 

[minos5000]

So, obwohl nun alles double ist, hab ich soeben feststellen müssen, daß manchmal immer noch falsche Ergebnisse raus kommen. Um mich auf Fehlersuche zu machen, hab ich eine der ellenlangen Rechnungen aufgesplittet und dabei auf folgendes gestoßen:

public static Point equation(double x1, double y1, double x2, double y2, double d) {
    double s = Math.hypot(x1-x2, y1-y2);

    double x1p3 = x1*x1*x1;
    double x1p2 = x1*x1;
    double x2p3 = x2*x2*x2;
    double x2p2 = x2*x2;
    double y1p3 = y1*y1*y1;
    double y1p2 = y1*y1;
    double y2p3 = y2*y2*y2;
    double y2p2 = y2*y2;
    double sp2 = s*s;
    double dp2 = d*d;
    double x1p4 = Math.pow(x1, 4);
    double x2p4 = Math.pow(x2, 4);
    double sp4 = Math.pow(s, 4);
    double y1p4 = Math.pow(y1, 4);
    double y2p4 = Math.pow(y2, 4);
    double x1x2 = x1*x2;
    double y2y1 = y2*y1;
    double sd = s*d;

    double sqrt_x1_1 = -8*x1p3*x2*sp2-y1p4*x2p2+4*y2*y1p3*x1p2+4*y1p3*x2p2*y2-8*x1*x2p3*sp2-
            y1p4*x1p2-8*y1p3*x1x2*y2+2*y1p4*x1x2-y2p4*x2p2-y2p4*x1p2-2*
            x2p4*y2p2-2*x2p4*y1p2-2*y1p2*x1p4+20*x1p3*x2p3-15*x1p2*x2p4+6*
            Math.pow(x1,5)*x2+6*x1*Math.pow(x2,5)-15*x1p4*x2p2+2*x2p4*sp2-x2p2*sp4+4*
            x2p4*dp2+2*x1p4*sp2-x1p2*sp4+4*x1p4*dp2+8*sp2*y1*x1x2*y2+2*sp2*y1p2*x2p2+4*y2p2*y2y1*x2p2-6*y2p2*y1p2*x2p2+4*y2p2*y2y1*x1p2-6*y2p2*y1p2*x1p2+2*sp2*y1p2*x1p2+2*
            y2p4*x1x2+8*x2p3*y2p2*x1+4*x2p4*y2y1-12*x2p2*y2p2*x1p2+2*x2p2*y2p2*sp2+8*x1p3*x2*y2p2+8*x2p3*y1p2*x1-12*x2p2*y1p2*x1p2+4*y2*



            x1p4*y1+2*y2p2*x1p2*sp2+8*x1p3*x2*y1p2+12*x1p2*x2p2*sp2+2*x1x2*sp4+24*x1p2*x2p2*dp2-16*x1*x2p3*dp2-16*x1p3*x2*dp2+4*y2p2*dp2*x2p2+4*y2p2*dp2*x1p2-8*y2p2*y2y1*x1x2+8*x2p2*y2y1*sd+8*x1x2*y2p2*sd-16*x1x2*y2y1*sd-2*y2p2*
            x1p4+16*y2y1*dp2*x2*x1-8*y2p2*dp2*x2*x1-8*y1p2*dp2*x2*x1+8*y2*x1p2*y1*sd+8*y1p2*sd*x1x2-4*y1p2*sd*x1p2-8*x1x2*sp2*sd+8*x1x2*sp2*dp2+16*x1p3*x2*sd+16*x1*x2p3*sd-24*x1p2*x2p2*sd-8*y2y1*dp2*x2p2-8*y2y1*dp2*x1p2-
            Math.pow(x2,6)-Math.pow(x1,6)+12*y2p2*y1p2*x1x2-4*sp2*y1*x2p2*y2-4*sp2*y1*y2*x1p2-4*sp2*y1p2*x1x2-16*x2p3*y2*x1*y1-4*x2p2*y2p2*sd+24*x2p2*y2y1*x1p2-16*x1p3*x2*y2y1-4*x1x2*y2p2*sp2-4*x2p2*y1p2*sd-4*y2p2*x1p2*sd+4*y1p2*dp2*x2p2+4*y1p2*dp2*x1p2+4*x2p2*sp2*sd-4*x2p2*sp2*dp2-4*
            x2p4*sd+4*x1p2*sp2*sd-4*x1p2*sp2*dp2-4*x1p4*sd;

Wenn ich die Funktion mit "Util.equation(28, 42, 28, 20, 2.0);" aufrufe, erhalte ich als Ergebnis für sqrt_x1_1: "0.0"
Wenn ich aber wie folgt die Berechnung aufsplitte erhalte ich bei gleichen Eingaben als Ergebnis "-4.867777333385449E19".

    double sqrt_x1_1_1 = -8*x1p3*x2*sp2-y1p4*x2p2+4*y2*y1p3*x1p2+4*y1p3*x2p2*y2-8*x1*x2p3*sp2-
            y1p4*x1p2-8*y1p3*x1x2*y2+2*y1p4*x1x2-y2p4*x2p2-y2p4*x1p2-2*
            x2p4*y2p2-2*x2p4*y1p2-2*y1p2*x1p4+20*x1p3*x2p3-15*x1p2*x2p4+6*
            Math.pow(x1,5)*x2+6*x1*Math.pow(x2,5)-15*x1p4*x2p2+2*x2p4*sp2-x2p2*sp4+4*
            x2p4*dp2+2*x1p4*sp2-x1p2*sp4+4*x1p4*dp2+8*sp2*y1*x1x2*y2+2*sp2*y1p2*x2p2+4*y2p2*y2y1*x2p2-6*y2p2*y1p2*x2p2+4*y2p2*y2y1*x1p2-6*y2p2*y1p2*x1p2+2*sp2*y1p2*x1p2+2*
            y2p4*x1x2+8*x2p3*y2p2*x1+4*x2p4*y2y1-12*x2p2*y2p2*x1p2+2*x2p2*y2p2*sp2+8*x1p3*x2*y2p2+8*x2p3*y1p2*x1-12*x2p2*y1p2*x1p2+4*y2;
    double sqrt_x1_1_2 = x1p4*y1+2*y2p2*x1p2*sp2+8*x1p3*x2*y1p2+12*x1p2*x2p2*sp2+2*x1x2*sp4+24*x1p2*x2p2*dp2-16*x1*x2p3*dp2-16*x1p3*x2*dp2+4*y2p2*dp2*x2p2+4*y2p2*dp2*x1p2-8*y2p2*y2y1*x1x2+8*x2p2*y2y1*sd+8*x1x2*y2p2*sd-16*x1x2*y2y1*sd-2*y2p2*
            x1p4+16*y2y1*dp2*x2*x1-8*y2p2*dp2*x2*x1-8*y1p2*dp2*x2*x1+8*y2*x1p2*y1*sd+8*y1p2*sd*x1x2-4*y1p2*sd*x1p2-8*x1x2*sp2*sd+8*x1x2*sp2*dp2+16*x1p3*x2*sd+16*x1*x2p3*sd-24*x1p2*x2p2*sd-8*y2y1*dp2*x2p2-8*y2y1*dp2*x1p2-
            Math.pow(x2,6)-Math.pow(x1,6)+12*y2p2*y1p2*x1x2-4*sp2*y1*x2p2*y2-4*sp2*y1*y2*x1p2-4*sp2*y1p2*x1x2-16*x2p3*y2*x1*y1-4*x2p2*y2p2*sd+24*x2p2*y2y1*x1p2-16*x1p3*x2*y2y1-4*x1x2*y2p2*sp2-4*x2p2*y1p2*sd-4*y2p2*x1p2*sd+4*y1p2*dp2*x2p2+4*y1p2*dp2*x1p2+4*x2p2*sp2*sd-4*x2p2*sp2*dp2-4*
            x2p4*sd+4*x1p2*sp2*sd-4*x1p2*sp2*dp2-4*x1p4*sd;

    sqrt_x1_1 = sqrt_x1_1_1*sqrt_x1_1_2;

Wie ist dieses Verhalten denn nun zu erklären und wie stelle ich es nur an, daß die Schoße endlich so läuft wie ich es mir wünsche?


Ciao,
minos

 

[Ark]

Vielleicht solltest du versuchen, möglichst in gleichen Wertebereichen zu bleiben, also zu verhindern, dass die Zahlen ganz groß und dann ganz klein werden oder anders herum. Mit double hast du 52 Bit (plus 1 Bit Vorzeichen), um exakt zu rechnen, mit long hast du 63 Bit (plus Vorzeichen). Vielleicht kommst du ohne double aus oder kannst dafür sorgen, möglichst lange mit reinen longs zu arbeiten. Fließkommazahlen werden dann zu einem Problem, wenn sie so nah an der 0 sind, dass sie Genauigkeit abgeben müssen, damit sie überhaupt so klein werden können. Wenn man dann Fast-Null durch Fast-Null teilen muss, kommen ziemlich komische Ergebnisse raus, weil es eben fast so ist, als würde man Null durch Null teilen. :shock:

Ark

 

[minos5000]

Liesse sich das Problem denn dann vermeiden, wenn ich BigInteger nehmen würde?

EDIT:
Aber andererseits hab ich grad nachgeschaut und bin von den Werten noch weit von den maximal möglichen entfernt.

double 4.9E-324 bis 1.7976931348623123E308

 

[Marco13]

Ähm - um das mal ganz allgemein nebenbei zu erwähnen: Auch die Rechengenauigkeit von double ist beschränkt.

Das Ergebnis liegt zwar in einem Bereich, der mit double noch dargestellt werden kann, aber das hat nicht viel zu sagen. Als Beispiel:

double x = 1E100;
double y = 1E-100;
double z = 1E100;

// Gewünschte Rechnung: x+y-z

double a = x+y; // Ergibt 1E100, weil y zu klein ist, um vernünftig zu x addiert zu werden
double b = a - z; // Ergibt 0. Sollte "eigentlich" aber 1E-100 sein

// Alternativ:

double a = x-z; // Ergibt 0
double b = a+y; // Ergibt 1E-100 - ads richtige Ergebnis.

Das Ergebnis "-4.867777333385449E19" ist nicht ungewöhnlich, und ist "praktisch gleich 0.0". Viel ungewöhnlicher ist imho, wenn bei der anderen rechnung (mit so einem gigantischen term) so eine glatte 0.0 rauskommt.... Was sagt denn Maple dazu? SOLL da 0.0 rauskommen? (Theoreitsch könnten durch das zusammenfassen von Teiltermen Fehler entstehen, aber die liegen in einer Größenordnung, die nur in den allerwenigsten Fällen relevant sein sollte...)

 

[minos5000]

Das ganze ist nur ein Ausschnitt, den ich nicht direkt in Maple getestet habe.

Insgesamt sollte bei der Berechnung laut Maple "28" rauskommen, aber Java liefert mir hier nicht mal 0.0 sondern "NaN".

Ich werd inzwischen mal versuchen, das ganze näherungsweise und nicht direkt zu lösen.

 

[SnooP]

BigInteger und BigDecimal sollten in jedem Fall bei solchen Rechnungen helfen, wenn auch die Performance darunter leidet, aber das ist ja in diesem Fall egal.

 

[Rock Lobster]

Es überrascht mich aber doch, wie stark sich die Verwendung von int auf das Ergebnis auswirken kann.

Das ist weniger überraschend, wenn man weiß, warum: Und zwar ist ein int eine Ganzzahl. Wenn Du solch eine Ganzzahl durch eine andere Zahl teilst, kann natürlich auch ein Bruch dabei herauskommen, aber es wird ja wieder in der Ganzzahl gespeichert:

int i = 7 / 2;

Hierbei steht nun keine 3.5 in "i", denn das geht nicht (weil "i" als Ganzzahl deklariert worden ist). Sondern es steht eine glatte 3 drin.
Nun ist es aber so, daß selbst der folgende Code schiefgeht:

int i = 7;
float f = i / 2;

Hier wird das Ergebnis zwar letztendlich in f gespeichert (eine float also), aber trotzdem steht hinterher eine 3 drin und keine 3.5, weil i eben ein int ist. Daher mußt Du entweder i auf float casten...

int i = 7;
float f = (float)i / 2;

...oder die 2 explizit als float angeben:

int i = 7;
float f = i / 2.0f;

Es reicht also, wenn eine der beiden Zahlen eine float ist. Daher liefert das folgende Beispiel auch eine "Unnecessary Cast"-Warnung:

int i = 7;
float f = (float)i / 2.0f;

 

[Marco13]

Es überrascht mich aber doch, wie stark sich die Verwendung von int auf das Ergebnis auswirken kann.

Das ist weniger überraschend, wenn man weiß, warum: Und zwar ist ein int eine Ganzzahl. Wenn Du solch eine Ganzzahl durch eine andere Zahl teilst, kann natürlich auch ein Bruch dabei herauskommen, aber es wird ja wieder in der Ganzzahl gespeichert:
[/code]

Wie überraschend es jetzt für dich ist, dass das mit dem Problem garnichts zu tun hat, weiß ich nicht :wink: In der ganzen Rechnung wird nirgendwo geteilt. Das Problem war wohl eher ein Überlauf, weil...

int x1 = 23; int y1 = 15;
int x2 = 17; int y2 = 37;

double result = ( (12*x2*x2*y2*y2*x1*x1)  .... <----------------------- HIER

... schon 2.5 Milliarden rauskommt, und das passt nichtmehr in int....


@minos5000

Wenn ich die Funktion mit "Util.equation(28, 42, 28, 20, 2.0);" aufrufe, erhalte ich als Ergebnis für sqrt_x1_1: "0.0"
Wenn ich aber wie folgt die Berechnung aufsplitte erhalte ich bei gleichen Eingaben als Ergebnis "-4.867777333385449E19".

DAS liegt nun daran, dass du falsch aufgesplittet hast. Praktischerweise gilt auch in Java: "Punktrechnung vor Strickrechnung". Wenn du in der "Kombinierten" Rechnung Klammern um die beiden Teile setzt, kommt auch das gleiche raus....

 

[Rock Lobster]

LOL okay ich muß zugeben, die Berechnungen waren mir ein wenig zu komplex, als daß ich sie mir ernsthaft durchgelesen hätte

Naja war halt früh am morgen

 

[minos5000]

Ich hab das Problem inzwischen insofern beseitigt, daß ich die Gleichung, die ich mit den langen Termen lösen wollte über das newtonsche Verfahren löse.
Ich dachte, ich könnte mir Arbeit sparen, wenn ich versuche die Zahlen direkt zu berechnen, aber wie es aussieht gibt es dabei einfach zu viel troubel.

Auf jeden fall Danke für eure Ratschläge.


Ciao,
minos

 

[Gast]

Na Hallo,

ich habe auch ein kleines Problem.
Und zwar muss so was wie 5 hoch 3 rechnen und weiss nicht wie ich es in Java eingebe

 

[Leroy42]

Math.pow(5, 3)

 

[MUPI]

eine frage mal...weil ich komm bei meinem programm nicht weiter..und das nervt... Frage: Wie lautet die maximale und durchschnittliche Vergleichszahl von Insertion sort? wäre nett wenn mir dsa jemand beantworten könnte..bei google hab ich es nicht gefunden.. im vorraus schonmal danke...

 

[masta // thomas]

Du bist ja frech, du hast du einen eigenen Thread!

 

[MUPI]

tut mir leid

 

[masta // thomas]

Ich verzeihe dir. Ausnahmsweise.