[libc-commits] [libc] [libc][math][c23] Add MPFR exhaustive test for fmodf16 (PR #94656)
via libc-commits
libc-commits at lists.llvm.org
Tue Jun 25 07:28:08 PDT 2024
https://github.com/overmighty updated https://github.com/llvm/llvm-project/pull/94656
>From ad5889456585bb8d2671a825a68286ede6bd15ba Mon Sep 17 00:00:00 2001
From: OverMighty <its.overmighty at gmail.com>
Date: Thu, 6 Jun 2024 20:29:46 +0200
Subject: [PATCH 1/4] [libc][math][c23] Add MPFR exhaustive test for fmodf16
---
libc/test/src/math/exhaustive/CMakeLists.txt | 15 ++
.../src/math/exhaustive/exhaustive_test.h | 150 ++++++++++++++++++
.../test/src/math/exhaustive/fmodf16_test.cpp | 41 +++++
libc/utils/MPFRWrapper/MPFRUtils.cpp | 6 +
4 files changed, 212 insertions(+)
create mode 100644 libc/test/src/math/exhaustive/fmodf16_test.cpp
diff --git a/libc/test/src/math/exhaustive/CMakeLists.txt b/libc/test/src/math/exhaustive/CMakeLists.txt
index 34df8720ed4db..422934d2f51ff 100644
--- a/libc/test/src/math/exhaustive/CMakeLists.txt
+++ b/libc/test/src/math/exhaustive/CMakeLists.txt
@@ -277,6 +277,21 @@ add_fp_unittest(
libc.src.__support.FPUtil.generic.fmod
)
+add_fp_unittest(
+ fmodf16_test
+ NO_RUN_POSTBUILD
+ NEED_MPFR
+ SUITE
+ libc_math_exhaustive_tests
+ SRCS
+ fmodf16_test.cpp
+ DEPENDS
+ .exhaustive_test
+ libc.src.math.fmodf16
+ LINK_LIBRARIES
+ -lpthread
+)
+
add_fp_unittest(
coshf_test
NO_RUN_POSTBUILD
diff --git a/libc/test/src/math/exhaustive/exhaustive_test.h b/libc/test/src/math/exhaustive/exhaustive_test.h
index 13e272783250b..9afbdabb7fd1f 100644
--- a/libc/test/src/math/exhaustive/exhaustive_test.h
+++ b/libc/test/src/math/exhaustive/exhaustive_test.h
@@ -8,6 +8,7 @@
#include "src/__support/CPP/type_traits.h"
#include "src/__support/FPUtil/FPBits.h"
+#include "src/__support/macros/properties/types.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
@@ -68,6 +69,43 @@ struct UnaryOpChecker : public virtual LIBC_NAMESPACE::testing::Test {
}
};
+template <typename T> using BinaryOp = T(T, T);
+
+template <typename T, mpfr::Operation Op, BinaryOp<T> Func>
+struct BinaryOpChecker : public virtual LIBC_NAMESPACE::testing::Test {
+ using FloatType = T;
+ using FPBits = LIBC_NAMESPACE::fputil::FPBits<FloatType>;
+ using StorageType = typename FPBits::StorageType;
+
+ static constexpr BinaryOp<FloatType> *FUNC = Func;
+
+ // Check in a range, return the number of failures.
+ uint64_t check(StorageType x_start, StorageType x_stop, StorageType y_start,
+ StorageType y_stop, mpfr::RoundingMode rounding) {
+ mpfr::ForceRoundingMode r(rounding);
+ if (!r.success)
+ return (x_stop > x_start || y_stop > y_start);
+ StorageType xbits = x_start;
+ uint64_t failed = 0;
+ do {
+ FloatType x = FPBits(xbits).get_val();
+ StorageType ybits = y_start;
+ do {
+ FloatType y = FPBits(ybits).get_val();
+ mpfr::BinaryInput<FloatType> input{x, y};
+ bool correct = TEST_MPFR_MATCH_ROUNDING_SILENTLY(Op, input, FUNC(x, y),
+ 0.5, rounding);
+ failed += (!correct);
+ // Uncomment to print out failed values.
+ // if (!correct) {
+ // TEST_MPFR_MATCH(Op::Operation, x, Op::func(x, y), 0.5, rounding);
+ // }
+ } while (ybits++ < y_stop);
+ } while (xbits++ < x_stop);
+ return failed;
+ }
+};
+
// Checker class needs inherit from LIBC_NAMESPACE::testing::Test and provide
// StorageType and check method.
template <typename Checker>
@@ -167,6 +205,114 @@ struct LlvmLibcExhaustiveMathTest
};
};
+template <typename Checker>
+struct LlvmLibcBinaryInputExhaustiveMathTest
+ : public virtual LIBC_NAMESPACE::testing::Test,
+ public Checker {
+ using FloatType = typename Checker::FloatType;
+ using FPBits = typename Checker::FPBits;
+ using StorageType = typename Checker::StorageType;
+
+ static constexpr StorageType Increment = (1 << 2);
+
+ // Break [start, stop) into `nthreads` subintervals and apply *check to each
+ // subinterval in parallel.
+ void test_full_range(StorageType x_start, StorageType x_stop,
+ StorageType y_start, StorageType y_stop,
+ mpfr::RoundingMode rounding) {
+ int n_threads = std::thread::hardware_concurrency();
+ std::vector<std::thread> thread_list;
+ std::mutex mx_cur_val;
+ int current_percent = -1;
+ StorageType current_value = x_start;
+ std::atomic<uint64_t> failed(0);
+
+ for (int i = 0; i < n_threads; ++i) {
+ thread_list.emplace_back([&, this]() {
+ while (true) {
+ StorageType range_begin, range_end;
+ int new_percent = -1;
+ {
+ std::lock_guard<std::mutex> lock(mx_cur_val);
+ if (current_value == x_stop)
+ return;
+
+ range_begin = current_value;
+ if (x_stop >= Increment && x_stop - Increment >= current_value) {
+ range_end = current_value + Increment;
+ } else {
+ range_end = x_stop;
+ }
+ current_value = range_end;
+ int pc = 100.0 * (range_end - x_start) / (x_stop - x_start);
+ if (current_percent != pc) {
+ new_percent = pc;
+ current_percent = pc;
+ }
+ }
+ if (new_percent >= 0) {
+ std::stringstream msg;
+ msg << new_percent << "% is in process \r";
+ std::cout << msg.str() << std::flush;
+ }
+
+ uint64_t failed_in_range =
+ Checker::check(range_begin, range_end, y_start, y_stop, rounding);
+ if (failed_in_range > 0) {
+ using T = LIBC_NAMESPACE::cpp::conditional_t<
+ LIBC_NAMESPACE::cpp::is_same_v<FloatType, float16>, float,
+ FloatType>;
+ std::stringstream msg;
+ msg << "Test failed for " << std::dec << failed_in_range
+ << " inputs in range: " << range_begin << " to " << range_end
+ << " [0x" << std::hex << range_begin << ", 0x" << range_end
+ << "), [" << std::hexfloat
+ << static_cast<T>(FPBits(range_begin).get_val()) << ", "
+ << static_cast<T>(FPBits(range_end).get_val()) << ")\n";
+ std::cerr << msg.str() << std::flush;
+
+ failed.fetch_add(failed_in_range);
+ }
+ }
+ });
+ }
+
+ for (auto &thread : thread_list) {
+ if (thread.joinable()) {
+ thread.join();
+ }
+ }
+
+ std::cout << std::endl;
+ std::cout << "Test " << ((failed > 0) ? "FAILED" : "PASSED") << std::endl;
+ ASSERT_EQ(failed.load(), uint64_t(0));
+ }
+
+ void test_full_range_all_roundings(StorageType x_start, StorageType x_stop,
+ StorageType y_start, StorageType y_stop) {
+ test_full_range(x_start, x_stop, y_start, y_stop,
+ mpfr::RoundingMode::Nearest);
+
+ std::cout << "-- Testing for FE_UPWARD in x range [0x" << std::hex
+ << x_start << ", 0x" << x_stop << ") y range [0x" << std::hex
+ << y_start << ", 0x" << y_stop << ") --" << std::dec << std::endl;
+ test_full_range(x_start, x_stop, y_start, y_stop,
+ mpfr::RoundingMode::Upward);
+
+ std::cout << "-- Testing for FE_DOWNWARD in x range [0x" << std::hex
+ << x_start << ", 0x" << x_stop << ") y range [0x" << std::hex
+ << y_start << ", 0x" << y_stop << ") --" << std::dec << std::endl;
+ test_full_range(x_start, x_stop, y_start, y_stop,
+ mpfr::RoundingMode::Downward);
+
+ std::cout << "-- Testing for FE_TOWARDZERO in x range [0x" << std::hex
+ << x_start << ", 0x" << x_stop << ") y range [0x" << std::hex
+ << y_start << ", 0x" << y_stop << ") --" << std::dec << std::endl;
+ test_full_range(x_start, x_stop, y_start, y_stop,
+ mpfr::RoundingMode::TowardZero);
+ };
+};
+
template <typename FloatType, mpfr::Operation Op, UnaryOp<FloatType> Func>
using LlvmLibcUnaryOpExhaustiveMathTest =
LlvmLibcExhaustiveMathTest<UnaryOpChecker<FloatType, FloatType, Op, Func>>;
@@ -175,3 +321,7 @@ template <typename OutType, typename InType, mpfr::Operation Op,
UnaryOp<OutType, InType> Func>
using LlvmLibcUnaryNarrowingOpExhaustiveMathTest =
LlvmLibcExhaustiveMathTest<UnaryOpChecker<OutType, InType, Op, Func>>;
+
+template <typename FloatType, mpfr::Operation Op, BinaryOp<FloatType> Func>
+using LlvmLibcBinaryOpExhaustiveMathTest =
+ LlvmLibcBinaryInputExhaustiveMathTest<BinaryOpChecker<FloatType, Op, Func>>;
diff --git a/libc/test/src/math/exhaustive/fmodf16_test.cpp b/libc/test/src/math/exhaustive/fmodf16_test.cpp
new file mode 100644
index 0000000000000..067cec969a4f7
--- /dev/null
+++ b/libc/test/src/math/exhaustive/fmodf16_test.cpp
@@ -0,0 +1,41 @@
+//===-- Exhaustive test for fmodf16 ---------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "exhaustive_test.h"
+#include "src/math/fmodf16.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+
+namespace mpfr = LIBC_NAMESPACE::testing::mpfr;
+
+using LlvmLibcFmodf16ExhaustiveTest =
+ LlvmLibcBinaryOpExhaustiveMathTest<float16, mpfr::Operation::Fmod,
+ LIBC_NAMESPACE::fmodf16>;
+
+// Range: [0, Inf];
+static constexpr uint16_t POS_START = 0x0000U;
+static constexpr uint16_t POS_STOP = 0x7c00U;
+
+// Range: [-Inf, 0];
+static constexpr uint16_t NEG_START = 0x8000U;
+static constexpr uint16_t NEG_STOP = 0xfc00U;
+
+TEST_F(LlvmLibcFmodf16ExhaustiveTest, PostivePositiveRange) {
+ test_full_range_all_roundings(POS_START, POS_STOP, POS_START, POS_STOP);
+}
+
+TEST_F(LlvmLibcFmodf16ExhaustiveTest, PostiveNegativeRange) {
+ test_full_range_all_roundings(POS_START, POS_STOP, NEG_START, NEG_STOP);
+}
+
+TEST_F(LlvmLibcFmodf16ExhaustiveTest, NegativePositiveRange) {
+ test_full_range_all_roundings(NEG_START, NEG_STOP, POS_START, POS_STOP);
+}
+
+TEST_F(LlvmLibcFmodf16ExhaustiveTest, NegativeNegativeRange) {
+ test_full_range_all_roundings(NEG_START, NEG_STOP, POS_START, POS_STOP);
+}
diff --git a/libc/utils/MPFRWrapper/MPFRUtils.cpp b/libc/utils/MPFRWrapper/MPFRUtils.cpp
index 521c2658b327a..88aef3e6e10c5 100644
--- a/libc/utils/MPFRWrapper/MPFRUtils.cpp
+++ b/libc/utils/MPFRWrapper/MPFRUtils.cpp
@@ -930,6 +930,8 @@ explain_binary_operation_one_output_error(Operation,
const BinaryInput<long double> &,
long double, double, RoundingMode);
#ifdef LIBC_TYPES_HAS_FLOAT16
+template void explain_binary_operation_one_output_error(
+ Operation, const BinaryInput<float16> &, float16, double, RoundingMode);
template void
explain_binary_operation_one_output_error(Operation, const BinaryInput<float> &,
float16, double, RoundingMode);
@@ -1088,6 +1090,10 @@ template bool
compare_binary_operation_one_output(Operation, const BinaryInput<long double> &,
long double, double, RoundingMode);
#ifdef LIBC_TYPES_HAS_FLOAT16
+template bool compare_binary_operation_one_output(Operation,
+ const BinaryInput<float16> &,
+ float16, double,
+ RoundingMode);
template bool compare_binary_operation_one_output(Operation,
const BinaryInput<float> &,
float16, double,
>From e394b864aa69cb4dc5e089bfa2afb270d39ec493 Mon Sep 17 00:00:00 2001
From: OverMighty <its.overmighty at gmail.com>
Date: Mon, 24 Jun 2024 22:34:29 +0200
Subject: [PATCH 2/4] fixup! [libc][math][c23] Add MPFR exhaustive test for
fmodf16
---
.../src/math/exhaustive/exhaustive_test.h | 186 ++++++------------
1 file changed, 65 insertions(+), 121 deletions(-)
diff --git a/libc/test/src/math/exhaustive/exhaustive_test.h b/libc/test/src/math/exhaustive/exhaustive_test.h
index 9afbdabb7fd1f..bf9be90f39e2c 100644
--- a/libc/test/src/math/exhaustive/exhaustive_test.h
+++ b/libc/test/src/math/exhaustive/exhaustive_test.h
@@ -69,22 +69,22 @@ struct UnaryOpChecker : public virtual LIBC_NAMESPACE::testing::Test {
}
};
-template <typename T> using BinaryOp = T(T, T);
+template <typename OutType, typename InType = OutType>
+using BinaryOp = OutType(InType, InType);
-template <typename T, mpfr::Operation Op, BinaryOp<T> Func>
+template <typename OutType, typename InType, mpfr::Operation Op,
+ BinaryOp<OutType, InType> Func>
struct BinaryOpChecker : public virtual LIBC_NAMESPACE::testing::Test {
- using FloatType = T;
+ using FloatType = InType;
using FPBits = LIBC_NAMESPACE::fputil::FPBits<FloatType>;
using StorageType = typename FPBits::StorageType;
- static constexpr BinaryOp<FloatType> *FUNC = Func;
-
// Check in a range, return the number of failures.
uint64_t check(StorageType x_start, StorageType x_stop, StorageType y_start,
StorageType y_stop, mpfr::RoundingMode rounding) {
mpfr::ForceRoundingMode r(rounding);
if (!r.success)
- return (x_stop > x_start || y_stop > y_start);
+ return x_stop > x_start || y_stop > y_start;
StorageType xbits = x_start;
uint64_t failed = 0;
do {
@@ -93,12 +93,12 @@ struct BinaryOpChecker : public virtual LIBC_NAMESPACE::testing::Test {
do {
FloatType y = FPBits(ybits).get_val();
mpfr::BinaryInput<FloatType> input{x, y};
- bool correct = TEST_MPFR_MATCH_ROUNDING_SILENTLY(Op, input, FUNC(x, y),
+ bool correct = TEST_MPFR_MATCH_ROUNDING_SILENTLY(Op, input, Func(x, y),
0.5, rounding);
failed += (!correct);
// Uncomment to print out failed values.
// if (!correct) {
- // TEST_MPFR_MATCH(Op::Operation, x, Op::func(x, y), 0.5, rounding);
+ // EXPECT_MPFR_MATCH_ROUNDING(Op, input, Func(x, y), 0.5, rounding);
// }
} while (ybits++ < y_stop);
} while (xbits++ < x_stop);
@@ -108,7 +108,7 @@ struct BinaryOpChecker : public virtual LIBC_NAMESPACE::testing::Test {
// Checker class needs inherit from LIBC_NAMESPACE::testing::Test and provide
// StorageType and check method.
-template <typename Checker>
+template <typename Checker, size_t Increment = 1 << 20>
struct LlvmLibcExhaustiveMathTest
: public virtual LIBC_NAMESPACE::testing::Test,
public Checker {
@@ -116,12 +116,37 @@ struct LlvmLibcExhaustiveMathTest
using FPBits = typename Checker::FPBits;
using StorageType = typename Checker::StorageType;
- static constexpr StorageType INCREMENT = (1 << 20);
+ static constexpr StorageType INCREMENT = Increment;
+
+ void explain_failed_range(std::stringstream &msg, StorageType x_begin,
+ StorageType x_end) {
+#ifdef LIBC_TYPES_HAS_FLOAT16
+ using T = LIBC_NAMESPACE::cpp::conditional_t<
+ LIBC_NAMESPACE::cpp::is_same_v<FloatType, float16>, float, FloatType>;
+#else
+ using T = FloatType;
+#endif
+
+ msg << x_begin << " to " << x_end << " [0x" << std::hex << x_begin << ", 0x"
+ << x_end << "), [" << std::hexfloat
+ << static_cast<T>(FPBits(x_begin).get_val()) << ", "
+ << static_cast<T>(FPBits(x_end).get_val()) << ")";
+ }
+
+ void explain_failed_range(std::stringstream &msg, StorageType x_begin,
+ StorageType x_end, StorageType y_begin,
+ StorageType y_end) {
+ msg << "x ";
+ explain_failed_range(msg, x_begin, x_end);
+ msg << ", y ";
+ explain_failed_range(msg, y_begin, y_end);
+ }
// Break [start, stop) into `nthreads` subintervals and apply *check to each
// subinterval in parallel.
- void test_full_range(StorageType start, StorageType stop,
- mpfr::RoundingMode rounding) {
+ template <typename... T>
+ void test_full_range(mpfr::RoundingMode rounding, StorageType start,
+ StorageType stop, T... extra_range_bounds) {
int n_threads = std::thread::hardware_concurrency();
std::vector<std::thread> thread_list;
std::mutex mx_cur_val;
@@ -158,15 +183,14 @@ struct LlvmLibcExhaustiveMathTest
std::cout << msg.str() << std::flush;
}
- uint64_t failed_in_range =
- Checker::check(range_begin, range_end, rounding);
+ uint64_t failed_in_range = Checker::check(
+ range_begin, range_end, extra_range_bounds..., rounding);
if (failed_in_range > 0) {
std::stringstream msg;
msg << "Test failed for " << std::dec << failed_in_range
- << " inputs in range: " << range_begin << " to " << range_end
- << " [0x" << std::hex << range_begin << ", 0x" << range_end
- << "), [" << std::hexfloat << FPBits(range_begin).get_val()
- << ", " << FPBits(range_end).get_val() << ")\n";
+ << " inputs in range: ";
+ explain_failed_range(msg, start, stop, extra_range_bounds...);
+ msg << "\n";
std::cerr << msg.str() << std::flush;
failed.fetch_add(failed_in_range);
@@ -189,127 +213,46 @@ struct LlvmLibcExhaustiveMathTest
void test_full_range_all_roundings(StorageType start, StorageType stop) {
std::cout << "-- Testing for FE_TONEAREST in range [0x" << std::hex << start
<< ", 0x" << stop << ") --" << std::dec << std::endl;
- test_full_range(start, stop, mpfr::RoundingMode::Nearest);
+ test_full_range(mpfr::RoundingMode::Nearest, start, stop);
std::cout << "-- Testing for FE_UPWARD in range [0x" << std::hex << start
<< ", 0x" << stop << ") --" << std::dec << std::endl;
- test_full_range(start, stop, mpfr::RoundingMode::Upward);
+ test_full_range(mpfr::RoundingMode::Upward, start, stop);
std::cout << "-- Testing for FE_DOWNWARD in range [0x" << std::hex << start
<< ", 0x" << stop << ") --" << std::dec << std::endl;
- test_full_range(start, stop, mpfr::RoundingMode::Downward);
+ test_full_range(mpfr::RoundingMode::Downward, start, stop);
std::cout << "-- Testing for FE_TOWARDZERO in range [0x" << std::hex
<< start << ", 0x" << stop << ") --" << std::dec << std::endl;
- test_full_range(start, stop, mpfr::RoundingMode::TowardZero);
+ test_full_range(mpfr::RoundingMode::TowardZero, start, stop);
};
-};
-
-template <typename Checker>
-struct LlvmLibcBinaryInputExhaustiveMathTest
- : public virtual LIBC_NAMESPACE::testing::Test,
- public Checker {
- using FloatType = typename Checker::FloatType;
- using FPBits = typename Checker::FPBits;
- using StorageType = typename Checker::StorageType;
-
- static constexpr StorageType Increment = (1 << 2);
-
- // Break [start, stop) into `nthreads` subintervals and apply *check to each
- // subinterval in parallel.
- void test_full_range(StorageType x_start, StorageType x_stop,
- StorageType y_start, StorageType y_stop,
- mpfr::RoundingMode rounding) {
- int n_threads = std::thread::hardware_concurrency();
- std::vector<std::thread> thread_list;
- std::mutex mx_cur_val;
- int current_percent = -1;
- StorageType current_value = x_start;
- std::atomic<uint64_t> failed(0);
-
- for (int i = 0; i < n_threads; ++i) {
- thread_list.emplace_back([&, this]() {
- while (true) {
- StorageType range_begin, range_end;
- int new_percent = -1;
- {
- std::lock_guard<std::mutex> lock(mx_cur_val);
- if (current_value == x_stop)
- return;
-
- range_begin = current_value;
- if (x_stop >= Increment && x_stop - Increment >= current_value) {
- range_end = current_value + Increment;
- } else {
- range_end = x_stop;
- }
- current_value = range_end;
- int pc = 100.0 * (range_end - x_start) / (x_stop - x_start);
- if (current_percent != pc) {
- new_percent = pc;
- current_percent = pc;
- }
- }
- if (new_percent >= 0) {
- std::stringstream msg;
- msg << new_percent << "% is in process \r";
- std::cout << msg.str() << std::flush;
- }
-
- uint64_t failed_in_range =
- Checker::check(range_begin, range_end, y_start, y_stop, rounding);
- if (failed_in_range > 0) {
- using T = LIBC_NAMESPACE::cpp::conditional_t<
- LIBC_NAMESPACE::cpp::is_same_v<FloatType, float16>, float,
- FloatType>;
- std::stringstream msg;
- msg << "Test failed for " << std::dec << failed_in_range
- << " inputs in range: " << range_begin << " to " << range_end
- << " [0x" << std::hex << range_begin << ", 0x" << range_end
- << "), [" << std::hexfloat
- << static_cast<T>(FPBits(range_begin).get_val()) << ", "
- << static_cast<T>(FPBits(range_end).get_val()) << ")\n";
- std::cerr << msg.str() << std::flush;
-
- failed.fetch_add(failed_in_range);
- }
- }
- });
- }
-
- for (auto &thread : thread_list) {
- if (thread.joinable()) {
- thread.join();
- }
- }
-
- std::cout << std::endl;
- std::cout << "Test " << ((failed > 0) ? "FAILED" : "PASSED") << std::endl;
- ASSERT_EQ(failed.load(), uint64_t(0));
- }
void test_full_range_all_roundings(StorageType x_start, StorageType x_stop,
StorageType y_start, StorageType y_stop) {
- test_full_range(x_start, x_stop, y_start, y_stop,
- mpfr::RoundingMode::Nearest);
+ std::cout << "-- Testing for FE_TONEAREST in x range [0x" << std::hex
+ << x_start << ", 0x" << x_stop << "), y range [0x" << y_start
+ << ", 0x" << y_stop << ") --" << std::dec << std::endl;
+ test_full_range(mpfr::RoundingMode::Nearest, x_start, x_stop, y_start,
+ y_stop);
std::cout << "-- Testing for FE_UPWARD in x range [0x" << std::hex
- << x_start << ", 0x" << x_stop << ") y range [0x" << std::hex
- << y_start << ", 0x" << y_stop << ") --" << std::dec << std::endl;
- test_full_range(x_start, x_stop, y_start, y_stop,
- mpfr::RoundingMode::Upward);
+ << x_start << ", 0x" << x_stop << "), y range [0x" << y_start
+ << ", 0x" << y_stop << ") --" << std::dec << std::endl;
+ test_full_range(mpfr::RoundingMode::Upward, x_start, x_stop, y_start,
+ y_stop);
std::cout << "-- Testing for FE_DOWNWARD in x range [0x" << std::hex
- << x_start << ", 0x" << x_stop << ") y range [0x" << std::hex
- << y_start << ", 0x" << y_stop << ") --" << std::dec << std::endl;
- test_full_range(x_start, x_stop, y_start, y_stop,
- mpfr::RoundingMode::Downward);
+ << x_start << ", 0x" << x_stop << "), y range [0x" << y_start
+ << ", 0x" << y_stop << ") --" << std::dec << std::endl;
+ test_full_range(mpfr::RoundingMode::Downward, x_start, x_stop, y_start,
+ y_stop);
std::cout << "-- Testing for FE_TOWARDZERO in x range [0x" << std::hex
- << x_start << ", 0x" << x_stop << ") y range [0x" << std::hex
- << y_start << ", 0x" << y_stop << ") --" << std::dec << std::endl;
- test_full_range(x_start, x_stop, y_start, y_stop,
- mpfr::RoundingMode::TowardZero);
+ << x_start << ", 0x" << x_stop << "), y range [0x" << y_start
+ << ", 0x" << y_stop << ") --" << std::dec << std::endl;
+ test_full_range(mpfr::RoundingMode::TowardZero, x_start, x_stop, y_start,
+ y_stop);
};
};
@@ -324,4 +267,5 @@ using LlvmLibcUnaryNarrowingOpExhaustiveMathTest =
template <typename FloatType, mpfr::Operation Op, BinaryOp<FloatType> Func>
using LlvmLibcBinaryOpExhaustiveMathTest =
- LlvmLibcBinaryInputExhaustiveMathTest<BinaryOpChecker<FloatType, Op, Func>>;
+ LlvmLibcExhaustiveMathTest<BinaryOpChecker<FloatType, FloatType, Op, Func>,
+ 1 << 2>;
>From 9f8eb2fbb9c7f145ef1f6fe575a86bd9f607d676 Mon Sep 17 00:00:00 2001
From: OverMighty <its.overmighty at gmail.com>
Date: Mon, 24 Jun 2024 23:06:16 +0200
Subject: [PATCH 3/4] fixup! [libc][math][c23] Add MPFR exhaustive test for
fmodf16
Update exhaustive_test dependencies.
---
libc/test/src/math/exhaustive/CMakeLists.txt | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/libc/test/src/math/exhaustive/CMakeLists.txt b/libc/test/src/math/exhaustive/CMakeLists.txt
index 422934d2f51ff..fb3596c3378ff 100644
--- a/libc/test/src/math/exhaustive/CMakeLists.txt
+++ b/libc/test/src/math/exhaustive/CMakeLists.txt
@@ -4,6 +4,10 @@ add_header_library(
exhaustive_test
HDRS
exhaustive_test.h
+ DEPENDS
+ libc.src.__support.CPP.type_traits
+ libc.src.__support.FPUtil.fp_bits
+ libc.src.__support.macros.properties.types
)
add_fp_unittest(
>From 6894d5c3bb1863bdb5984fa9898c01fa2e75d0f8 Mon Sep 17 00:00:00 2001
From: OverMighty <its.overmighty at gmail.com>
Date: Tue, 25 Jun 2024 00:43:41 +0200
Subject: [PATCH 4/4] fixup! [libc][math][c23] Add MPFR exhaustive test for
fmodf16
---
libc/test/src/math/exhaustive/exhaustive_test.h | 6 ++----
1 file changed, 2 insertions(+), 4 deletions(-)
diff --git a/libc/test/src/math/exhaustive/exhaustive_test.h b/libc/test/src/math/exhaustive/exhaustive_test.h
index bf9be90f39e2c..6f0c78ebefa47 100644
--- a/libc/test/src/math/exhaustive/exhaustive_test.h
+++ b/libc/test/src/math/exhaustive/exhaustive_test.h
@@ -116,8 +116,6 @@ struct LlvmLibcExhaustiveMathTest
using FPBits = typename Checker::FPBits;
using StorageType = typename Checker::StorageType;
- static constexpr StorageType INCREMENT = Increment;
-
void explain_failed_range(std::stringstream &msg, StorageType x_begin,
StorageType x_end) {
#ifdef LIBC_TYPES_HAS_FLOAT16
@@ -165,8 +163,8 @@ struct LlvmLibcExhaustiveMathTest
return;
range_begin = current_value;
- if (stop >= INCREMENT && stop - INCREMENT >= current_value) {
- range_end = current_value + INCREMENT;
+ if (stop >= Increment && stop - Increment >= current_value) {
+ range_end = current_value + Increment;
} else {
range_end = stop;
}
More information about the libc-commits
mailing list