Moving decimal places over in a double
Solution 1
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.
Solution 2
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.
Solution 3
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
Solution 4
In financial software it is common to use integers for pennies. In school, we were taught how to use fixed-point instead of floating, but that is usually powers of two. Storing pennies in integers might be called "fixed point" as well.
int i=1234;
printf("%d.%02d\r\n",i/100,i%100);
In class, we were asked in general what numbers can be exactly represented in a base.
For base=p1^n1*p2^n2
... you can represent any N where N=n*p1^m1*p2^m2.
Let base=14=2^1*7^1
... you can represent 1/7 1/14 1/28 1/49 but not 1/3
I know about financial software -- I converted Ticketmaster's financial reports from VAX asm to PASCAL. They had their own formatln() with codes for pennies. The reason for the conversion was 32 bit integers were no longer enough. +/- 2 billion pennies is $20 million and that overflowed for the World Cup or Olympics, I forgot.
I was sworn to secrecy. Oh well. In academea, if it's good you publish; in industry, you keep it secret.
Solution 5
you can try integer number representation
int i =1234;
int q = i /100;
int r = i % 100;
System.out.printf("%d.%02d",q, r);
Related videos on Youtube
BlackCow
Updated on September 28, 2021Comments
-
BlackCow over 2 years
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?
-
bsd over 12 yearsHere's a link to the original article "What Every Computer Scientist Should Know About Floating-Point Arithmetic"
-
Adam McKee over 12 yearsIs there a reason you didn't do
x /= 100;
? -
user207421 over 2 yearsOr
x *= 0.01;
?
-
-
Pops over 13 yearsArgh, I was just writing an explanation linking to the exact same place. +1.
-
CanSpice over 13 years@Lord Haha, sorry. I got Skeeted anyhow. :-)
-
BlackCow over 13 yearsI figured thats why, but I wonder if there is some creative way to move the decimal place over? Because it is possible to store 12.34 cleanly in a double, it just doesn't like the multiplying by .1
-
CanSpice over 13 yearsIf it were possible to store 12.34 cleanly in a double, don't you think Java would have done it? It's not. You'll have to use some other datatype (like BigDecimal). Also, why don't you just divide by 100 instead of doing it in a loop?
-
BlackCow over 13 yearsDo'h... yeah, dividing it by 100 results in a clean 12.34... thanks :-P
-
BlackCow over 13 yearsI can't believe I didn't think of doing that in the first place! Thanks :-P
-
Brooks Moses over 12 yearsAlthough 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 writing1234 * 0.01
. -
Vishy over 12 years@BrooksMoses it will if the number is odd. However, if the number is even or a multiple of 5, you will get less rounding error. The extreme example being 100 / 100. In the worst cases examples,
x / 100
andx * 0.01
should be much the same. -
Aaron over 12 yearsOr, more precisely, they are exactly stored as the closest number (1+(n/223))*(2*k) where n and k are integers, and 0 <= n < 223. There are more details, but none relevant
-
eremzeit over 12 years@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.
-
Amadan over 12 years
/100
and*0.01
are equivalent to each other, but not to OP's*0.1*0.1
. -
Amadan over 12 years@Dan: Why? This is the correct approach for financial apps (or any other apps where even a tiny rounding error is unacceptable), while still maintaining hardware-level speed. (Of course, it would be wrapped in a class, normally, not written out every time)
-
Vishy over 12 years@Amadan equivalent perhaps, but not always exactly the same. See my edit.
-
Ar5hv1r over 12 yearsThe 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. -
Jasper Bekkers over 12 years@Amadan Double can represent any valid integer between -(1<<53) and (1<<53) (roughly) however, 0.01 is represented with a binary floating point mantissa (64 bit) of [10100011110101110000][10100011110101110000][1010001111011 ]. The brackets are there to mark the repetition. As you can see, the value of 0.01 can NOT be represented perfectly by a float, which is where the inaccuracy comes from. Play around with this to see what's going on babbage.cs.qc.edu/IEEE-754
-
nemetroid over 12 years@Amadan The important thing to remember is that the literal
0.01
is converted into aDouble
before the calculation occurs, introducing the difference. -
Amadan over 12 yearsAll 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.
-
Vishy over 12 years@Amadan I agree that 0.1*0.1 != 0.01 in double.
-
jakebman about 12 yearsThere is a slight problem with this solution - if the remainder
r
is less than 10, no 0 padding occurs and 1204 would produce a result of 12.4. The correct formatting string is more similar to "%d.%02d" -
user2108462 over 9 yearsAre you sure that Double.toString() does rounding? When I do System.out.println((double)0.9999999999999999); System.out.println((double)0.99999999999999999); System.out.println((double)0.9999999999999999==(double)1.0); System.out.println((double)0.99999999999999999==(double)1.0); it prints out the whole of 0.9999999999999999 and prints 0.99999999999999999 as 1.0, and seems to think it is the same as 1.0 as well. Does that mean the rounding is not done in the toString() but already in the internal representation of the number?
-
Vishy over 9 years@user2108462 When
0.999..999
becomes1.0
this is because it is picking the nearest representable value. It is not rounding the sense that while it happens to round this value, a different value might be de-rounded. e.g.0.1
actually becomes0.1000000000000000055511151231257827021181583404541015625
as this is the nearest representable value.