使用std :: max比较两个双打是否安全？

Question

I know for comparing two doubles we have to do something like this

bool AreSame(double a, double b)
{
    return fabs(a - b) < EPSILON;
}

But I do not know that does std::max compares two doubles the same way or if not the same way safely? That is what will be the answer if I call std::max(0.1,0.11) . I am getting right results but still , I am not sure! Morover I used it last night at codeforces and got my solution accepted!

Why am I worried? I checked http://www.cplusplus.com/ were it was written that the behaviour of max is same as the following code

template <class T> const T& max (const T& a, const T& b) {
  return (a<b)?b:a;     // or: return comp(a,b)?b:a; for version (2)
}

The link to page Link

(The relative difference being 10^-6)

Answer 1

std::max isn't concerned with equality, it only cares when the two numbers are not equal. Additionally the epsilon thing is related to looking for approximately equal numbers whose difference is caused by floating point errors. Floating point errors should cause std::max to pick one over the other as std::max has no way of knowing what epsilon would be appropriate.

Remember your system may want AreSame(0.1000001, 0.1) == true but std::max(0.1000001, 0.1) should return 0.1000001 in case you do care.

Answer 2

(as you just amended to your question) max should be doing a simple '<', like

(a < b) ? b : a

This should be "safe" in that you can do a comparison between two doubles/floats. However, doubles/floats are really just approximations for values, they may or may not be the exact value. You can see this in base 10 with a value like 1/3 = .3333... the written decimal value can never be exact 1/3 because it is an infinitely repeating value. In order for the processor to work with discrete values a limited number of bits must be used, therefore rounding will occur. This makes the concept of "equals" a bit muddy, really are you saying two values are approximately equal, close enough given some tolerance (epsilon). You can argue that > and < are also effected by the vagaries of this approximation process. However, generally people are willing to accept the "broader" idea of two values having a < or > relationship.

It can actually be a quite complicated question. It depends largely on what you are doing and the sort of tolerance your application has to these numeric approximation issues. I know of one case where an AI algorithm was affected by a change from using FPU instructions to using MMX/SSE/AVX... type instructions (PC FPUs generally calculate internally at 80 bits then round, while AVX instructions use 64 bits stem to stern ). Over the course of many iterations differences based on rounding caused different paths to be taken leading to different results. This largely had to do with these types of comparisons. You can't say that the approach (depending on FPU behavior) was incorrect, only that it wasn't tolerant of changes to a "lower resolution" FP calculation.