Printing double without losing precision

Question

How do you print a double to a stream so that when it is read in you don\'t lose precision?

I tried:

std::stringstream ss;

double v = 0.1 * 0.1;
ss          


        

Answer 1

A double has the precision of 52 binary digits or 15.95 decimal digits. See http://en.wikipedia.org/wiki/IEEE_754-2008. You need at least 16 decimal digits to record the full precision of a double in all cases. [But see fourth edit, below].

By the way, this means significant digits.

Answer to OP edits:

Your floating point to decimal string runtime is outputing way more digits than are significant. A double can only hold 52 bits of significand (actually, 53, if you count a "hidden" 1 that is not stored). That means the the resolution is not more than 2 ^ -53 = 1.11e-16.

For example: 1 + 2 ^ -52 = 1.0000000000000002220446049250313 . . . .

Those decimal digits, .0000000000000002220446049250313 . . . . are the smallest binary "step" in a double when converted to decimal.

The "step" inside the double is:

.0000000000000000000000000000000000000000000000000001 in binary.

Note that the binary step is exact, while the decimal step is inexact.

Hence the decimal representation above,

1.0000000000000002220446049250313 . . .

is an inexact representation of the exact binary number:

1.0000000000000000000000000000000000000000000000000001.

Third Edit:

The next possible value for a double, which in exact binary is:

1.0000000000000000000000000000000000000000000000000010

converts inexactly in decimal to

1.0000000000000004440892098500626 . . . .

So all of those extra digits in the decimal are not really significant, they are just base conversion artifacts.

Fourth Edit:

Though a double stores at most 16 significant decimal digits, sometimes 17 decimal digits are necessary to represent the number. The reason has to do with digit slicing.

As I mentioned above, there are 52 + 1 binary digits in the double. The "+ 1" is an assumed leading 1, and is neither stored nor significant. In the case of an integer, those 52 binary digits form a number between 0 and 2^53 - 1. How many decimal digits are necessary to store such a number? Well, log_10 (2^53 - 1) is about 15.95. So at most 16 decimal digits are necessary. Let's label these d_0 to d_15.

Now consider that IEEE floating point numbers also have an binary exponent. What happens when we increment the exponet by, say, 2? We have multiplied our 52-bit number, whatever it was, by 4. Now, instead of our 52 binary digits aligning perfectly with our decimal digits d_0 to d_15, we have some significant binary digits represented in d_16. However, since we multiplied by something less than 10, we still have significant binary digits represented in d_0. So our 15.95 decimal digits now occuply d_1 to d_15, plus some upper bits of d_0 and some lower bits of d_16. This is why 17 decimal digits are sometimes needed to represent a IEEE double.

Fifth Edit

Fixed numerical errors