From 34d36a7de9ae33d9ac6966c7d1b1d19cc5d31d65 Mon Sep 17 00:00:00 2001 From: Matt Borland Date: Thu, 23 Jul 2026 20:27:52 -0400 Subject: [PATCH] Rename functions from op_sat to saturating_op --- .github/workflows/amalgamate.yml | 2 +- doc/modules/ROOT/pages/api_reference.adoc | 10 +- doc/modules/ROOT/pages/examples.adoc | 16 ++-- doc/modules/ROOT/pages/numeric.adoc | 24 ++--- examples/saturating_arithmetic.cpp | 20 ++-- include/boost/int128/numeric.hpp | 20 ++-- test/cuda_jamfile | 16 ++-- test/sycl_jamfile | 16 ++-- test/test_saturating_arith.cpp | 96 +++++++++---------- ...d_sat.cu => test_signed_saturating_add.cu} | 4 +- ...pp => test_signed_saturating_add_sycl.cpp} | 2 +- ...v_sat.cu => test_signed_saturating_div.cu} | 4 +- ...pp => test_signed_saturating_div_sycl.cpp} | 2 +- ...l_sat.cu => test_signed_saturating_mul.cu} | 4 +- ...pp => test_signed_saturating_mul_sycl.cpp} | 2 +- ...b_sat.cu => test_signed_saturating_sub.cu} | 4 +- ...pp => test_signed_saturating_sub_sycl.cpp} | 2 +- ...sat.cu => test_unsigned_saturating_add.cu} | 4 +- ... => test_unsigned_saturating_add_sycl.cpp} | 2 +- ...sat.cu => test_unsigned_saturating_div.cu} | 4 +- ... => test_unsigned_saturating_div_sycl.cpp} | 2 +- ...sat.cu => test_unsigned_saturating_mul.cu} | 4 +- ... => test_unsigned_saturating_mul_sycl.cpp} | 2 +- ...sat.cu => test_unsigned_saturating_sub.cu} | 4 +- ... => test_unsigned_saturating_sub_sycl.cpp} | 2 +- 25 files changed, 134 insertions(+), 134 deletions(-) rename test/{test_signed_add_sat.cu => test_signed_saturating_add.cu} (95%) rename test/{test_signed_mul_sat_sycl.cpp => test_signed_saturating_add_sycl.cpp} (92%) rename test/{test_signed_div_sat.cu => test_signed_saturating_div.cu} (94%) rename test/{test_signed_div_sat_sycl.cpp => test_signed_saturating_div_sycl.cpp} (84%) rename test/{test_signed_mul_sat.cu => test_signed_saturating_mul.cu} (94%) rename test/{test_signed_add_sat_sycl.cpp => test_signed_saturating_mul_sycl.cpp} (92%) rename test/{test_signed_sub_sat.cu => test_signed_saturating_sub.cu} (94%) rename test/{test_signed_sub_sat_sycl.cpp => test_signed_saturating_sub_sycl.cpp} (92%) rename test/{test_unsigned_add_sat.cu => test_unsigned_saturating_add.cu} (94%) rename test/{test_unsigned_mul_sat_sycl.cpp => test_unsigned_saturating_add_sycl.cpp} (92%) rename test/{test_unsigned_div_sat.cu => test_unsigned_saturating_div.cu} (94%) rename test/{test_unsigned_div_sat_sycl.cpp => test_unsigned_saturating_div_sycl.cpp} (84%) rename test/{test_unsigned_mul_sat.cu => test_unsigned_saturating_mul.cu} (94%) rename test/{test_unsigned_sub_sat_sycl.cpp => test_unsigned_saturating_mul_sycl.cpp} (92%) rename test/{test_unsigned_sub_sat.cu => test_unsigned_saturating_sub.cu} (94%) rename test/{test_unsigned_add_sat_sycl.cpp => test_unsigned_saturating_sub_sycl.cpp} (92%) diff --git a/.github/workflows/amalgamate.yml b/.github/workflows/amalgamate.yml index 950029e7..221c878c 100644 --- a/.github/workflows/amalgamate.yml +++ b/.github/workflows/amalgamate.yml @@ -66,7 +66,7 @@ jobs: return 2; } - if (add_sat(a, b) != (std::numeric_limits::max)()) + if (saturating_add(a, b) != (std::numeric_limits::max)()) { return 3; } diff --git a/doc/modules/ROOT/pages/api_reference.adoc b/doc/modules/ROOT/pages/api_reference.adoc index ce854697..b7c27d6b 100644 --- a/doc/modules/ROOT/pages/api_reference.adoc +++ b/doc/modules/ROOT/pages/api_reference.adoc @@ -249,19 +249,19 @@ Listed by analogous STL header. |=== | Function | Description -| xref:numeric.adoc#sat_arith[`add_sat`] +| xref:numeric.adoc#sat_arith[`saturating_add`] | Saturating addition -| xref:numeric.adoc#sat_arith[`sub_sat`] +| xref:numeric.adoc#sat_arith[`saturating_sub`] | Saturating subtraction -| xref:numeric.adoc#sat_arith[`mul_sat`] +| xref:numeric.adoc#sat_arith[`saturating_mul`] | Saturating multiplication -| xref:numeric.adoc#sat_arith[`div_sat`] +| xref:numeric.adoc#sat_arith[`saturating_div`] | Saturating division -| xref:numeric.adoc#saturating_cast[`saturate_cast`] +| xref:numeric.adoc#saturating_cast[`saturating_cast`] | Saturating type cast | xref:numeric.adoc#gcd[`gcd`] diff --git a/doc/modules/ROOT/pages/examples.adoc b/doc/modules/ROOT/pages/examples.adoc index a7c38f3a..9d9b0f0b 100644 --- a/doc/modules/ROOT/pages/examples.adoc +++ b/doc/modules/ROOT/pages/examples.adoc @@ -219,20 +219,20 @@ int128_t max = 170141183460469231731687303715884105727 int128_t min = -170141183460469231731687303715884105728 === Saturating Addition and Subtraction === -add_sat(uint_max, uint_max) = 340282366920938463463374607431768211455 (saturates to uint_max) -sub_sat(0, uint_max) = 0 (saturates to 0, not underflow) +saturating_add(uint_max, uint_max) = 340282366920938463463374607431768211455 (saturates to uint_max) +saturating_sub(0, uint_max) = 0 (saturates to 0, not underflow) === Saturating Multiplication === -mul_sat(int_max, 2) = 170141183460469231731687303715884105727 (saturates to int_max) -mul_sat(-(int_max - 2), 5) = -170141183460469231731687303715884105728 (saturates to int_min) +saturating_mul(int_max, 2) = 170141183460469231731687303715884105727 (saturates to int_max) +saturating_mul(-(int_max - 2), 5) = -170141183460469231731687303715884105728 (saturates to int_min) === Saturating Division === -div_sat(int_min, -1) = 170141183460469231731687303715884105727 (saturates to int_max; normally this overflows) +saturating_div(int_min, -1) = 170141183460469231731687303715884105727 (saturates to int_max; normally this overflows) === Saturating Casts === -saturate_cast(uint_max) = 170141183460469231731687303715884105727 (saturates to int_max) -saturate_cast(int_max) = 9223372036854775807 (saturates to INT64_MAX) -saturate_cast(uint_max) = 2147483647 (saturates to INT32_MAX) +saturating_cast(uint_max) = 170141183460469231731687303715884105727 (saturates to int_max) +saturating_cast(int_max) = 9223372036854775807 (saturates to INT64_MAX) +saturating_cast(uint_max) = 2147483647 (saturates to INT32_MAX) ---- ==== diff --git a/doc/modules/ROOT/pages/numeric.adoc b/doc/modules/ROOT/pages/numeric.adoc index 51dea723..4c8a4f22 100644 --- a/doc/modules/ROOT/pages/numeric.adoc +++ b/doc/modules/ROOT/pages/numeric.adoc @@ -23,29 +23,29 @@ The following functions are provided for saturating arithmetic, and they *do not namespace boost { namespace int128 { -BOOST_INT128_HOST_DEVICE constexpr uint128_t add_sat(uint128_t lhs, uint128_t rhs) noexcept; +BOOST_INT128_HOST_DEVICE constexpr uint128_t saturating_add(uint128_t lhs, uint128_t rhs) noexcept; -BOOST_INT128_HOST_DEVICE constexpr int128_t add_sat(int128_t lhs, int128_t rhs) noexcept; +BOOST_INT128_HOST_DEVICE constexpr int128_t saturating_add(int128_t lhs, int128_t rhs) noexcept; -BOOST_INT128_HOST_DEVICE constexpr uint128_t sub_sat(uint128_t lhs, uint128_t rhs) noexcept; +BOOST_INT128_HOST_DEVICE constexpr uint128_t saturating_sub(uint128_t lhs, uint128_t rhs) noexcept; -BOOST_INT128_HOST_DEVICE constexpr int128_t sub_sat(int128_t lhs, int128_t rhs) noexcept; +BOOST_INT128_HOST_DEVICE constexpr int128_t saturating_sub(int128_t lhs, int128_t rhs) noexcept; -BOOST_INT128_HOST_DEVICE constexpr uint128_t mul_sat(uint128_t lhs, uint128_t rhs) noexcept; +BOOST_INT128_HOST_DEVICE constexpr uint128_t saturating_mul(uint128_t lhs, uint128_t rhs) noexcept; -BOOST_INT128_HOST_DEVICE constexpr int128_t mul_sat(int128_t lhs, int128_t rhs) noexcept; +BOOST_INT128_HOST_DEVICE constexpr int128_t saturating_mul(int128_t lhs, int128_t rhs) noexcept; -BOOST_INT128_HOST_DEVICE constexpr uint128_t div_sat(uint128_t lhs, uint128_t rhs) noexcept; +BOOST_INT128_HOST_DEVICE constexpr uint128_t saturating_div(uint128_t lhs, uint128_t rhs) noexcept; -BOOST_INT128_HOST_DEVICE constexpr int128_t div_sat(int128_t lhs, int128_t rhs) noexcept; +BOOST_INT128_HOST_DEVICE constexpr int128_t saturating_div(int128_t lhs, int128_t rhs) noexcept; } // namespace int128 } // namespace boost ---- -For `div_sat` the only value that can overflow is the signed `INT128_MIN / -1`, which saturates to `INT128_MAX`; every other non-zero divisor gives the same result as the plain `operator/`. -Division by zero is a precondition violation and therefore undefined behavior (the divisor must be non-zero), exactly as for the built-in `__int128` types and the plain division operator; `div_sat` adds no zero-divisor check. +For `saturating_div` the only value that can overflow is the signed `INT128_MIN / -1`, which saturates to `INT128_MAX`; every other non-zero divisor gives the same result as the plain `operator/`. +Division by zero is a precondition violation and therefore undefined behavior (the divisor must be non-zero), exactly as for the built-in `__int128` types and the plain division operator; `saturating_div` adds no zero-divisor check. [#saturating_cast] == Saturating Cast @@ -62,10 +62,10 @@ namespace boost { namespace int128 { template -BOOST_INT128_HOST_DEVICE constexpr TargetType saturate_cast(uint128_t value) noexcept; +BOOST_INT128_HOST_DEVICE constexpr TargetType saturating_cast(uint128_t value) noexcept; template -BOOST_INT128_HOST_DEVICE constexpr TargetType saturate_cast(int128_t value) noexcept; +BOOST_INT128_HOST_DEVICE constexpr TargetType saturating_cast(int128_t value) noexcept; } // namespace int128 } // namespace boost diff --git a/examples/saturating_arithmetic.cpp b/examples/saturating_arithmetic.cpp index 44e2c98c..cb1960fc 100644 --- a/examples/saturating_arithmetic.cpp +++ b/examples/saturating_arithmetic.cpp @@ -35,34 +35,34 @@ int main() // Saturating arithmetic returns max on overflow, or min on underflow rather than rolling over std::cout << "\n=== Saturating Addition and Subtraction ===" << std::endl; - std::cout << "add_sat(uint_max, uint_max) = " << boost::int128::add_sat(uint_max, uint_max) + std::cout << "saturating_add(uint_max, uint_max) = " << boost::int128::saturating_add(uint_max, uint_max) << " (saturates to uint_max)" << std::endl; - std::cout << "sub_sat(0, uint_max) = " << boost::int128::sub_sat(uint128_t{0}, uint_max) + std::cout << "saturating_sub(0, uint_max) = " << boost::int128::saturating_sub(uint128_t{0}, uint_max) << " (saturates to 0, not underflow)" << std::endl; // This is especially useful for signed types since rollover is undefined std::cout << "\n=== Saturating Multiplication ===" << std::endl; - std::cout << "mul_sat(int_max, 2) = " << boost::int128::mul_sat(int_max, 2) + std::cout << "saturating_mul(int_max, 2) = " << boost::int128::saturating_mul(int_max, 2) << " (saturates to int_max)" << std::endl; - std::cout << "mul_sat(-(int_max - 2), 5) = " << boost::int128::mul_sat(-(int_max - 2), 5) + std::cout << "saturating_mul(-(int_max - 2), 5) = " << boost::int128::saturating_mul(-(int_max - 2), 5) << " (saturates to int_min)" << std::endl; - // The only case in the library where div_sat overflows is x = int_min and y = -1 + // The only case in the library where saturating_div overflows is x = int_min and y = -1 std::cout << "\n=== Saturating Division ===" << std::endl; - std::cout << "div_sat(int_min, -1) = " << boost::int128::div_sat(int_min, -1) + std::cout << "saturating_div(int_min, -1) = " << boost::int128::saturating_div(int_min, -1) << " (saturates to int_max; normally this overflows)" << std::endl; - // saturate_cast allows types to be safely converted without rollover behavior + // saturating_cast allows types to be safely converted without rollover behavior std::cout << "\n=== Saturating Casts ===" << std::endl; - std::cout << "saturate_cast(uint_max) = " << boost::int128::saturate_cast(uint_max) + std::cout << "saturating_cast(uint_max) = " << boost::int128::saturating_cast(uint_max) << " (saturates to int_max)" << std::endl; // You can also cast to builtin types - std::cout << "saturate_cast(int_max) = " << boost::int128::saturate_cast(int_max) + std::cout << "saturating_cast(int_max) = " << boost::int128::saturating_cast(int_max) << " (saturates to INT64_MAX)" << std::endl; // Even of different signedness as this is treated like a static cast - std::cout << "saturate_cast(uint_max) = " << boost::int128::saturate_cast(uint_max) + std::cout << "saturating_cast(uint_max) = " << boost::int128::saturating_cast(uint_max) << " (saturates to INT32_MAX)" << std::endl; return 0; diff --git a/include/boost/int128/numeric.hpp b/include/boost/int128/numeric.hpp index 8b255b5f..e9ed9cfa 100644 --- a/include/boost/int128/numeric.hpp +++ b/include/boost/int128/numeric.hpp @@ -53,7 +53,7 @@ BOOST_INT128_INLINE_CONSTEXPR bool is_reduced_integer_v {reduced_integers max - y (subtraction safe: max - non_negative >= 0) @@ -108,7 +108,7 @@ BOOST_INT128_EXPORT BOOST_INT128_HOST_DEVICE constexpr int128_t add_sat(const in return x + y; } -BOOST_INT128_EXPORT BOOST_INT128_HOST_DEVICE constexpr int128_t sub_sat(const int128_t x, const int128_t y) noexcept +BOOST_INT128_EXPORT BOOST_INT128_HOST_DEVICE constexpr int128_t saturating_sub(const int128_t x, const int128_t y) noexcept { // Detect overflow BEFORE the subtraction to avoid signed overflow UB. // Positive overflow: x >= 0 and y < 0 and x > max + y (safe: max + negative < max) @@ -137,7 +137,7 @@ BOOST_INT128_EXPORT BOOST_INT128_HOST_DEVICE constexpr int128_t sub_sat(const in # pragma warning(pop) #endif -BOOST_INT128_EXPORT BOOST_INT128_HOST_DEVICE constexpr uint128_t mul_sat(const uint128_t x, const uint128_t y) noexcept +BOOST_INT128_EXPORT BOOST_INT128_HOST_DEVICE constexpr uint128_t saturating_mul(const uint128_t x, const uint128_t y) noexcept { const auto x_bits {bit_width(x)}; const auto y_bits {bit_width(y)}; @@ -150,7 +150,7 @@ BOOST_INT128_EXPORT BOOST_INT128_HOST_DEVICE constexpr uint128_t mul_sat(const u return x * y; } -BOOST_INT128_EXPORT BOOST_INT128_HOST_DEVICE constexpr int128_t mul_sat(const int128_t x, const int128_t y) noexcept +BOOST_INT128_EXPORT BOOST_INT128_HOST_DEVICE constexpr int128_t saturating_mul(const int128_t x, const int128_t y) noexcept { const auto x_bits {bit_width(static_cast(abs(x)))}; const auto y_bits {bit_width(static_cast(abs(y)))}; @@ -171,12 +171,12 @@ BOOST_INT128_EXPORT BOOST_INT128_HOST_DEVICE constexpr int128_t mul_sat(const in return res; } -BOOST_INT128_EXPORT BOOST_INT128_HOST_DEVICE constexpr uint128_t div_sat(const uint128_t x, const uint128_t y) noexcept +BOOST_INT128_EXPORT BOOST_INT128_HOST_DEVICE constexpr uint128_t saturating_div(const uint128_t x, const uint128_t y) noexcept { return x / y; } -BOOST_INT128_EXPORT BOOST_INT128_HOST_DEVICE constexpr int128_t div_sat(const int128_t x, const int128_t y) noexcept +BOOST_INT128_EXPORT BOOST_INT128_HOST_DEVICE constexpr int128_t saturating_div(const int128_t x, const int128_t y) noexcept { if (BOOST_INT128_UNLIKELY(x == (std::numeric_limits::min)() && y == -1)) { @@ -193,7 +193,7 @@ BOOST_INT128_EXPORT BOOST_INT128_HOST_DEVICE constexpr int128_t div_sat(const in #endif BOOST_INT128_EXPORT template , bool> = true> -BOOST_INT128_HOST_DEVICE constexpr TargetType saturate_cast(const uint128_t value) noexcept +BOOST_INT128_HOST_DEVICE constexpr TargetType saturating_cast(const uint128_t value) noexcept { BOOST_INT128_IF_CONSTEXPR (std::is_same::value) { @@ -215,7 +215,7 @@ BOOST_INT128_HOST_DEVICE constexpr TargetType saturate_cast(const uint128_t valu #endif BOOST_INT128_EXPORT template , bool> = true> -BOOST_INT128_HOST_DEVICE constexpr TargetType saturate_cast(const int128_t value) noexcept +BOOST_INT128_HOST_DEVICE constexpr TargetType saturating_cast(const int128_t value) noexcept { BOOST_INT128_IF_CONSTEXPR (std::is_same::value) { diff --git a/test/cuda_jamfile b/test/cuda_jamfile index e7279d01..2c232280 100644 --- a/test/cuda_jamfile +++ b/test/cuda_jamfile @@ -65,14 +65,14 @@ run test_signed_cstdlib_div.cu ; run test_signed_to_unsigned_conversion.cu ; run test_unsigned_to_signed_conversion.cu ; -run test_unsigned_add_sat.cu ; -run test_signed_add_sat.cu ; -run test_unsigned_sub_sat.cu ; -run test_signed_sub_sat.cu ; -run test_unsigned_mul_sat.cu ; -run test_signed_mul_sat.cu ; -run test_unsigned_div_sat.cu ; -run test_signed_div_sat.cu ; +run test_unsigned_saturating_add.cu ; +run test_signed_saturating_add.cu ; +run test_unsigned_saturating_sub.cu ; +run test_signed_saturating_sub.cu ; +run test_unsigned_saturating_mul.cu ; +run test_signed_saturating_mul.cu ; +run test_unsigned_saturating_div.cu ; +run test_signed_saturating_div.cu ; run test_unsigned_gcd.cu ; run test_signed_gcd.cu ; run test_unsigned_lcm.cu ; diff --git a/test/sycl_jamfile b/test/sycl_jamfile index ae480b5d..9c0b3de5 100644 --- a/test/sycl_jamfile +++ b/test/sycl_jamfile @@ -65,14 +65,14 @@ run test_signed_cstdlib_div_sycl.cpp ; run test_signed_to_unsigned_conversion_sycl.cpp ; run test_unsigned_to_signed_conversion_sycl.cpp ; -run test_unsigned_add_sat_sycl.cpp ; -run test_signed_add_sat_sycl.cpp ; -run test_unsigned_sub_sat_sycl.cpp ; -run test_signed_sub_sat_sycl.cpp ; -run test_unsigned_mul_sat_sycl.cpp ; -run test_signed_mul_sat_sycl.cpp ; -run test_unsigned_div_sat_sycl.cpp ; -run test_signed_div_sat_sycl.cpp ; +run test_unsigned_saturating_add_sycl.cpp ; +run test_signed_saturating_add_sycl.cpp ; +run test_unsigned_saturating_sub_sycl.cpp ; +run test_signed_saturating_sub_sycl.cpp ; +run test_unsigned_saturating_mul_sycl.cpp ; +run test_signed_saturating_mul_sycl.cpp ; +run test_unsigned_saturating_div_sycl.cpp ; +run test_signed_saturating_div_sycl.cpp ; run test_unsigned_gcd_sycl.cpp ; run test_signed_gcd_sycl.cpp ; run test_unsigned_lcm_sycl.cpp ; diff --git a/test/test_saturating_arith.cpp b/test/test_saturating_arith.cpp index b1ea52d3..6e790195 100644 --- a/test/test_saturating_arith.cpp +++ b/test/test_saturating_arith.cpp @@ -17,13 +17,13 @@ void test_add_sat(); template <> void test_add_sat() { - using boost::int128::add_sat; + using boost::int128::saturating_add; auto near_max {std::numeric_limits::max() - boost::int128::uint128_t{5}}; for (boost::int128::uint128_t i {0}; i < boost::int128::uint128_t{5}; ++i) { - const auto sat_res {add_sat(near_max, i)}; + const auto sat_res {saturating_add(near_max, i)}; BOOST_TEST(sat_res < std::numeric_limits::max()); const auto res {near_max + i}; @@ -33,7 +33,7 @@ void test_add_sat() near_max += boost::int128::uint128_t{5}; for (boost::int128::uint128_t i {1}; i < boost::int128::uint128_t{5}; ++i) { - const auto sat_res {add_sat(near_max, i)}; + const auto sat_res {saturating_add(near_max, i)}; BOOST_TEST(sat_res == std::numeric_limits::max()); const auto res {near_max + i}; @@ -50,7 +50,7 @@ void test_add_sat() // 3) x > 0 && y < 0 // 4) x <= 0 && y <= 0 - using boost::int128::add_sat; + using boost::int128::saturating_add; constexpr auto min {std::numeric_limits::min()}; constexpr auto max {std::numeric_limits::max()}; @@ -61,7 +61,7 @@ void test_add_sat() for (boost::int128::int128_t i {0}; i < boost::int128::int128_t{5}; ++i) { - const auto sat_res {add_sat(near_max, i)}; + const auto sat_res {saturating_add(near_max, i)}; BOOST_TEST(sat_res < max); const auto res {near_max + i}; @@ -71,7 +71,7 @@ void test_add_sat() near_max += boost::int128::int128_t{5}; for (boost::int128::int128_t i {1}; i < boost::int128::int128_t{5}; ++i) { - const auto sat_res {add_sat(near_max, i)}; + const auto sat_res {saturating_add(near_max, i)}; BOOST_TEST(sat_res == max); } } @@ -93,12 +93,12 @@ void test_add_sat() } const auto naive_res {x + y}; - const auto sat_res {add_sat(x, y)}; + const auto sat_res {saturating_add(x, y)}; BOOST_TEST(naive_res == sat_res); } const auto min_max_naive_res {min + max}; - const auto min_max_sat_res {add_sat(min, max)}; + const auto min_max_sat_res {saturating_add(min, max)}; BOOST_TEST(min_max_naive_res == min_max_sat_res); } @@ -119,12 +119,12 @@ void test_add_sat() } const auto naive_res {x + y}; - const auto sat_res {add_sat(x, y)}; + const auto sat_res {saturating_add(x, y)}; BOOST_TEST(naive_res == sat_res); } const auto min_max_naive_res {max + min}; - const auto min_max_sat_res {add_sat(max, min)}; + const auto min_max_sat_res {saturating_add(max, min)}; BOOST_TEST(min_max_naive_res == min_max_sat_res); } @@ -134,7 +134,7 @@ void test_add_sat() for (boost::int128::int128_t i {0}; i > boost::int128::int128_t{-5}; --i) { - const auto sat_res {add_sat(near_min, i)}; + const auto sat_res {saturating_add(near_min, i)}; BOOST_TEST(sat_res > min); const auto res {near_min + i}; @@ -144,7 +144,7 @@ void test_add_sat() near_min -= boost::int128::int128_t{5}; for (boost::int128::int128_t i {-1}; i > boost::int128::int128_t{-5}; --i) { - const auto sat_res {add_sat(near_min, i)}; + const auto sat_res {saturating_add(near_min, i)}; BOOST_TEST(sat_res == min); } } @@ -156,13 +156,13 @@ void test_sub_sat(); template <> void test_sub_sat() { - using boost::int128::sub_sat; + using boost::int128::saturating_sub; auto near_min {std::numeric_limits::min() + boost::int128::uint128_t{5}}; for (boost::int128::uint128_t i {0}; i < boost::int128::uint128_t{5}; ++i) { - const auto sat_res {sub_sat(near_min, i)}; + const auto sat_res {saturating_sub(near_min, i)}; BOOST_TEST(sat_res > std::numeric_limits::min()); const auto res {near_min - i}; @@ -172,7 +172,7 @@ void test_sub_sat() near_min -= boost::int128::uint128_t{5}; for (boost::int128::uint128_t i {1}; i < boost::int128::uint128_t{5}; ++i) { - const auto sat_res {sub_sat(near_min, i)}; + const auto sat_res {saturating_sub(near_min, i)}; BOOST_TEST(sat_res == std::numeric_limits::min()); const auto res {near_min + i}; @@ -183,14 +183,14 @@ void test_sub_sat() template <> void test_sub_sat() { - // The same as add_sat but the logic backwards + // The same as saturating_add but the logic backwards // There are four branches that need to be tested // 1) x > 0 && y > 0 // 2) x < 0 && y > 0 // 3) x > 0 && y < 0 // 4) x <= 0 && y <= 0 - using boost::int128::sub_sat; + using boost::int128::saturating_sub; constexpr auto min {std::numeric_limits::min()}; constexpr auto max {std::numeric_limits::max()}; @@ -212,12 +212,12 @@ void test_sub_sat() } const auto naive_res {x - y}; - const auto sat_res {sub_sat(x, y)}; + const auto sat_res {saturating_sub(x, y)}; BOOST_TEST(naive_res == sat_res); } const auto min_max_naive_res {max - max}; - const auto min_max_sat_res {sub_sat(max, max)}; + const auto min_max_sat_res {saturating_sub(max, max)}; BOOST_TEST(min_max_naive_res == min_max_sat_res); } @@ -227,7 +227,7 @@ void test_sub_sat() for (boost::int128::int128_t i {0}; i < boost::int128::int128_t{5}; ++i) { - const auto sat_res {sub_sat(near_min, i)}; + const auto sat_res {saturating_sub(near_min, i)}; BOOST_TEST(sat_res > min); const auto res {near_min - i}; @@ -237,7 +237,7 @@ void test_sub_sat() near_min = min; for (boost::int128::int128_t i {1}; i < boost::int128::int128_t{5}; ++i) { - const auto sat_res {sub_sat(near_min, i)}; + const auto sat_res {saturating_sub(near_min, i)}; BOOST_TEST(sat_res == min); // Signed overflow seems to saturate on ARM graviton @@ -254,7 +254,7 @@ void test_sub_sat() for (boost::int128::int128_t i {0}; i > boost::int128::int128_t{-5}; --i) { - const auto sat_res {sub_sat(near_max, i)}; + const auto sat_res {saturating_sub(near_max, i)}; BOOST_TEST(sat_res < max); const auto res {near_max - i}; @@ -264,7 +264,7 @@ void test_sub_sat() near_max += boost::int128::int128_t{5}; for (boost::int128::int128_t i {-1}; i > boost::int128::int128_t{-5}; --i) { - const auto sat_res {sub_sat(near_max, i)}; + const auto sat_res {saturating_sub(near_max, i)}; BOOST_TEST(sat_res == max); } } @@ -286,12 +286,12 @@ void test_sub_sat() } const auto naive_res {x - y}; - const auto sat_res {sub_sat(x, y)}; + const auto sat_res {saturating_sub(x, y)}; BOOST_TEST(naive_res == sat_res); } const auto min_max_naive_res {min - min}; - const auto min_max_sat_res {sub_sat(min, min)}; + const auto min_max_sat_res {saturating_sub(min, min)}; BOOST_TEST(min_max_naive_res == min_max_sat_res); } } @@ -302,7 +302,7 @@ void test_mul_sat(); template <> void test_mul_sat() { - using boost::int128::mul_sat; + using boost::int128::saturating_mul; boost::int128::uint128_t x {2U}; boost::int128::uint128_t y {2U}; @@ -310,7 +310,7 @@ void test_mul_sat() while (bit_count <= 128) { - const auto sat_res {mul_sat(x, y)}; + const auto sat_res {saturating_mul(x, y)}; BOOST_TEST(sat_res < std::numeric_limits::max()); const auto res {x * y}; @@ -324,7 +324,7 @@ void test_mul_sat() while (bit_count < 256) { - const auto sat_res {mul_sat(x, y)}; + const auto sat_res {saturating_mul(x, y)}; BOOST_TEST(sat_res == std::numeric_limits::max()); const auto res {x * y}; @@ -341,7 +341,7 @@ void test_mul_sat() template <> void test_mul_sat() { - using boost::int128::mul_sat; + using boost::int128::saturating_mul; { boost::int128::int128_t x {2}; @@ -350,7 +350,7 @@ void test_mul_sat() while (bit_count < 128) { - const auto sat_res {mul_sat(x, y)}; + const auto sat_res {saturating_mul(x, y)}; BOOST_TEST(sat_res < std::numeric_limits::max()); const auto res {x * y}; @@ -364,7 +364,7 @@ void test_mul_sat() while (bit_count < 254) { - const auto sat_res {mul_sat(x, y)}; + const auto sat_res {saturating_mul(x, y)}; BOOST_TEST(sat_res == std::numeric_limits::max()); const auto res {x * y}; @@ -383,7 +383,7 @@ void test_mul_sat() while (bit_count < 128) { - const auto sat_res {mul_sat(x, y)}; + const auto sat_res {saturating_mul(x, y)}; BOOST_TEST(sat_res < std::numeric_limits::max()); BOOST_TEST(sat_res > std::numeric_limits::min()); @@ -403,7 +403,7 @@ void test_mul_sat() return; // LCOV_EXCL_LINE } - const boost::int128::int128_t sat_res {mul_sat(x, y)}; + const boost::int128::int128_t sat_res {saturating_mul(x, y)}; BOOST_TEST(sat_res == std::numeric_limits::min()); x <<= 1; y *= 2; @@ -419,14 +419,14 @@ void test_div_sat(); template <> void test_div_sat() { - using boost::int128::div_sat; + using boost::int128::saturating_div; for (std::size_t i {}; i < N; ++i) { const boost::int128::uint128_t value1{dist(rng), dist(rng)}; const boost::int128::uint128_t value2{dist(rng), dist(rng)}; - const auto sat_res {div_sat(value1, value2)}; + const auto sat_res {saturating_div(value1, value2)}; const auto res {value1 / value2}; BOOST_TEST(sat_res == res); @@ -436,14 +436,14 @@ void test_div_sat() template <> void test_div_sat() { - using boost::int128::div_sat; + using boost::int128::saturating_div; for (std::size_t i {}; i < N; ++i) { const boost::int128::int128_t value1{signed_dist(rng), dist(rng)}; const boost::int128::int128_t value2{signed_dist(rng), dist(rng)}; - const auto sat_res {div_sat(value1, value2)}; + const auto sat_res {saturating_div(value1, value2)}; const auto res {value1 / value2}; BOOST_TEST(sat_res == res); @@ -451,7 +451,7 @@ void test_div_sat() constexpr auto min_val {std::numeric_limits::min()}; constexpr auto max_val{std::numeric_limits::max()}; - BOOST_TEST(div_sat(min_val, -1) == max_val); + BOOST_TEST(saturating_div(min_val, -1) == max_val); } template @@ -460,38 +460,38 @@ void test_saturate_cast(); template <> void test_saturate_cast() { - using boost::int128::saturate_cast; + using boost::int128::saturating_cast; for (std::size_t i {}; i < N; ++i) { const auto value {dist(rng)}; const boost::int128::uint128_t big_value{value}; - BOOST_TEST(saturate_cast(big_value) == value); - BOOST_TEST(saturate_cast(big_value) == static_cast(big_value)); + BOOST_TEST(saturating_cast(big_value) == value); + BOOST_TEST(saturating_cast(big_value) == static_cast(big_value)); } for (std::size_t i {}; i < N; ++i) { const auto value {dist(rng)}; const boost::int128::uint128_t big_value{value, value}; - BOOST_TEST(saturate_cast(big_value) == std::numeric_limits::max()); - BOOST_TEST(saturate_cast(big_value) != static_cast(big_value)); + BOOST_TEST(saturating_cast(big_value) == std::numeric_limits::max()); + BOOST_TEST(saturating_cast(big_value) != static_cast(big_value)); } } template <> void test_saturate_cast() { - using boost::int128::saturate_cast; + using boost::int128::saturating_cast; for (std::size_t i {}; i < N; ++i) { const auto value {signed_dist(rng)}; const boost::int128::int128_t big_value{value}; - BOOST_TEST(saturate_cast(big_value) == value); - BOOST_TEST(saturate_cast(big_value) == static_cast(big_value)); + BOOST_TEST(saturating_cast(big_value) == value); + BOOST_TEST(saturating_cast(big_value) == static_cast(big_value)); } for (std::size_t i {}; i < N; ++i) @@ -502,11 +502,11 @@ void test_saturate_cast() if (hi_word > 0) { - BOOST_TEST(saturate_cast(big_value) == std::numeric_limits::max()); + BOOST_TEST(saturating_cast(big_value) == std::numeric_limits::max()); } else { - BOOST_TEST(saturate_cast(big_value) == std::numeric_limits::min()); + BOOST_TEST(saturating_cast(big_value) == std::numeric_limits::min()); } } } diff --git a/test/test_signed_add_sat.cu b/test/test_signed_saturating_add.cu similarity index 95% rename from test/test_signed_add_sat.cu rename to test/test_signed_saturating_add.cu index aef72c4b..3f1b8081 100644 --- a/test/test_signed_add_sat.cu +++ b/test/test_signed_saturating_add.cu @@ -24,7 +24,7 @@ __global__ void cuda_test(const test_type *in, const test_type *in2, test_type * if (i < numElements) { - out[i] = boost::int128::add_sat(in[i], in2[i]); + out[i] = boost::int128::saturating_add(in[i], in2[i]); } } @@ -71,7 +71,7 @@ int main(void) w.reset(); for (int i = 0; i < numElements; ++i) { - results.push_back(boost::int128::add_sat(input_vector[i], input_vector2[i])); + results.push_back(boost::int128::saturating_add(input_vector[i], input_vector2[i])); } double t = w.elapsed(); diff --git a/test/test_signed_mul_sat_sycl.cpp b/test/test_signed_saturating_add_sycl.cpp similarity index 92% rename from test/test_signed_mul_sat_sycl.cpp rename to test/test_signed_saturating_add_sycl.cpp index 920e07ca..91bdb58b 100644 --- a/test/test_signed_mul_sat_sycl.cpp +++ b/test/test_signed_saturating_add_sycl.cpp @@ -9,5 +9,5 @@ using boost::int128::int128_t; int main() { return int128_sycl_test::run( - [](int128_t a, int128_t b, int) { return boost::int128::mul_sat(a, b); }); + [](int128_t a, int128_t b, int) { return boost::int128::saturating_add(a, b); }); } diff --git a/test/test_signed_div_sat.cu b/test/test_signed_saturating_div.cu similarity index 94% rename from test/test_signed_div_sat.cu rename to test/test_signed_saturating_div.cu index 27ab307f..7753deff 100644 --- a/test/test_signed_div_sat.cu +++ b/test/test_signed_saturating_div.cu @@ -24,7 +24,7 @@ __global__ void cuda_test(const test_type *in, const test_type *in2, test_type * if (i < numElements) { - out[i] = boost::int128::div_sat(in[i], in2[i]); + out[i] = boost::int128::saturating_div(in[i], in2[i]); } } @@ -74,7 +74,7 @@ int main(void) w.reset(); for (int i = 0; i < numElements; ++i) { - results.push_back(boost::int128::div_sat(input_vector[i], input_vector2[i])); + results.push_back(boost::int128::saturating_div(input_vector[i], input_vector2[i])); } double t = w.elapsed(); diff --git a/test/test_signed_div_sat_sycl.cpp b/test/test_signed_saturating_div_sycl.cpp similarity index 84% rename from test/test_signed_div_sat_sycl.cpp rename to test/test_signed_saturating_div_sycl.cpp index 3eddd6c2..2b94634d 100644 --- a/test/test_signed_div_sat_sycl.cpp +++ b/test/test_signed_saturating_div_sycl.cpp @@ -9,5 +9,5 @@ using boost::int128::int128_t; int main() { return int128_sycl_test::run( - [](int128_t a, int128_t b, int) { return boost::int128::div_sat(a, int128_sycl_test::safe_divisor(a, b)); }); + [](int128_t a, int128_t b, int) { return boost::int128::saturating_div(a, int128_sycl_test::safe_divisor(a, b)); }); } diff --git a/test/test_signed_mul_sat.cu b/test/test_signed_saturating_mul.cu similarity index 94% rename from test/test_signed_mul_sat.cu rename to test/test_signed_saturating_mul.cu index ce1e4f1b..264deb82 100644 --- a/test/test_signed_mul_sat.cu +++ b/test/test_signed_saturating_mul.cu @@ -24,7 +24,7 @@ __global__ void cuda_test(const test_type *in, const test_type *in2, test_type * if (i < numElements) { - out[i] = boost::int128::mul_sat(in[i], in2[i]); + out[i] = boost::int128::saturating_mul(in[i], in2[i]); } } @@ -71,7 +71,7 @@ int main(void) w.reset(); for (int i = 0; i < numElements; ++i) { - results.push_back(boost::int128::mul_sat(input_vector[i], input_vector2[i])); + results.push_back(boost::int128::saturating_mul(input_vector[i], input_vector2[i])); } double t = w.elapsed(); diff --git a/test/test_signed_add_sat_sycl.cpp b/test/test_signed_saturating_mul_sycl.cpp similarity index 92% rename from test/test_signed_add_sat_sycl.cpp rename to test/test_signed_saturating_mul_sycl.cpp index c60c4599..6a77bcf7 100644 --- a/test/test_signed_add_sat_sycl.cpp +++ b/test/test_signed_saturating_mul_sycl.cpp @@ -9,5 +9,5 @@ using boost::int128::int128_t; int main() { return int128_sycl_test::run( - [](int128_t a, int128_t b, int) { return boost::int128::add_sat(a, b); }); + [](int128_t a, int128_t b, int) { return boost::int128::saturating_mul(a, b); }); } diff --git a/test/test_signed_sub_sat.cu b/test/test_signed_saturating_sub.cu similarity index 94% rename from test/test_signed_sub_sat.cu rename to test/test_signed_saturating_sub.cu index aac56f0c..26ec3fd5 100644 --- a/test/test_signed_sub_sat.cu +++ b/test/test_signed_saturating_sub.cu @@ -24,7 +24,7 @@ __global__ void cuda_test(const test_type *in, const test_type *in2, test_type * if (i < numElements) { - out[i] = boost::int128::sub_sat(in[i], in2[i]); + out[i] = boost::int128::saturating_sub(in[i], in2[i]); } } @@ -71,7 +71,7 @@ int main(void) w.reset(); for (int i = 0; i < numElements; ++i) { - results.push_back(boost::int128::sub_sat(input_vector[i], input_vector2[i])); + results.push_back(boost::int128::saturating_sub(input_vector[i], input_vector2[i])); } double t = w.elapsed(); diff --git a/test/test_signed_sub_sat_sycl.cpp b/test/test_signed_saturating_sub_sycl.cpp similarity index 92% rename from test/test_signed_sub_sat_sycl.cpp rename to test/test_signed_saturating_sub_sycl.cpp index c4f90682..21decc2a 100644 --- a/test/test_signed_sub_sat_sycl.cpp +++ b/test/test_signed_saturating_sub_sycl.cpp @@ -9,5 +9,5 @@ using boost::int128::int128_t; int main() { return int128_sycl_test::run( - [](int128_t a, int128_t b, int) { return boost::int128::sub_sat(a, b); }); + [](int128_t a, int128_t b, int) { return boost::int128::saturating_sub(a, b); }); } diff --git a/test/test_unsigned_add_sat.cu b/test/test_unsigned_saturating_add.cu similarity index 94% rename from test/test_unsigned_add_sat.cu rename to test/test_unsigned_saturating_add.cu index 57b5d43e..50faed85 100644 --- a/test/test_unsigned_add_sat.cu +++ b/test/test_unsigned_saturating_add.cu @@ -24,7 +24,7 @@ __global__ void cuda_test(const test_type *in, const test_type *in2, test_type * if (i < numElements) { - out[i] = boost::int128::add_sat(in[i], in2[i]); + out[i] = boost::int128::saturating_add(in[i], in2[i]); } } @@ -71,7 +71,7 @@ int main(void) w.reset(); for (int i = 0; i < numElements; ++i) { - results.push_back(boost::int128::add_sat(input_vector[i], input_vector2[i])); + results.push_back(boost::int128::saturating_add(input_vector[i], input_vector2[i])); } double t = w.elapsed(); diff --git a/test/test_unsigned_mul_sat_sycl.cpp b/test/test_unsigned_saturating_add_sycl.cpp similarity index 92% rename from test/test_unsigned_mul_sat_sycl.cpp rename to test/test_unsigned_saturating_add_sycl.cpp index 86505059..02a4ca84 100644 --- a/test/test_unsigned_mul_sat_sycl.cpp +++ b/test/test_unsigned_saturating_add_sycl.cpp @@ -9,5 +9,5 @@ using boost::int128::uint128_t; int main() { return int128_sycl_test::run( - [](uint128_t a, uint128_t b, int) { return boost::int128::mul_sat(a, b); }); + [](uint128_t a, uint128_t b, int) { return boost::int128::saturating_add(a, b); }); } diff --git a/test/test_unsigned_div_sat.cu b/test/test_unsigned_saturating_div.cu similarity index 94% rename from test/test_unsigned_div_sat.cu rename to test/test_unsigned_saturating_div.cu index c6a69fb9..1925dd26 100644 --- a/test/test_unsigned_div_sat.cu +++ b/test/test_unsigned_saturating_div.cu @@ -24,7 +24,7 @@ __global__ void cuda_test(const test_type *in, const test_type *in2, test_type * if (i < numElements) { - out[i] = boost::int128::div_sat(in[i], in2[i]); + out[i] = boost::int128::saturating_div(in[i], in2[i]); } } @@ -71,7 +71,7 @@ int main(void) w.reset(); for (int i = 0; i < numElements; ++i) { - results.push_back(boost::int128::div_sat(input_vector[i], input_vector2[i])); + results.push_back(boost::int128::saturating_div(input_vector[i], input_vector2[i])); } double t = w.elapsed(); diff --git a/test/test_unsigned_div_sat_sycl.cpp b/test/test_unsigned_saturating_div_sycl.cpp similarity index 84% rename from test/test_unsigned_div_sat_sycl.cpp rename to test/test_unsigned_saturating_div_sycl.cpp index b7fdd633..83f08209 100644 --- a/test/test_unsigned_div_sat_sycl.cpp +++ b/test/test_unsigned_saturating_div_sycl.cpp @@ -9,5 +9,5 @@ using boost::int128::uint128_t; int main() { return int128_sycl_test::run( - [](uint128_t a, uint128_t b, int) { return boost::int128::div_sat(a, int128_sycl_test::safe_divisor(a, b)); }); + [](uint128_t a, uint128_t b, int) { return boost::int128::saturating_div(a, int128_sycl_test::safe_divisor(a, b)); }); } diff --git a/test/test_unsigned_mul_sat.cu b/test/test_unsigned_saturating_mul.cu similarity index 94% rename from test/test_unsigned_mul_sat.cu rename to test/test_unsigned_saturating_mul.cu index 81a125fe..b619cc6f 100644 --- a/test/test_unsigned_mul_sat.cu +++ b/test/test_unsigned_saturating_mul.cu @@ -24,7 +24,7 @@ __global__ void cuda_test(const test_type *in, const test_type *in2, test_type * if (i < numElements) { - out[i] = boost::int128::mul_sat(in[i], in2[i]); + out[i] = boost::int128::saturating_mul(in[i], in2[i]); } } @@ -71,7 +71,7 @@ int main(void) w.reset(); for (int i = 0; i < numElements; ++i) { - results.push_back(boost::int128::mul_sat(input_vector[i], input_vector2[i])); + results.push_back(boost::int128::saturating_mul(input_vector[i], input_vector2[i])); } double t = w.elapsed(); diff --git a/test/test_unsigned_sub_sat_sycl.cpp b/test/test_unsigned_saturating_mul_sycl.cpp similarity index 92% rename from test/test_unsigned_sub_sat_sycl.cpp rename to test/test_unsigned_saturating_mul_sycl.cpp index 1e731c77..49412e43 100644 --- a/test/test_unsigned_sub_sat_sycl.cpp +++ b/test/test_unsigned_saturating_mul_sycl.cpp @@ -9,5 +9,5 @@ using boost::int128::uint128_t; int main() { return int128_sycl_test::run( - [](uint128_t a, uint128_t b, int) { return boost::int128::sub_sat(a, b); }); + [](uint128_t a, uint128_t b, int) { return boost::int128::saturating_mul(a, b); }); } diff --git a/test/test_unsigned_sub_sat.cu b/test/test_unsigned_saturating_sub.cu similarity index 94% rename from test/test_unsigned_sub_sat.cu rename to test/test_unsigned_saturating_sub.cu index 71856613..d3fd7dcf 100644 --- a/test/test_unsigned_sub_sat.cu +++ b/test/test_unsigned_saturating_sub.cu @@ -24,7 +24,7 @@ __global__ void cuda_test(const test_type *in, const test_type *in2, test_type * if (i < numElements) { - out[i] = boost::int128::sub_sat(in[i], in2[i]); + out[i] = boost::int128::saturating_sub(in[i], in2[i]); } } @@ -71,7 +71,7 @@ int main(void) w.reset(); for (int i = 0; i < numElements; ++i) { - results.push_back(boost::int128::sub_sat(input_vector[i], input_vector2[i])); + results.push_back(boost::int128::saturating_sub(input_vector[i], input_vector2[i])); } double t = w.elapsed(); diff --git a/test/test_unsigned_add_sat_sycl.cpp b/test/test_unsigned_saturating_sub_sycl.cpp similarity index 92% rename from test/test_unsigned_add_sat_sycl.cpp rename to test/test_unsigned_saturating_sub_sycl.cpp index 8157fd84..e0247ea2 100644 --- a/test/test_unsigned_add_sat_sycl.cpp +++ b/test/test_unsigned_saturating_sub_sycl.cpp @@ -9,5 +9,5 @@ using boost::int128::uint128_t; int main() { return int128_sycl_test::run( - [](uint128_t a, uint128_t b, int) { return boost::int128::add_sat(a, b); }); + [](uint128_t a, uint128_t b, int) { return boost::int128::saturating_sub(a, b); }); }