compare_almost_equal.hpp

Go to the documentation of this file.

#ifndef SCRAN_TESTS_COMPARE_ALMOST_EQUAL_HPP
#define SCRAN_TESTS_COMPARE_ALMOST_EQUAL_HPP
 
#include <gtest/gtest.h>
#include <cmath>
 
namespace scran_tests {
 
struct CompareAlmostEqualParameters {
    double relative_tolerance = 1e-8;
 
    double absolute_tolerance = 1e-15;
 
    bool nan_equal = true;
 
    bool report = true;
};
 
inline bool compare_almost_equal(double left, double right, const CompareAlmostEqualParameters& params) {
    const auto message = [&]() -> void {
        if (params.report) {
            EXPECT_TRUE(false) << "mismatching floats (" << left << " versus " << right << ")";
        }
    };
 
    if (std::isnan(left) || std::isnan(right)) {
        if (std::isnan(left) != std::isnan(right) || !params.nan_equal) {
            message();
            return false;
        } else {
            return true;
        }
    }
 
    if (left == right) {
        return true;
    }
 
    // Use relative tolerance to check that we get a similar float.
    // EXPECT_EQ and even EXPECT_DOUBLE_EQ tend to be a bit too stringent when numerical imprecision is expected.
    // We define the relative difference as '|difference| / |mean|' of the two values, and check that this is below some acceptable error, in this case 1e-8.
    //
    // It's worth nothing that I spent a long time using EXPECT_FLOAT_EQ when I really should have been using EXPECT_DOUBLE_EQ.
    // This would have implicitly used a relative threshold at the 8th significant figure, which is why it allowed tests to pass despite imprecision.
    const double denom = std::abs(left + right) / 2;
    double threshold = denom * params.relative_tolerance;
 
    // 'relative difference < tol' is equivalent to '|difference| < threshold'.
    // However, if '|mean|' is very small, we start to revert back to an exact equality test.
    // This is not ideal - we DON'T want to fail the test if one value is zero and another is very slightly non-zero.
    // So we need to ensure that the threshold doesn't get too small, by setting a lower bound similar to the machine epsilon.
    // (That said, if we're dealing with lots of very-near-zero values, this function won't be appropriate as it'll consider them to be the same.)
    if (threshold < params.absolute_tolerance) { 
        threshold = params.absolute_tolerance;
    }
    if (std::abs(left - right) > threshold) {
        message();
        return false;
    }
 
    return true;
}
 
template<class LeftContainer_, class RightContainer_>
void compare_almost_equal_containers(const LeftContainer_& left, const RightContainer_& right, CompareAlmostEqualParameters params) {
    auto n = left.size();
    ASSERT_EQ(n, right.size());
 
    params.report = false;
    for (decltype(n) i = 0; i < n; ++i) {
        if (!compare_almost_equal(left[i], right[i], params)) {
            EXPECT_TRUE(false) << "mismatch in almost-equal floats at element " << i << " (expected " << left[i] << ", got " << right[i] << ")";
            return;
        }
    }
}
 
// Back-compatibility.
inline bool compare_almost_equal(double left, double right) {
    return compare_almost_equal(left, right, {});
}
 
template<class Vector_>
void compare_almost_equal(const Vector_& left, const Vector_& right, double tol = 1e-8) {
    compare_almost_equal_containers(left, right, [&]{
        CompareAlmostEqualParameters params;
        params.relative_tolerance = tol;
        return params;
    }());
}
}
 
#endif