cuda-cccl 0.3.2__cp313-cp313-manylinux_2_24_aarch64.whl → 0.3.4__cp313-cp313-manylinux_2_24_aarch64.whl

cuda/cccl/headers/include/cuda/std/__random/seed_seq.h

@@ -0,0 +1,204 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___RANDOM_SEED_SEQ_H
+#define _CUDA_STD___RANDOM_SEED_SEQ_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
+
+#include <cuda/std/__algorithm/copy_n.h>
+#include <cuda/std/__algorithm/fill.h>
+#include <cuda/std/__algorithm/max.h>
+#include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__exception/exception_macros.h>
+#include <cuda/std/__type_traits/is_integer.h>
+#include <cuda/std/cstddef>
+#include <cuda/std/cstdint>
+#include <cuda/std/initializer_list>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+/// @class seed_seq
+///
+/// Generate unbiased seeds by filling the output range [begin, end) with 32-bit
+/// unsigned integer values, based on the (possibly biased) seeds stored in the
+/// internal buffer. If `begin == end`, the function does nothing. Otherwise,
+/// the values are produced by the standard seed sequence mixing algorithm.
+///
+/// If `std::iterator_traits<RandomIt>::value_type` is not an unsigned integer
+/// type, or its width is less than 32 bits, the program is ill-formed.
+/// If `RandomIt` does not meet the requirements of a LegacyRandomAccessIterator
+/// or is not mutable, the behavior is undefined.
+class _CCCL_TYPE_VISIBILITY_DEFAULT seed_seq
+{
+public:
+  using result_type = uint_least32_t;
+
+  /// @brief Default-construct an empty seed sequence.
+  ///
+  /// `size()` will return 0.
+  _CCCL_HIDE_FROM_ABI constexpr seed_seq() noexcept = default;
+
+  /// @brief Construct from an iterator range of seed values.
+  /// @tparam _InputIt Input iterator type yielding values convertible to `result_type`.
+  /// @param __begin Iterator pointing to the first seed value.
+  /// @param __end Iterator one-past-the-last seed value.
+  template <class _InputIt>
+  _CCCL_API _CCCL_CONSTEXPR_CXX20 seed_seq(_InputIt __begin, _InputIt __end)
+  {
+    auto __n = ::cuda::std::distance(__begin, __end);
+    if (__n <= 0)
+    {
+      return;
+    }
+    __data_ = new result_type[__n]{};
+    __size_ = static_cast<size_t>(__n);
+    _CCCL_TRY
+    {
+      for (size_t __i = 0; __i < __size_; ++__i, ++__begin)
+      {
+        __data_[__i] = static_cast<uint32_t>(*__begin);
+      }
+    }
+    _CCCL_CATCH_ALL
+    {
+      delete[] __data_;
+      _CCCL_RETHROW;
+    }
+  }
+
+  /// @brief Construct from an initializer list of seed values.
+  /// @tparam _InitT Element type convertible to `result_type`.
+  /// @param __il The list of seed values.
+  _CCCL_TEMPLATE(typename _InitT)
+  _CCCL_REQUIRES(__cccl_is_integer_v<_InitT>)
+  _CCCL_API _CCCL_CONSTEXPR_CXX20 seed_seq(initializer_list<_InitT> __il)
+      : seed_seq(__il.begin(), __il.end())
+  {}
+
+  /// @brief seed_seq is not copyable.
+  seed_seq(const seed_seq&) = delete;
+
+  _CCCL_API _CCCL_CONSTEXPR_CXX20 ~seed_seq()
+  {
+    delete[] __data_;
+  }
+
+  /// @brief seed_seq is not copy-assignable.
+  seed_seq& operator=(const seed_seq&) = delete;
+
+  /// @brief Returns the number of seed values stored.
+  /// @return Number of internal seed values (may be 0).
+  [[nodiscard]] _CCCL_API constexpr size_t size() const noexcept
+  {
+    return __size_;
+  }
+
+  /// @brief Copy stored seed values into the output iterator `__dest`.
+  /// @tparam _OutputIt Output iterator type accepting `result_type` values.
+  /// @param __dest Destination iterator where stored values will be written.
+  template <class _OutputIt>
+  _CCCL_API constexpr void param(_OutputIt __dest) const
+  {
+    ::cuda::std::copy_n(__data_, __size_, __dest);
+  }
+
+  /// @brief Generate unbiased seeds by filling the output range [begin, end) with 32-bit unsigned integer values, based
+  /// on the (possibly biased) seeds stored in v. The generation algorithm is adapted from the initialization sequence
+  /// of the Mersenne Twister generator by Makoto Matsumoto and Takuji Nishimura, incorporating the improvements made by
+  /// Mutsuo Saito in 2007.
+  /// @tparam _RandomIt Random-access iterator to writable storage for `result_type`.
+  /// @param __begin Iterator to the beginning of the destination range.
+  /// @param __end Iterator one-past-the-end of the destination range.
+  template <class _RandomIt>
+  _CCCL_API constexpr void generate(_RandomIt __begin, _RandomIt __end) const
+  {
+    if (__begin == __end)
+    {
+      return;
+    }
+    // https://en.cppreference.com/w/cpp/numeric/random/seed_seq/generate.html
+    const result_type __z = static_cast<result_type>(__size_);
+    const result_type __n = static_cast<result_type>(::cuda::std::distance(__begin, __end));
+    const result_type __m = ::cuda::std::max(__z + 1, __n);
+    const result_type __t = (__n >= 623) ? 11 : (__n >= 68) ? 7 : (__n >= 39) ? 5 : (__n >= 7) ? 3 : (__n - 1) / 2;
+    const result_type __p = (__n - __t) / 2;
+    const result_type __q = __p + __t;
+
+    // 1.
+    ::cuda::std::fill(__begin, __end, result_type{0x8b8b8b8b});
+
+    // 2.
+    for (size_t __k = 0; __k < __m; ++__k)
+    {
+      result_type __k_mod_n   = __k % __n;
+      result_type __k_p_mod_n = (__k + __p) % __n;
+      result_type __k_q_mod_n = (__k + __q) % __n;
+      // 2.1
+      const result_type __r1 =
+        1664525 * __generate_T(__begin[__k_mod_n] ^ __begin[__k_p_mod_n] ^ __begin[(__k - 1) % __n]);
+      // 2.2
+      result_type __r2 = (__k == 0)   ? __r1 + __z
+                       : (__k <= __z) ? __r1 + __k_mod_n + __data_[__k - 1]
+                                      : __r1 + __k_mod_n;
+      // 2.3
+      __begin[__k_p_mod_n] += __r1;
+      __begin[__k_p_mod_n] &= 0xFFFFFFFF;
+      __begin[__k_q_mod_n] += __r2;
+      __begin[__k_q_mod_n] &= 0xFFFFFFFF;
+      __begin[__k_mod_n] = __r2 & 0xFFFFFFFF;
+    }
+
+    // 3.
+    for (size_t __k = __m; __k < __m + __n; ++__k)
+    {
+      result_type __k_mod_n   = __k % __n;
+      result_type __k_p_mod_n = (__k + __p) % __n;
+      result_type __k_q_mod_n = (__k + __q) % __n;
+      // 3.1
+      const result_type __r3 =
+        1566083941 * __generate_T(__begin[__k_mod_n] + __begin[__k_p_mod_n] + __begin[(__k - 1) % __n]);
+      // 3.2
+      const result_type __r4 = __r3 - __k_mod_n;
+      // 3.3
+      __begin[__k_p_mod_n] ^= __r3;
+      __begin[__k_p_mod_n] &= 0xFFFFFFFF;
+      // 3.4
+      __begin[__k_q_mod_n] ^= __r4;
+      __begin[__k_q_mod_n] &= 0xFFFFFFFF;
+      // 3.5
+      __begin[__k_mod_n] = __r4 & 0xFFFFFFFF;
+    }
+  }
+
+private:
+  [[nodiscard]] _CCCL_API static constexpr result_type __generate_T(result_type __x) noexcept
+  {
+    return (__x ^ (__x >> 27));
+  }
+  result_type* __data_ = nullptr;
+  size_t __size_       = 0;
+};
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___RANDOM_SEED_SEQ_H

cuda/cccl/headers/include/cuda/std/__random_

@@ -22,6 +22,8 @@
 #endif // no system header
 
 #include <cuda/std/__random/linear_congruential_engine.h>
+#include <cuda/std/__random/philox_engine.h>
+#include <cuda/std/__random/seed_seq.h>
 #include <cuda/std/__random/uniform_int_distribution.h>
 #include <cuda/std/__random/uniform_real_distribution.h>
 #include <cuda/std/version>

cuda/cccl/headers/include/cuda/std/__ranges/concepts.h

@@ -125,19 +125,13 @@ concept contiguous_range = random_access_range<_Tp> && contiguous_iterator<itera
 template <class _Tp>
 concept common_range = range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp>>;
 
-template <class _Tp>
-inline constexpr bool __is_std_initializer_list = false;
-
-template <class _Ep>
-inline constexpr bool __is_std_initializer_list<initializer_list<_Ep>> = true;
-
 template <class _Tp>
 concept viewable_range =
   range<_Tp>
   && ((view<remove_cvref_t<_Tp>> && constructible_from<remove_cvref_t<_Tp>, _Tp>)
       || (!view<remove_cvref_t<_Tp>>
           && (is_lvalue_reference_v<_Tp>
-              || (movable<remove_reference_t<_Tp>> && !__is_std_initializer_list<remove_cvref_t<_Tp>>) )));
+              || (movable<remove_reference_t<_Tp>> && !__is_cuda_std_initializer_list<remove_cvref_t<_Tp>>) )));
 
 #else // ^^^ _CCCL_HAS_CONCEPTS() ^^^ / vvv !_CCCL_HAS_CONCEPTS() vvv
 // [range.range]
@@ -272,21 +266,15 @@ _CCCL_CONCEPT_FRAGMENT(__common_range_,
 template <class _Tp>
 _CCCL_CONCEPT common_range = _CCCL_FRAGMENT(__common_range_, _Tp);
 
-template <class _Tp>
-inline constexpr bool __is_std_initializer_list = false;
-
-template <class _Ep>
-inline constexpr bool __is_std_initializer_list<initializer_list<_Ep>> = true;
-
 template <class _Tp>
 _CCCL_CONCEPT_FRAGMENT(
   __viewable_range_,
-  requires()(
-    requires(range<_Tp>),
-    requires(((view<remove_cvref_t<_Tp>> && constructible_from<remove_cvref_t<_Tp>, _Tp>)
-              || (!view<remove_cvref_t<_Tp>>
-                  && (is_lvalue_reference_v<_Tp>
-                      || (movable<remove_reference_t<_Tp>> && !__is_std_initializer_list<remove_cvref_t<_Tp>>) ))))));
+  requires()(requires(range<_Tp>),
+             requires(((view<remove_cvref_t<_Tp>> && constructible_from<remove_cvref_t<_Tp>, _Tp>)
+                       || (!view<remove_cvref_t<_Tp>>
+                           && (is_lvalue_reference_v<_Tp>
+                               || (movable<remove_reference_t<_Tp>>
+                                   && !__is_cuda_std_initializer_list<remove_cvref_t<_Tp>>) ))))));
 
 template <class _Tp>
 _CCCL_CONCEPT viewable_range = _CCCL_FRAGMENT(__viewable_range_, _Tp);

cuda/cccl/headers/include/cuda/std/__ranges/movable_box.h

@@ -141,7 +141,7 @@ struct __mb_optional_copy_assign : __mb_optional_destruct_base<_Tp>
 {
   _LIBCUDACXX_DELEGATE_CONSTRUCTORS(__mb_optional_copy_assign, __mb_optional_destruct_base, _Tp);
 
-  _CCCL_HIDE_FROM_ABI constexpr __mb_optional_copy_assign(const __mb_optional_copy_assign&) = default;
+  _CCCL_HIDE_FROM_ABI constexpr __mb_optional_copy_assign(const __mb_optional_copy_assign&) = delete;
   _CCCL_HIDE_FROM_ABI constexpr __mb_optional_copy_assign(__mb_optional_copy_assign&&)      = default;
 
   _CCCL_HIDE_FROM_ABI constexpr __mb_optional_copy_assign& operator=(const __mb_optional_copy_assign&) = delete;
@@ -209,9 +209,7 @@ struct __mb_optional_move_assign<_Tp, false> : __mb_optional_copy_assign<_Tp>
 };
 
 template <class _Tp>
-struct __mb_optional_base
-    : __mb_optional_move_assign<_Tp>
-    , __sfinae_move_base<copy_constructible<_Tp>, true>
+struct __mb_optional_base : __mb_optional_move_assign<_Tp>
 {
   _LIBCUDACXX_DELEGATE_CONSTRUCTORS(__mb_optional_base, __mb_optional_move_assign, _Tp);
 

cuda/cccl/headers/include/cuda/std/__ranges/owning_view.h

@@ -33,6 +33,7 @@
 #include <cuda/std/__type_traits/is_nothrow_default_constructible.h>
 #include <cuda/std/__type_traits/remove_cvref.h>
 #include <cuda/std/__utility/move.h>
+#include <cuda/std/initializer_list>
 
 #include <cuda/std/__cccl/prologue.h>
 
@@ -40,12 +41,12 @@ _CCCL_BEGIN_NAMESPACE_RANGES
 
 #if _CCCL_HAS_CONCEPTS()
 template <range _Rp>
-  requires movable<_Rp> && (!__is_std_initializer_list<remove_cvref_t<_Rp>>)
+  requires movable<_Rp> && (!__is_cuda_std_initializer_list<remove_cvref_t<_Rp>>)
 #else // ^^^ _CCCL_HAS_CONCEPTS() ^^^ / vvv !_CCCL_HAS_CONCEPTS() vvv
 template <class _Rp,
-          enable_if_t<range<_Rp>, int>                                      = 0,
-          enable_if_t<movable<_Rp>, int>                                    = 0,
-          enable_if_t<!__is_std_initializer_list<remove_cvref_t<_Rp>>, int> = 0>
+          enable_if_t<range<_Rp>, int>                                           = 0,
+          enable_if_t<movable<_Rp>, int>                                         = 0,
+          enable_if_t<!__is_cuda_std_initializer_list<remove_cvref_t<_Rp>>, int> = 0>
 #endif // ^^^ !_CCCL_HAS_CONCEPTS() ^^^
 class owning_view : public view_interface<owning_view<_Rp>>
 {

cuda/cccl/headers/include/cuda/std/__ranges/repeat_view.h

@@ -40,7 +40,7 @@
 #include <cuda/std/__utility/in_place.h>
 #include <cuda/std/__utility/move.h>
 #include <cuda/std/__utility/piecewise_construct.h>
-#include <cuda/std/detail/libcxx/include/tuple>
+#include <cuda/std/tuple>
 
 #include <cuda/std/__cccl/prologue.h>
 

cuda/cccl/headers/include/cuda/std/__string/string_view.h

@@ -23,10 +23,10 @@
 #if _LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
 #  include <cuda/std/compare>
 #endif
+#include <cuda/std/__exception/throw_error.h>
 #include <cuda/std/__string/char_traits.h>
 #include <cuda/std/__type_traits/is_constant_evaluated.h>
 #include <cuda/std/cstddef>
-#include <cuda/std/detail/libcxx/include/stdexcept>
 
 #include <cuda/std/__cccl/prologue.h>
 
@@ -170,16 +170,16 @@ public:
 
 #if _LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
 
-  [[nodiscard]] _CCCL_API friend constexpr auto
-  operator<=>(__string_view const& __lhs, __string_view const& __rhs) noexcept
+  [[nodiscard]]
+  _CCCL_API friend constexpr auto operator<=>(__string_view const& __lhs, __string_view const& __rhs) noexcept
   {
     return __lhs.compare(__rhs) <=> 0;
   }
 
 #else // ^^^ _LIBCUDACXX_HAS_SPACESHIP_OPERATOR() ^^^ / vvv !_LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
 
-  [[nodiscard]] _CCCL_API friend constexpr bool
-  operator!=(__string_view const& __lhs, __string_view const& __rhs) noexcept
+  [[nodiscard]]
+  _CCCL_API friend constexpr bool operator!=(__string_view const& __lhs, __string_view const& __rhs) noexcept
   {
     return !(__lhs == __rhs);
   }

cuda/cccl/headers/include/cuda/std/__tuple_dir/apply.h

@@ -0,0 +1,82 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, 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___TUPLE_APPLY_H
+#define _CUDA_STD___TUPLE_APPLY_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
+
+#include <cuda/std/__functional/invoke.h>
+#include <cuda/std/__tuple_dir/get.h>
+#include <cuda/std/__tuple_dir/tuple.h>
+#include <cuda/std/__tuple_dir/tuple_indices.h>
+#include <cuda/std/__tuple_dir/tuple_like.h>
+#include <cuda/std/__tuple_dir/tuple_size.h>
+#include <cuda/std/__type_traits/remove_reference.h>
+#include <cuda/std/__utility/forward.h>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+template <class _Fn, class _Tuple>
+inline constexpr bool __can_apply_impl = false;
+
+template <class _Fn, class... _Types>
+inline constexpr bool __can_apply_impl<_Fn, __tuple_types<_Types...>> = is_invocable_v<_Fn, _Types...>;
+
+template <class _Fn, class _Tuple, bool = __tuple_like<_Tuple>>
+inline constexpr bool __can_apply = false;
+
+template <class _Fn, class _Tuple>
+inline constexpr bool __can_apply<_Fn, _Tuple, true> = __can_apply_impl<_Fn, __make_tuple_types_t<_Tuple>>;
+
+#define _LIBCUDACXX_NOEXCEPT_RETURN(...) \
+  noexcept(noexcept(__VA_ARGS__))        \
+  {                                      \
+    return __VA_ARGS__;                  \
+  }
+
+template <class _Fn, class _Tuple, size_t... _Id>
+_CCCL_API constexpr decltype(auto) __apply_tuple_impl(_Fn&& __f, _Tuple&& __t, __tuple_indices<_Id...>)
+  _LIBCUDACXX_NOEXCEPT_RETURN(
+    ::cuda::std::__invoke(::cuda::std::forward<_Fn>(__f), ::cuda::std::get<_Id>(::cuda::std::forward<_Tuple>(__t))...))
+
+    template <class _Fn, class _Tuple>
+    _CCCL_API constexpr decltype(auto) apply(_Fn&& __f, _Tuple&& __t)
+      _LIBCUDACXX_NOEXCEPT_RETURN(::cuda::std::__apply_tuple_impl(
+        ::cuda::std::forward<_Fn>(__f),
+        ::cuda::std::forward<_Tuple>(__t),
+        __make_tuple_indices_t<tuple_size_v<remove_reference_t<_Tuple>>>{}))
+
+        template <class _Tp, class _Tuple, size_t... _Idx>
+        _CCCL_API constexpr _Tp
+  __make_from_tuple_impl(_Tuple&& __t, __tuple_indices<_Idx...>)
+    _LIBCUDACXX_NOEXCEPT_RETURN(_Tp(::cuda::std::get<_Idx>(::cuda::std::forward<_Tuple>(__t))...))
+
+      template <class _Tp, class _Tuple>
+      _CCCL_API constexpr _Tp
+  make_from_tuple(_Tuple&& __t) _LIBCUDACXX_NOEXCEPT_RETURN(::cuda::std::__make_from_tuple_impl<_Tp>(
+    ::cuda::std::forward<_Tuple>(__t), __make_tuple_indices_t<tuple_size_v<remove_reference_t<_Tuple>>>{}))
+
+#undef _LIBCUDACXX_NOEXCEPT_RETURN
+
+    _CCCL_END_NAMESPACE_CUDA_STD
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___TUPLE_APPLY_H

cuda/cccl/headers/include/cuda/std/__tuple_dir/get.h

@@ -0,0 +1,122 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, 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___TUPLE_GET_H
+#define _CUDA_STD___TUPLE_GET_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
+
+#include <cuda/std/__fwd/get.h>
+#include <cuda/std/__tuple_dir/tuple.h>
+#include <cuda/std/__tuple_dir/tuple_element.h>
+#include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/__utility/move.h>
+#include <cuda/std/cstdint>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+template <size_t _Ip, class... _Tp>
+[[nodiscard]] _CCCL_API constexpr tuple_element_t<_Ip, tuple<_Tp...>>& get(tuple<_Tp...>& __t) noexcept
+{
+  return __t.template __get_impl<_Ip>();
+}
+
+template <size_t _Ip, class... _Tp>
+[[nodiscard]] _CCCL_API constexpr const tuple_element_t<_Ip, tuple<_Tp...>>& get(const tuple<_Tp...>& __t) noexcept
+{
+  return __t.template __get_impl<_Ip>();
+}
+
+template <size_t _Ip, class... _Tp>
+[[nodiscard]] _CCCL_API constexpr tuple_element_t<_Ip, tuple<_Tp...>>&& get(tuple<_Tp...>&& __t) noexcept
+{
+  return ::cuda::std::move(__t).template __get_impl<_Ip>();
+}
+
+template <size_t _Ip, class... _Tp>
+[[nodiscard]] _CCCL_API constexpr const tuple_element_t<_Ip, tuple<_Tp...>>&& get(const tuple<_Tp...>&& __t) noexcept
+{
+  return ::cuda::std::move(__t).template __get_impl<_Ip>();
+}
+
+namespace __find_detail
+{
+static constexpr size_t __not_found = ~size_t(0);
+static constexpr size_t __ambiguous = __not_found - 1;
+
+[[nodiscard]] _CCCL_API constexpr size_t __find_idx_return(size_t __curr_i, size_t __res, bool __matches) noexcept
+{
+  return !__matches ? __res : (__res == __not_found ? __curr_i : __ambiguous);
+}
+
+template <size_t _Nx>
+[[nodiscard]] _CCCL_API constexpr size_t __find_idx(size_t __i, const bool (&__matches)[_Nx]) noexcept
+{
+  return __i == _Nx ? __not_found : __find_idx_return(__i, __find_idx(__i + 1, __matches), __matches[__i]);
+}
+
+template <class _T1, class... _Args>
+struct __find_exactly_one_checked
+{
+  static constexpr bool __matches[sizeof...(_Args)] = {is_same_v<_T1, _Args>...};
+  static constexpr size_t value                     = __find_detail::__find_idx(0, __matches);
+  static_assert(value != __not_found, "type not found in type list");
+  static_assert(value != __ambiguous, "type occurs more than once in type list");
+};
+
+template <class _T1>
+struct __find_exactly_one_checked<_T1>
+{
+  static_assert(!is_same_v<_T1, _T1>, "type not in empty type list");
+};
+} // namespace __find_detail
+
+template <typename _T1, typename... _Args>
+struct __find_exactly_one_t : public __find_detail::__find_exactly_one_checked<_T1, _Args...>
+{};
+
+template <class _T1, class... _Args>
+[[nodiscard]] _CCCL_API constexpr _T1& get(tuple<_Args...>& __tup) noexcept
+{
+  return ::cuda::std::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
+}
+
+template <class _T1, class... _Args>
+[[nodiscard]] _CCCL_API constexpr _T1 const& get(tuple<_Args...> const& __tup) noexcept
+{
+  return ::cuda::std::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
+}
+
+template <class _T1, class... _Args>
+[[nodiscard]] _CCCL_API constexpr _T1&& get(tuple<_Args...>&& __tup) noexcept
+{
+  return ::cuda::std::get<__find_exactly_one_t<_T1, _Args...>::value>(::cuda::std::move(__tup));
+}
+
+template <class _T1, class... _Args>
+[[nodiscard]] _CCCL_API constexpr _T1 const&& get(tuple<_Args...> const&& __tup) noexcept
+{
+  return ::cuda::std::get<__find_exactly_one_t<_T1, _Args...>::value>(::cuda::std::move(__tup));
+}
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___TUPLE_GET_H