98

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?

3

9 Answers 9

192

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.

12
  • 26
    I can't believe I didn't think of doing that in the first place! Thanks :-P
    – BlackCow
    Feb 8, 2011 at 19:55
  • 6
    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
  • 1
    @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.
    – eremzeit
    Jan 12, 2012 at 7:37
  • 1
    /100 and *0.01 are equivalent to each other, but not to OP's *0.1*0.1.
    – Amadan
    Jan 12, 2012 at 7:44
  • 1
    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.
    – Amadan
    Jan 12, 2012 at 18:21
52

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.

0
46

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
1
  • 8
    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.
    – dimo414
    Jan 12, 2012 at 14:19
31

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.

0
12

you can try integer number representation

int i =1234;
int q = i /100;
int r = i % 100;

System.out.printf("%d.%02d",q, r);
2
  • 5
    @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)
    – Amadan
    Jan 12, 2012 at 7:45
  • 7
    There 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"
    – jakebman
    Apr 16, 2012 at 17:05
10

This is caused by the way computers store floating-point numbers. They don't do so exactly. As a programmer, you should read this floating-point guide to familiarize yourself with the trials and tribulations of handling floating-point numbers.

6
  • Argh, I was just writing an explanation linking to the exact same place. +1.
    – Pops
    Feb 8, 2011 at 19:36
  • @Lord Haha, sorry. I got Skeeted anyhow. :-)
    – CanSpice
    Feb 8, 2011 at 19:37
  • I 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
    – BlackCow
    Feb 8, 2011 at 19:40
  • 1
    If 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?
    – CanSpice
    Feb 8, 2011 at 19:46
  • Do'h... yeah, dividing it by 100 results in a clean 12.34... thanks :-P
    – BlackCow
    Feb 8, 2011 at 19:49
10

Funny that numerous posts mention to use BigDecimal but no-one bothers to give the correct answer based on BigDecimal? Because even with BigDecimal, you can still go wrong, as demonstrated by this code

String numstr = "1234";
System.out.println(new BigDecimal(numstr).movePointLeft(2));
System.out.println(new BigDecimal(numstr).multiply(new BigDecimal(0.01)));
System.out.println(new BigDecimal(numstr).multiply(new BigDecimal("0.01")));

Gives this output

12.34
12.34000000000000025687785232264559454051777720451354980468750
12.34

The BigDecimal constructor specifically mentions that it is better to use String constructor than a numeric constructor. Ultimate precision is also influenced by the optional MathContext.

According to the BigDecimal Javadoc it is possible to create a BigDecimal which is exactly equal to 0.1, provided you use the String constructor.

5

Yes, there is. With each double operation you may lose accuracy but the amount of accuracy differs for each operation and can be minimized by choosing the right sequence of operations. For example when multiplying set of numbers, it is best to sort set by exponent before multiplying.

Any decent book on number crunching describes this. For example: http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html

And to answer your question:

Use divide instead of multiply, this way you get correct result.

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

No, as Java floating point types (indeed all floating point types) are a trade-off between size and precision. While they're very useful for a lot of tasks, if you need arbitrary precision, you should use BigDecimal.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.