Do we need epsilon value for lesser or greater comparison for float value?

Question

I have gone through different threads for comparing lesser or greater float value not equal comparison but not clear do we need epsilon value logic to compare lesser or greater float value as well?

e.g ->

float a, b;
 if (a < b) // is this correct way to compare two float value or we need epsilon value for lesser comparator 
{
}
if (a > b) // is this correct way to compare two float value for greater comparator
{
}

I know for comparing for equality of float, we need some epsilon value

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

Answer 1

It really depends on what should happen when both value are close enough to be seen as equal, meaning fabs(a - b) < EPSILON. In some use cases (for example for computing statistics), it is not very important if the comparison between 2 close values gives or not equality.

If it matters, you should first determine the uncertainty of the values. It really depends on the use case (where the input values come from and how they are processed), and then 2 value differing by less than that uncertainty should be considered as equal. But that equality is not longer a true mathematical equivalence relation: you can easily imagine how to build a chain a close values between 2 truely different values. In math words, the relation is not transitive (or is almost transitive is current language words).

I am sorry but as soon as you have to process approximations there cannot be any precise and consistent way: you have to think of the real world use case to determine how you should handle the approximation.

Answer 2

When you are working with floats, it's inevitable that you will run into precision errors.

In order to mitigate this, when checking for the equality two floats we often check if their difference is small enough.

For lesser and greater, however, there is no way to tell with full certainty which float is larger. The best (presumably for your intentions) approach is to first check if the two floats are the same, using the areSame function. If so return false (as a = b implies that a < b and a > b are both false).

Otherwise, return the value of either a < b or a > b.

Answer 3

The answer is application dependent.

If you are sure that a and b are sufficiently different that numerical errors will not reverse the order, then a < b is good enough.

But if a and b are dangerously close, you might require a < b + EPSILON. In such a case, it should be clear to you that < and ≤ are not distinguishable.

Needless to say, EPSILON should be chosen with the greatest care (which is often pretty difficult).

Answer 4

It ultimately depends on your application, but I would say generally no.

The problem, very simplified, is that if you calculate: (1/3) * 3 and get the answer 0.999999, then you want that to compare equal to 1. This is why we use epsilon values for equal comparisons (and the epsilon should be chosen according to the application and expected precision).

On the other hand, if you want to sort a list of floats then by default the 0.999999 value will sort before 1. But then again what would the correct behavior be? If they both are sorted as 1, then it will be somewhat random which one is actually sorted first (depending on the initial order of the list and the sorting algorithm you use).

The problem with floating point numbers is not that they are "random" and that it is impossible to predict their exact values. The problem is that base-10 fractions don't translate cleanly into base-2 fractions, and that non-repeating decimals in one system can translate into repeating one in the other - which then result in rounding errors when truncated to a finite number of decimals. We use epsilon values for equal comparisons to handle rounding errors that arise from these back and forth translations.

But do be aware that the nice relations that ==, < and <= have for integers, don't always translate over to floating points exactly because of the epsilons involved. Example:

• a = x
• b = a + epsilon/2
• c = b + epsilon/2
• d = c + epsilon/2

Now: a == b, b == c, c == d, BUT a != d, a < d. In fact, you can continue the sequence keeping num(n) == num(n+1) and at the same time get an arbitrarily large difference between a and the last number in the sequence.

Answer 5

As others have stated, there would always be precision errors when dealing with floats.

Thus, you should have an epsilon value even for comparing less than / greater than.

We know that in order for a to be less than b, firstly, a must be different from b. Checking this is a simple NOT equals, which uses the epsilon. Then, once you already know a != b, the operator < is sufficient.