cuda-cccl 0.3.0__cp312-cp312-manylinux_2_24_aarch64.whl → 0.3.2__cp312-cp312-manylinux_2_24_aarch64.whl

cuda/cccl/headers/include/cuda/std/__chrono/system_clock.h

@@ -39,11 +39,11 @@ namespace chrono
 class _CCCL_TYPE_VISIBILITY_DEFAULT system_clock
 {
 public:
-  using duration                        = ::cuda::std::chrono::nanoseconds;
-  using rep                             = duration::rep;
-  using period                          = duration::period;
-  using time_point                      = ::cuda::std::chrono::time_point<system_clock>;
-  static constexpr const bool is_steady = false;
+  using duration                  = ::cuda::std::chrono::nanoseconds;
+  using rep                       = duration::rep;
+  using period                    = duration::period;
+  using time_point                = ::cuda::std::chrono::time_point<system_clock>;
+  static constexpr bool is_steady = false;
 
   [[nodiscard]] _CCCL_API inline static time_point now() noexcept
   {

cuda/cccl/headers/include/cuda/std/__cmath/isnan.h

@@ -27,9 +27,10 @@
 #include <cuda/std/__type_traits/is_floating_point.h>
 #include <cuda/std/__type_traits/is_integral.h>
 
-#if _CCCL_COMPILER(MSVC) || _CCCL_CUDA_COMPILER(CLANG) || !_CCCL_CUDA_COMPILATION()
+// MSVC and clang cuda need the host side functions included
+#if _CCCL_HOST_COMPILATION() || _CCCL_CUDA_COMPILER(CLANG)
 #  include <math.h>
-#endif // _CCCL_COMPILER(MSVC) || _CCCL_CUDA_COMPILER(CLANG) || !_CCCL_CUDA_COMPILATION()
+#endif // _CCCL_HOST_COMPILATION() || _CCCL_CUDA_COMPILER(CLANG)
 
 #include <cuda/std/__cccl/prologue.h>
 

cuda/cccl/headers/include/cuda/std/__complex/complex.h

@@ -23,6 +23,7 @@
 
 #include <cuda/std/__complex/vector_support.h>
 #include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__fwd/complex.h>
 #include <cuda/std/__fwd/get.h>
 #include <cuda/std/__tuple_dir/tuple_element.h>
 #include <cuda/std/__tuple_dir/tuple_size.h>
@@ -36,9 +37,9 @@
 #include <cuda/std/limits>
 
 // Compatibility helpers for thrust to convert between `std::complex` and `cuda::std::complex`
+// todo: find a way to get rid of this include
 #if !_CCCL_COMPILER(NVRTC)
-#  include <complex>
-#  include <sstream> // for std::basic_ostringstream
+#  include <complex> // for std::complex stream operators
 
 #  define _LIBCUDACXX_ACCESS_STD_COMPLEX_REAL(__c) reinterpret_cast<const _Up(&)[2]>(__c)[0]
 #  define _LIBCUDACXX_ACCESS_STD_COMPLEX_IMAG(__c) reinterpret_cast<const _Up(&)[2]>(__c)[1]

cuda/cccl/headers/include/cuda/std/__complex/literals.h

@@ -21,28 +21,28 @@
 #  pragma system_header
 #endif // no system header
 
-#include <cuda/std/__complex/complex.h>
+// gcc < 8 warns about it's extended literals being shadowed by the implementation, so let's just disable the complex
+// literals
+#if !_CCCL_COMPILER(GCC, <, 8)
 
-#include <cuda/std/__cccl/prologue.h>
+#  include <cuda/std/__complex/complex.h>
 
-_CCCL_BEGIN_NAMESPACE_CUDA_STD
+#  include <cuda/std/__cccl/prologue.h>
 
-#ifdef _LIBCUDACXX_HAS_STL_LITERALS
-// Literal suffix for complex number literals [complex.literals]
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 _CCCL_DIAG_PUSH
 _CCCL_DIAG_SUPPRESS_GCC("-Wliteral-suffix")
 _CCCL_DIAG_SUPPRESS_CLANG("-Wuser-defined-literals")
-_CCCL_DIAG_SUPPRESS_MSVC(4455)
+_CCCL_DIAG_SUPPRESS_NVHPC(lit_suffix_no_underscore)
+_CCCL_DIAG_SUPPRESS_MSVC(4455) // literal suffix identifiers that do not start with an underscore are reserved
+_CCCL_BEGIN_NV_DIAG_SUPPRESS(2506, 20208) // a user-provided literal suffix must begin with "_",
+                                          // long double treated as double
 
 inline namespace literals
 {
 inline namespace complex_literals
 {
-#  if !_CCCL_CUDA_COMPILER(NVCC) && !_CCCL_COMPILER(NVRTC)
-// NOTE: if you get a warning from GCC <7 here that "literal operator suffixes not preceded by ‘_’ are reserved for
-// future standardization" then we are sorry. The warning was implemented before GCC 7, but can only be disabled since
-// GCC 7. See also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69523
 _CCCL_API constexpr complex<long double> operator""il(long double __im)
 {
   return {0.0l, __im};
@@ -71,36 +71,16 @@ _CCCL_API constexpr complex<float> operator""if(unsigned long long __im)
 {
   return {0.0f, static_cast<float>(__im)};
 }
-#  else // ^^^ !_CCCL_CUDA_COMPILER(NVCC) && !_CCCL_COMPILER(NVRTC) ^^^ / vvv other compilers vvv
-_CCCL_API constexpr complex<double> operator""i(double __im)
-{
-  return {0.0, static_cast<double>(__im)};
-}
-
-_CCCL_API constexpr complex<double> operator""i(unsigned long long __im)
-{
-  return {0.0, static_cast<double>(__im)};
-}
-
-_CCCL_API constexpr complex<float> operator""if(double __im)
-{
-  return {0.0f, static_cast<float>(__im)};
-}
-
-_CCCL_API constexpr complex<float> operator""if(unsigned long long __im)
-{
-  return {0.0f, static_cast<float>(__im)};
-}
-#  endif // other compilers
 } // namespace complex_literals
 } // namespace literals
 
+_CCCL_END_NV_DIAG_SUPPRESS()
 _CCCL_DIAG_POP
 
-#endif // _LIBCUDACXX_HAS_STL_LITERALS
-
 _CCCL_END_NAMESPACE_CUDA_STD
 
-#include <cuda/std/__cccl/epilogue.h>
+#  include <cuda/std/__cccl/epilogue.h>
+
+#endif // !_CCCL_COMPILER(GCC, <, 8)
 
 #endif // _CUDA_STD___COMPLEX_LITERALS_H

cuda/cccl/headers/include/cuda/std/__complex/nvbf16.h

@@ -31,8 +31,9 @@
 #  include <cuda/std/__type_traits/enable_if.h>
 #  include <cuda/std/__type_traits/is_constructible.h>
 
+// todo: find a way to get rid of this include
 #  if !_CCCL_COMPILER(NVRTC)
-#    include <sstream> // for std::basic_ostringstream
+#    include <complex> // for std::complex stream operators
 #  endif // !_CCCL_COMPILER(NVRTC)
 
 #  include <cuda/std/__cccl/prologue.h>

cuda/cccl/headers/include/cuda/std/__complex/nvfp16.h

@@ -31,8 +31,9 @@
 #  include <cuda/std/__type_traits/enable_if.h>
 #  include <cuda/std/__type_traits/is_constructible.h>
 
+// todo: find a way to get rid of this include
 #  if !_CCCL_COMPILER(NVRTC)
-#    include <sstream> // for std::basic_ostringstream
+#    include <complex> // for std::complex stream operators
 #  endif // !_CCCL_COMPILER(NVRTC)
 
 #  include <cuda/std/__cccl/prologue.h>
@@ -294,7 +295,7 @@ struct __get_complex_impl<__half>
   }
 };
 
-#  if !defined(_LIBCUDACXX_HAS_NO_LOCALIZATION) && !_CCCL_COMPILER(NVRTC)
+#  if !_CCCL_COMPILER(NVRTC)
 template <class _CharT, class _Traits>
 ::std::basic_istream<_CharT, _Traits>& operator>>(::std::basic_istream<_CharT, _Traits>& __is, complex<__half>& __x)
 {
@@ -310,7 +311,7 @@ operator<<(::std::basic_ostream<_CharT, _Traits>& __os, const complex<__half>& _
 {
   return __os << complex<float>{__x};
 }
-#  endif // !_LIBCUDACXX_HAS_NO_LOCALIZATION && !_CCCL_COMPILER(NVRTC)
+#  endif // !_CCCL_COMPILER(NVRTC)
 
 _CCCL_END_NAMESPACE_CUDA_STD
 

cuda/cccl/headers/include/cuda/std/__concepts/invocable.h

@@ -35,8 +35,8 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 template <class _Fn, class... _Args>
 concept invocable = requires(_Fn&& __fn, _Args&&... __args) {
-  ::cuda::std::__invoke(::cuda::std::forward<_Fn>(__fn), ::cuda::std::forward<_Args>(__args)...); // not required to be
-                                                                                                  // equality preserving
+  ::cuda::std::invoke(::cuda::std::forward<_Fn>(__fn), ::cuda::std::forward<_Args>(__args)...); // not required to be
+                                                                                                // equality preserving
 };
 
 // [concept.regular.invocable]

cuda/cccl/headers/include/cuda/std/__cstdlib/malloc.h

@@ -21,8 +21,9 @@
 #  pragma system_header
 #endif // no system header
 
+#include <cuda/__cmath/mul_hi.h>
 #include <cuda/std/__cstddef/types.h>
-#include <cuda/std/cstring>
+#include <cuda/std/__cstring/memset.h>
 
 #if !_CCCL_COMPILER(NVRTC)
 #  include <cstdlib>
@@ -44,7 +45,7 @@ using ::malloc;
 
   const size_t __nbytes = __n * __size;
 
-  if (::__umul64hi(__n, __size) == 0)
+  if (::cuda::mul_hi(__n, __size) == 0)
   {
     __ptr = ::cuda::std::malloc(__nbytes);
     if (__ptr != nullptr)

cuda/cccl/headers/include/cuda/std/__floating_point/fp.h

@@ -11,7 +11,7 @@
 #ifndef _CUDA_STD___FLOATING_POINT_FP_H
 #define _CUDA_STD___FLOATING_POINT_FP_H
 
-#include <cuda/__cccl_config>
+#include <cuda/std/detail/__config>
 
 #if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
 #  pragma GCC system_header

cuda/cccl/headers/include/cuda/std/__functional/bind.h

@@ -97,14 +97,13 @@ _CCCL_API inline _Tp& __mu(reference_wrapper<_Tp> __t, _Uj&)
 }
 
 template <class _Ti, class... _Uj, size_t... _Indx>
-_CCCL_API inline typename __invoke_of<_Ti&, _Uj...>::type
-__mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>)
+_CCCL_API inline invoke_result_t<_Ti&, _Uj...> __mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>)
 {
   return __ti(::cuda::std::forward<_Uj>(::cuda::std::get<_Indx>(__uj))...);
 }
 
 template <class _Ti, class... _Uj>
-_CCCL_API inline enable_if_t<is_bind_expression<_Ti>::value, __invoke_of<_Ti&, _Uj...>>
+_CCCL_API inline enable_if_t<is_bind_expression<_Ti>::value, invoke_result<_Ti&, _Uj...>>
 __mu(_Ti& __ti, tuple<_Uj...>& __uj)
 {
   using __indices = __make_tuple_indices_t<sizeof...(_Uj)>;
@@ -151,12 +150,12 @@ struct __mu_return_invocable // false
 template <class _Ti, class... _Uj>
 struct __mu_return_invocable<true, _Ti, _Uj...>
 {
-  using type = typename __invoke_of<_Ti&, _Uj...>::type;
+  using type = invoke_result_t<_Ti&, _Uj...>;
 };
 
 template <class _Ti, class... _Uj>
 struct __mu_return_impl<_Ti, false, true, false, tuple<_Uj...>>
-    : public __mu_return_invocable<__invocable<_Ti&, _Uj...>::value, _Ti, _Uj...>
+    : public __mu_return_invocable<is_invocable_v<_Ti&, _Uj...>, _Ti, _Uj...>
 {};
 
 template <class _Ti, class _TupleUj>
@@ -196,13 +195,13 @@ struct __is_valid_bind_return
 template <class _Fp, class... _BoundArgs, class _TupleUj>
 struct __is_valid_bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj>
 {
-  static const bool value = __invocable<_Fp, typename __mu_return<_BoundArgs, _TupleUj>::type...>::value;
+  static const bool value = is_invocable_v<_Fp, typename __mu_return<_BoundArgs, _TupleUj>::type...>;
 };
 
 template <class _Fp, class... _BoundArgs, class _TupleUj>
 struct __is_valid_bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj>
 {
-  static const bool value = __invocable<_Fp, typename __mu_return<const _BoundArgs, _TupleUj>::type...>::value;
+  static const bool value = is_invocable_v<_Fp, typename __mu_return<const _BoundArgs, _TupleUj>::type...>;
 };
 
 template <class _Fp, class _BoundArgs, class _TupleUj, bool = __is_valid_bind_return<_Fp, _BoundArgs, _TupleUj>::value>
@@ -211,13 +210,13 @@ struct __bind_return;
 template <class _Fp, class... _BoundArgs, class _TupleUj>
 struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj, true>
 {
-  using type = typename __invoke_of<_Fp&, typename __mu_return<_BoundArgs, _TupleUj>::type...>::type;
+  using type = invoke_result_t<_Fp&, typename __mu_return<_BoundArgs, _TupleUj>::type...>;
 };
 
 template <class _Fp, class... _BoundArgs, class _TupleUj>
 struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj, true>
 {
-  using type = typename __invoke_of<_Fp&, typename __mu_return<const _BoundArgs, _TupleUj>::type...>::type;
+  using type = invoke_result_t<_Fp&, typename __mu_return<const _BoundArgs, _TupleUj>::type...>;
 };
 
 template <class _Fp, class _BoundArgs, class _TupleUj>
@@ -295,8 +294,7 @@ public:
               result_type>
   operator()(_Args&&... __args)
   {
-    using _Invoker = __invoke_void_return_wrapper<_Rp>;
-    return _Invoker::__call(static_cast<base&>(*this), ::cuda::std::forward<_Args>(__args)...);
+    return ::cuda::std::invoke_r<_Rp>(static_cast<base&>(*this), ::cuda::std::forward<_Args>(__args)...);
   }
 
   template <class... _Args>
@@ -305,8 +303,7 @@ public:
     result_type>
   operator()(_Args&&... __args) const
   {
-    using _Invoker = __invoke_void_return_wrapper<_Rp>;
-    return _Invoker::__call(static_cast<base const&>(*this), ::cuda::std::forward<_Args>(__args)...);
+    return ::cuda::std::invoke_r<_Rp>(static_cast<base const&>(*this), ::cuda::std::forward<_Args>(__args)...);
   }
 };
 

cuda/cccl/headers/include/cuda/std/__functional/function.h

@@ -174,8 +174,7 @@ public:
 
   _CCCL_API inline _Rp operator()(_ArgTypes&&... __arg)
   {
-    using _Invoker = __invoke_void_return_wrapper<_Rp>;
-    return _Invoker::__call(__f_.first(), ::cuda::std::forward<_ArgTypes>(__arg)...);
+    return ::cuda::std::invoke_r<_Rp>(__f_.first(), ::cuda::std::forward<_ArgTypes>(__arg)...);
   }
 
   _CCCL_API inline __alloc_func* __clone() const
@@ -227,8 +226,7 @@ public:
 
   _CCCL_API inline _Rp operator()(_ArgTypes&&... __arg)
   {
-    using _Invoker = __invoke_void_return_wrapper<_Rp>;
-    return _Invoker::__call(__f_, ::cuda::std::forward<_ArgTypes>(__arg)...);
+    return ::cuda::std::invoke_r<_Rp>(__f_, ::cuda::std::forward<_ArgTypes>(__arg)...);
   }
 
   _CCCL_API inline __default_alloc_func* __clone() const
@@ -963,7 +961,7 @@ public:
 
   virtual _Rp operator()(_ArgTypes&&... __arg)
   {
-    return ::cuda::std::__invoke(__f_, ::cuda::std::forward<_ArgTypes>(__arg)...);
+    return ::cuda::std::invoke(__f_, ::cuda::std::forward<_ArgTypes>(__arg)...);
   }
 
 #    ifndef _CCCL_NO_RTTI
@@ -996,13 +994,12 @@ class _CCCL_TYPE_VISIBILITY_DEFAULT function<_Rp(_ArgTypes...)>
 
   __func __f_;
 
-  template <class _Fp, bool = !is_same_v<remove_cvref_t<_Fp>, function> && __invocable<_Fp, _ArgTypes...>::value>
+  template <class _Fp, bool = !is_same_v<remove_cvref_t<_Fp>, function> && is_invocable_v<_Fp, _ArgTypes...>>
   struct __callable;
   template <class _Fp>
   struct __callable<_Fp, true>
   {
-    static const bool value =
-      is_void_v<_Rp> || __is_core_convertible<typename __invoke_of<_Fp, _ArgTypes...>::type, _Rp>::value;
+    static const bool value = is_void_v<_Rp> || __is_core_convertible<invoke_result_t<_Fp, _ArgTypes...>, _Rp>::value;
   };
   template <class _Fp>
   struct __callable<_Fp, false>