backport std integer comparison functions to C++11

libcudacxx/include/cuda/std/__utility/cmp.h

@@ -20,7 +20,10 @@
 #  pragma system_header
 #endif // no system header
 
+#include <cuda/std/__concepts/concept_macros.h>
 #include <cuda/std/__type_traits/disjunction.h>
+#include <cuda/std/__type_traits/enable_if.h>
+#include <cuda/std/__type_traits/integral_constant.h>
 #include <cuda/std/__type_traits/is_integral.h>
 #include <cuda/std/__type_traits/is_same.h>
 #include <cuda/std/__type_traits/is_signed.h>
@@ -31,99 +34,127 @@
 
 _CCCL_PUSH_MACROS
 
+_CCCL_DIAG_PUSH
+_CCCL_DIAG_SUPPRESS_MSVC(4018) // required cast from signed to unsigned
+_CCCL_DIAG_SUPPRESS_MSVC(4388) // required cast from signed to larger unsigned
+_CCCL_DIAG_SUPPRESS_MSVC(4389) // signed/unsigned mismatch for == and !=
+
 _LIBCUDACXX_BEGIN_NAMESPACE_STD
 
-#if _CCCL_STD_VER > 2017
 template <class _Tp, class... _Up>
-struct _IsSameAsAny : _Or<_IsSame<_Tp, _Up>...>
-{};
+using __is_same_as_any = __fold_or<_CCCL_TRAIT(is_same, _Tp, _Up)...>;
 
 template <class _Tp>
-concept __is_safe_integral_cmp =
-  is_integral_v<_Tp>
-  && !_IsSameAsAny<_Tp,
-                   bool,
-                   char,
-                   char16_t,
-                   char32_t
-#  ifndef _LIBCUDACXX_NO_HAS_CHAR8_T
-                   ,
-                   char8_t
-#  endif
-#  ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS
-                   ,
-                   wchar_t
-#  endif
-                   >::value;
-
-template <__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+struct __is_safe_integral_cmp
+    : bool_constant<_CCCL_TRAIT(is_integral, _Tp)
+                    && !__is_same_as_any<_Tp,
+                                         bool,
+                                         char,
+                                         char16_t,
+                                         char32_t
+#ifndef _LIBCUDACXX_NO_HAS_CHAR8_T
+                                         ,
+                                         char8_t
+#endif // _LIBCUDACXX_NO_HAS_CHAR8_T
+#ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS
+                                         ,
+                                         wchar_t
+#endif // _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS
+                                         >::value>
+{};
+
+_CCCL_TEMPLATE(class _Tp, class _Up)
+_CCCL_REQUIRES(__is_safe_integral_cmp<_Tp>::value _CCCL_AND __is_safe_integral_cmp<_Up>::value)
 _LIBCUDACXX_HIDE_FROM_ABI constexpr bool cmp_equal(_Tp __t, _Up __u) noexcept
 {
-  if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
+#if !defined(_CCCL_NO_IF_CONSTEXPR)
+  if constexpr (_CCCL_TRAIT(is_signed, _Tp) == _CCCL_TRAIT(is_signed, _Up))
   {
     return __t == __u;
   }
-  else if constexpr (is_signed_v<_Tp>)
+  else if constexpr (_CCCL_TRAIT(is_signed, _Tp))
   {
     return __t < 0 ? false : make_unsigned_t<_Tp>(__t) == __u;
   }
   else
   {
     return __u < 0 ? false : __t == make_unsigned_t<_Up>(__u);
   }
+  _CCCL_UNREACHABLE();
+#else // ^^^ !_CCCL_NO_IF_CONSTEXPR ^^^ / vvv _CCCL_NO_IF_CONSTEXPR vvv
+  return ((_CCCL_TRAIT(is_signed, _Tp) == _CCCL_TRAIT(is_signed, _Up))
+            ? (__t == __u)
+            : (_CCCL_TRAIT(is_signed, _Tp) ? (__t < 0 ? false : make_unsigned_t<_Tp>(__t) == __u)
+                                           : (__u < 0 ? false : __t == make_unsigned_t<_Up>(__u))));
+#endif // _CCCL_NO_IF_CONSTEXPR
 }
 
-template <__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_CCCL_TEMPLATE(class _Tp, class _Up)
+_CCCL_REQUIRES(__is_safe_integral_cmp<_Tp>::value _CCCL_AND __is_safe_integral_cmp<_Up>::value)
 _LIBCUDACXX_HIDE_FROM_ABI constexpr bool cmp_not_equal(_Tp __t, _Up __u) noexcept
 {
   return !_CUDA_VSTD::cmp_equal(__t, __u);
 }
 
-template <__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_CCCL_TEMPLATE(class _Tp, class _Up)
+_CCCL_REQUIRES(__is_safe_integral_cmp<_Tp>::value _CCCL_AND __is_safe_integral_cmp<_Up>::value)
 _LIBCUDACXX_HIDE_FROM_ABI constexpr bool cmp_less(_Tp __t, _Up __u) noexcept
 {
-  if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
+#if !defined(_CCCL_NO_IF_CONSTEXPR)
+  if constexpr (_CCCL_TRAIT(is_signed, _Tp) == _CCCL_TRAIT(is_signed, _Up))
   {
     return __t < __u;
   }
-  else if constexpr (is_signed_v<_Tp>)
+  else if constexpr (_CCCL_TRAIT(is_signed, _Tp))
   {
     return __t < 0 ? true : make_unsigned_t<_Tp>(__t) < __u;
   }
   else
   {
     return __u < 0 ? false : __t < make_unsigned_t<_Up>(__u);
   }
+  _CCCL_UNREACHABLE();
+#else // ^^^ !_CCCL_NO_IF_CONSTEXPR ^^^ / vvv _CCCL_NO_IF_CONSTEXPR vvv
+  return ((_CCCL_TRAIT(is_signed, _Tp) == _CCCL_TRAIT(is_signed, _Up))
+            ? (__t < __u)
+            : (_CCCL_TRAIT(is_signed, _Tp) ? (__t < 0 ? true : make_unsigned_t<_Tp>(__t) < __u)
+                                           : (__u < 0 ? false : __t < make_unsigned_t<_Up>(__u))));
+#endif // _CCCL_NO_IF_CONSTEXPR
 }
 
-template <__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_CCCL_TEMPLATE(class _Tp, class _Up)
+_CCCL_REQUIRES(__is_safe_integral_cmp<_Tp>::value _CCCL_AND __is_safe_integral_cmp<_Up>::value)
 _LIBCUDACXX_HIDE_FROM_ABI constexpr bool cmp_greater(_Tp __t, _Up __u) noexcept
 {
   return _CUDA_VSTD::cmp_less(__u, __t);
 }
 
-template <__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_CCCL_TEMPLATE(class _Tp, class _Up)
+_CCCL_REQUIRES(__is_safe_integral_cmp<_Tp>::value _CCCL_AND __is_safe_integral_cmp<_Up>::value)
 _LIBCUDACXX_HIDE_FROM_ABI constexpr bool cmp_less_equal(_Tp __t, _Up __u) noexcept
 {
   return !_CUDA_VSTD::cmp_greater(__t, __u);
 }
 
-template <__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_CCCL_TEMPLATE(class _Tp, class _Up)
+_CCCL_REQUIRES(__is_safe_integral_cmp<_Tp>::value _CCCL_AND __is_safe_integral_cmp<_Up>::value)
 _LIBCUDACXX_HIDE_FROM_ABI constexpr bool cmp_greater_equal(_Tp __t, _Up __u) noexcept
 {
   return !_CUDA_VSTD::cmp_less(__t, __u);
 }
 
-template <__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_CCCL_TEMPLATE(class _Tp, class _Up)
+_CCCL_REQUIRES(__is_safe_integral_cmp<_Tp>::value _CCCL_AND __is_safe_integral_cmp<_Up>::value)
 _LIBCUDACXX_HIDE_FROM_ABI constexpr bool in_range(_Up __u) noexcept
 {
   return _CUDA_VSTD::cmp_less_equal(__u, numeric_limits<_Tp>::max())
       && _CUDA_VSTD::cmp_greater_equal(__u, numeric_limits<_Tp>::min());
 }
-#endif // _CCCL_STD_VER > 2017
 
 _LIBCUDACXX_END_NAMESPACE_STD
 
+_CCCL_DIAG_POP
+
 _CCCL_POP_MACROS
 
 #endif // _LIBCUDACXX___UTILITY_CMP_H

libcudacxx/include/cuda/std/version

@@ -43,11 +43,12 @@
 #  define __cccl_lib_exchange_function 201304L
 #  define __cccl_lib_expected          202211L
 // # define __cccl_lib_generic_associative_lookup           201304L
-#  define __cccl_lib_integer_sequence           201304L
-#  define __cccl_lib_integral_constant_callable 201304L
-#  define __cccl_lib_is_final                   201402L
-#  define __cccl_lib_is_null_pointer            201309L
-#  define __cccl_lib_make_reverse_iterator      201402L
+#  define __cccl_lib_integer_sequence             201304L
+#  define __cccl_lib_integer_comparison_functions 202002L
+#  define __cccl_lib_integral_constant_callable   201304L
+#  define __cccl_lib_is_final                     201402L
+#  define __cccl_lib_is_null_pointer              201309L
+#  define __cccl_lib_make_reverse_iterator        201402L
 // # define __cccl_lib_make_unique                          201304L
 #  if !_CCCL_COMPILER(MSVC) || _CCCL_STD_VER >= 2020
 #    define __cccl_lib_mdspan 202207L
@@ -178,7 +179,6 @@
 // #   define __cccl_lib_format                             202106L
 // # define __cccl_lib_generic_unordered_lookup             201811L
 // # define __cccl_lib_int_pow2                             202002L
-// # define __cccl_lib_integer_comparison_functions         202002L
 // # define __cccl_lib_interpolate                          201902L
 #  ifdef _CCCL_BUILTIN_IS_CONSTANT_EVALUATED
 #    define __cccl_lib_is_constant_evaluated 201811L

libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_equal/cmp_equal.pass.cpp

@@ -7,12 +7,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
 // <utility>
 
 // template<class T, class U>
-//   constexpr bool cmp_equal(T t, U u) noexcept;         // C++20
+//   constexpr bool cmp_equal(T t, U u) noexcept;
 
 #include <cuda/std/cassert>
 #include <cuda/std/limits>
@@ -24,28 +22,17 @@
 template <typename T>
 struct Tuple
 {
-  T min;
-  T max;
-  T mid;
-  __host__ __device__ constexpr Tuple()
-  {
-    min = cuda::std::numeric_limits<T>::min();
-    max = cuda::std::numeric_limits<T>::max();
-    if constexpr (cuda::std::is_signed_v<T>)
-    {
-      mid = T(-1);
-    }
-    else
-    {
-      mid = max >> 1;
-    }
-  }
+  T min = cuda::std::numeric_limits<T>::min();
+  T max = cuda::std::numeric_limits<T>::max();
+  T mid = cuda::std::is_signed<T>::value ? T(-1) : max >> 1;
+
+  __host__ __device__ constexpr Tuple() noexcept {}
 };
 
 template <typename T>
-__host__ __device__ constexpr void test_cmp_equal1()
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test1()
 {
-  constexpr Tuple<T> tup;
+  constexpr Tuple<T> tup{};
   assert(cuda::std::cmp_equal(T(0), T(0)));
   assert(cuda::std::cmp_equal(T(10), T(10)));
   assert(cuda::std::cmp_equal(tup.min, tup.min));
@@ -68,10 +55,10 @@ __host__ __device__ constexpr void test_cmp_equal1()
 }
 
 template <typename T, typename U>
-__host__ __device__ constexpr void test_cmp_equal2()
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test2()
 {
-  constexpr Tuple<T> ttup;
-  constexpr Tuple<U> utup;
+  constexpr Tuple<T> ttup{};
+  constexpr Tuple<U> utup{};
   assert(cuda::std::cmp_equal(T(0), U(0)));
   assert(cuda::std::cmp_equal(T(10), U(10)));
   assert(!cuda::std::cmp_equal(T(0), U(1)));
@@ -82,51 +69,51 @@ __host__ __device__ constexpr void test_cmp_equal2()
   assert(!cuda::std::cmp_equal(utup.min, ttup.max));
 }
 
-template <class... Ts>
-__host__ __device__ constexpr void test1(const cuda::std::tuple<Ts...>&)
-{
-  (test_cmp_equal1<Ts>(), ...);
-}
-
-template <class T, class... Us>
-__host__ __device__ constexpr void test2_impl(const cuda::std::tuple<Us...>&)
+template <class T>
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test()
 {
-  (test_cmp_equal2<T, Us>(), ...);
-}
-
-template <class... Ts, class UTuple>
-__host__ __device__ constexpr void test2(const cuda::std::tuple<Ts...>&, const UTuple& utuple)
-{
-  (test2_impl<Ts>(utuple), ...);
+  test1<T>();
+#ifndef TEST_HAS_NO_INT128_T
+  test2<T, __int128_t>();
+  test2<T, __uint128_t>();
+#endif // TEST_HAS_NO_INT128_T
+  test2<T, unsigned long long>();
+  test2<T, long long>();
+  test2<T, unsigned long>();
+  test2<T, long>();
+  test2<T, unsigned int>();
+  test2<T, int>();
+  test2<T, unsigned short>();
+  test2<T, short>();
+  test2<T, unsigned char>();
+  test2<T, signed char>();
 }
 
-__host__ __device__ constexpr bool test()
+__host__ __device__ TEST_CONSTEXPR_CXX14 bool test()
 {
-  cuda::std::tuple<
 #ifndef TEST_HAS_NO_INT128_T
-    __int128_t,
-    __uint128_t,
-#endif
-    unsigned long long,
-    long long,
-    unsigned long,
-    long,
-    unsigned int,
-    int,
-    unsigned short,
-    short,
-    unsigned char,
-    signed char>
-    types;
-  test1(types);
-  test2(types, types);
+  test<__int128_t>();
+  test<__uint128_t>();
+#endif // TEST_HAS_NO_INT128_T
+  test<unsigned long long>();
+  test<long long>();
+  test<unsigned long>();
+  test<long>();
+  test<unsigned int>();
+  test<int>();
+  test<unsigned short>();
+  test<short>();
+  test<unsigned char>();
+  test<signed char>();
   return true;
 }
 
 int main(int, char**)
 {
   ASSERT_NOEXCEPT(cuda::std::cmp_equal(0, 0));
   test();
-  static_assert(test());
+#if TEST_STD_VER >= 2014
+  static_assert(test(), "");
+#endif // TEST_STD_VER >= 2014
   return 0;
 }