strictfp

[MrChance]

Hat jemand ein Beispiel, wo eine Berechung mit strictfp ein anderes Ergebnis liefert als eine ohne strictfp. Also f(x) != strict f(x) ?

 

[Wildcard]

Das währe abhängig von der Plattform, genau deshalb gibt's ja strictfp :wink:

 

[MrChance]

Ich hab XP und Intel Pentium 4.

 

[Wildcard]

Ich nicht

 

[MrChance]

Naja, ich will ja das einmal plattformunabhängig und einmal plattformabhängig berechnet wird, um den Unterschied zu sehen.

Wir können es auch so erweitern,um zu sehen was deine Plattform berechnet und was auf meiner Plattform rauskommt.

(Aber die strictfp-Berechnung ist dann ja eh gleich)

 

[Wildcard]

Schonmal dran gedacht das es auch möglich ist das auf deiner Plattform kein Unterschied existiert?
Warum interessiert dich das überhaupt? Ist doch ziemlich klar wann man strictfp benutzt und wann nicht.

 

[MrChance]

Weil ich neugierig bin und Anfänger ;-)

Soweit ich weiss, ist bei strictfp die Bitbreite geringer als bei der plattformabhängigen Variante. Also muss es bei bestimmten Berechnungen Unterschiede geben, oder ???

 

[Wildcard]

Bei strictfp werden Gleitkommazahlen nach IEEE Standard verwendet. Die Rechnerarchitektur muss allerdings nicht zwangsläufig der IEEE entsprechen.

 

[MrChance]

Richtig. Deshalb sollten Unterschiede zwischen strictfp und nicht-strictfp zu finden sein !?

 

[Wildcard]

oder eben nicht.

 

[MrChance]

"Eben nicht" gilt aber nicht im Allgemeinen, sondern nur in einem Sonderfall.

 

[Wildcard]

Dann bastel dir doch einfach was und werde glücklich.

 

[MrChance]

Danke.

 

[Wildcard]

Bitte

 

[MrChance]

Hey...wer setzt hier einfach einen Haken ?
Die Frage war nach einem Beispiel !!!!
Nicht was strictfp bedeutet.

 

[Wildcard]

Warum bedankst du dich dann?
Jetzt mal im ernst, wie schwer kann es sein an die Grenze der IEEE Genauigkeit zu gehen, dann an Stückchen weiter, und schauen was dabei rauskommt?
Oder benutz google und finde heraus wie in deinem Prozessor Gleitkommazahlen definiert sind.
Ein besonders spannendes Thema ist das nun wirklich nicht.

 

[MrChance]

Also, nur irgendeine 80-Bit FP-Zahl nehmen und einmal in einer strictfp Klasse ausgeben und in einer nicht-strictfp Klasse ausgeben ?

 

[Wildcard]

Wieso denn bitte 80 bit?
http://de.wikipedia.org/wiki/IEEE_754

 

[MrChance]

Weil IEEE nur 32 bzw. 64 beherrscht. Also muss ich mehr Bits nehmen als IEEE (falls dies meine Plattform zulässt) !?!?!?

 

[Wildcard]

Zuerst musst du wissen wie deine Plattform überhaupt aussieht. Wie viele bits insgesamt, wie viele entfallen auf Mantisse und wie viele auf Exponent.
Dann wird dir vermutlich langweilig und dir wird klar das vielleicht 10 Leute jemals strictfp gebraucht haben :roll:

 

[MrChance]

Deshalb dachte ich, jemand hat das bereits ausprobiert oder musste es mal machen und kann mir eine kleine Berechung zeigen wo es zu einem Unterschied kam.

 

[MrChance]

(in der wahrscheinlichen Annahme, dass derjenige und auch ich mehr Bits zur Verfügung haben als im IEEE vorgesehen)

 

[Wildcard]

Warum willst du nicht verstehen das das Plattformabhängig ist. Sieh dir die Spezifikation deiner Hardware an und konstruiere entsprechende Grenzfälle. Wenn du es allerdings bis dahin geschafft hast, wird dir klar das du die tatsächlich Berechnung nicht mehr machen musst, weil du dann bereits weißt was passieren wird :bae:

 

[MrChance]

Ha -ich habs: Ich kann doch einfach zwei Methoden schreiben der 1/x macht, einmal mit strict und einmal ohne. Und das in eine Schleife von 1.......Integer.MAX_VALUE ... und immer Abfragen ob die Ergebnisse gleich sind. Oder ?

 

[MrChance]

	public static strictfp void main(String[] args) {
		
		
		for(long i = 1; i < Long.MAX_VALUE; ++i) {
			if (f1(i) != f2(i)) System.out.println("Unterschied bei "+i);
		}
	}
	
	
	public static strictfp double f1(long x) {
		return 1.0/x;
	}

	public static  double f2(long x) {
		return 1.0/x;
	}

Müsste gehen, oder ? Vielleicht wäre (x-1.0)/x besser ?

 

[MrChance]

... main darf nicht strictfp sein, denke ich.

 

[Wildcard]

Nur Klassen können strictfp sein

 

[MrChance]

nö ... das Programm läuft.

 

[MrChance]

... aber irgendwie denk ich komm ich damit auch nicht ans Ziel

 

[MrChance]

Und wie ist es damit ?

	public static void main(String[] args) {
			
		for( int i = 1; i < Integer.MAX_VALUE; ++i) {
			if ( StrictMath.IEEEremainder( StrictMath.atan(i), Math.atan(i) ) > 0 ){
				
				System.out.println("Ungleich bei " + i);
				break;
			}
				
		}

	}

 

[MrChance]

Ist dies das was ich suche: ????

double a = 16.0;
double b = 7.0/16.0;

System.out.print("Plattformabhängig: " + (a%b) );
System.out.println(" Plattformunabhängig: " + StrictMath.IEEEremainder(a, b) );

 

[MrChance]

SO ENDLICH EIN BEISPIEL GEFUNDEN !!!!

public class StrictTest {
	
		  private static double defaultDmul(double a, double b) {
		    return a * b;
		  }

		  private static strictfp double strictDmul(double a, double b) {
		    return a * b;
		  }

		  private static double defaultDdiv(double a, double b) {
		    return a / b;
		  }

		  private static strictfp double strictDdiv(double a, double b) {
		    return a / b;
		  }

		  public static void main(String[] args) {
		    double a, b, c;

		    /* multiplication */
		    a = Double.longBitsToDouble(0x0008008000000000L);
		    b = Double.longBitsToDouble(0x3ff0000000000001L);

		    System.out.println(a + " (0x0008008000000000)");
		    System.out.println("  * " + b + " (0x3ff0000000000001)");

		    c = defaultDmul(a, b);
		    System.out.println("default : " + c +
				" (0x" + Long.toHexString(Double.doubleToLongBits(c)) + ")");

		    c = strictDmul(a, b);
		    System.out.println("strictfp: " + c +
				" (0x" + Long.toHexString(Double.doubleToLongBits(c)) + ")");

		    System.out.println();

		    /* division */
		    a = Double.longBitsToDouble(0x000fffffffffffffL);
		    b = Double.longBitsToDouble(0x3fefffffffffffffL);

		    System.out.println(a + " (0x000fffffffffffff)");
		    System.out.println("  / " + b + " (0x3fefffffffffffff)");

		    c = defaultDdiv(a, b);
		    System.out.println("default : " + c +
				" (0x" + Long.toHexString(Double.doubleToLongBits(c)) + ")");

		    c = strictDdiv(a, b);
		    System.out.println("strictfp: " + c +
				" (0x" + Long.toHexString(Double.doubleToLongBits(c)) + ")");
		  }
		}