Categories

# Moving decimal places over in a double

So I have a double set to equal 1234, I want to move a decimal place over to make it 12.34

So to do this I multiply .1 to 1234 two times, kinda like this

``````double x = 1234;
for(int i=1;i<=2;i++)
{
x = x*.1;
}
System.out.println(x);
``````

This will print the result, “12.340000000000002”

Is there a way, without simply formatting it to two decimal places, to have the double store 12.34 correctly?

If you use `double` or `float`, you should use rounding or expect to see some rounding errors. If you can’t do this, use `BigDecimal`.

The problem you have is that 0.1 is not an exact representation, and by performing the calculation twice, you are compounding that error.

However, 100 can be represented accurately, so try:

``````double x = 1234;
x /= 100;
System.out.println(x);
``````

which prints:

``````12.34
``````

This works because `Double.toString(d)` performs a small amount of rounding on your behalf, but it is not much. If you are wondering what it might look like without rounding:

``````System.out.println(new BigDecimal(0.1));
System.out.println(new BigDecimal(x));
``````

prints:

``````0.100000000000000005551115123125782702118158340454101562
12.339999999999999857891452847979962825775146484375
``````

In short, rounding is unavoidable for sensible answers in floating point whether you are doing this explicitly or not.

Note: `x / 100` and `x * 0.01` are not exactly the same when it comes to rounding error. This is because the round error for the first expression depends on the values of x, whereas the `0.01` in the second has a fixed round error.

``````for(int i=0;i<200;i++) {
double d1 = (double) i / 100;
double d2 = i * 0.01;
if (d1 != d2)
System.out.println(d1 + " != "+d2);
}
``````

prints

``````0.35 != 0.35000000000000003
0.41 != 0.41000000000000003
0.47 != 0.47000000000000003
0.57 != 0.5700000000000001
0.69 != 0.6900000000000001
0.7 != 0.7000000000000001
0.82 != 0.8200000000000001
0.83 != 0.8300000000000001
0.94 != 0.9400000000000001
0.95 != 0.9500000000000001
1.13 != 1.1300000000000001
1.14 != 1.1400000000000001
1.15 != 1.1500000000000001
1.38 != 1.3800000000000001
1.39 != 1.3900000000000001
1.4 != 1.4000000000000001
1.63 != 1.6300000000000001
1.64 != 1.6400000000000001
1.65 != 1.6500000000000001
1.66 != 1.6600000000000001
1.88 != 1.8800000000000001
1.89 != 1.8900000000000001
1.9 != 1.9000000000000001
1.91 != 1.9100000000000001
``````

NOTE: This has nothing to do with randomness in your system (or your power supply). This is due to a representation error, which will produce the same outcome every time. The precision of `double` is limited and in base 2 rather than base 10, so numbers which can be precisely represented in decimal often cann’t be precisely represented in base 2.

• I can’t believe I didn’t think of doing that in the first place! Thanks 😛

Feb 8, 2011 at 19:55

• Although 100 can be represented exactly in binary format, division by 100 cannot be represented exactly. Thus, writing `1234/100`, as you have done, does not really do anything about the underlying problem — it should be exactly equal to writing `1234 * 0.01`.

Jan 11, 2012 at 20:58

• @Peter Lawrey: Can you explain more why whether the number is odd or even would affect rounding? I’d think that /=100 and *=.01 would be the same because even though 100 is an int, it will be converted into 100.0 anyways as a result of type coercion.

Jan 12, 2012 at 7:37

• `/100` and `*0.01` are equivalent to each other, but not to OP’s `*0.1*0.1`.

Jan 12, 2012 at 7:44

• All I’m saying is that multiplying by 0.1 twice will on the average introduce a greater error than multiplying by 0.01 once; but I’ll happily concede @JasperBekkers’s point about 100 being different, being exactly binary-representable.

Jan 12, 2012 at 18:21

No – if you want to store decimal values accurately, use `BigDecimal`. `double` simply can’t represent a number like 0.1 exactly, any more than you can write the value of a third exactly with a finite number of decimal digits.

if it’s just formatting, try printf

``````double x = 1234;
for(int i=1;i<=2;i++)
{
x = x*.1;
}
System.out.printf("%.2f",x);
``````

output

``````12.34
``````

• The higher rated answers are more technically insightful, but this is the correct answer to OP’s problem. We generally don’t care about the slight inaccuracy of double, so BigDecimal is overkill, but when displaying we often want to ensure our output matches our intuition, so `System.out.printf()` is the right way to go.

Jan 12, 2012 at 14:19