cuda-cccl 0.3.1__cp311-cp311-manylinux_2_24_aarch64.whl → 0.3.2__cp311-cp311-manylinux_2_24_aarch64.whl

cuda/cccl/headers/include/cuda/std/__algorithm/find.h

@@ -33,7 +33,7 @@ template <class _Iter, class _Sent, class _Tp, class _Proj>
 {
   for (; __first != __last; ++__first)
   {
-    if (::cuda::std::__invoke(__proj, *__first) == __value)
+    if (::cuda::std::invoke(__proj, *__first) == __value)
     {
       break;
     }

cuda/cccl/headers/include/cuda/std/__algorithm/includes.h

@@ -40,13 +40,11 @@ _CCCL_API constexpr bool __includes(
   for (; __first2 != __last2; ++__first1)
   {
     if (__first1 == __last1
-        || ::cuda::std::__invoke(
-          __comp, ::cuda::std::__invoke(__proj2, *__first2), ::cuda::std::__invoke(__proj1, *__first1)))
+        || ::cuda::std::invoke(__comp, ::cuda::std::invoke(__proj2, *__first2), ::cuda::std::invoke(__proj1, *__first1)))
     {
       return false;
     }
-    if (!::cuda::std::__invoke(
-          __comp, ::cuda::std::__invoke(__proj1, *__first1), ::cuda::std::__invoke(__proj2, *__first2)))
+    if (!::cuda::std::invoke(__comp, ::cuda::std::invoke(__proj1, *__first1), ::cuda::std::invoke(__proj2, *__first2)))
     {
       ++__first2;
     }

cuda/cccl/headers/include/cuda/std/__algorithm/lower_bound.h

@@ -46,7 +46,7 @@ _CCCL_API constexpr _Iter __lower_bound(_Iter __first, _Sent __last, const _Type
     auto __l2 = ::cuda::std::__half_positive(__len);
     _Iter __m = __first;
     _IterOps<_AlgPolicy>::advance(__m, __l2);
-    if (::cuda::std::__invoke(__comp, ::cuda::std::__invoke(__proj, *__m), __value))
+    if (::cuda::std::invoke(__comp, ::cuda::std::invoke(__proj, *__m), __value))
     {
       __first = ++__m;
       __len -= __l2 + 1;

cuda/cccl/headers/include/cuda/std/__algorithm/make_projected.h

@@ -47,26 +47,18 @@ struct _ProjectedPred
   {}
 
   template <class _Tp>
-  typename __invoke_of<
-    _Pred&,
-    decltype(::cuda::std::__invoke(::cuda::std::declval<_Proj&>(), ::cuda::std::declval<_Tp>()))>::type constexpr
-    _CCCL_API inline
-    operator()(_Tp&& __v) const
+  invoke_result_t<_Pred&, invoke_result_t<_Proj&, _Tp>> constexpr _CCCL_API inline operator()(_Tp&& __v) const
   {
-    return ::cuda::std::__invoke(__pred, ::cuda::std::__invoke(__proj, ::cuda::std::forward<_Tp>(__v)));
+    return ::cuda::std::invoke(__pred, ::cuda::std::invoke(__proj, ::cuda::std::forward<_Tp>(__v)));
   }
 
   template <class _T1, class _T2>
-  typename __invoke_of<
-    _Pred&,
-    decltype(::cuda::std::__invoke(::cuda::std::declval<_Proj&>(), ::cuda::std::declval<_T1>())),
-    decltype(::cuda::std::__invoke(::cuda::std::declval<_Proj&>(), ::cuda::std::declval<_T2>()))>::type constexpr
-    _CCCL_API inline
-    operator()(_T1&& __lhs, _T2&& __rhs) const
+  invoke_result_t<_Pred&, invoke_result_t<_Proj&, _T1>, invoke_result_t<_Proj&, _T2>> _CCCL_API inline
+  operator()(_T1&& __lhs, _T2&& __rhs) const
   {
-    return ::cuda::std::__invoke(__pred,
-                                 ::cuda::std::__invoke(__proj, ::cuda::std::forward<_T1>(__lhs)),
-                                 ::cuda::std::__invoke(__proj, ::cuda::std::forward<_T2>(__rhs)));
+    return ::cuda::std::invoke(__pred,
+                               ::cuda::std::invoke(__proj, ::cuda::std::forward<_T1>(__lhs)),
+                               ::cuda::std::invoke(__proj, ::cuda::std::forward<_T2>(__rhs)));
   }
 };
 

cuda/cccl/headers/include/cuda/std/__algorithm/min_element.h

@@ -44,7 +44,7 @@ _CCCL_API constexpr _Iter __min_element(_Iter __first, _Sent __last, _Comp __com
   _Iter __i = __first;
   while (++__i != __last)
   {
-    if (::cuda::std::__invoke(__comp, ::cuda::std::__invoke(__proj, *__i), ::cuda::std::__invoke(__proj, *__first)))
+    if (::cuda::std::invoke(__comp, ::cuda::std::invoke(__proj, *__i), ::cuda::std::invoke(__proj, *__first)))
     {
       __first = __i;
     }

cuda/cccl/headers/include/cuda/std/__algorithm/minmax_element.h

@@ -46,8 +46,7 @@ public:
   template <class _Iter>
   _CCCL_API constexpr bool operator()(_Iter& __it1, _Iter& __it2)
   {
-    return ::cuda::std::__invoke(
-      __comp_, ::cuda::std::__invoke(__proj_, *__it1), ::cuda::std::__invoke(__proj_, *__it2));
+    return ::cuda::std::invoke(__comp_, ::cuda::std::invoke(__proj_, *__it1), ::cuda::std::invoke(__proj_, *__it2));
   }
 };
 

cuda/cccl/headers/include/cuda/std/__algorithm/partial_sort_copy.h

@@ -69,8 +69,8 @@ _CCCL_API constexpr pair<_InputIterator, _RandomAccessIterator> __partial_sort_c
     typename iterator_traits<_RandomAccessIterator>::difference_type __len = __r - __result_first;
     for (; __first != __last; ++__first)
     {
-      if (::cuda::std::__invoke(
-            __comp, ::cuda::std::__invoke(__proj1, *__first), ::cuda::std::__invoke(__proj2, *__result_first)))
+      if (::cuda::std::invoke(
+            __comp, ::cuda::std::invoke(__proj1, *__first), ::cuda::std::invoke(__proj2, *__result_first)))
       {
         *__result_first = *__first;
         ::cuda::std::__sift_down<_AlgPolicy>(__result_first, __projected_comp, __len, __result_first);

cuda/cccl/headers/include/cuda/std/__algorithm/upper_bound.h

@@ -45,7 +45,7 @@ __upper_bound(_Iter __first, _Sent __last, const _Tp& __value, _Compare&& __comp
   {
     auto __half_len = ::cuda::std::__half_positive(__len);
     auto __mid      = _IterOps<_AlgPolicy>::next(__first, __half_len);
-    if (::cuda::std::__invoke(__comp, __value, ::cuda::std::__invoke(__proj, *__mid)))
+    if (::cuda::std::invoke(__comp, __value, ::cuda::std::invoke(__proj, *__mid)))
     {
       __len = __half_len;
     }

cuda/cccl/headers/include/cuda/std/__cccl/algorithm_wrapper.h

@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_STD__CCCL_ALGORITHM_WRAPPER_H
+#define _CUDA_STD__CCCL_ALGORITHM_WRAPPER_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// When nvc++ uses CCCL components as part of its implementation of
+// Standard C++ algorithms, a cycle of included files may result when CCCL code
+// tries to use a standard algorithm. The THRUST_INCLUDING_ALGORITHMS_HEADER macro
+// is defined only when CCCL is including an algorithms-related header, giving
+// the compiler a chance to detect and break the cycle of includes.
+
+#if !_CCCL_COMPILER(NVRTC)
+#  define THRUST_INCLUDING_ALGORITHMS_HEADER
+#  include <algorithm>
+#  undef THRUST_INCLUDING_ALGORITHMS_HEADER
+#endif // !_CCCL_COMPILER(NVRTC)
+
+#endif // _CUDA_STD__CCCL_ALGORITHM_WRAPPER_H

cuda/cccl/headers/include/cuda/std/__cccl/builtin.h

@@ -25,6 +25,7 @@
 
 #include <cuda/std/__cccl/attributes.h>
 #include <cuda/std/__cccl/extended_data_types.h>
+#include <cuda/std/__cccl/host_std_lib.h>
 
 //! This file consolidates all compiler builtin detection for CCCL.
 //!
@@ -607,55 +608,51 @@
 #  define _CCCL_BUILTIN_STRLEN(...) __builtin_strlen(__VA_ARGS__)
 #endif
 
-// Some compilers provide std::move/std::forward/etc as builtins
-#if defined(__cplusplus)
-// Bring in the feature test macros (needed for std::forward_like)
-#  if _CCCL_HAS_INCLUDE(<version>) // <version> should be the smallest include possible
-#    include <version>
-#  elif !_CCCL_COMPILER(NVRTC)
-#    include <ciso646> // otherwise go for the smallest possible header
-#  endif // !_CCCL_COMPILER(NVRTC)
-
-// Bring in the bits of the STL we need
-#  if defined(_GLIBCXX_VERSION)
-#    include <bits/move.h> // for move, forward, forward_like, and addressof
-#  elif defined(_LIBCPP_VERSION)
-#    include <__memory/addressof.h>
-#    include <__utility/as_const.h>
-#    include <__utility/forward.h>
-#    include <__utility/forward_like.h>
-#    include <__utility/move.h>
-#  endif
-
-#  if defined(_GLIBCXX_VERSION) || defined(_LIBCPP_VERSION)
-// std::move builtin
-#    if _CCCL_COMPILER(CLANG, >=, 15) || _CCCL_COMPILER(GCC, >=, 15)
-#      define _CCCL_HAS_BUILTIN_STD_MOVE() 1
-#    endif
-
-// std::forward builtin
-#    if _CCCL_COMPILER(CLANG, >=, 15) || _CCCL_COMPILER(GCC, >=, 15)
-#      define _CCCL_HAS_BUILTIN_STD_FORWARD() 1
-#    endif
-
-// std::addressof builtin
-#    if _CCCL_COMPILER(CLANG, >=, 15) || _CCCL_COMPILER(GCC, >=, 15)
-#      define _CCCL_HAS_BUILTIN_STD_ADDRESSOF() 1
-#    endif
-
-// std::as_const builtin
-#    if _CCCL_COMPILER(CLANG, >=, 15)
-#      define _CCCL_HAS_BUILTIN_STD_AS_CONST() 1
-#    endif
-
-// std::forward_like builtin
-// Leaving out MSVC for now because it is hard for forward-declare std::forward_like.
-#    if (_CCCL_COMPILER(CLANG, >=, 17) || _CCCL_COMPILER(GCC, >=, 15)) && defined(__cpp_lib_forward_like) \
-      && (__cpp_lib_forward_like >= 202217L)
-#      define _CCCL_HAS_BUILTIN_STD_FORWARD_LIKE() 1
-#    endif
-#  endif // defined(_GLIBCXX_VERSION) || defined(_LIBCPP_VERSION) || defined(_MSVC_STL_VERSION)
-#endif // defined(__cplusplus)
+// todo: re-enable std builtins
+
+// // Some compilers provide std::move/std::forward/etc as builtins
+// #if defined(__cplusplus)
+// // Bring in the bits of the STL we need
+// #  if _CCCL_HOST_STD_LIB(LIBSTDCXX)
+// #    include <bits/move.h> // for move, forward, forward_like, and addressof
+// #  elif _CCCL_HOST_STD_LIB(LIBCXX)
+// #    include <__memory/addressof.h>
+// #    include <__utility/as_const.h>
+// #    include <__utility/forward.h>
+// #    if __cpp_lib_forward_like >= 202217L
+// #      include <__utility/forward_like.h>
+// #    endif // __cpp_lib_forward_like >= 202217L
+// #    include <__utility/move.h>
+// #  endif
+
+// #  if _CCCL_HOST_STD_LIB(LIBSTDCXX) || _CCCL_HOST_STD_LIB(LIBCXX)
+// // std::move builtin
+// #    if _CCCL_COMPILER(CLANG, >=, 15) || _CCCL_COMPILER(GCC, >=, 15)
+// #      define _CCCL_HAS_BUILTIN_STD_MOVE() 1
+// #    endif
+
+// // std::forward builtin
+// #    if _CCCL_COMPILER(CLANG, >=, 15) || _CCCL_COMPILER(GCC, >=, 15)
+// #      define _CCCL_HAS_BUILTIN_STD_FORWARD() 1
+// #    endif
+
+// // std::addressof builtin
+// #    if _CCCL_COMPILER(CLANG, >=, 15) || _CCCL_COMPILER(GCC, >=, 15)
+// #      define _CCCL_HAS_BUILTIN_STD_ADDRESSOF() 1
+// #    endif
+
+// // std::as_const builtin
+// #    if _CCCL_COMPILER(CLANG, >=, 15)
+// #      define _CCCL_HAS_BUILTIN_STD_AS_CONST() 1
+// #    endif
+
+// // std::forward_like builtin
+// // Leaving out MSVC for now because it is hard for forward-declare std::forward_like.
+// #    if (_CCCL_COMPILER(CLANG, >=, 17) || _CCCL_COMPILER(GCC, >=, 15)) && __cpp_lib_forward_like >= 202217L
+// #      define _CCCL_HAS_BUILTIN_STD_FORWARD_LIKE() 1
+// #    endif
+// #  endif // _CCCL_HOST_STD_LIB(LIBSTDCXX) || _CCCL_HOST_STD_LIB(LIBCXX)
+// #endif // defined(__cplusplus)
 
 #ifndef _CCCL_HAS_BUILTIN_STD_MOVE
 #  define _CCCL_HAS_BUILTIN_STD_MOVE() 0

cuda/cccl/headers/include/cuda/std/__cccl/execution_space.h

@@ -65,4 +65,10 @@
 #  endif // _CCCL_CUDA_COMPILER(NVCC)
 #endif // !_CCCL_EXEC_CHECK_DISABLE
 
+#if _CCCL_CUDA_COMPILER(NVHPC)
+#  define _CCCL_TARGET_CONSTEXPR
+#else // ^^^ _CCCL_CUDA_COMPILER(NVHPC) ^^^ / vvv !_CCCL_CUDA_COMPILER(NVHPC) vvv
+#  define _CCCL_TARGET_CONSTEXPR constexpr
+#endif // ^^^ !_CCCL_CUDA_COMPILER(NVHPC) ^^^
+
 #endif // __CCCL_EXECUTION_SPACE_H

cuda/cccl/headers/include/cuda/std/__cccl/host_std_lib.h

@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CCCL_HOST_STD_LIB_H
+#define __CCCL_HOST_STD_LIB_H
+
+#include <cuda/std/__cccl/compiler.h>
+#include <cuda/std/__cccl/preprocessor.h>
+#include <cuda/std/__cccl/system_header.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#define _CCCL_HOST_STD_LIB_LIBSTDCXX() 0
+#define _CCCL_HOST_STD_LIB_LIBCXX()    0
+#define _CCCL_HOST_STD_LIB_STL()       0
+
+// include a minimal header
+#if _CCCL_HAS_INCLUDE(<version>)
+#  include <version>
+#elif _CCCL_HAS_INCLUDE(<ciso646>)
+#  include <ciso646>
+#endif // ^^^ _CCCL_HAS_INCLUDE(<ciso646>) ^^^
+
+#if defined(_MSVC_STL_VERSION)
+#  undef _CCCL_HOST_STD_LIB_STL
+#  define _CCCL_HOST_STD_LIB_STL() 1
+#elif defined(__GLIBCXX__)
+#  undef _CCCL_HOST_STD_LIB_LIBSTDCXX
+#  define _CCCL_HOST_STD_LIB_LIBSTDCXX() 1
+#elif defined(_LIBCPP_VERSION)
+#  undef _CCCL_HOST_STD_LIB_LIBCXX
+#  define _CCCL_HOST_STD_LIB_LIBCXX() 1
+#endif // ^^^ _LIBCPP_VERSION ^^^
+
+#define _CCCL_HOST_STD_LIB(_X) _CCCL_HOST_STD_LIB_##_X()
+#define _CCCL_HAS_HOST_STD_LIB() \
+  (_CCCL_HOST_STD_LIB_LIBSTDCXX() || _CCCL_HOST_STD_LIB_LIBCXX() || _CCCL_HOST_STD_LIB_STL())
+
+#endif // __CCCL_HOST_STD_LIB_H

cuda/cccl/headers/include/cuda/std/__cccl/memory_wrapper.h

@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_STD__CCCL_MEMORY_WRAPPER_H
+#define _CUDA_STD__CCCL_MEMORY_WRAPPER_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// When nvc++ uses CCCL components as part of its implementation of
+// Standard C++ algorithms, a cycle of included files may result when CCCL code
+// tries to use a standard algorithm. The THRUST_INCLUDING_ALGORITHMS_HEADER macro
+// is defined only when CCCL is including an algorithms-related header, giving
+// the compiler a chance to detect and break the cycle of includes.
+
+#if !_CCCL_COMPILER(NVRTC)
+#  define THRUST_INCLUDING_ALGORITHMS_HEADER
+#  include <memory>
+#  undef THRUST_INCLUDING_ALGORITHMS_HEADER
+#endif // !_CCCL_COMPILER(NVRTC)
+
+#endif // _CUDA_STD__CCCL_MEMORY_WRAPPER_H

cuda/cccl/headers/include/cuda/std/__cccl/numeric_wrapper.h

@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_STD__CCCL_NUMERIC_WRAPPER_H
+#define _CUDA_STD__CCCL_NUMERIC_WRAPPER_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// When a compiler uses CCCL components as part of its implementation of
+// Standard C++ algorithms, a cycle of included files may result when CCCL code
+// tries to use a standard algorithm. The THRUST_INCLUDING_ALGORITHMS_HEADER macro
+// is defined only when CCCL is including an algorithms-related header, giving
+// the compiler a chance to detect and break the cycle of includes.
+
+#if !_CCCL_COMPILER(NVRTC)
+#  define THRUST_INCLUDING_ALGORITHMS_HEADER
+#  include <numeric>
+#  undef THRUST_INCLUDING_ALGORITHMS_HEADER
+#endif // !_CCCL_COMPILER(NVRTC)
+
+#endif // _CUDA_STD__CCCL_NUMERIC_WRAPPER_H

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)