Read-only mirrors. Development, issues and pull requests are on GitHub.

summaryrefslogtreecommitdiffhomepage
path: root/src
diff options
context:
space:
mode:
authorMartin Hořeňovský2021-07-26 22:01:04 +0200
committerMartin Hořeňovský2021-07-27 21:04:41 +0200
commit3d1cf95b3247e962ab7ae926b5547c64738a13d9 (patch)
tree2189db1a3c3016bf7ac5d6708e2e7dd670222504 /src
parent6f21a3609cea360846a0ca93be55877cca14c86d (diff)
downloadcatch3-3d1cf95b3247e962ab7ae926b5547c64738a13d9.tar.gz
Fix ulp distance calculation for numbers with different signs
This is a simplification of the fix proposed in #2152, with the critical function split out so that it can be tested directly, without having to go through the ULP matcher. Closes #2152
Diffstat (limited to 'src')
-rw-r--r--src/CMakeLists.txt2
-rw-r--r--src/catch2/catch_all.hpp1
-rw-r--r--src/catch2/internal/catch_floating_point_helpers.cpp32
-rw-r--r--src/catch2/internal/catch_floating_point_helpers.hpp88
-rw-r--r--src/catch2/matchers/catch_matchers_floating_point.cpp32
5 files changed, 130 insertions, 25 deletions
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 270f3fdd..5d7aa8c3 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -65,6 +65,7 @@ set(INTERNAL_HEADERS
${SOURCES_DIR}/internal/catch_errno_guard.hpp
${SOURCES_DIR}/internal/catch_exception_translator_registry.hpp
${SOURCES_DIR}/internal/catch_fatal_condition_handler.hpp
+ ${SOURCES_DIR}/internal/catch_floating_point_helpers.hpp
${SOURCES_DIR}/internal/catch_unique_name.hpp
${SOURCES_DIR}/generators/catch_generator_exception.hpp
${SOURCES_DIR}/generators/catch_generators.hpp
@@ -160,6 +161,7 @@ set(IMPL_SOURCES
${SOURCES_DIR}/internal/catch_enum_values_registry.cpp
${SOURCES_DIR}/internal/catch_exception_translator_registry.cpp
${SOURCES_DIR}/internal/catch_fatal_condition_handler.cpp
+ ${SOURCES_DIR}/internal/catch_floating_point_helpers.cpp
${SOURCES_DIR}/generators/internal/catch_generators_combined_tu.cpp
${SOURCES_DIR}/interfaces/catch_interfaces_combined_tu.cpp
${SOURCES_DIR}/interfaces/catch_interfaces_reporter.cpp
diff --git a/src/catch2/catch_all.hpp b/src/catch2/catch_all.hpp
index c6ab59ec..6b8ecf4e 100644
--- a/src/catch2/catch_all.hpp
+++ b/src/catch2/catch_all.hpp
@@ -66,6 +66,7 @@
#include <catch2/internal/catch_errno_guard.hpp>
#include <catch2/internal/catch_exception_translator_registry.hpp>
#include <catch2/internal/catch_fatal_condition_handler.hpp>
+#include <catch2/internal/catch_floating_point_helpers.hpp>
#include <catch2/internal/catch_lazy_expr.hpp>
#include <catch2/internal/catch_leak_detector.hpp>
#include <catch2/internal/catch_list.hpp>
diff --git a/src/catch2/internal/catch_floating_point_helpers.cpp b/src/catch2/internal/catch_floating_point_helpers.cpp
new file mode 100644
index 00000000..55a95a28
--- /dev/null
+++ b/src/catch2/internal/catch_floating_point_helpers.cpp
@@ -0,0 +1,32 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+#include <catch2/internal/catch_floating_point_helpers.hpp>
+
+#include <cstring>
+
+namespace Catch {
+ namespace Detail {
+
+ uint32_t convertToBits(float f) {
+ static_assert(sizeof(float) == sizeof(uint32_t), "Important ULP matcher assumption violated");
+ uint32_t i;
+ std::memcpy(&i, &f, sizeof(f));
+ return i;
+ }
+
+ uint64_t convertToBits(double d) {
+ static_assert(sizeof(double) == sizeof(uint64_t), "Important ULP matcher assumption violated");
+ uint64_t i;
+ std::memcpy(&i, &d, sizeof(d));
+ return i;
+ }
+
+ } // end namespace Detail
+} // end namespace Catch
+
diff --git a/src/catch2/internal/catch_floating_point_helpers.hpp b/src/catch2/internal/catch_floating_point_helpers.hpp
new file mode 100644
index 00000000..3e73b3a7
--- /dev/null
+++ b/src/catch2/internal/catch_floating_point_helpers.hpp
@@ -0,0 +1,88 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#ifndef CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
+#define CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
+
+#include <catch2/internal/catch_polyfills.hpp>
+
+#include <cmath>
+#include <cstdint>
+#include <utility>
+#include <limits>
+
+namespace Catch {
+ namespace Detail {
+
+ uint32_t convertToBits(float f);
+ uint64_t convertToBits(double d);
+
+ } // end namespace Detail
+
+
+ /**
+ * Calculates the ULP distance between two floating point numbers
+ *
+ * The ULP distance of two floating point numbers is the count of
+ * valid floating point numbers representable between them.
+ *
+ * There are some exceptions between how this function counts the
+ * distance, and the interpretation of the standard as implemented.
+ * by e.g. `nextafter`. For this function it always holds that:
+ * * `(x == y) => ulpDistance(x, y) == 0` (so `ulpDistance(-0, 0) == 0`)
+ * * `ulpDistance(maxFinite, INF) == 1`
+ * * `ulpDistance(x, -x) == 2 * ulpDistance(x, 0)`
+ *
+ * \pre `!isnan( lhs )`
+ * \pre `!isnan( rhs )`
+ * \pre floating point numbers are represented in IEEE-754 format
+ */
+ template <typename FP>
+ uint64_t ulpDistance( FP lhs, FP rhs ) {
+ assert( std::numeric_limits<FP>::is_iec559 &&
+ "ulpDistance assumes IEEE-754 format for floating point types" );
+ assert( !Catch::isnan( lhs ) &&
+ "Distance between NaN and number is not meaningful" );
+ assert( !Catch::isnan( rhs ) &&
+ "Distance between NaN and number is not meaningful" );
+
+ // We want X == Y to imply 0 ULP distance even if X and Y aren't
+ // bit-equal (-0 and 0), or X - Y != 0 (same sign infinities).
+ if ( lhs == rhs ) { return 0; }
+
+ // We need a properly typed positive zero for type inference.
+ static constexpr FP positive_zero{};
+
+ // We want to ensure that +/- 0 is always represented as positive zero
+ if ( lhs == positive_zero ) { lhs = positive_zero; }
+ if ( rhs == positive_zero ) { rhs = positive_zero; }
+
+ // If arguments have different signs, we can handle them by summing
+ // how far are they from 0 each.
+ if ( std::signbit( lhs ) != std::signbit( rhs ) ) {
+ return ulpDistance( std::abs( lhs ), positive_zero ) +
+ ulpDistance( std::abs( rhs ), positive_zero );
+ }
+
+ // When both lhs and rhs are of the same sign, we can just
+ // read the numbers bitwise as integers, and then subtract them
+ // (assuming IEEE).
+ uint64_t lc = Detail::convertToBits( lhs );
+ uint64_t rc = Detail::convertToBits( rhs );
+
+ // The ulp distance between two numbers is symmetric, so to avoid
+ // dealing with overflows we want the bigger converted number on the lhs
+ if ( lc < rc ) {
+ std::swap( lc, rc );
+ }
+
+ return lc - rc;
+ }
+
+} // end namespace Catch
+
+#endif // CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
diff --git a/src/catch2/matchers/catch_matchers_floating_point.cpp b/src/catch2/matchers/catch_matchers_floating_point.cpp
index b3c1c335..ad0fd378 100644
--- a/src/catch2/matchers/catch_matchers_floating_point.cpp
+++ b/src/catch2/matchers/catch_matchers_floating_point.cpp
@@ -10,12 +10,12 @@
#include <catch2/internal/catch_polyfills.hpp>
#include <catch2/internal/catch_to_string.hpp>
#include <catch2/catch_tostring.hpp>
+#include <catch2/internal/catch_floating_point_helpers.hpp>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstdint>
-#include <cstring>
#include <sstream>
#include <iomanip>
#include <limits>
@@ -24,20 +24,6 @@
namespace Catch {
namespace {
- int32_t convert(float f) {
- static_assert(sizeof(float) == sizeof(int32_t), "Important ULP matcher assumption violated");
- int32_t i;
- std::memcpy(&i, &f, sizeof(f));
- return i;
- }
-
- int64_t convert(double d) {
- static_assert(sizeof(double) == sizeof(int64_t), "Important ULP matcher assumption violated");
- int64_t i;
- std::memcpy(&i, &d, sizeof(d));
- return i;
- }
-
template <typename FP>
bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
// Comparison with NaN should always be false.
@@ -46,17 +32,10 @@ namespace {
return false;
}
- auto lc = convert(lhs);
- auto rc = convert(rhs);
-
- if ((lc < 0) != (rc < 0)) {
- // Potentially we can have +0 and -0
- return lhs == rhs;
- }
+ // This should also handle positive and negative zeros, infinities
+ const auto ulpDist = ulpDistance(lhs, rhs);
- // static cast as a workaround for IBM XLC
- auto ulpDiff = std::abs(static_cast<FP>(lc - rc));
- return static_cast<uint64_t>(ulpDiff) <= maxUlpDiff;
+ return ulpDist <= maxUlpDiff;
}
#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
@@ -131,6 +110,9 @@ namespace Detail {
CATCH_ENFORCE(m_type == Detail::FloatingPointKind::Double
|| m_ulps < (std::numeric_limits<uint32_t>::max)(),
"Provided ULP is impossibly large for a float comparison.");
+ CATCH_ENFORCE( std::numeric_limits<double>::is_iec559,
+ "WithinUlp matcher only supports platforms with "
+ "IEEE-754 compatible floating point representation" );
}
#if defined(__clang__)