Decrementieren mit Fehlern

[Hatschi]

public class Test   {
	public static void main(String[] args) {
		double x = 1.0;
		for(int i=0; i<100; i++) {
			x -= 0.1;
			System.out.println(x);
		}
    }
}

Ausgabe:

0.9
0.8
0.7000000000000001
0.6000000000000001
0.5000000000000001
0.40000000000000013
0.30000000000000016
...

 

[Gast2]

Was ist deine Frage?

manche Werte lassen sich nicht exakt binär speichern, daher kommen die "komischen" Werte zustande.

 

[maki]

EikeB hat recht, Fliesskommazahlen sind immer ungenau, liegt an der Hardware und nicht an der Programmiersprache.

 

[Hatschi]

elegante Lösung?

public class Test   {
    public static void main(String[] args) {
        double x = 1.0;
        int y = 100;
        for(int i=0; i<100; i++) {
            y -= 1;
            x = (double)y/100;
            System.out.println(x);
        }
    }
}

 

[eRaaaa]

elegante Lösung?

Wenn sie funktioniert ist doch alles gut 🙂
Kürzer schreiben kann mans ja immer noch
(

y -= 1;[/c] --> [c]y--;

&

x = (double)y/100; [/c]--> [c] x = y/100.;

zum Beispiel)

oder

		for (int i = 99; i >= 0; i--) {
			double x = i / 100.; //oder eben direkt in die nächste zeile :-)
			System.out.println(x);
		}

oder
.......

 

[Landei]

EikeB hat recht, Fliesskommazahlen sind immer ungenau, liegt an der Hardware und nicht an der Programmiersprache.

Fließkommazahlen sind manchmal auch genau. 1/2, 1/4 oder 57/65536 lassen sich ganz genau speichern, und werden beim Aufsummieren auch nie solche Fehler bringen.

Und die Ungenauigkeiten liegen weder an der Programmiersprache, noch an der Hardware, sondern einfach an der Mathematik und der Tatsache, dass wir für das Speichern von Zahlen nicht beliebig viel Platz verwenden können. Stell dir vor, die Zahlen wären im normalen Zehnersystem gespeichert, und mit 10 Nachkommastellen. Nun rechnen wir 1/3 + 2/3, aber statt 1 erhalten wir:

0.3333333333
0.6666666666
-------------
0.9999999999

Genau das passiert im Rechner, nur im Zweier-System (Binär- oder Dualsystem). 0.1 ist dort nicht exakt darstellbar, genauso wie 1/3 im Zehnersystem nicht exakt darstellbar ist. Rechnen wir es einfach aus:

10 dezimal = 1010 binär

1.000000000 / 1010 = 0.0110011001100110...
 -1010
------  
  01100
  -1010
  -----
     10000
     -1010
     -----
      0110
      ...

Wenn man diese Zahl mit 1010 (binär) multipliziert, kommt 0.1111111111.... (binär) heraus, was zu denselben Effekten wie im Zehnersystem führt.

 

[maki]

Und dui Ungenauigkeiten liegen weder an der Programmiersprache, noch an der Hardware, sondern einfach an der Mathematik und der Tatsache, dass wir für das Speichern von Zahlen nicht beliebig viel Platz verwenden können.

War wohl etwas ungenau, auch wenn es in der Mathematik doch das Konzept der Periodität gibt, oder?

Binärsysteme gibt es viele, du meinst das Dualsystem, ansonsten stimme ich dir zu.

 

[Landei]

Binärsysteme gibt es viele, du meinst das Dualsystem, ansonsten stimme ich dir zu.

Ähm, welche denn?

 

[ice-breaker]

Es gibt nur ein Binärsystem, das Dualsystem, es gibt jedoch mehrere Systeme um Kommazahlen Binär darzustellen.

 

[Landei]

Das würde ich gerne sehen, ich kenne nur eine Methode, Kommazahlen als Binärzahlen darzustellen (sieht man einmal von Feinheiten wie Exponentialschreibweise u.s.w. ab).

Natürlich sind andere Codierungen mit 0 und 1 möglich (z.B. Fibonacci-Codierung oder Gray-Code), aber sowas meinst du sicher nicht, oder?