https://gcc.gnu.org/g:c9525a790291bb924ac5d9887dd1f57e76a66a03
commit r16-8385-gc9525a790291bb924ac5d9887dd1f57e76a66a03 Author: Jonathan Wakely <[email protected]> Date: Mon Mar 30 12:13:39 2026 +0100 libstdc++: Rename saturation arithmetic for C++26 (P4052R0) Last week in Croydon we approved P4052R0 to rename std::add_sat etc. for C++26 libstdc++-v3/ChangeLog: * include/bits/sat_arith.h (add_sat, sub_sat, mul_sat, div_sat) (saturate_cast): Rename to saturating_xxx as per P4052R0. * include/bits/version.def (saturation_arithmetic): Bump value. * include/bits/version.h: Regenerate. * testsuite/26_numerics/saturation/add.cc: Use new name. * testsuite/26_numerics/saturation/cast.cc: Likewise. * testsuite/26_numerics/saturation/div.cc: Likewise. * testsuite/26_numerics/saturation/extended.cc: Likewise. * testsuite/26_numerics/saturation/mul.cc: Likewise. * testsuite/26_numerics/saturation/sub.cc: Likewise. * testsuite/26_numerics/saturation/version.cc: Check for updated value. Reviewed-by: Tomasz Kamiński <[email protected]> Diff: --- libstdc++-v3/include/bits/sat_arith.h | 10 +- libstdc++-v3/include/bits/version.def | 2 +- libstdc++-v3/include/bits/version.h | 4 +- .../testsuite/26_numerics/saturation/add.cc | 82 ++++++++-------- .../testsuite/26_numerics/saturation/cast.cc | 30 +++--- .../testsuite/26_numerics/saturation/div.cc | 40 ++++---- .../testsuite/26_numerics/saturation/extended.cc | 32 +++--- .../testsuite/26_numerics/saturation/mul.cc | 38 ++++---- .../testsuite/26_numerics/saturation/sub.cc | 108 ++++++++++----------- .../testsuite/26_numerics/saturation/version.cc | 4 +- 10 files changed, 175 insertions(+), 175 deletions(-) diff --git a/libstdc++-v3/include/bits/sat_arith.h b/libstdc++-v3/include/bits/sat_arith.h index bce86d919919..7f0149de0ecf 100644 --- a/libstdc++-v3/include/bits/sat_arith.h +++ b/libstdc++-v3/include/bits/sat_arith.h @@ -48,7 +48,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// Add two integers, with saturation in case of overflow. template<typename _Tp> requires __is_signed_or_unsigned_integer<_Tp>::value constexpr _Tp - add_sat(_Tp __x, _Tp __y) noexcept + saturating_add(_Tp __x, _Tp __y) noexcept { _Tp __z; if (!__builtin_add_overflow(__x, __y, &__z)) @@ -64,7 +64,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// Subtract one integer from another, with saturation in case of overflow. template<typename _Tp> requires __is_signed_or_unsigned_integer<_Tp>::value constexpr _Tp - sub_sat(_Tp __x, _Tp __y) noexcept + saturating_sub(_Tp __x, _Tp __y) noexcept { _Tp __z; if (!__builtin_sub_overflow(__x, __y, &__z)) @@ -80,7 +80,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// Multiply two integers, with saturation in case of overflow. template<typename _Tp> requires __is_signed_or_unsigned_integer<_Tp>::value constexpr _Tp - mul_sat(_Tp __x, _Tp __y) noexcept + saturating_mul(_Tp __x, _Tp __y) noexcept { _Tp __z; if (!__builtin_mul_overflow(__x, __y, &__z)) @@ -96,7 +96,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// Divide one integer by another, with saturation in case of overflow. template<typename _Tp> requires __is_signed_or_unsigned_integer<_Tp>::value constexpr _Tp - div_sat(_Tp __x, _Tp __y) noexcept + saturating_div(_Tp __x, _Tp __y) noexcept { __glibcxx_assert(__y != 0); if constexpr (is_signed_v<_Tp>) @@ -110,7 +110,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION requires __is_signed_or_unsigned_integer<_Res>::value && __is_signed_or_unsigned_integer<_Tp>::value constexpr _Res - saturate_cast(_Tp __x) noexcept + saturating_cast(_Tp __x) noexcept { constexpr int __digits_R = __gnu_cxx::__int_traits<_Res>::__digits; constexpr int __digits_T = __gnu_cxx::__int_traits<_Tp>::__digits; diff --git a/libstdc++-v3/include/bits/version.def b/libstdc++-v3/include/bits/version.def index bb513e391d76..8c9ec854d3b2 100644 --- a/libstdc++-v3/include/bits/version.def +++ b/libstdc++-v3/include/bits/version.def @@ -2157,7 +2157,7 @@ ftms = { ftms = { name = saturation_arithmetic; values = { - v = 202311; + v = 202603; cxxmin = 26; }; }; diff --git a/libstdc++-v3/include/bits/version.h b/libstdc++-v3/include/bits/version.h index e469944208a7..836aae02d773 100644 --- a/libstdc++-v3/include/bits/version.h +++ b/libstdc++-v3/include/bits/version.h @@ -2418,9 +2418,9 @@ #if !defined(__cpp_lib_saturation_arithmetic) # if (__cplusplus > 202302L) -# define __glibcxx_saturation_arithmetic 202311L +# define __glibcxx_saturation_arithmetic 202603L # if defined(__glibcxx_want_all) || defined(__glibcxx_want_saturation_arithmetic) -# define __cpp_lib_saturation_arithmetic 202311L +# define __cpp_lib_saturation_arithmetic 202603L # endif # endif #endif /* !defined(__cpp_lib_saturation_arithmetic) */ diff --git a/libstdc++-v3/testsuite/26_numerics/saturation/add.cc b/libstdc++-v3/testsuite/26_numerics/saturation/add.cc index 3eee6abca9a1..2695f7296112 100644 --- a/libstdc++-v3/testsuite/26_numerics/saturation/add.cc +++ b/libstdc++-v3/testsuite/26_numerics/saturation/add.cc @@ -7,67 +7,67 @@ template<typename T, typename U> concept can_add_sat - = requires(T t, U u) { { std::add_sat(t, u) } -> std::same_as<T>; }; + = requires(T t, U u) { { std::saturating_add(t, u) } -> std::same_as<T>; }; static_assert( can_add_sat<int, int> ); static_assert( not can_add_sat<int, short> ); static_assert( not can_add_sat<unsigned, int> ); -static_assert( noexcept(std::add_sat(0, 0)) ); +static_assert( noexcept(std::saturating_add(0, 0)) ); -using std::add_sat; +using std::saturating_add; // Signed type -static_assert(add_sat(0, 0) == 0); -static_assert(add_sat(1, 1) == 2); -static_assert(add_sat(-1, -1) == -2); -static_assert(add_sat(-1, 1) == 0); +static_assert(saturating_add(0, 0) == 0); +static_assert(saturating_add(1, 1) == 2); +static_assert(saturating_add(-1, -1) == -2); +static_assert(saturating_add(-1, 1) == 0); constexpr auto max = std::numeric_limits<int>::max(); constexpr auto min = std::numeric_limits<int>::min(); -static_assert(add_sat(max, 1) == max); -static_assert(add_sat(1, max) == max); -static_assert(add_sat(max, max) == max); -static_assert(add_sat(min, -1) == min); -static_assert(add_sat(-1, min) == min); -static_assert(add_sat(min, min) == min); -static_assert(add_sat(max, min) == -1); -static_assert(add_sat(min, max) == -1); +static_assert(saturating_add(max, 1) == max); +static_assert(saturating_add(1, max) == max); +static_assert(saturating_add(max, max) == max); +static_assert(saturating_add(min, -1) == min); +static_assert(saturating_add(-1, min) == min); +static_assert(saturating_add(min, min) == min); +static_assert(saturating_add(max, min) == -1); +static_assert(saturating_add(min, max) == -1); // Wider signed type than the args -static_assert(add_sat<long long>(max, max) == (long long)max * 2); -static_assert(add_sat<long long>(min, min) == (long long)min * 2); +static_assert(saturating_add<long long>(max, max) == (long long)max * 2); +static_assert(saturating_add<long long>(min, min) == (long long)min * 2); // Signed type that undergoes integer promotion constexpr auto shrt_max = std::numeric_limits<short>::max(); constexpr auto shrt_min = std::numeric_limits<short>::min(); -static_assert(add_sat<short>(0, 0) == 0); -static_assert(add_sat<short>(1, 1) == 2); -static_assert(add_sat<short>(shrt_max, shrt_max) == shrt_max); -static_assert(add_sat<short>(shrt_max, 1) == shrt_max); -static_assert(add_sat<short>(1, shrt_max) == shrt_max); -static_assert(add_sat<short>(shrt_min, (short)-1) == shrt_min); -static_assert(add_sat<short>((short)-1, shrt_min) == shrt_min); -static_assert(add_sat<short>(shrt_min, (short)1) == -shrt_max); -static_assert(add_sat<short>((short)1, shrt_min) == -shrt_max); +static_assert(saturating_add<short>(0, 0) == 0); +static_assert(saturating_add<short>(1, 1) == 2); +static_assert(saturating_add<short>(shrt_max, shrt_max) == shrt_max); +static_assert(saturating_add<short>(shrt_max, 1) == shrt_max); +static_assert(saturating_add<short>(1, shrt_max) == shrt_max); +static_assert(saturating_add<short>(shrt_min, (short)-1) == shrt_min); +static_assert(saturating_add<short>((short)-1, shrt_min) == shrt_min); +static_assert(saturating_add<short>(shrt_min, (short)1) == -shrt_max); +static_assert(saturating_add<short>((short)1, shrt_min) == -shrt_max); // Unsigned type -static_assert(add_sat(0u, 0u) == 0u); -static_assert(add_sat(1u, 1u) == 2u); +static_assert(saturating_add(0u, 0u) == 0u); +static_assert(saturating_add(1u, 1u) == 2u); constexpr auto umax = std::numeric_limits<unsigned>::max(); -static_assert(add_sat(umax, 1u) == umax); -static_assert(add_sat(1u, umax) == umax); -static_assert(add_sat(umax, umax) == umax); -static_assert(add_sat(0u, umax) == umax); -static_assert(add_sat(umax, 0u) == umax); -static_assert(add_sat(0u, 1u) == 1u); -static_assert(add_sat(1u, 0u) == 1u); +static_assert(saturating_add(umax, 1u) == umax); +static_assert(saturating_add(1u, umax) == umax); +static_assert(saturating_add(umax, umax) == umax); +static_assert(saturating_add(0u, umax) == umax); +static_assert(saturating_add(umax, 0u) == umax); +static_assert(saturating_add(0u, 1u) == 1u); +static_assert(saturating_add(1u, 0u) == 1u); // Wider unsigned type than the args -static_assert(add_sat<unsigned long long>(umax, umax) == (long long)umax * 2); +static_assert(saturating_add<unsigned long long>(umax, umax) == (long long)umax * 2); // Unsigned type that undergoes integer promotion constexpr auto ushrt_max = std::numeric_limits<unsigned short>::max(); -static_assert(add_sat<unsigned short>(0, 0) == 0); -static_assert(add_sat<unsigned short>(1, 1) == 2); -static_assert(add_sat<unsigned short>(ushrt_max, ushrt_max) == ushrt_max); -static_assert(add_sat<unsigned short>(ushrt_max, 1) == ushrt_max); -static_assert(add_sat<unsigned short>(1, ushrt_max) == ushrt_max); +static_assert(saturating_add<unsigned short>(0, 0) == 0); +static_assert(saturating_add<unsigned short>(1, 1) == 2); +static_assert(saturating_add<unsigned short>(ushrt_max, ushrt_max) == ushrt_max); +static_assert(saturating_add<unsigned short>(ushrt_max, 1) == ushrt_max); +static_assert(saturating_add<unsigned short>(1, ushrt_max) == ushrt_max); diff --git a/libstdc++-v3/testsuite/26_numerics/saturation/cast.cc b/libstdc++-v3/testsuite/26_numerics/saturation/cast.cc index 672e9c46be1c..e23d727bdb68 100644 --- a/libstdc++-v3/testsuite/26_numerics/saturation/cast.cc +++ b/libstdc++-v3/testsuite/26_numerics/saturation/cast.cc @@ -6,19 +6,19 @@ #include <climits> #if CHAR_BIT == 8 -static_assert(std::saturate_cast<unsigned char>(999) == 255); -static_assert(std::saturate_cast<signed char>(999) == 127); +static_assert(std::saturating_cast<unsigned char>(999) == 255); +static_assert(std::saturating_cast<signed char>(999) == 127); #endif -static_assert(std::saturate_cast<unsigned short>(999) == 999); -static_assert(std::saturate_cast<signed short>(999) == 999); -static_assert(std::saturate_cast<short>(INT_MAX) == SHRT_MAX); -static_assert(std::saturate_cast<short>(UINT_MAX) == SHRT_MAX); -static_assert(std::saturate_cast<short>(UINT_MAX) == SHRT_MAX); -static_assert(std::saturate_cast<unsigned short>(UINT_MAX) == USHRT_MAX); -static_assert(std::saturate_cast<int>(UINT_MAX) == INT_MAX); -static_assert(std::saturate_cast<int>(INT_MAX) == INT_MAX); -static_assert(std::saturate_cast<unsigned>(-1) == 0); -static_assert(std::saturate_cast<unsigned>(INT_MIN) == 0); -static_assert(std::saturate_cast<unsigned>(UINT_MAX) == UINT_MAX); -static_assert(std::saturate_cast<unsigned>(LLONG_MAX) == UINT_MAX); -static_assert(std::saturate_cast<unsigned>(ULLONG_MAX) == UINT_MAX); +static_assert(std::saturating_cast<unsigned short>(999) == 999); +static_assert(std::saturating_cast<signed short>(999) == 999); +static_assert(std::saturating_cast<short>(INT_MAX) == SHRT_MAX); +static_assert(std::saturating_cast<short>(UINT_MAX) == SHRT_MAX); +static_assert(std::saturating_cast<short>(UINT_MAX) == SHRT_MAX); +static_assert(std::saturating_cast<unsigned short>(UINT_MAX) == USHRT_MAX); +static_assert(std::saturating_cast<int>(UINT_MAX) == INT_MAX); +static_assert(std::saturating_cast<int>(INT_MAX) == INT_MAX); +static_assert(std::saturating_cast<unsigned>(-1) == 0); +static_assert(std::saturating_cast<unsigned>(INT_MIN) == 0); +static_assert(std::saturating_cast<unsigned>(UINT_MAX) == UINT_MAX); +static_assert(std::saturating_cast<unsigned>(LLONG_MAX) == UINT_MAX); +static_assert(std::saturating_cast<unsigned>(ULLONG_MAX) == UINT_MAX); diff --git a/libstdc++-v3/testsuite/26_numerics/saturation/div.cc b/libstdc++-v3/testsuite/26_numerics/saturation/div.cc index a3f43573651a..71d4970d632d 100644 --- a/libstdc++-v3/testsuite/26_numerics/saturation/div.cc +++ b/libstdc++-v3/testsuite/26_numerics/saturation/div.cc @@ -7,32 +7,32 @@ template<typename T, typename U> concept can_div_sat - = requires(T t, U u) { { std::div_sat(t, u) } -> std::same_as<T>; }; + = requires(T t, U u) { { std::saturating_div(t, u) } -> std::same_as<T>; }; static_assert( can_div_sat<int, int> ); static_assert( not can_div_sat<int, short> ); static_assert( not can_div_sat<unsigned, int> ); -static_assert( noexcept(std::div_sat(0, 1)) ); - -using std::div_sat; - -static_assert(std::div_sat(0, 1) == 0); -static_assert(std::div_sat(0, -1) == 0); -static_assert(std::div_sat(1, -1) == -1); -static_assert(std::div_sat(10, -2) == -5); -static_assert(std::div_sat(-10, -2) == 5); -static_assert(std::div_sat(INT_MAX, 1) == INT_MAX); -static_assert(std::div_sat(INT_MIN, 1) == INT_MIN); -static_assert(std::div_sat(INT_MIN + 1, -1) == INT_MAX); -static_assert(std::div_sat(0u, 1u) == 0u); -static_assert(std::div_sat(UINT_MAX, 1u) == UINT_MAX); -static_assert(std::div_sat(INT_MIN, -1) == INT_MAX); -static_assert(std::div_sat((short)SHRT_MIN, (short)-1) == SHRT_MAX); -static_assert(std::div_sat(LONG_MIN, -1L) == LONG_MAX); -static_assert(std::div_sat(LLONG_MIN, -1LL) == LLONG_MAX); +static_assert( noexcept(std::saturating_div(0, 1)) ); + +using std::saturating_div; + +static_assert(std::saturating_div(0, 1) == 0); +static_assert(std::saturating_div(0, -1) == 0); +static_assert(std::saturating_div(1, -1) == -1); +static_assert(std::saturating_div(10, -2) == -5); +static_assert(std::saturating_div(-10, -2) == 5); +static_assert(std::saturating_div(INT_MAX, 1) == INT_MAX); +static_assert(std::saturating_div(INT_MIN, 1) == INT_MIN); +static_assert(std::saturating_div(INT_MIN + 1, -1) == INT_MAX); +static_assert(std::saturating_div(0u, 1u) == 0u); +static_assert(std::saturating_div(UINT_MAX, 1u) == UINT_MAX); +static_assert(std::saturating_div(INT_MIN, -1) == INT_MAX); +static_assert(std::saturating_div((short)SHRT_MIN, (short)-1) == SHRT_MAX); +static_assert(std::saturating_div(LONG_MIN, -1L) == LONG_MAX); +static_assert(std::saturating_div(LLONG_MIN, -1LL) == LLONG_MAX); template<auto N> -std::integral_constant<decltype(N), std::div_sat(N, N-N)> +std::integral_constant<decltype(N), std::saturating_div(N, N-N)> div_sat_by_zero(); template<auto N> diff --git a/libstdc++-v3/testsuite/26_numerics/saturation/extended.cc b/libstdc++-v3/testsuite/26_numerics/saturation/extended.cc index fbef62826c23..8095a32d01f2 100644 --- a/libstdc++-v3/testsuite/26_numerics/saturation/extended.cc +++ b/libstdc++-v3/testsuite/26_numerics/saturation/extended.cc @@ -14,22 +14,22 @@ test() constexpr S smin = std::numeric_limits<S>::min(); constexpr U umax = std::numeric_limits<U>::max(); - static_assert( std::add_sat(smax, (S)1) == smax ); - static_assert( std::add_sat(smin, (S)-2) == smin ); - static_assert( std::add_sat(umax, (U)3) == umax ); - - static_assert( std::sub_sat(smax, (S)-1) == smax ); - static_assert( std::sub_sat(smin, (S)2) == smin ); - static_assert( std::sub_sat((U)0, (U)3) == (U)0 ); - - static_assert( std::mul_sat((S)(smax >> 1), (S)3) == smax ); - static_assert( std::mul_sat((S)(smin >> 1), (S)5) == smin ); - static_assert( std::mul_sat((U)(umax >> 1), (U)7) == umax ); - - static_assert( std::div_sat(smax, (S)2) == (smax >> 1) ); - static_assert( std::div_sat(smin, (S)4) == (smin >> 2) ); - static_assert( std::div_sat(smin, (S)-1) == smax ); - static_assert( std::div_sat(umax, (U)8) == (umax >> 3) ); + static_assert( std::saturating_add(smax, (S)1) == smax ); + static_assert( std::saturating_add(smin, (S)-2) == smin ); + static_assert( std::saturating_add(umax, (U)3) == umax ); + + static_assert( std::saturating_sub(smax, (S)-1) == smax ); + static_assert( std::saturating_sub(smin, (S)2) == smin ); + static_assert( std::saturating_sub((U)0, (U)3) == (U)0 ); + + static_assert( std::saturating_mul((S)(smax >> 1), (S)3) == smax ); + static_assert( std::saturating_mul((S)(smin >> 1), (S)5) == smin ); + static_assert( std::saturating_mul((U)(umax >> 1), (U)7) == umax ); + + static_assert( std::saturating_div(smax, (S)2) == (smax >> 1) ); + static_assert( std::saturating_div(smin, (S)4) == (smin >> 2) ); + static_assert( std::saturating_div(smin, (S)-1) == smax ); + static_assert( std::saturating_div(umax, (U)8) == (umax >> 3) ); return true; } diff --git a/libstdc++-v3/testsuite/26_numerics/saturation/mul.cc b/libstdc++-v3/testsuite/26_numerics/saturation/mul.cc index 1b5538c9af3b..ea8ca2e76522 100644 --- a/libstdc++-v3/testsuite/26_numerics/saturation/mul.cc +++ b/libstdc++-v3/testsuite/26_numerics/saturation/mul.cc @@ -7,28 +7,28 @@ template<typename T, typename U> concept can_mul_sat - = requires(T t, U u) { { std::mul_sat(t, u) } -> std::same_as<T>; }; + = requires(T t, U u) { { std::saturating_mul(t, u) } -> std::same_as<T>; }; static_assert( can_mul_sat<int, int> ); static_assert( not can_mul_sat<int, short> ); static_assert( not can_mul_sat<unsigned, int> ); -static_assert( noexcept(std::mul_sat(0, 0)) ); +static_assert( noexcept(std::saturating_mul(0, 0)) ); -using std::mul_sat; +using std::saturating_mul; -static_assert(mul_sat(1, 1) == 1); -static_assert(mul_sat(10, 11) == 110); -static_assert(mul_sat(INT_MAX / 2, 3) == INT_MAX); -static_assert(mul_sat(INT_MAX / 2, -3) == INT_MIN); -static_assert(mul_sat(INT_MAX / -2, 3) == INT_MIN); -static_assert(mul_sat(INT_MIN / 2, -3) == INT_MAX); -static_assert(mul_sat(INT_MIN, -1) == INT_MAX); -static_assert(mul_sat(INT_MAX, -1) == INT_MIN + 1); -static_assert(mul_sat(INT_MAX, INT_MAX) == INT_MAX); -static_assert(mul_sat(INT_MAX, -INT_MAX) == INT_MIN); -static_assert(mul_sat(UINT_MAX, UINT_MAX) == UINT_MAX); -static_assert(mul_sat(UINT_MAX, 0u) == 0); -static_assert(mul_sat(0u, UINT_MAX) == 0); -static_assert(mul_sat((short)SHRT_MAX, (short)2) == SHRT_MAX); -static_assert(mul_sat((short)SHRT_MAX, (short)SHRT_MIN) == SHRT_MIN); -static_assert(mul_sat<long long>(SHRT_MAX, 2) == 2L * SHRT_MAX); +static_assert(saturating_mul(1, 1) == 1); +static_assert(saturating_mul(10, 11) == 110); +static_assert(saturating_mul(INT_MAX / 2, 3) == INT_MAX); +static_assert(saturating_mul(INT_MAX / 2, -3) == INT_MIN); +static_assert(saturating_mul(INT_MAX / -2, 3) == INT_MIN); +static_assert(saturating_mul(INT_MIN / 2, -3) == INT_MAX); +static_assert(saturating_mul(INT_MIN, -1) == INT_MAX); +static_assert(saturating_mul(INT_MAX, -1) == INT_MIN + 1); +static_assert(saturating_mul(INT_MAX, INT_MAX) == INT_MAX); +static_assert(saturating_mul(INT_MAX, -INT_MAX) == INT_MIN); +static_assert(saturating_mul(UINT_MAX, UINT_MAX) == UINT_MAX); +static_assert(saturating_mul(UINT_MAX, 0u) == 0); +static_assert(saturating_mul(0u, UINT_MAX) == 0); +static_assert(saturating_mul((short)SHRT_MAX, (short)2) == SHRT_MAX); +static_assert(saturating_mul((short)SHRT_MAX, (short)SHRT_MIN) == SHRT_MIN); +static_assert(saturating_mul<long long>(SHRT_MAX, 2) == 2L * SHRT_MAX); diff --git a/libstdc++-v3/testsuite/26_numerics/saturation/sub.cc b/libstdc++-v3/testsuite/26_numerics/saturation/sub.cc index c56154a49ff5..8b2eabc280af 100644 --- a/libstdc++-v3/testsuite/26_numerics/saturation/sub.cc +++ b/libstdc++-v3/testsuite/26_numerics/saturation/sub.cc @@ -7,80 +7,80 @@ template<typename T, typename U> concept can_sub_sat - = requires(T t, U u) { { std::sub_sat(t, u) } -> std::same_as<T>; }; + = requires(T t, U u) { { std::saturating_sub(t, u) } -> std::same_as<T>; }; static_assert( can_sub_sat<int, int> ); static_assert( not can_sub_sat<int, short> ); static_assert( not can_sub_sat<unsigned, int> ); -static_assert( noexcept(std::sub_sat(0, 0)) ); +static_assert( noexcept(std::saturating_sub(0, 0)) ); -using std::sub_sat; +using std::saturating_sub; // Signed type -static_assert(sub_sat(0, 0) == 0); -static_assert(sub_sat(1, 1) == 0); -static_assert(sub_sat(-1, -1) == 0); -static_assert(sub_sat(-1, 1) == -2); +static_assert(saturating_sub(0, 0) == 0); +static_assert(saturating_sub(1, 1) == 0); +static_assert(saturating_sub(-1, -1) == 0); +static_assert(saturating_sub(-1, 1) == -2); constexpr auto max = std::numeric_limits<int>::max(); constexpr auto min = std::numeric_limits<int>::min(); -static_assert(sub_sat(max, 1) == max - 1); -static_assert(sub_sat(1, max) == 1 - max); -static_assert(sub_sat(max, max) == 0); -static_assert(sub_sat(min, 1) == min); -static_assert(sub_sat(min, 123) == min); -static_assert(sub_sat(0, max) == min + 1); -static_assert(sub_sat(-1, max) == min); -static_assert(sub_sat(-2, max) == min); -static_assert(sub_sat(-2, min) == max - 1); -static_assert(sub_sat(-1, min) == max); -static_assert(sub_sat(0, min) == max); -static_assert(sub_sat(1, min) == max); -static_assert(sub_sat(min, -1) == min + 1); -static_assert(sub_sat(min, min) == 0); -static_assert(sub_sat(max, min) == max); -static_assert(sub_sat(min, max) == min); +static_assert(saturating_sub(max, 1) == max - 1); +static_assert(saturating_sub(1, max) == 1 - max); +static_assert(saturating_sub(max, max) == 0); +static_assert(saturating_sub(min, 1) == min); +static_assert(saturating_sub(min, 123) == min); +static_assert(saturating_sub(0, max) == min + 1); +static_assert(saturating_sub(-1, max) == min); +static_assert(saturating_sub(-2, max) == min); +static_assert(saturating_sub(-2, min) == max - 1); +static_assert(saturating_sub(-1, min) == max); +static_assert(saturating_sub(0, min) == max); +static_assert(saturating_sub(1, min) == max); +static_assert(saturating_sub(min, -1) == min + 1); +static_assert(saturating_sub(min, min) == 0); +static_assert(saturating_sub(max, min) == max); +static_assert(saturating_sub(min, max) == min); // Wider signed type than the args -static_assert(sub_sat<long long>(max, min) == (long long)max * 2 + 1); -static_assert(sub_sat<long long>(min, max) == (long long)min * 2 + 1); +static_assert(saturating_sub<long long>(max, min) == (long long)max * 2 + 1); +static_assert(saturating_sub<long long>(min, max) == (long long)min * 2 + 1); // Signed type that undergoes integer promotion constexpr auto shrt_max = std::numeric_limits<short>::max(); constexpr auto shrt_min = std::numeric_limits<short>::min(); -static_assert(sub_sat<short>(0, 0) == 0); -static_assert(sub_sat<short>(1, 1) == 0); -static_assert(sub_sat<short>(3, 1) == 2); -static_assert(sub_sat<short>(shrt_max, shrt_max) == 0); -static_assert(sub_sat<short>(shrt_max, 1) == shrt_max - 1); -static_assert(sub_sat<short>(1, shrt_max) == shrt_min + 2); -static_assert(sub_sat<short>(shrt_max, shrt_min) == shrt_max); -static_assert(sub_sat<short>(0, shrt_min) == shrt_max); -static_assert(sub_sat<short>(shrt_min, (short)1) == shrt_min); -static_assert(sub_sat<short>(shrt_min, (short)-1) == shrt_min + 1); -static_assert(sub_sat<short>((short)-1, shrt_min) == shrt_max); -static_assert(sub_sat<short>((short)1, shrt_min) == shrt_max); +static_assert(saturating_sub<short>(0, 0) == 0); +static_assert(saturating_sub<short>(1, 1) == 0); +static_assert(saturating_sub<short>(3, 1) == 2); +static_assert(saturating_sub<short>(shrt_max, shrt_max) == 0); +static_assert(saturating_sub<short>(shrt_max, 1) == shrt_max - 1); +static_assert(saturating_sub<short>(1, shrt_max) == shrt_min + 2); +static_assert(saturating_sub<short>(shrt_max, shrt_min) == shrt_max); +static_assert(saturating_sub<short>(0, shrt_min) == shrt_max); +static_assert(saturating_sub<short>(shrt_min, (short)1) == shrt_min); +static_assert(saturating_sub<short>(shrt_min, (short)-1) == shrt_min + 1); +static_assert(saturating_sub<short>((short)-1, shrt_min) == shrt_max); +static_assert(saturating_sub<short>((short)1, shrt_min) == shrt_max); // Unsigned type -static_assert(sub_sat(0u, 0u) == 0u); -static_assert(sub_sat(1u, 1u) == 0u); -static_assert(sub_sat(-1u, -1u) == 0u); -static_assert(sub_sat(-1u, 1u) == -2u); +static_assert(saturating_sub(0u, 0u) == 0u); +static_assert(saturating_sub(1u, 1u) == 0u); +static_assert(saturating_sub(-1u, -1u) == 0u); +static_assert(saturating_sub(-1u, 1u) == -2u); constexpr auto umax = std::numeric_limits<unsigned>::max(); -static_assert(sub_sat(0u, 1u) == 0u); -static_assert(sub_sat(umax, umax) == 0u); -static_assert(sub_sat(umax, 0u) == umax); -static_assert(sub_sat(0u, umax) == 0u); -static_assert(sub_sat(umax, 1u) == umax - 1u); -static_assert(sub_sat(0u, 0u) == 0u); +static_assert(saturating_sub(0u, 1u) == 0u); +static_assert(saturating_sub(umax, umax) == 0u); +static_assert(saturating_sub(umax, 0u) == umax); +static_assert(saturating_sub(0u, umax) == 0u); +static_assert(saturating_sub(umax, 1u) == umax - 1u); +static_assert(saturating_sub(0u, 0u) == 0u); // Wider unsigned type than the args -static_assert(sub_sat<unsigned long long>(0u, umax) == 0u); +static_assert(saturating_sub<unsigned long long>(0u, umax) == 0u); // Unsigned type that undergoes integer promotion constexpr auto ushrt_max = std::numeric_limits<unsigned short>::max(); -static_assert(sub_sat<unsigned short>(0, 0) == 0); -static_assert(sub_sat<unsigned short>(1, 1) == 0); -static_assert(sub_sat<unsigned short>(3, 1) == 2); -static_assert(sub_sat<unsigned short>(ushrt_max, ushrt_max) == 0); -static_assert(sub_sat<unsigned short>(0, 1) == 0); -static_assert(sub_sat<unsigned short>(1, ushrt_max) == 0); +static_assert(saturating_sub<unsigned short>(0, 0) == 0); +static_assert(saturating_sub<unsigned short>(1, 1) == 0); +static_assert(saturating_sub<unsigned short>(3, 1) == 2); +static_assert(saturating_sub<unsigned short>(ushrt_max, ushrt_max) == 0); +static_assert(saturating_sub<unsigned short>(0, 1) == 0); +static_assert(saturating_sub<unsigned short>(1, ushrt_max) == 0); diff --git a/libstdc++-v3/testsuite/26_numerics/saturation/version.cc b/libstdc++-v3/testsuite/26_numerics/saturation/version.cc index ca94ef1212a2..7b08820b5984 100644 --- a/libstdc++-v3/testsuite/26_numerics/saturation/version.cc +++ b/libstdc++-v3/testsuite/26_numerics/saturation/version.cc @@ -5,7 +5,7 @@ #ifndef __cpp_lib_saturation_arithmetic # error "Feature test macro for saturation arithmetic is missing in <numeric>" -#elif __cpp_lib_saturation_arithmetic < 202311L +#elif __cpp_lib_saturation_arithmetic < 202603L # error "Feature test macro for saturation arithmetic has wrong value in <numeric>" #endif @@ -14,6 +14,6 @@ #ifndef __cpp_lib_saturation_arithmetic # error "Feature test macro for saturation arithmetic is missing in <version>" -#elif __cpp_lib_saturation_arithmetic < 202311L +#elif __cpp_lib_saturation_arithmetic < 202603L # error "Feature test macro for saturation arithmetic has wrong value in <version>" #endif
