Comparison between floats... can it be dangerous?

[Andrea B]

Hi everybody,

a guy told me during a job interview that we can't compare directly 2
floats, because in very rare situations we can get wrong results.
I googled it, with no result.
Do you know something about that?

Bye,
Andrea

 

[Jonathan Mcdougall]

Hi everybody,

a guy told me during a job interview that we can't compare directly 2
floats, because in very rare situations we can get wrong results.
I googled it, with no result.

Funny, I just googled "float comparisons" and I got some pretty good
hits.


Jonathan

 

[Andrea B]

Andrea B wrote: [...]
Funny, I just googled "float comparisons" and I got some pretty good
hits.

Alright, I've found the generic problem of float comparison (related to
machine precision), but I haven't found the 'standard' solution to this
problem in C++.
To avoid instability I'd write a function like:

bool AlmostEqualRelative(float A, float B, float maxRelativeError)
{
if (A == B)
return true;
float relativeError = fabs((A - B) / B);
if (relativeError <= maxRelativeError)
return true;
return false;
}

But that's not the best solution.
Is there a std library providing some useful functions?

Thank you,
bye

 

[Jonathan Mcdougall]

Andrea B wrote: [...]
Funny, I just googled "float comparisons" and I got some pretty good
hits.

Alright, I've found the generic problem of float comparison (related to
machine precision), but I haven't found the 'standard' solution to this
problem in C++.

There is none.

1) google it
2) check the FAQ (http://www.parashift.com/c++-faq-lite)


Jonathan

 

[Rolf Magnus]

Andrea B wrote: [...]
Funny, I just googled "float comparisons" and I got some pretty good
hits.

Alright, I've found the generic problem of float comparison (related to
machine precision), but I haven't found the 'standard' solution to this
problem in C++.

That's because there is no standard solution.

To avoid instability I'd write a function like:

bool AlmostEqualRelative(float A, float B, float maxRelativeError)
{
if (A == B)
return true;
float relativeError = fabs((A - B) / B);
if (relativeError <= maxRelativeError)
return true;
return false;
}

But that's not the best solution.

Then write a better one.

Is there a std library providing some useful functions?

No.

 

[Alan Johnson]

Hi everybody,

a guy told me during a job interview that we can't compare directly 2
floats, because in very rare situations we can get wrong results.
I googled it, with no result.
Do you know something about that?

http://docs.sun.com/source/806-3568/ncg_goldberg.html

Some possibly heavy duty reading depending on your familiarity with the
topic, but a worthwhile read for any serious programmer.

 

[noone]

Hi everybody,

a guy told me during a job interview that we can't compare directly 2
floats, because in very rare situations we can get wrong results. I
googled it, with no result.
Do you know something about that?

yup...Because floating point numbers in computers are generally
approximations you have to think about how close two numbers are to each
other to decide if they are equivalent. what amount of error is
allowable?

Is (35.400003456 == 35.400003457) ?

Well, it is if you are only concerned about the first 8 digits of the
fractional part. The first number is definitely less than the second
number but can they be (considered) equal for your intended purpose?