I've a double
variable called x
. In the code, x
gets assigned a value of 0.1
and I check it in an 'if' statement comparing x
and 0.1
if (x==0.1) { ---- }
Unfortunately it does not enter the if
statement
Should I use Double
or double
?
What's the reason behind this? Can you suggest a solution for this?
To compare two floating point or double values, we have to consider the precision in to the comparison. For example, if two numbers are 3.1428 and 3.1415, then they are same up to the precision 0.01, but after that, like 0.001 they are not same.
Using the == Operator As a result, we can't have an exact representation of most double values in our computers. They must be rounded to be saved. In that case, comparing both values with the == operator would produce a wrong result.
The compare() method of Double Class is a built-in method in Java that compares the two specified double values. The sign of the integer value returned is the same as that of the integer that would be returned by the function call.
Sure we can. C will automatically convert the int into a double, and is transparent for the programmer.
It's a standard problem due to how the computer stores floating point values. Search here for "floating point problem" and you'll find tons of information.
In short – a float/double can't store 0.1
precisely. It will always be a little off.
You can try using the decimal
type which stores numbers in decimal notation. Thus 0.1
will be representable precisely.
You wanted to know the reason:
Float/double are stored as binary fractions, not decimal fractions. To illustrate:
12.34
in decimal notation (what we use) means
1 * 101 + 2 * 100 + 3 * 10-1 + 4 * 10-2
The computer stores floating point numbers in the same way, except it uses base 2
: 10.01
means
1 * 21 + 0 * 20 + 0 * 2-1 + 1 * 2-2
Now, you probably know that there are some numbers that cannot be represented fully with our decimal notation. For example, 1/3
in decimal notation is 0.3333333…
. The same thing happens in binary notation, except that the numbers that cannot be represented precisely are different. Among them is the number 1/10
. In binary notation that is 0.000110011001100…
.
Since the binary notation cannot store it precisely, it is stored in a rounded-off way. Hence your problem.
double
and Double
are the same (double
is an alias for Double
) and can be used interchangeably.
The problem with comparing a double with another value is that doubles are approximate values, not exact values. So when you set x
to 0.1
it may in reality be stored as 0.100000001
or something like that.
Instead of checking for equality, you should check that the difference is less than a defined minimum difference (tolerance). Something like:
if (Math.Abs(x - 0.1) < 0.0000001) { ... }
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With