Problems with double

Question

I'm storing a number as a double. It works well with small numbers but if the double is 1000000 and I try to add 10 to it, it doesn't work but I can add 100 to it. If the double is 100000 and I try to add 1 to it, it doesn't work but I can add 10 to it.

Is this a problem with using a double? What format should I be using for up to a 9 digit number?

Edit: I'm doing calculations on the number and putting it in a 0.00 decimal format. It works on small numbers but not on big. It might have something to do with the other calculations. Just seeing if maybe double was the problem.

I run into problems when I take 1000001 / 100 and put in 0.00 decimal format. But 1000100 / 100 put into a 0.00 dec format works.

Are you using a `Double` (capital `D`) or a `double` (lowercase `d`)? — Matt Ball, Apr 06 '11 at 21:56
Okay, thanks for the clarification. In Java, `double` and `Double` are different things. — Matt Ball, Apr 06 '11 at 22:01
We can't wait to see how it "doesn't work" adding 1 to 1 million. — Ingo, Apr 06 '11 at 22:03
Hang on, your code isn't something like `double x = 1000001 / 100;`, is it? — biziclop, Apr 06 '11 at 22:15
I'm pulling a number stored as a String, I double x = Double.parseDouble(myString). then I dec.format(x) ... the string is in 0.00 decimal format. When it gets large then it doesn't work. — Roger, Apr 06 '11 at 22:23
Wait a minute are you asking why 100.01 prints as 100.01 and 100.0001 prints as 100.00? — tvanfosson, Apr 06 '11 at 22:35

score 4 · Accepted Answer · answered Apr 06 '11 at 21:58

Not sure what you mean by "it doesn't work", considering that it should:

System.out.println(1000000d + 10d); // 1000010.0

Cases where it wouldn't work are where there is a value that is more than about 15 digits from the most significant digit of the largest double involved:

System.out.println(Math.pow(10, 18) + 10d - Math.pow(10, 18)); // 0.0
System.out.println(Math.pow(10, 17) + 10d - Math.pow(10, 17)); // 16.0
System.out.println(Math.pow(10, 16) + 10d - Math.pow(10, 16)); // 10.0

score 2 · Answer 2 · edited May 23 '17 at 09:58

Yes, this is how floating point works in general. (Although, as others pointed out, this should be well within the actual capabilities of double.) It loses more and more precision as the number is getting bigger. And even with small numbers, it isn't guaranteed to be precise. For small integers it is, as a general rule, but in practice, relying on the precision of floating point is a bad idea.

For integers, long should be good enough, 2⁶³-1 is the biggest number you can store in it.

Otherwise BigDecimal is the answer. Not very convenient, but it is precise.

Judging by the update to your question, you want to store prices or something similar. In that case, you can either use a library dedicated to currency arithmetic (as there are often weird rules of rounding involved for example), or store pennies/cents in a long.

score 2 · Answer 3 · answered Apr 06 '11 at 21:53

2

An int is absolutely large enough to store a 9-digit number, since the maximum value stored by a (signed) integer is 2^31 - 1 = 2,147,483,647 which has 10 digits.

If you need a larger range, use a long.

Java Tutorial: Primitive Data Types

answered Apr 06 '11 at 21:53

Matt Ball

354,903
100
647
710

score 1 · Answer 4 · answered Apr 06 '11 at 21:59

A double is actually able to hold that result. The most likely thing is probably that you're inspecting/printing out the number in such a way that appears like the number isn't different (could you post your test code?).

As a general rule of thumb, doubles give you ~16 digits of precision, and floats give you ~8 digits of precision.

score 1 · Answer 5 · answered Apr 06 '11 at 22:06

What kind of 9-digit number do you need to keep? A double should have enough precision track 9 significant digits as would an int, but you need to know which type of number you need before you choose a type. If you need real values (i.e., they have digits to the right of the decimal), then choose double. If they are integers, choose int.

score 1 · Answer 6 · answered Apr 06 '11 at 22:29

I don't think your exact problem is very clear. Are you using integer arithmetic? In which case you should expect an integer division to round down the answer.

int i = 1000001 / 100;
System.out.println(i);

double d = (double) 1000001 / 100;
System.out.println(d);

prints as expected

10000
10000.01

However, since you have't given a clear example of what does work and what you expect to happen, we are just guessing what your problem might be.

score 0 · Answer 7 · answered Apr 06 '11 at 22:01

0

Nevertheless, there is something wrong. It should be possible to (ab)use a double (which is in 64bit IEEE format in Java) as an 48-bit-or so integer. 48 bt should be enough to store 9 decimal digits.

answered Apr 06 '11 at 22:01

Ingo

36,037
5
53
100

Problems with double

7 Answers7