Is to round a correct way for making float-double comparison

Question

With this question as base, it is well known that we should not apply equals comparison operation to decimal variables, due numeric erros (it is not bound to programming language):

bool CompareDoubles1 (double A, double B)
{
   return A == B;
}

The abouve code it is not right. My questions are:

1. It is right to round to both numbers and then compare?
2. It is more efficient?

For instance:

bool CompareDoubles1 (double A, double B)
    {
       double a = round(A,4);
       double b = round(B,4)
       return a == b;
    }

It is correct?

EDIT

I'm considering round is a method that take a double (number) and int (precition):

bool round (float number, int precision);

EDIT I consider that a better idea of what I mean with this question will be expressed with this compare method:

bool CompareDoubles1 (double A, double B, int precision)
        {
           //precition could be the error expected when rounding
           double a = round(A,precision);
           double b = round(B,precision)
           return a == b;
        }

Answer 1

Usually, if you really have to compare floating values, you'd specify a tolerance:

bool CompareDoubles1 (double A, double B, double tolerance)
{
   return std::abs(A - B) < tolerance;
}

Choosing an appropriate tolerance will depend on the nature of the values and the calculations that produce them.

Rounding is not appropriate: two very close values, which you'd want to compare equal, might round in different directions and appear unequal. For example, when rounding to the nearest integer, 0.3 and 0.4 would compare equal, but 0.499999 and 0.500001 wouldn't.

Answer 2

A common comparison for doubles is implemented as

bool CompareDoubles2 (double A, double B)
{
   return std::abs(A - B) < 1e-6; // small magic constant here
}

It is clearly not as efficient as the check A == B, because it involves more steps, namely subtraction, calling std::abs and finally comparison with a constant.

The same argument about efficiency holds for you proposed solution:

bool CompareDoubles1 (double A, double B)
{
   double a = round(A,4); // the magic constant hides in the 4
   double b = round(B,4); // and here again
   return a == b;
}

Again, this won't be as efficient as direct comparison, but -- again -- it doesn't even try to do the same.

Whether CompareDoubles2 or CompareDoubles1 is faster depends on your machine and the choice of magic constants. Just measure it. You need to make sure to supply matching magic constants, otherwise you are checking for equality with a different trust region which yields different results.

Answer 3

I think comparing the difference with a fixed tolerance is a bad idea.

Say what happens if you set the tolerance to 1e-6, but the two numbers you compare are 1.11e-9 and 1.19e-9?

These would be considered equal, even if they differ after the second significant digit. This may not what you want.

I think a better way to do the comparison is

equal = ( fabs(A - B) <= tol*max(fabs(A), fabs(B)) )

Note, the <= (and not <), because the above must also work for 0==0. If you set tol=1e-14, two numbers will be considered equal when they are equal up to 14 significant digits.

Sidenote: When you want to test if a number is zero, then the above test might not be ideal and then one indeed should use an absolute threshold.

Answer 4

If the round function used in your example means to round to 4th decimal digit, this is not correct at all. For example, if A and B are 0.000003 and 0.000004 they would be rounded to 0.0 and would therefore be compared to be equal.

A general purpose compairison function must not work with a constant tolarance but with a relative one. But it is all explained in the post you cite in your question.

Answer 5

There is no 'correct' way to compare floating point values (Even a f == 0.0 might be correct). Different comparison may be suitable. Have a look at http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/

Answer 6

Similar to other posts, but introducing scale-invariance: If you are doing something like adding two sets of numbers together and then you want to know if the two set sums are equal, you can take the absolute value of the log-ratio (difference of logarithms) and test to see if this is less than your prescribed tolerance. That way, e.g. if you multiply all your numbers by 10 or 100 in summation calculations, it won't affect the result about whether the answers are equal or not. You should have a separate test to determine if two numbers are equal because they are close enough to 0.