Comparing Floating Point Numbers

Comparing ranges that contain floating-point numbers requires careful handling due to potential precision issues. Floating-point arithmetic can introduce small errors, making direct comparisons unreliable. Instead, it's best to use a tolerance-based comparison.

Using a Custom Comparison Function

You can create a custom comparison function that checks if the absolute difference between two floating-point numbers is within a specified tolerance.

Here's an example:

1#include <algorithm>
2#include <cmath>  // Needed for std::abs
3#include <iostream>
4#include <vector>
5
6bool almostEqual(double a, double b) {
7  return std::abs(a - b) < 0.0001;
8}
9
10int main() {
11  std::vector<double> A{1.0, 2.000001, 3.0};
12  std::vector<double> B{1.0, 2.0, 3.0};
13
14  if (std::ranges::equal(A, B, almostEqual)) {
15    std::cout << "Ranges are equal";
16  } else {
17    std::cout << "Ranges are not equal";
18  }
19}

1Ranges are equal

In this example, almostEqual() compares the floating-point numbers within a tolerance of 0.0001, ensuring that small differences due to precision issues are ignored.

Comparing with std::ranges::mismatch()

You can also use std::ranges::mismatch() to find where two ranges of floating-point numbers differ:

1#include <algorithm>
2#include <cmath>  // Needed for std::abs
3#include <iostream>
4#include <vector>
5
6bool almostEqual(double a, double b) {
7  return std::abs(a - b) < 0.0001;
8}
9
10int main() {
11  std::vector<double> A{1.0, 2.00001, 3.0};
12  std::vector<double> B{1.0, 2.0, 3.1};
13
14  auto [itA, itB] = std::ranges::mismatch(
15    A, B, almostEqual);
16
17  if (itA != A.end() && itB != B.end()) {
18    std::cout << "First mismatch - A: " << *itA
19      << ", B: " << *itB;
20  } else {
21    std::cout
22      << "Ranges are equal within tolerance";
23  }
24}

1First mismatch - A: 3, B: 3.1

Practical Considerations

• Tolerance Level: Choose an appropriate tolerance level for your application. The value may need adjustment based on the precision of your data.
• Performance: Custom comparison functions may introduce a small performance overhead, but they are essential for accurate floating-point comparisons.
• Consistency: Ensure consistent use of the tolerance level across all comparisons to avoid discrepancies.

Comparing floating-point numbers accurately requires accounting for precision issues, and using a custom comparison function with a defined tolerance is the most reliable method.