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

cuda/cccl/headers/include/cuda/__iterator/zip_common.h

@@ -35,16 +35,6 @@
 
 _CCCL_BEGIN_NAMESPACE_CUDA
 
-_CCCL_TEMPLATE(class... _Iterators)
-_CCCL_REQUIRES((sizeof...(_Iterators) != 2))
-[[nodiscard]] _CCCL_API constexpr auto __tuple_or_pair_impl() noexcept -> ::cuda::std::tuple<_Iterators...>;
-
-template <class _Tp, class _Up>
-[[nodiscard]] _CCCL_API constexpr auto __tuple_or_pair_impl() noexcept -> ::cuda::std::pair<_Tp, _Up>;
-
-template <class... _Iterators>
-using __tuple_or_pair = decltype(::cuda::__tuple_or_pair_impl<_Iterators...>());
-
 template <class... _Iterators>
 struct __zip_iter_constraints
 {
@@ -106,7 +96,7 @@ template <class... _Iterators>
 struct __zip_op_star
 {
   template <class... _Iterators>
-  using reference = __tuple_or_pair<::cuda::std::iter_reference_t<_Iterators>...>;
+  using reference = ::cuda::std::tuple<::cuda::std::iter_reference_t<_Iterators>...>;
 
   _CCCL_EXEC_CHECK_DISABLE
   template <class... _Iterators>
@@ -140,7 +130,7 @@ struct __zip_op_decrement
 struct __zip_iter_move
 {
   template <class... _Iterators>
-  using __iter_move_ret = __tuple_or_pair<::cuda::std::iter_rvalue_reference_t<_Iterators>...>;
+  using __iter_move_ret = ::cuda::std::tuple<::cuda::std::iter_rvalue_reference_t<_Iterators>...>;
 
   _CCCL_EXEC_CHECK_DISABLE
   template <class... _Iterators>

cuda/cccl/headers/include/cuda/__iterator/zip_iterator.h

@@ -42,7 +42,6 @@
 #include <cuda/std/__utility/forward.h>
 #include <cuda/std/__utility/integer_sequence.h>
 #include <cuda/std/__utility/move.h>
-#include <cuda/std/__utility/pair.h>
 #include <cuda/std/tuple>
 
 #include <cuda/std/__cccl/prologue.h>
@@ -123,7 +122,7 @@ using __zv_iter_category_base =
 template <class... _Iterators>
 class zip_iterator : public __zv_iter_category_base<_Iterators...>
 {
-  __tuple_or_pair<_Iterators...> __current_;
+  ::cuda::std::tuple<_Iterators...> __current_;
 
   template <class...>
   friend class zip_iterator;
@@ -131,8 +130,8 @@ class zip_iterator : public __zv_iter_category_base<_Iterators...>
   template <class _Fn>
   _CCCL_API static constexpr auto
   __zip_apply(const _Fn& __fun,
-              const __tuple_or_pair<_Iterators...>& __tuple1,
-              const __tuple_or_pair<_Iterators...>& __tuple2) //
+              const ::cuda::std::tuple<_Iterators...>& __tuple1,
+              const ::cuda::std::tuple<_Iterators...>& __tuple2) //
     noexcept(noexcept(__fun(__tuple1, __tuple2, ::cuda::std::make_index_sequence<sizeof...(_Iterators)>())))
   {
     return __fun(__tuple1, __tuple2, ::cuda::std::make_index_sequence<sizeof...(_Iterators)>());
@@ -143,8 +142,8 @@ public:
   _CCCL_HIDE_FROM_ABI zip_iterator() = default;
 
   //! @brief Constructs a @c zip_iterator from a tuple of iterators
-  //! @param __iters A tuple or pair of iterators
-  _CCCL_API constexpr explicit zip_iterator(__tuple_or_pair<_Iterators...> __iters)
+  //! @param __iters A tuple of iterators
+  _CCCL_API constexpr explicit zip_iterator(::cuda::std::tuple<_Iterators...> __iters)
       : __current_(::cuda::std::move(__iters))
   {}
 
@@ -163,8 +162,8 @@ public:
   {}
 
   using iterator_concept = decltype(__get_zip_iterator_concept<_Iterators...>());
-  using value_type       = __tuple_or_pair<::cuda::std::iter_value_t<_Iterators>...>;
-  using reference        = __tuple_or_pair<::cuda::std::iter_reference_t<_Iterators>...>;
+  using value_type       = ::cuda::std::tuple<::cuda::std::iter_value_t<_Iterators>...>;
+  using reference        = ::cuda::std::tuple<::cuda::std::iter_reference_t<_Iterators>...>;
   using difference_type  = ::cuda::std::common_type_t<::cuda::std::iter_difference_t<_Iterators>...>;
 
   // Those are technically not to spec, but pre-ranges iterator_traits do not work properly with iterators that do not
@@ -360,8 +359,8 @@ public:
     _CCCL_EXEC_CHECK_DISABLE
     template <size_t _Zero, size_t... _Indices>
     [[nodiscard]] _CCCL_API constexpr difference_type
-    operator()(const __tuple_or_pair<_Iterators...>& __iters1,
-               const __tuple_or_pair<_Iterators...>& __iters2,
+    operator()(const ::cuda::std::tuple<_Iterators...>& __iters1,
+               const ::cuda::std::tuple<_Iterators...>& __iters2,
                ::cuda::std::index_sequence<_Zero, _Indices...>) const //
       noexcept(noexcept(((::cuda::std::get<_Indices>(__iters1) - ::cuda::std::get<_Indices>(__iters2)) && ...)))
     {
@@ -391,8 +390,8 @@ public:
   {
     _CCCL_EXEC_CHECK_DISABLE
     template <size_t... _Indices>
-    _CCCL_API constexpr bool operator()(const __tuple_or_pair<_Iterators...>& __iters1,
-                                        const __tuple_or_pair<_Iterators...>& __iters2,
+    _CCCL_API constexpr bool operator()(const ::cuda::std::tuple<_Iterators...>& __iters1,
+                                        const ::cuda::std::tuple<_Iterators...>& __iters2,
                                         ::cuda::std::index_sequence<_Indices...>) const
       noexcept(noexcept(((::cuda::std::get<_Indices>(__iters1) == ::cuda::std::get<_Indices>(__iters2)) || ...)))
     {
@@ -490,8 +489,8 @@ public:
   struct __zip_op_iter_swap
   {
     template <size_t... _Indices>
-    _CCCL_API constexpr void operator()(const __tuple_or_pair<_Iterators...>& __iters1,
-                                        const __tuple_or_pair<_Iterators...>& __iters2,
+    _CCCL_API constexpr void operator()(const ::cuda::std::tuple<_Iterators...>& __iters1,
+                                        const ::cuda::std::tuple<_Iterators...>& __iters2,
                                         ::cuda::std::index_sequence<_Indices...>) const
       noexcept(__zip_iter_constraints<_Iterators...>::__all_noexcept_swappable)
     {
@@ -508,12 +507,12 @@ public:
     return __zip_apply(__zip_op_iter_swap{}, __lhs.__current_, __rhs.__current_);
   }
 
-  [[nodiscard]] _CCCL_API constexpr __tuple_or_pair<_Iterators...>& __iterators() noexcept
+  [[nodiscard]] _CCCL_API constexpr ::cuda::std::tuple<_Iterators...>& __iterators() noexcept
   {
     return __current_;
   }
 
-  [[nodiscard]] _CCCL_API constexpr const __tuple_or_pair<_Iterators...>& __iterators() const noexcept
+  [[nodiscard]] _CCCL_API constexpr const ::cuda::std::tuple<_Iterators...>& __iterators() const noexcept
   {
     return __current_;
   }
@@ -522,9 +521,6 @@ public:
 template <class... _Iterators>
 _CCCL_HOST_DEVICE zip_iterator(::cuda::std::tuple<_Iterators...>) -> zip_iterator<_Iterators...>;
 
-template <class _Iterator1, class _Iterator2>
-_CCCL_HOST_DEVICE zip_iterator(::cuda::std::pair<_Iterator1, _Iterator2>) -> zip_iterator<_Iterator1, _Iterator2>;
-
 template <class... _Iterators>
 _CCCL_HOST_DEVICE zip_iterator(_Iterators...) -> zip_iterator<_Iterators...>;
 

cuda/cccl/headers/include/cuda/__iterator/zip_transform_iterator.h

@@ -33,6 +33,7 @@
 #include <cuda/std/__iterator/concepts.h>
 #include <cuda/std/__iterator/incrementable_traits.h>
 #include <cuda/std/__iterator/iterator_traits.h>
+#include <cuda/std/__ranges/compressed_movable_box.h>
 #include <cuda/std/__ranges/concepts.h>
 #include <cuda/std/__ranges/movable_box.h>
 #include <cuda/std/__type_traits/common_type.h>
@@ -41,7 +42,6 @@
 #include <cuda/std/__utility/forward.h>
 #include <cuda/std/__utility/integer_sequence.h>
 #include <cuda/std/__utility/move.h>
-#include <cuda/std/__utility/pair.h>
 #include <cuda/std/tuple>
 
 #include <cuda/std/__cccl/prologue.h>
@@ -153,8 +153,29 @@ template <class _Fn, class... _Iterators>
 template <class _Fn, class... _Iterators>
 class zip_transform_iterator
 {
-  ::cuda::std::ranges::__movable_box<_Fn> __func_;
-  __tuple_or_pair<_Iterators...> __current_;
+private:
+  // Not a base because then the friend operators would be ambiguous
+  ::cuda::std::__compressed_movable_box<::cuda::std::tuple<_Iterators...>, _Fn> __store_;
+
+  [[nodiscard]] _CCCL_API constexpr ::cuda::std::tuple<_Iterators...>& __iters() noexcept
+  {
+    return __store_.template __get<0>();
+  }
+
+  [[nodiscard]] _CCCL_API constexpr const ::cuda::std::tuple<_Iterators...>& __iters() const noexcept
+  {
+    return __store_.template __get<0>();
+  }
+
+  [[nodiscard]] _CCCL_API constexpr _Fn& __func() noexcept
+  {
+    return __store_.template __get<1>();
+  }
+
+  [[nodiscard]] _CCCL_API constexpr const _Fn& __func() const noexcept
+  {
+    return __store_.template __get<1>();
+  }
 
   template <class, class...>
   friend class zip_transform_iterator;
@@ -162,8 +183,8 @@ class zip_transform_iterator
   template <class _Op>
   _CCCL_API static constexpr auto
   __zip_apply(const _Op& __op,
-              const __tuple_or_pair<_Iterators...>& __tuple1,
-              const __tuple_or_pair<_Iterators...>& __tuple2) //
+              const ::cuda::std::tuple<_Iterators...>& __tuple1,
+              const ::cuda::std::tuple<_Iterators...>& __tuple2) //
     noexcept(noexcept(__op(__tuple1, __tuple2, ::cuda::std::make_index_sequence<sizeof...(_Iterators)>())))
   {
     return __op(__tuple1, __tuple2, ::cuda::std::make_index_sequence<sizeof...(_Iterators)>());
@@ -171,13 +192,6 @@ class zip_transform_iterator
 
 public:
   //! @brief Default-constructs a @c zip_transform_iterator by value-initializing the functor and all stored iterators
-#if _CCCL_HAS_CONCEPTS()
-  _CCCL_EXEC_CHECK_DISABLE
-  _CCCL_HIDE_FROM_ABI zip_transform_iterator()
-    requires ::cuda::std::default_initializable<_Fn>
-            && __zip_iter_constraints<_Iterators...>::__all_default_initializable
-  = default;
-#else // ^^^ _CCCL_HAS_CONCEPTS() ^^^ / vvv !_CCCL_HAS_CONCEPTS() vvv
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_TEMPLATE(class _Fn2 = _Fn)
   _CCCL_REQUIRES(
@@ -185,32 +199,19 @@ public:
   _CCCL_API constexpr zip_transform_iterator() noexcept(
     ::cuda::std::is_nothrow_default_constructible_v<_Fn2>
     && __zip_iter_constraints<_Iterators...>::__all_nothrow_default_constructible)
-      : __func_(::cuda::std::in_place)
-      , __current_()
+      : __store_()
   {}
-#endif // ^^^ !_CCCL_HAS_CONCEPTS() ^^^
 
   //! @brief Constructs a @c zip_transform_iterator from a tuple of iterators
   //! @param __iters A tuple or pair of iterators
-  _CCCL_API constexpr explicit zip_transform_iterator(_Fn __fun, __tuple_or_pair<_Iterators...> __iters)
-      : __func_(::cuda::std::in_place, ::cuda::std::move(__fun))
-      , __current_(::cuda::std::move(__iters))
-  {}
-
-  //! @brief Constructs a @c zip_transform_iterator from a tuple of iterators
-  //! @param __iters A tuple of iterators
-  _CCCL_TEMPLATE(size_t _NumIterators = sizeof...(_Iterators))
-  _CCCL_REQUIRES((_NumIterators == 2))
   _CCCL_API constexpr explicit zip_transform_iterator(_Fn __fun, ::cuda::std::tuple<_Iterators...> __iters)
-      : __func_(::cuda::std::in_place, ::cuda::std::move(__fun))
-      , __current_(::cuda::std::get<0>(::cuda::std::move(__iters)), ::cuda::std::get<1>(::cuda::std::move(__iters)))
+      : __store_(::cuda::std::move(__iters), ::cuda::std::move(__fun))
   {}
 
   //! @brief Constructs a @c zip_transform_iterator from variadic set of iterators
   //! @param __iters The input iterators
   _CCCL_API constexpr explicit zip_transform_iterator(_Fn __fun, _Iterators... __iters)
-      : __func_(::cuda::std::in_place, ::cuda::std::move(__fun))
-      , __current_(::cuda::std::move(__iters)...)
+      : __store_(::cuda::std::tuple<_Iterators...>{::cuda::std::move(__iters)...}, ::cuda::std::move(__fun))
   {}
 
   using iterator_concept  = decltype(::cuda::__get_zip_iterator_concept<_Iterators...>());
@@ -226,14 +227,14 @@ public:
 
   // Internal helper functions to extract internals for device dispatch, must be a tuple for cub_transform_many
   [[nodiscard]] _CCCL_API constexpr ::cuda::std::tuple<_Iterators...>
-  __base() && noexcept(::cuda::std::is_nothrow_move_constructible_v<__tuple_or_pair<_Iterators...>>)
+  __base() && noexcept(::cuda::std::is_nothrow_move_constructible_v<::cuda::std::tuple<_Iterators...>>)
   {
-    return ::cuda::std::move(__current_);
+    return ::cuda::std::move(__iters());
   }
 
   [[nodiscard]] _CCCL_API constexpr _Fn __pred() && noexcept(::cuda::std::is_nothrow_move_constructible_v<_Fn>)
   {
-    return ::cuda::std::move(*__func_);
+    return ::cuda::std::move(__func());
   }
 
   struct __zip_transform_op_star
@@ -252,7 +253,7 @@ public:
   [[nodiscard]] _CCCL_API constexpr reference operator*() const
     noexcept(::cuda::std::is_nothrow_invocable_v<_Fn&, ::cuda::std::iter_reference_t<const _Iterators>...>)
   {
-    return ::cuda::std::apply(__zip_transform_op_star{const_cast<_Fn&>(*__func_)}, __current_);
+    return ::cuda::std::apply(__zip_transform_op_star{const_cast<_Fn&>(__func())}, __iters());
   }
 
   struct __zip_transform_op_subscript
@@ -274,16 +275,17 @@ public:
   _CCCL_TEMPLATE(class _Constraints = __zip_iter_constraints<_Iterators...>)
   _CCCL_REQUIRES(_Constraints::__all_random_access)
   _CCCL_API constexpr reference operator[](difference_type __n) const
-    noexcept(noexcept(::cuda::std::apply(__zip_transform_op_subscript{__n, const_cast<_Fn&>(*__func_)}, __current_)))
+    noexcept(noexcept(::cuda::std::apply(__zip_transform_op_subscript{__n, ::cuda::std::declval<_Fn&>()},
+                                         ::cuda::std::declval<const ::cuda::std::tuple<_Iterators...>&>())))
   {
-    return ::cuda::std::apply(__zip_transform_op_subscript{__n, const_cast<_Fn&>(*__func_)}, __current_);
+    return ::cuda::std::apply(__zip_transform_op_subscript{__n, const_cast<_Fn&>(__func())}, __iters());
   }
 
   //! @brief Increments all stored iterators
-  _CCCL_API constexpr zip_transform_iterator&
-  operator++() noexcept(noexcept(::cuda::std::apply(__zip_op_increment{}, __current_)))
+  _CCCL_API constexpr zip_transform_iterator& operator++() noexcept(
+    noexcept(::cuda::std::apply(__zip_op_increment{}, ::cuda::std::declval<::cuda::std::tuple<_Iterators...>&>())))
   {
-    ::cuda::std::apply(__zip_op_increment{}, __current_);
+    ::cuda::std::apply(__zip_op_increment{}, __iters());
     return *this;
   }
 
@@ -306,10 +308,10 @@ public:
   //! @brief Decrements all stored iterators
   _CCCL_TEMPLATE(class _Constraints = __zip_iter_constraints<_Iterators...>)
   _CCCL_REQUIRES(_Constraints::__all_bidirectional)
-  _CCCL_API constexpr zip_transform_iterator&
-  operator--() noexcept(noexcept(::cuda::std::apply(__zip_op_decrement{}, __current_)))
+  _CCCL_API constexpr zip_transform_iterator& operator--() noexcept(
+    noexcept(::cuda::std::apply(__zip_op_decrement{}, ::cuda::std::declval<::cuda::std::tuple<_Iterators...>&>())))
   {
-    ::cuda::std::apply(__zip_op_decrement{}, __current_);
+    ::cuda::std::apply(__zip_op_decrement{}, __iters());
     return *this;
   }
 
@@ -339,10 +341,10 @@ public:
   //! @param __n The number of elements to increment
   _CCCL_TEMPLATE(class _Constraints = __zip_iter_constraints<_Iterators...>)
   _CCCL_REQUIRES(_Constraints::__all_random_access)
-  _CCCL_API constexpr zip_transform_iterator&
-  operator+=(difference_type __n) noexcept(noexcept(::cuda::std::apply(__zip_op_pe{__n}, __current_)))
+  _CCCL_API constexpr zip_transform_iterator& operator+=(difference_type __n) noexcept(
+    noexcept(::cuda::std::apply(__zip_op_pe{__n}, ::cuda::std::declval<::cuda::std::tuple<_Iterators...>&>())))
   {
-    ::cuda::std::apply(__zip_op_pe{__n}, __current_);
+    ::cuda::std::apply(__zip_op_pe{__n}, __iters());
     return *this;
   }
 
@@ -362,9 +364,10 @@ public:
   //! @param __n The number of elements to decrement
   _CCCL_TEMPLATE(class _Constraints = __zip_iter_constraints<_Iterators...>)
   _CCCL_REQUIRES(_Constraints::__all_random_access)
-  _CCCL_API constexpr zip_transform_iterator& operator-=(difference_type __n)
+  _CCCL_API constexpr zip_transform_iterator& operator-=(difference_type __n) noexcept(
+    noexcept(::cuda::std::apply(__zip_op_me{__n}, ::cuda::std::declval<::cuda::std::tuple<_Iterators...>&>())))
   {
-    ::cuda::std::apply(__zip_op_me{__n}, __current_);
+    ::cuda::std::apply(__zip_op_me{__n}, __iters());
     return *this;
   }
 
@@ -425,8 +428,8 @@ public:
     _CCCL_EXEC_CHECK_DISABLE
     template <size_t _Zero, size_t... _Indices>
     [[nodiscard]] _CCCL_API constexpr difference_type
-    operator()(const __tuple_or_pair<_Iterators...>& __iters1,
-               const __tuple_or_pair<_Iterators...>& __iters2,
+    operator()(const ::cuda::std::tuple<_Iterators...>& __iters1,
+               const ::cuda::std::tuple<_Iterators...>& __iters2,
                ::cuda::std::index_sequence<_Zero, _Indices...>) const //
       noexcept(noexcept(((::cuda::std::get<_Indices>(__iters1) - ::cuda::std::get<_Indices>(__iters2)) && ...)))
     {
@@ -449,15 +452,15 @@ public:
   _CCCL_API friend constexpr auto operator-(const zip_transform_iterator& __n, const zip_transform_iterator& __y)
     _CCCL_TRAILING_REQUIRES(difference_type)(_Constraints::__all_sized_sentinel)
   {
-    return __zip_apply(__zip_op_minus{}, __n.__current_, __y.__current_);
+    return __zip_apply(__zip_op_minus{}, __n.__iters(), __y.__iters());
   }
 
   struct __zip_op_eq
   {
     _CCCL_EXEC_CHECK_DISABLE
     template <size_t... _Indices>
-    _CCCL_API constexpr bool operator()(const __tuple_or_pair<_Iterators...>& __iters1,
-                                        const __tuple_or_pair<_Iterators...>& __iters2,
+    _CCCL_API constexpr bool operator()(const ::cuda::std::tuple<_Iterators...>& __iters1,
+                                        const ::cuda::std::tuple<_Iterators...>& __iters2,
                                         ::cuda::std::index_sequence<_Indices...>) const
       noexcept(noexcept(((::cuda::std::get<_Indices>(__iters1) == ::cuda::std::get<_Indices>(__iters2)) || ...)))
     {
@@ -472,11 +475,11 @@ public:
   {
     if constexpr (_Constraints::__all_bidirectional)
     {
-      return __n.__current_ == __y.__current_;
+      return __n.__iters() == __y.__iters();
     }
     else
     {
-      return __zip_apply(__zip_op_eq{}, __n.__current_, __y.__current_);
+      return __zip_apply(__zip_op_eq{}, __n.__iters(), __y.__iters());
     }
     _CCCL_UNREACHABLE();
   }
@@ -489,11 +492,11 @@ public:
   {
     if constexpr (_Constraints::__all_bidirectional)
     {
-      return __n.__current_ != __y.__current_;
+      return __n.__iters() != __y.__iters();
     }
     else
     {
-      return !__zip_apply(__zip_op_eq{}, __n.__current_, __y.__current_);
+      return !__zip_apply(__zip_op_eq{}, __n.__iters(), __y.__iters());
     }
     _CCCL_UNREACHABLE();
   }
@@ -505,7 +508,7 @@ public:
   _CCCL_API friend constexpr auto operator<=>(const zip_transform_iterator& __n, const zip_transform_iterator& __y)
     _CCCL_TRAILING_REQUIRES(bool)(_Constraints::__all_random_access&& _Constraints::__all_three_way_comparable)
   {
-    return __n.__current_ <=> __y.__current_;
+    return __n.__iters() <=> __y.__iters();
   }
 
 #else // ^^^ _LIBCUDACXX_HAS_SPACESHIP_OPERATOR() ^^^ / vvv !_LIBCUDACXX_HAS_SPACESHIP_OPERATOR() vvv
@@ -515,7 +518,7 @@ public:
   _CCCL_API friend constexpr auto operator<(const zip_transform_iterator& __n, const zip_transform_iterator& __y)
     _CCCL_TRAILING_REQUIRES(bool)(_Constraints::__all_random_access)
   {
-    return __n.__current_ < __y.__current_;
+    return __n.__iters() < __y.__iters();
   }
 
   //! @brief Compares two @c zip_transform_iterator for greater than by comparing the tuple of stored iterators
@@ -548,10 +551,6 @@ template <class _Fn, class... _Iterators>
 _CCCL_HOST_DEVICE zip_transform_iterator(_Fn, ::cuda::std::tuple<_Iterators...>)
   -> zip_transform_iterator<_Fn, _Iterators...>;
 
-template <class _Fn, class _Iterator1, class _Iterator2>
-_CCCL_HOST_DEVICE zip_transform_iterator(_Fn, ::cuda::std::pair<_Iterator1, _Iterator2>)
-  -> zip_transform_iterator<_Fn, _Iterator1, _Iterator2>;
-
 template <class _Fn, class... _Iterators>
 _CCCL_HOST_DEVICE zip_transform_iterator(_Fn, _Iterators...) -> zip_transform_iterator<_Fn, _Iterators...>;