2

Possible Duplicate:
Retain precision with Doubles in java

Alright so I've got the following chunk of code:

int rotation = e.getWheelRotation();
if(rotation < 0)
    zoom(zoom + rotation * -.05); 
else if(zoom - .05 > 0)
    zoom(zoom - rotation * .05);

System.out.println(zoom);

Now, the zoom variable is of type double, initially set to 1. So, I would expect the results to be like 1 - .05 = .95; .95 - .05 = .9; .9 - .05 = .85; etc. This appears to be not the case though when I print the result as you can see below:

  • 0.95
  • 0.8999999999999999
  • 0.8499999999999999
  • 0.7999999999999998
  • 0.7499999999999998
  • 0.6999999999999997

Hopefully someone is able to clearly explain. I searched the internet and I read it has something to do with some limitations when we're storing floats in binary but I still don't quite understand. A solution to my problem is not shockingly important but I would like to understand this kind of behavior.

Community
  • 1
  • 1
arjen1988
  • 109
  • 1
  • 5

4 Answers4

3

Java uses IEEE-754 floating point numbers. They're not perfectly precise. The famous example is:

System.out.println(0.1d + 0.2d);

...which outputs 0.30000000000000004.

What you're seeing is just a symptom of that imprecision. You can improve the precision by using double rather than float.

If you're dealing with financial calculations, you might prefer BigDecimal to float or double.

T.J. Crowder
  • 1,031,962
  • 187
  • 1,923
  • 1,875
3

float and double have limited precision because its fractional part is represented as a series of powers of 2 e.g. 1/2 + 1/4 + 1/8 ... If you have an number like 1/10 it has to be approximated.

For this reason, whenever you deal with floating point you must use reasonable rounding or you can see small errors.

e.g.

System.out.printf("%.2f%n", zoom);

To minimise round errors, you could count the number of rotations instead and divide this int value by 20.0. You won't see a rounding error this way, and it will be faster, with less magic numbers.

Peter Lawrey
  • 525,659
  • 79
  • 751
  • 1,130
0

float and double have precision issues. I would recommend you take a look at the BigDecimal Class. That should take care of precision issues.

npinti
  • 51,780
  • 5
  • 72
  • 96
0

Since decimal numbers (and integer numbers as well) can have an infinite number of possible values, they are impossible to map precisely to bits using a standard format. Computers circumvent this problem by limiting the range the numbers can assume.

For example, an int in java can represent nothing larger then Integer.MAX_VALUE or 2^31 - 1.

For decimal numbers, there is also a problem with the numbers after the comma, which also might be infinite. This is solved by not allowing all decimal values, but limiting to a (smartly chosen) number of possibilities, based on powers of 2. This happens automatically but is often nothing to worry about, you can interpret your result of 0.899999 as 0.9. In case you do need explicit precision, you will have to resort to other data types, which might have other limitations.

DieterDP
  • 4,039
  • 2
  • 29
  • 38