How to ensure that floating-point variables entered with 2 decimal places retain their exact value

Question

Is there any way to ensure that a floating-point variable entered by the user, having 2 decimal places after the decimal point, retains its exact value, rather than losing precision?

This is the example case: I want to round a float with 50 numbers after radix point, like this

Before rounding = 0.70999997854232788085937500000000000000000000000000

to this:

After rounding = 0.71000000000000000000000000000000000000000000000000

I became confused when I wanted to compare a float number in a condition like this:

== Program Start==
Input : 0.71

/* program logic */
if (input == 0.71) {
    printf("True !");     
} else {
    printf("False !");
}

Output : False !
==Program End==

The output was False ! and will always be False ! because the true value of user's input is 0.70999997854232788085937500000000000000000000000000, and not 0.71000000000000000000000000000000000000000000000000

Is there any way to round a float value like that? I read about the potential for inaccuracies with floating point here:

• Why Are Floating Point Numbers Inaccurate?
• and followed it to these links: Is there a function to round a float in C or do I need to write my own?
• and Rounding Number to 2 Decimal Places in C

However, these don't answer my question. If I use ceilf(input * 100) / 100 function, it will make the input 0.71 into 0.71000 when printf()d using %.5f format - which seems to work. But when I print with %.50f, the real input value appears as 0.709999978542327880859375. So, I can't compare to that value in my condition.

So, if floating point can never be accurate, what is the trick for the program logic above to get a true return value at that condition?

Answer 1

All of the user's input comes in as text. The easiest -- and, possibly, safest -- way to check it is to compare it as a string before even converting to number:

if (strcmp("0.71", input) == 0) {
    printf("True !");
} else {
    printf("False !");
}

Of course, this may not be acceptable to you, if you wish to check for something other than equality :)

The other point is that you are interested in fixed, rather than floating numbers here -- but are confusing them with actual integers. If hundredths is what you'd like to work with, then work with the integer numbers of hundredths... For example, consider money -- instead of using float (or double) to store the amounts of dollars (like $7.61), use int (or, god bless you, long) to store cents (like ¢761).

Similarly, for another example, if you are counting time and need precision of one thousandth of a second, then use integer numbers of milliseconds, instead of floating-point number of seconds.

This will sidestep your entire problem altogether and may also make your programs faster...

Answer 2

You can test equality with a range as you've experienced. Just rewrite your equality test with:

if(input <= .71 + EPSILON && input >= .71 - EPSILON) {
}

Here you can create your own EPSILON based on your tolerance, or you can perhaps use FLT_EPSILON from #include<cfloat> for C++ or #include <float.h> in C.

Recall that floats do not have 50 digits of decimal precision. So trying to round at the 50th decimal place isn't going to work out so well. Floats have about 6 (sometimes more) digits of precision.

Answer 3

I'm sure this question has been answered before, however:

float rounded_down = floorf(input * 100) / 100;   /* Result: 0.70 */
float nearest = roundf(input * 100) / 100;  /* Result: 0.71 */
float rounded_up = ceilf(input * 100) / 100; /* Result: 0.71 */

The library this functions belongs I think is math.h.