Floating-point math, often perceived as simple, harbors surprising complexities. Comparing two floating-point numbers (floats) for equality can lead to unexpected results due to inherent inaccuracies in their representation. This article delves into various techniques for comparing floats, discussing their strengths, limitations, and best-use cases.
Why Direct Comparison Fails
Floats cannot precisely represent all decimal values. Values like 0.1 are stored as approximations in binary format. This, coupled with rounding errors during calculations, makes direct comparisons using == unreliable. For instance:
float f = 0.1f;
float sum = 0;
for (int i = 0; i < 10; ++i) sum += f;
float product = f * 10;
printf("sum = %1.15f, mul = %1.15f, mul2 = %1.15fn", sum, product, f * 10);This code yields three different results for seemingly the same calculation:
sum=1.000000119209290, mul=1.000000000000000, mul2=1.000000014901161 This discrepancy arises from accumulated rounding errors in the summation and subtle differences in multiplication implementations.
Epsilon Comparisons: Defining “Close Enough”
Instead of strict equality, we can check if two floats are within an acceptable difference, or epsilon (ε). This involves comparing the absolute difference between two floats against a predefined threshold:
bool isEqual = fabs(f1 - f2) <= epsilon;However, choosing an appropriate epsilon is crucial. A fixed epsilon like FLT_EPSILON (the smallest representable difference between two floats) is often insufficient. For numbers smaller than 1.0, FLT_EPSILON becomes too large, and for numbers larger than 2.0, it becomes redundant.
Relative Epsilon Comparisons: Scaling with Magnitude
Relative epsilon comparisons address this by scaling the epsilon with the magnitude of the compared numbers:
bool AlmostEqualRelative(float A, float B, float maxRelDiff = FLT_EPSILON) {
float diff = fabs(A - B);
A = fabs(A);
B = fabs(B);
float largest = (B > A) ? B : A;
return diff <= largest * maxRelDiff;
}This approach offers better accuracy across different magnitudes but still struggles with comparisons near zero.
ULP Comparisons: Units in the Last Place
ULP (Units in the Last Place) provides a more intuitive measure of the difference between two floats. It leverages the fact that floats have adjacent integer representations. Subtracting these representations reveals the distance between the floats in “float space.” A difference of one ULP signifies the smallest possible difference.
bool AlmostEqualUlps(float A, float B, int maxUlpsDiff); //Implementation details omitted for brevityWhile ULP comparisons generally align with relative epsilon comparisons, they differ in specific cases (e.g., numbers slightly below a power of two). Performance characteristics also vary depending on the architecture. Crucially, both ULP and relative epsilon comparisons face challenges near zero.
The Zero Problem and Catastrophic Cancellation
Relative comparisons falter near zero because even tiny differences become significant compared to zero itself. This often arises from catastrophic cancellation, where subtracting nearly equal numbers leads to a significant loss of precision. For instance, sin(pi) should theoretically be zero, but due to the inability to represent pi exactly, the result reflects the error in the approximation of pi.
To mitigate this, combine absolute and relative epsilon checks:
bool AlmostEqualUlpsAndAbs(float A, float B, float maxDiff, int maxUlpsDiff); //Implementation combines absolute and ULP checks
bool AlmostEqualRelativeAndAbs(float A, float B, float maxDiff, float maxRelDiff = FLT_EPSILON); //Implementation combines absolute and relative epsilon checksConclusion: Choosing the Right Comparison
There is no one-size-fits-all solution. The best approach depends on the specific context:
- Comparing to zero: Use absolute epsilon.
- Comparing to non-zero: Use relative epsilon or ULPs.
- Comparing arbitrary numbers: Combine absolute and relative epsilon or ULPs checks.
Ultimately, understanding the nature of your calculations, potential error sources, and the desired level of precision is paramount for choosing the most effective float comparison strategy. Remember to prioritize algorithm stability over simply increasing epsilon values.
