Rounding problem with double type [duplicate]

Answer 1

In the set of double values, there is no such thing as the number 1.11 because internally, double uses a binary representation (as opposed to humans who are used to a decimal representation). Most finite decimal numbers (such as 1.11) have an infinite representation in binary, but since memory is limited, you lose some precision because of rounding.

The closest you can get to 1.11 with the double data type is 1.1100000000000000976996261670137755572795867919921875, which is internally represented as 0x3ff1c28f5c28f5c3.

Your requirement of two decimal places sounds like you are working with money. A simple solution is to store the cents in an integer (as opposed to the dollars in a double):

int cents = 111;

This way, you don't lose any precision. Another solution is to use a dedicated decimal data type.

Answer 2

the floating-point types like float and double are not 100% precise. They may store 14.3 as 14.299999... and there is nothing wrong about that. That is why you should NEVER compare two floats or doubles with == operator, instread you should check if the absolute value of their difference is smaller than a certain epsilon, like 0.000000001

Now, if you want to output the number in a pleasant way, you can use setprecision from <iomanip>

E.g.

#include <iostream>
#include <iomanip>

int main()
{
   double d = 1.389040598345;
   std::cout << setprecision(2) << d; //outputs 1.39
}

If you want to obtain the value of d rounded 2 decimal places after the point, then you can use this formula

d = floor((d*100)+0.5)/100.0; //d is now 1.39

Answer 3

Not every decimal number has an exact, finite, binary floating-point representation. You've already found one example, but another one is 0.1 (decimal) = 0.0001100110011... (binary).

You either need to live with that, or use a decimal floating-point library (which will be less efficient).

My recommendation would be to store numbers to full precision, and only round when you need to display them to humans.