diff --git a/include/gpu_array.hpp b/include/gpu_array.hpp
index aa56b8a..e9fd8a8 100644
--- a/include/gpu_array.hpp
+++ b/include/gpu_array.hpp
@@ -48,6 +48,197 @@
 #define SIGSEGV_DEPRECATED [[deprecated("Cannot access GPU memory directly")]]
 #endif
 
+namespace gpu_array
+{
+    // Custom implementation of tuple for device code
+
+    namespace detail
+    {
+        template <std::size_t I, class T>
+        struct tuple_leaf
+        {
+            tuple_leaf()
+            requires std::default_initializable<T>
+            = default;
+            template <class U>
+            __host__ __device__ tuple_leaf(U&& u) : value(std::forward<U>(u))
+            {
+            }
+            using type = T;
+            T value;
+        };
+
+        template <std::size_t I, class T>
+        tuple_leaf<I, T> at_index(const tuple_leaf<I, T>&);  // undefined
+
+        template <class Seq, class... Ts>
+        struct tuple_impl;
+
+        template <std::size_t... Is, class... Ts>
+        struct tuple_impl<std::index_sequence<Is...>, Ts...> : tuple_leaf<Is, Ts>...
+        {
+            tuple_impl()
+            requires (std::default_initializable<Ts> && ...)
+            = default;
+            template <class... Us>
+            requires (sizeof...(Us) == sizeof...(Ts))
+            __host__ __device__ tuple_impl(Us&&... us) : tuple_leaf<Is, Ts>(std::forward<Us>(us))...
+            {
+            }
+        };
+
+        template <class... Ts>
+        struct tuple
+        {
+            tuple()
+            requires (std::default_initializable<Ts> && ...)
+            = default;
+
+            template <class... Us>
+            struct is_single_tuple : std::false_type
+            {
+            };
+            template <class... Us>
+            struct is_single_tuple<tuple<Us...>> : std::true_type
+            {
+            };
+            template <class... Us>
+            requires (sizeof...(Us) == sizeof...(Ts) && !is_single_tuple<std::remove_cvref_t<Us>...>::value)
+            __host__ __device__ tuple(Us&&... us) : base_(std::forward<Us>(us)...)
+            {
+            }
+
+            template <class... Us>
+            requires (sizeof...(Us) == sizeof...(Ts))
+            __host__ __device__ tuple(const tuple<Us...>& t) : tuple{tuple_convert(t, std::index_sequence_for<Ts...>{})}
+            {
+            }
+            template <class... Us>
+            requires (sizeof...(Us) == sizeof...(Ts))
+            __host__ __device__ tuple(tuple<Us...>&& t)
+                : tuple{tuple_convert(std::move(t), std::index_sequence_for<Ts...>{})}
+            {
+            }
+            template <class... Us>
+            requires (sizeof...(Us) == sizeof...(Ts))
+            __host__ __device__ auto& operator=(const tuple<Us...>& t)
+            {
+                *this = tuple_convert(t, std::index_sequence_for<Ts...>{});
+                return *this;
+            }
+            template <class... Us>
+            requires (sizeof...(Us) == sizeof...(Ts))
+            __host__ __device__ auto& operator=(tuple<Us...>&& t)
+            {
+                *this = tuple_convert(std::move(t), std::index_sequence_for<Ts...>{});
+                return *this;
+            }
+
+            template <std::size_t I, class... Us>
+            __host__ __device__ friend auto& get(tuple<Us...>&);
+            template <std::size_t I, class... Us>
+            __host__ __device__ friend const auto& get(const tuple<Us...>&);
+            template <std::size_t I, class... Us>
+            __host__ __device__ friend auto&& get(tuple<Us...>&&);
+            template <std::size_t I, class... Us>
+            __host__ __device__ friend const auto&& get(const tuple<Us...>&&);
+
+        private:
+            template <class... Us, std::size_t... Is>
+            static auto tuple_convert(const tuple<Us...>& t, std::index_sequence<Is...>)
+            {
+                return tuple<Ts...>{get<Is>(t)...};
+            }
+            template <class... Us, std::size_t... Is>
+            static auto tuple_convert(tuple<Us...>&& t, std::index_sequence<Is...>)
+            {
+                return tuple<Ts...>{std::move(get<Is>(t))...};
+            }
+
+            using base = tuple_impl<std::index_sequence_for<Ts...>, Ts...>;
+            base base_;
+        };
+
+        template <class... Ts>
+        tuple(Ts...) -> tuple<Ts...>;
+
+        template <std::size_t I, class... Us>
+        __host__ __device__ auto& get(tuple<Us...>& t)
+        {
+            using leaf = decltype(at_index<I>(t.base_));
+            return static_cast<leaf&>(t.base_).value;
+        }
+        template <std::size_t I, class... Us>
+        __host__ __device__ const auto& get(const tuple<Us...>& t)
+        {
+            using leaf = decltype(at_index<I>(t.base_));
+            return static_cast<const leaf&>(t.base_).value;
+        }
+        template <std::size_t I, class... Us>
+        __host__ __device__ auto&& get(tuple<Us...>&& t)
+        {
+            using leaf = decltype(at_index<I>(t.base_));
+            return static_cast<typename leaf::type&&>(static_cast<leaf&>(t.base_).value);
+        }
+        template <std::size_t I, class... Us>
+        __host__ __device__ const auto&& get(const tuple<Us...>&& t)
+        {
+            using leaf = decltype(at_index<I>(t.base_));
+            return static_cast<const typename leaf::type&&>(static_cast<const leaf&>(t.base_).value);
+        }
+
+        template <class... Ts, class... Us, std::size_t... Is>
+        __host__ __device__ bool tuple_equal_impl(const tuple<Ts...>& t, const tuple<Us...>& u,
+                                                  std::index_sequence<Is...>)
+        {
+            return ((get<Is>(t) == get<Is>(u)) && ...);
+        }
+        template <class... Ts, class... Us>
+        requires (sizeof...(Ts) == sizeof...(Us))
+        __host__ __device__ bool operator==(const tuple<Ts...>& t, const tuple<Us...>& u)
+        {
+            return tuple_equal_impl(t, u, std::index_sequence_for<Ts...>{});
+        }
+
+        template <class F, class Tuple, std::size_t... Is>
+        requires requires { std::declval<F>()(get<Is>(std::declval<Tuple>())...); }
+        __host__ __device__ decltype(auto) apply_impl(F&& f, Tuple&& t, std::index_sequence<Is...>)
+        {
+            return std::forward<F>(f)(get<Is>(std::forward<Tuple>(t))...);
+        }
+        template <class F, class Tuple>
+        requires requires { std::tuple_size_v<std::remove_reference_t<Tuple>>; }
+        __host__ __device__ decltype(auto) apply(F&& f, Tuple&& t)
+        {
+            return apply_impl(std::forward<F>(f), std::forward<Tuple>(t),
+                              std::make_index_sequence<std::tuple_size_v<std::remove_reference_t<Tuple>>>{});
+        }
+    }  // namespace detail
+
+    using detail::tuple, detail::get, detail::apply;
+}  // namespace gpu_array
+
+template <class... Ts>
+struct std::tuple_size<gpu_array::tuple<Ts...>> : std::integral_constant<std::size_t, sizeof...(Ts)>
+{
+};
+template <std::size_t I, class... Ts>
+struct std::tuple_element<I, gpu_array::tuple<Ts...>> : std::tuple_element<I, std::tuple<Ts...>>
+{
+};
+template <class... TTypes, class... UTypes>
+requires requires { typename gpu_array::tuple<std::common_type_t<TTypes, UTypes>...>; }
+struct std::common_type<gpu_array::tuple<TTypes...>, gpu_array::tuple<UTypes...>>
+{
+    using type = gpu_array::tuple<std::common_type_t<TTypes, UTypes>...>;
+};
+template <class... TTypes, class... UTypes, template <class> class TQual, template <class> class UQual>
+requires requires { typename gpu_array::tuple<std::common_reference_t<TQual<TTypes>, UQual<UTypes>>...>; }
+struct std::basic_common_reference<gpu_array::tuple<TTypes...>, gpu_array::tuple<UTypes...>, TQual, UQual>
+{
+    using type = gpu_array::tuple<std::common_reference_t<TQual<TTypes>, UQual<UTypes>>...>;
+};
+
 namespace gpu_array
 {
 #if defined(GPU_USE_32BIT_SIZE_TYPE_DEFAULT)
@@ -120,11 +311,11 @@ namespace gpu_array
 
         protected:
             size_type size_ = 0U;
-            std::tuple<ValueTypes*...> data_;
+            gpu_array::tuple<ValueTypes*...> data_;
             std::uint32_t* ref_count_ = nullptr;  // reference counter, not used on GPU
 
             template <std::size_t N>
-            using element_type = std::tuple_element_t<N, std::tuple<ValueTypes...>>;
+            using element_type = std::tuple_element_t<N, gpu_array::tuple<ValueTypes...>>;
 
             __host__ __device__ void init()
             {
@@ -255,11 +446,11 @@ namespace gpu_array
 
             __host__ __device__ void tuple_for_each(auto&& f) const
             {
-                std::apply([&f](const auto&... args) { (f(args), ...); }, data_);
+                gpu_array::apply([&f](const auto&... args) { (f(args), ...); }, data_);
             }
             __host__ __device__ void tuple_for_each(auto&& f)
             {
-                std::apply([&f](auto&... args) { (f(args), ...); }, data_);
+                gpu_array::apply([&f](auto&... args) { (f(args), ...); }, data_);
             }
         };
 
@@ -427,8 +618,8 @@ namespace gpu_array
         {
             return *(data() + base::size_ - 1);
         }
-        __host__ __device__ pointer data() noexcept { return std::get<0>(base::data_); }
-        __host__ __device__ const_pointer data() const noexcept { return std::get<0>(base::data_); }
+        __host__ __device__ pointer data() noexcept { return gpu_array::get<0>(base::data_); }
+        __host__ __device__ const_pointer data() const noexcept { return gpu_array::get<0>(base::data_); }
 
         array() = default;
         __host__ __device__ array(const array& r) : base(r) {}
@@ -438,8 +629,8 @@ namespace gpu_array
         {
             if (base::size_ == 0) return;
             auto buf = std::make_unique<value_type[]>(base::size_);
-            GPU_CHECK_ERROR(
-                api::gpuMalloc(reinterpret_cast<void**>(&std::get<0>(base::data_)), sizeof(value_type) * base::size_));
+            GPU_CHECK_ERROR(api::gpuMalloc(reinterpret_cast<void**>(&gpu_array::get<0>(base::data_)),
+                                           sizeof(value_type) * base::size_));
             assert(data() != nullptr);
             GPU_CHECK_ERROR(api::gpuMemcpy(data(), buf.get(), sizeof(value_type) * base::size_, gpuMemcpyHostToDevice));
         }
@@ -447,8 +638,8 @@ namespace gpu_array
         __host__ array(std::size_t size, default_init_tag) : base(size)
         {
             if (base::size_ == 0) return;
-            GPU_CHECK_ERROR(
-                api::gpuMalloc(reinterpret_cast<void**>(&std::get<0>(base::data_)), sizeof(value_type) * base::size_));
+            GPU_CHECK_ERROR(api::gpuMalloc(reinterpret_cast<void**>(&gpu_array::get<0>(base::data_)),
+                                           sizeof(value_type) * base::size_));
             assert(data() != nullptr);
             if constexpr (!std::is_trivially_default_constructible_v<value_type>)
             {
@@ -465,8 +656,8 @@ namespace gpu_array
             auto al = std::allocator<value_type>();
             auto buf = al.allocate(base::size_);
             std::ranges::uninitialized_fill(buf, buf + base::size_, value);
-            GPU_CHECK_ERROR(
-                api::gpuMalloc(reinterpret_cast<void**>(&std::get<0>(base::data_)), sizeof(value_type) * base::size_));
+            GPU_CHECK_ERROR(api::gpuMalloc(reinterpret_cast<void**>(&gpu_array::get<0>(base::data_)),
+                                           sizeof(value_type) * base::size_));
             assert(data() != nullptr);
             GPU_CHECK_ERROR(api::gpuMemcpy(data(), buf, sizeof(value_type) * base::size_, gpuMemcpyHostToDevice));
             al.deallocate(buf, base::size_);
@@ -481,8 +672,8 @@ namespace gpu_array
         {
             if (base::size_ == 0) return;
 
-            GPU_CHECK_ERROR(
-                api::gpuMalloc(reinterpret_cast<void**>(&std::get<0>(base::data_)), sizeof(value_type) * base::size_));
+            GPU_CHECK_ERROR(api::gpuMalloc(reinterpret_cast<void**>(&gpu_array::get<0>(base::data_)),
+                                           sizeof(value_type) * base::size_));
             assert(data() != nullptr);
             GPU_CHECK_ERROR(
                 api::gpuMemcpy(data(), std::ranges::data(r), sizeof(value_type) * base::size_, gpuMemcpyHostToDevice));
@@ -499,8 +690,8 @@ namespace gpu_array
             auto buf = al.allocate(base::size_);
             for (auto i = std::size_t{0}; const auto& v : r) std::ranges::construct_at(buf + i++, v);
 
-            GPU_CHECK_ERROR(
-                api::gpuMalloc(reinterpret_cast<void**>(&std::get<0>(base::data_)), sizeof(value_type) * base::size_));
+            GPU_CHECK_ERROR(api::gpuMalloc(reinterpret_cast<void**>(&gpu_array::get<0>(base::data_)),
+                                           sizeof(value_type) * base::size_));
             assert(data() != nullptr);
             GPU_CHECK_ERROR(api::gpuMemcpy(data(), buf, sizeof(value_type) * base::size_, gpuMemcpyHostToDevice));
             al.deallocate(buf, base::size_);
@@ -509,8 +700,8 @@ namespace gpu_array
         __host__ array(std::initializer_list<value_type> r) : base(std::ranges::size(r))
         {
             if (base::size_ == 0) return;
-            GPU_CHECK_ERROR(
-                api::gpuMalloc(reinterpret_cast<void**>(&std::get<0>(base::data_)), sizeof(value_type) * base::size_));
+            GPU_CHECK_ERROR(api::gpuMalloc(reinterpret_cast<void**>(&gpu_array::get<0>(base::data_)),
+                                           sizeof(value_type) * base::size_));
             assert(data() != nullptr);
             GPU_CHECK_ERROR(
                 api::gpuMemcpy(data(), std::ranges::data(r), sizeof(ValueType) * base::size_, gpuMemcpyHostToDevice));
@@ -710,7 +901,7 @@ namespace gpu_array
             {
                 throw std::runtime_error("pointer type mismatch: expected device memory pointer");
             }
-            std::get<0>(base::data_) = ptr;
+            gpu_array::get<0>(base::data_) = ptr;
         }
 #endif
 #if defined(GPU_OVERLOAD_DEVICE)
@@ -756,7 +947,7 @@ namespace gpu_array
                                    [](auto acc, const auto& r) { return acc + std::ranges::size(r); }))
         {
             if (base::size_ == 0) return;
-            GPU_CHECK_ERROR(api::gpuMallocManaged(reinterpret_cast<void**>(&std::get<0>(base::data_)),
+            GPU_CHECK_ERROR(api::gpuMallocManaged(reinterpret_cast<void**>(&gpu_array::get<0>(base::data_)),
                                                   sizeof(ValueType) * base::size_));
             assert(data() != nullptr);
 
@@ -812,8 +1003,8 @@ namespace gpu_array
         __host__ __device__ const_reference front() const noexcept { return *begin(); }
         __host__ __device__ reference back() noexcept { return *(data() + base::size_ - 1); }
         __host__ __device__ const_reference back() const noexcept { return *(data() + base::size_ - 1); }
-        __host__ __device__ pointer data() noexcept { return std::get<0>(base::data_); }
-        __host__ __device__ const_pointer data() const noexcept { return std::get<0>(base::data_); }
+        __host__ __device__ pointer data() noexcept { return gpu_array::get<0>(base::data_); }
+        __host__ __device__ const_pointer data() const noexcept { return gpu_array::get<0>(base::data_); }
 
         managed_array() = default;
         __host__ __device__ managed_array(const managed_array& r) : base(r) {}
@@ -822,7 +1013,7 @@ namespace gpu_array
         __host__ explicit managed_array(std::size_t size) : base(size)
         {
             if (base::size_ == 0) return;
-            GPU_CHECK_ERROR(api::gpuMallocManaged(reinterpret_cast<void**>(&std::get<0>(base::data_)),
+            GPU_CHECK_ERROR(api::gpuMallocManaged(reinterpret_cast<void**>(&gpu_array::get<0>(base::data_)),
                                                   sizeof(value_type) * base::size_));
             assert(data() != nullptr);
             std::ranges::uninitialized_value_construct(*this);
@@ -831,7 +1022,7 @@ namespace gpu_array
         __host__ explicit managed_array(std::size_t size, default_init_tag) : base(size)
         {
             if (base::size_ == 0) return;
-            GPU_CHECK_ERROR(api::gpuMallocManaged(reinterpret_cast<void**>(&std::get<0>(base::data_)),
+            GPU_CHECK_ERROR(api::gpuMallocManaged(reinterpret_cast<void**>(&gpu_array::get<0>(base::data_)),
                                                   sizeof(value_type) * base::size_));
             assert(data() != nullptr);
             std::ranges::uninitialized_default_construct(*this);
@@ -840,7 +1031,7 @@ namespace gpu_array
         __host__ managed_array(std::size_t size, const value_type& value) : base(size)
         {
             if (base::size_ == 0) return;
-            GPU_CHECK_ERROR(api::gpuMallocManaged(reinterpret_cast<void**>(&std::get<0>(base::data_)),
+            GPU_CHECK_ERROR(api::gpuMallocManaged(reinterpret_cast<void**>(&gpu_array::get<0>(base::data_)),
                                                   sizeof(value_type) * base::size_));
             assert(data() != nullptr);
             std::ranges::uninitialized_fill(*this, value);
@@ -851,7 +1042,7 @@ namespace gpu_array
         __host__ explicit managed_array(const T& r) : base(std::ranges::size(r))
         {
             if (base::size_ == 0) return;
-            GPU_CHECK_ERROR(api::gpuMallocManaged(reinterpret_cast<void**>(&std::get<0>(base::data_)),
+            GPU_CHECK_ERROR(api::gpuMallocManaged(reinterpret_cast<void**>(&gpu_array::get<0>(base::data_)),
                                                   sizeof(value_type) * base::size_));
             assert(data() != nullptr);
 
@@ -864,7 +1055,7 @@ namespace gpu_array
         __host__ managed_array(std::initializer_list<value_type> r) : base(std::ranges::size(r))
         {
             if (base::size_ == 0) return;
-            GPU_CHECK_ERROR(api::gpuMallocManaged(reinterpret_cast<void**>(&std::get<0>(base::data_)),
+            GPU_CHECK_ERROR(api::gpuMallocManaged(reinterpret_cast<void**>(&gpu_array::get<0>(base::data_)),
                                                   sizeof(value_type) * base::size_));
             assert(data() != nullptr);
             for (auto i = std::size_t{0}; const auto& v : r) std::ranges::construct_at(data() + i++, v);
@@ -1070,7 +1261,7 @@ namespace gpu_array
             {
                 throw std::runtime_error("pointer type mismatch: expected managed memory pointer");
             }
-            std::get<0>(base::data_) = ptr;
+            gpu_array::get<0>(base::data_) = ptr;
         }
 #endif
 #if defined(GPU_OVERLOAD_DEVICE)
@@ -1125,7 +1316,8 @@ namespace gpu_array
 
         __host__ explicit value(default_init_tag) : base(1)
         {
-            GPU_CHECK_ERROR(api::gpuMalloc(reinterpret_cast<void**>(&std::get<0>(base::data_)), sizeof(value_type)));
+            GPU_CHECK_ERROR(
+                api::gpuMalloc(reinterpret_cast<void**>(&gpu_array::get<0>(base::data_)), sizeof(value_type)));
             assert(get() != nullptr);
             if constexpr (!std::is_trivially_default_constructible_v<value_type>)
             {
@@ -1136,7 +1328,8 @@ namespace gpu_array
 
         __host__ explicit value(const value_type& r) : base(1)
         {
-            GPU_CHECK_ERROR(api::gpuMalloc(reinterpret_cast<void**>(&std::get<0>(base::data_)), sizeof(value_type)));
+            GPU_CHECK_ERROR(
+                api::gpuMalloc(reinterpret_cast<void**>(&gpu_array::get<0>(base::data_)), sizeof(value_type)));
             assert(get() != nullptr);
             GPU_CHECK_ERROR(api::gpuMemcpy(get(), &r, sizeof(value_type), gpuMemcpyHostToDevice));
         }
@@ -1146,7 +1339,8 @@ namespace gpu_array
         __host__ explicit value(Args&&... args) : base(1)
         {
             auto temp = value_type(std::forward<Args>(args)...);
-            GPU_CHECK_ERROR(api::gpuMalloc(reinterpret_cast<void**>(&std::get<0>(base::data_)), sizeof(value_type)));
+            GPU_CHECK_ERROR(
+                api::gpuMalloc(reinterpret_cast<void**>(&gpu_array::get<0>(base::data_)), sizeof(value_type)));
             assert(get() != nullptr);
             GPU_CHECK_ERROR(api::gpuMemcpy(get(), &temp, sizeof(value_type), gpuMemcpyHostToDevice));
         }
@@ -1162,7 +1356,7 @@ namespace gpu_array
             {
                 throw std::runtime_error("pointer type mismatch: expected device memory pointer");
             }
-            std::get<0>(base::data_) = ptr;
+            gpu_array::get<0>(base::data_) = ptr;
         }
 #else
             : base(ptr, ptr == nullptr ? 0 : 1)
@@ -1181,8 +1375,11 @@ namespace gpu_array
             return *this;
         }
 
-        __host__ __device__ pointer get() const noexcept { return std::get<0>(base::data_); }
-        __host__ __device__ explicit operator bool() const noexcept { return std::get<0>(base::data_) != nullptr; }
+        __host__ __device__ pointer get() const noexcept { return gpu_array::get<0>(base::data_); }
+        __host__ __device__ explicit operator bool() const noexcept
+        {
+            return gpu_array::get<0>(base::data_) != nullptr;
+        }
 
 #if defined(GPU_OVERLOAD_DEVICE)
         __device__ reference operator*() const noexcept
@@ -1252,7 +1449,7 @@ namespace gpu_array
         __host__ explicit managed_value(default_init_tag) : base(1)
         {
             GPU_CHECK_ERROR(
-                api::gpuMallocManaged(reinterpret_cast<void**>(&std::get<0>(base::data_)), sizeof(ValueType)));
+                api::gpuMallocManaged(reinterpret_cast<void**>(&gpu_array::get<0>(base::data_)), sizeof(ValueType)));
             assert(get() != nullptr);
             std::ranges::uninitialized_default_construct_n(get(), 1);
         }
@@ -1260,7 +1457,7 @@ namespace gpu_array
         __host__ explicit managed_value(const ValueType& r) : base(1)
         {
             GPU_CHECK_ERROR(
-                api::gpuMallocManaged(reinterpret_cast<void**>(&std::get<0>(base::data_)), sizeof(ValueType)));
+                api::gpuMallocManaged(reinterpret_cast<void**>(&gpu_array::get<0>(base::data_)), sizeof(ValueType)));
             assert(get() != nullptr);
             std::ranges::construct_at(get(), r);
         }
@@ -1268,7 +1465,7 @@ namespace gpu_array
         __host__ explicit managed_value(ValueType&& r) : base(1)
         {
             GPU_CHECK_ERROR(
-                api::gpuMallocManaged(reinterpret_cast<void**>(&std::get<0>(base::data_)), sizeof(ValueType)));
+                api::gpuMallocManaged(reinterpret_cast<void**>(&gpu_array::get<0>(base::data_)), sizeof(ValueType)));
             assert(get() != nullptr);
             std::ranges::construct_at(get(), std::move(r));
         }
@@ -1278,7 +1475,7 @@ namespace gpu_array
         __host__ explicit managed_value(Args&&... args) : base(1)
         {
             GPU_CHECK_ERROR(
-                api::gpuMallocManaged(reinterpret_cast<void**>(&std::get<0>(base::data_)), sizeof(ValueType)));
+                api::gpuMallocManaged(reinterpret_cast<void**>(&gpu_array::get<0>(base::data_)), sizeof(ValueType)));
             assert(get() != nullptr);
             std::ranges::construct_at(get(), std::forward<Args>(args)...);
         }
@@ -1294,7 +1491,7 @@ namespace gpu_array
             {
                 throw std::runtime_error("pointer type mismatch: expected managed memory pointer");
             }
-            std::get<0>(base::data_) = ptr;
+            gpu_array::get<0>(base::data_) = ptr;
         }
 #else
             : base(ptr, ptr == nullptr ? 0 : 1)
@@ -1324,8 +1521,11 @@ namespace gpu_array
             return get();
         }
 
-        __host__ __device__ pointer get() const noexcept { return std::get<0>(base::data_); }
-        __host__ __device__ explicit operator bool() const noexcept { return std::get<0>(base::data_) != nullptr; }
+        __host__ __device__ pointer get() const noexcept { return gpu_array::get<0>(base::data_); }
+        __host__ __device__ explicit operator bool() const noexcept
+        {
+            return gpu_array::get<0>(base::data_) != nullptr;
+        }
 
         __host__ void prefetch(int device_id, api::gpuStream_t stream = 0, bool recursive = true) const
         {
@@ -1376,10 +1576,10 @@ namespace gpu_array
         template <std::size_t N, typename Tuple, typename... Ts>
         constexpr bool assignable_to_tuple_helper_n()
         {
-            return requires(const Tuple& t1, std::tuple<Ts...>& t2) {
-                std::get<N>(t1);
-                std::get<N>(t2);
-                requires std::assignable_from<decltype(std::get<N>(t2)), decltype(std::get<N>(t1))>;
+            return requires(const Tuple& t1, gpu_array::tuple<Ts...>& t2) {
+                gpu_array::get<N>(t1);
+                gpu_array::get<N>(t2);
+                requires std::assignable_from<decltype(gpu_array::get<N>(t2)), decltype(gpu_array::get<N>(t1))>;
             };
         }
         template <typename Tuple, typename... Ts>
@@ -1396,7 +1596,7 @@ namespace gpu_array
     template <template <typename...> typename Tuple, typename... Ts>
     class structure_of_arrays_iterator
     {
-        std::tuple<Ts*...> ptrs_;
+        gpu_array::tuple<Ts*...> ptrs_;
 
     public:
         using difference_type = std::ptrdiff_t;
@@ -1411,15 +1611,15 @@ namespace gpu_array
         structure_of_arrays_iterator& operator=(const structure_of_arrays_iterator&) = default;
         structure_of_arrays_iterator& operator=(structure_of_arrays_iterator&&) noexcept = default;
 
-        __host__ __device__ explicit structure_of_arrays_iterator(std::tuple<Ts*...> ptrs) : ptrs_(ptrs) {}
+        __host__ __device__ explicit structure_of_arrays_iterator(gpu_array::tuple<Ts*...> ptrs) : ptrs_(ptrs) {}
 
         __host__ __device__ Tuple<Ts&...> operator*() const
         {
-            return std::apply([](auto*... ptrs) { return Tuple<Ts&...>(*ptrs...); }, ptrs_);
+            return gpu_array::apply([](auto*... ptrs) { return Tuple<Ts&...>(*ptrs...); }, ptrs_);
         }
         __host__ __device__ Tuple<Ts&...> operator[](size_type n) const
         {
-            return std::apply([n](auto*... ptrs) { return Tuple<Ts&...>(ptrs[n]...); }, ptrs_);
+            return gpu_array::apply([n](auto*... ptrs) { return Tuple<Ts&...>(ptrs[n]...); }, ptrs_);
         }
         __host__ __device__ auto operator->() const
         {
@@ -1432,7 +1632,7 @@ namespace gpu_array
         }
         __host__ __device__ structure_of_arrays_iterator& operator++()
         {
-            std::apply([](auto*&... ptrs) { (++ptrs, ...); }, ptrs_);
+            gpu_array::apply([](auto*&... ptrs) { (++ptrs, ...); }, ptrs_);
             return *this;
         }
         __host__ __device__ structure_of_arrays_iterator operator++(int)
@@ -1443,12 +1643,12 @@ namespace gpu_array
         }
         __host__ __device__ structure_of_arrays_iterator& operator+=(difference_type n)
         {
-            std::apply([n](auto*&... ptrs) { ((ptrs += n), ...); }, ptrs_);
+            gpu_array::apply([n](auto*&... ptrs) { ((ptrs += n), ...); }, ptrs_);
             return *this;
         }
         __host__ __device__ structure_of_arrays_iterator& operator--()
         {
-            std::apply([](auto*&... ptrs) { (--ptrs, ...); }, ptrs_);
+            gpu_array::apply([](auto*&... ptrs) { (--ptrs, ...); }, ptrs_);
             return *this;
         }
         __host__ __device__ structure_of_arrays_iterator operator--(int)
@@ -1459,20 +1659,20 @@ namespace gpu_array
         }
         __host__ __device__ structure_of_arrays_iterator& operator-=(difference_type n)
         {
-            std::apply([n](auto*&... ptrs) { ((ptrs -= n), ...); }, ptrs_);
+            gpu_array::apply([n](auto*&... ptrs) { ((ptrs -= n), ...); }, ptrs_);
             return *this;
         }
 
         __host__ __device__ friend difference_type operator-(const structure_of_arrays_iterator& lhs,
                                                              const structure_of_arrays_iterator& rhs)
         {
-            return std::get<0>(lhs.ptrs_) - std::get<0>(rhs.ptrs_);
+            return gpu_array::get<0>(lhs.ptrs_) - gpu_array::get<0>(rhs.ptrs_);
         }
         __host__ __device__ friend structure_of_arrays_iterator operator+(const structure_of_arrays_iterator& lhs,
                                                                           difference_type n)
         {
             return structure_of_arrays_iterator(
-                std::apply([n](auto*... ptrs) { return std::tuple{ptrs + n...}; }, lhs.ptrs_));
+                gpu_array::apply([n](auto*... ptrs) { return gpu_array::tuple{ptrs + n...}; }, lhs.ptrs_));
         }
         __host__ __device__ friend structure_of_arrays_iterator operator+(structure_of_arrays_iterator&& lhs,
                                                                           difference_type n)
@@ -1494,7 +1694,7 @@ namespace gpu_array
                                                                           difference_type n)
         {
             return structure_of_arrays_iterator(
-                std::apply([n](auto*... ptrs) { return std::tuple{ptrs - n...}; }, lhs.ptrs_));
+                gpu_array::apply([n](auto*... ptrs) { return gpu_array::tuple{ptrs - n...}; }, lhs.ptrs_));
         }
         __host__ __device__ friend structure_of_arrays_iterator operator-(structure_of_arrays_iterator&& lhs,
                                                                           difference_type n)
@@ -1506,16 +1706,16 @@ namespace gpu_array
         __host__ __device__ friend bool operator==(const structure_of_arrays_iterator& lhs,
                                                    const structure_of_arrays_iterator& rhs)
         {
-            return std::get<0>(lhs.ptrs_) == std::get<0>(rhs.ptrs_);
+            return gpu_array::get<0>(lhs.ptrs_) == gpu_array::get<0>(rhs.ptrs_);
         }
         __host__ __device__ friend std::strong_ordering operator<=>(const structure_of_arrays_iterator& lhs,
                                                                     const structure_of_arrays_iterator& rhs)
         {
-            return std::get<0>(lhs.ptrs_) <=> std::get<0>(rhs.ptrs_);
+            return gpu_array::get<0>(lhs.ptrs_) <=> gpu_array::get<0>(rhs.ptrs_);
         }
         __host__ __device__ friend auto iter_move(const structure_of_arrays_iterator& x)
         {
-            return std::apply(
+            return gpu_array::apply(
                 [](auto*... ptrs) {
                     using RetType = std::remove_cvref_t<decltype(x)>::value_type;
                     return RetType(std::move(*ptrs)...);
@@ -1527,15 +1727,15 @@ namespace gpu_array
         {
             constexpr std::size_t size = std::tuple_size_v<std::remove_cvref_t<decltype(lhs.ptrs_)>>;
             [&lhs, &rhs]<std::size_t... N>(std::index_sequence<N...>) {
-                (std::swap(*std::get<N>(lhs.ptrs_), *std::get<N>(rhs.ptrs_)), ...);
+                (std::swap(*gpu_array::get<N>(lhs.ptrs_), *gpu_array::get<N>(rhs.ptrs_)), ...);
             }(std::make_index_sequence<size>());
         }
     };
 
     template <typename... Ts>
-    class structure_of_arrays : public structure_of_arrays<std::tuple<Ts...>, size_type_default>
+    class structure_of_arrays : public structure_of_arrays<gpu_array::tuple<Ts...>, size_type_default>
     {
-        using base = structure_of_arrays<std::tuple<Ts...>, size_type_default>;
+        using base = structure_of_arrays<gpu_array::tuple<Ts...>, size_type_default>;
         using base::base;
 
     public:
@@ -1567,9 +1767,9 @@ namespace gpu_array
         static constexpr auto num_arrays = sizeof...(Ts);
         using base = detail::base<false, SizeType, Ts...>;
 
-        using tuple_value_type = std::tuple<Ts...>;
-        using tuple_pointer_type = std::tuple<Ts*...>;
-        using tuple_const_pointer_type = std::tuple<const Ts*...>;
+        using tuple_value_type = gpu_array::tuple<Ts...>;
+        using tuple_pointer_type = gpu_array::tuple<Ts*...>;
+        using tuple_const_pointer_type = gpu_array::tuple<const Ts*...>;
         using ret_tuple_value_type = Tuple<Ts...>;
         using ret_tuple_reference_type = Tuple<Ts&...>;
         using ret_tuple_const_reference_type = Tuple<const Ts&...>;
@@ -1584,18 +1784,18 @@ namespace gpu_array
         SIGSEGV_DEPRECATED __host__ __device__ auto begin() noexcept { return iterator_type(base::data_); }
         SIGSEGV_DEPRECATED __host__ __device__ auto end() noexcept
         {
-            return std::apply(
+            return gpu_array::apply(
                 [this](auto&... ptrs) { return iterator_type(tuple_pointer_type{(ptrs + base::size_)...}); },
                 base::data_);
         }
         SIGSEGV_DEPRECATED __host__ __device__ auto begin() const noexcept
         {
-            return std::apply([](auto&... ptrs) { return const_iterator_type(tuple_const_pointer_type{(ptrs)...}); },
-                              base::data_);
+            return gpu_array::apply(
+                [](auto&... ptrs) { return const_iterator_type(tuple_const_pointer_type{(ptrs)...}); }, base::data_);
         }
         SIGSEGV_DEPRECATED __host__ __device__ auto end() const noexcept
         {
-            return std::apply(
+            return gpu_array::apply(
                 [this](auto&... ptrs) {
                     return const_iterator_type(tuple_const_pointer_type{(ptrs + base::size_)...});
                 },
@@ -1604,28 +1804,29 @@ namespace gpu_array
         SIGSEGV_DEPRECATED __host__ __device__ auto operator[](size_type i) &
         {
             assert(i < base::size_);
-            return std::apply([i](auto&... ptrs) { return ret_tuple_reference_type{*(ptrs + i)...}; }, base::data_);
+            return gpu_array::apply([i](auto&... ptrs) { return ret_tuple_reference_type{*(ptrs + i)...}; },
+                                    base::data_);
         }
         SIGSEGV_DEPRECATED __host__ __device__ auto operator[](size_type i) const&
         {
             assert(i < base::size_);
-            return std::apply([i](auto&... ptrs) { return ret_tuple_const_reference_type{*(ptrs + i)...}; },
-                              base::data_);
+            return gpu_array::apply([i](auto&... ptrs) { return ret_tuple_const_reference_type{*(ptrs + i)...}; },
+                                    base::data_);
         }
         SIGSEGV_DEPRECATED __host__ __device__ auto operator[](size_type i) &&
         {
             assert(i < base::size_);
-            return std::apply([i](auto&... ptrs) { return ret_tuple_value_type{*(ptrs + i)...}; }, base::data_);
+            return gpu_array::apply([i](auto&... ptrs) { return ret_tuple_value_type{*(ptrs + i)...}; }, base::data_);
         }
         template <std::size_t N>
         __host__ __device__ auto* data() noexcept
         {
-            return std::get<N>(base::data_);
+            return gpu_array::get<N>(base::data_);
         }
         template <std::size_t N>
         __host__ __device__ const auto* data() const noexcept
         {
-            return std::get<N>(base::data_);
+            return gpu_array::get<N>(base::data_);
         }
 
         structure_of_arrays() = default;
@@ -1672,7 +1873,7 @@ namespace gpu_array
             };
 
             [this, &value, alloc_ptr]<std::size_t... N>(std::index_sequence<N...>) {
-                (alloc_ptr(std::get<N>(base::data_), std::get<N>(value)), ...);
+                (alloc_ptr(gpu_array::get<N>(base::data_), gpu_array::get<N>(value)), ...);
             }(std::make_index_sequence<num_arrays>());
         }
 
@@ -1691,8 +1892,8 @@ namespace gpu_array
             };
 
             [this, &array, alloc_ptr]<std::size_t... N>(std::index_sequence<N...>) {
-                (alloc_ptr(std::get<N>(base::data_),
-                           array | std::views::transform([](const auto& v) { return (std::get<N>(v)); })),
+                (alloc_ptr(gpu_array::get<N>(base::data_),
+                           array | std::views::transform([](const auto& v) { return (gpu_array::get<N>(v)); })),
                  ...);
             }(std::make_index_sequence<num_arrays>());
         }
@@ -1710,15 +1911,15 @@ namespace gpu_array
             };
 
             [this, &list, alloc_ptr]<std::size_t... N>(std::index_sequence<N...>) {
-                (alloc_ptr(std::get<N>(base::data_),
-                           list | std::views::transform([](const auto& v) { return (std::get<N>(v)); })),
+                (alloc_ptr(gpu_array::get<N>(base::data_),
+                           list | std::views::transform([](const auto& v) { return (gpu_array::get<N>(v)); })),
                  ...);
             }(std::make_index_sequence<num_arrays>());
         }
 
         template <detail::array_convertible_for_copy... Ranges>
         requires (sizeof...(Ranges) == num_arrays) &&
-                 detail::assignable_to_tuple<std::tuple<std::ranges::range_value_t<Ranges>...>, Ts...>
+                 detail::assignable_to_tuple<gpu_array::tuple<std::ranges::range_value_t<Ranges>...>, Ts...>
         __host__ explicit structure_of_arrays(const Ranges&... arrays) : base(std::max({std::ranges::size(arrays)...}))
         {
             if (base::size_ == 0) return;
@@ -1737,9 +1938,9 @@ namespace gpu_array
                 GPU_CHECK_ERROR(api::gpuMemcpy(ptr, buf.get(), sizeof(T) * base::size_, gpuMemcpyHostToDevice));
             };
 
-            auto arrays_tuple = std::tuple<const Ranges&...>(arrays...);
+            auto arrays_tuple = gpu_array::tuple<const Ranges&...>(arrays...);
             [this, &arrays_tuple, alloc_ptr]<std::size_t... N>(std::index_sequence<N...>) {
-                (alloc_ptr(std::get<N>(base::data_), std::get<N>(arrays_tuple)), ...);
+                (alloc_ptr(gpu_array::get<N>(base::data_), gpu_array::get<N>(arrays_tuple)), ...);
             }(std::make_index_sequence<num_arrays>());
         }
 
@@ -1762,9 +1963,9 @@ namespace gpu_array
                 GPU_CHECK_ERROR(api::gpuMemcpy(ptr, buf.get(), sizeof(T) * base::size_, gpuMemcpyHostToDevice));
             };
 
-            auto arrays_tuple = std::tuple<std::initializer_list<Ts>...>(lists...);
+            auto arrays_tuple = gpu_array::tuple<std::initializer_list<Ts>...>(lists...);
             [this, &arrays_tuple, alloc_ptr]<std::size_t... N>(std::index_sequence<N...>) {
-                (alloc_ptr(std::get<N>(base::data_), std::get<N>(arrays_tuple)), ...);
+                (alloc_ptr(gpu_array::get<N>(base::data_), gpu_array::get<N>(arrays_tuple)), ...);
             }(std::make_index_sequence<num_arrays>());
         }
 
@@ -1796,9 +1997,9 @@ namespace gpu_array
                 return buf;
             };
 
-            const auto tmp_bufs = std::apply(
+            const auto tmp_bufs = gpu_array::apply(
                 [copy_buffer](const auto*... ptrs) {
-                    return std::tuple<std::unique_ptr<Ts[]>...>(copy_buffer(ptrs)...);
+                    return gpu_array::tuple<std::unique_ptr<Ts[]>...>(copy_buffer(ptrs)...);
                 },
                 base::data_);
 
@@ -1814,7 +2015,7 @@ namespace gpu_array
 
                 for (size_type i = 0; i < base::size_; ++i)
                 {
-                    std::apply([&result, i](const auto&... bufs) { result.push_back(U{bufs[i]...}); }, tmp_bufs);
+                    gpu_array::apply([&result, i](const auto&... bufs) { result.push_back(U{bufs[i]...}); }, tmp_bufs);
                 }
 
                 return result;
@@ -1826,7 +2027,7 @@ namespace gpu_array
 
                 for (size_type i = 0; i < base::size_; ++i)
                 {
-                    std::apply([&result, i](const auto&... bufs) { result[i] = U{bufs[i]...}; }, tmp_bufs);
+                    gpu_array::apply([&result, i](const auto&... bufs) { result[i] = U{bufs[i]...}; }, tmp_bufs);
                 }
 
                 return result;
@@ -1852,7 +2053,7 @@ namespace gpu_array
             if (base::size_ > 0) assert(ptr != nullptr);
 
             // reset specified pointer only
-            std::get<N>(base::data_) = base::size_ == 0 ? nullptr : ptr;
+            gpu_array::get<N>(base::data_) = base::size_ == 0 ? nullptr : ptr;
         }
 
         template <std::size_t N, gpu_array_ptr T>
@@ -1872,9 +2073,9 @@ namespace gpu_array
     };
 
     template <typename... Ts>
-    class managed_structure_of_arrays : public managed_structure_of_arrays<std::tuple<Ts...>, size_type_default>
+    class managed_structure_of_arrays : public managed_structure_of_arrays<gpu_array::tuple<Ts...>, size_type_default>
     {
-        using base = managed_structure_of_arrays<std::tuple<Ts...>, size_type_default>;
+        using base = managed_structure_of_arrays<gpu_array::tuple<Ts...>, size_type_default>;
         using base::base;
 
     public:
@@ -1907,9 +2108,9 @@ namespace gpu_array
         static constexpr auto num_arrays = sizeof...(Ts);
         using base = detail::base<true, SizeType, Ts...>;
 
-        using tuple_value_type = std::tuple<Ts...>;
-        using tuple_pointer_type = std::tuple<Ts*...>;
-        using tuple_const_pointer_type = std::tuple<const Ts*...>;
+        using tuple_value_type = gpu_array::tuple<Ts...>;
+        using tuple_pointer_type = gpu_array::tuple<Ts*...>;
+        using tuple_const_pointer_type = gpu_array::tuple<const Ts*...>;
         using ret_tuple_value_type = Tuple<Ts...>;
         using ret_tuple_reference_type = Tuple<Ts&...>;
         using ret_tuple_const_reference_type = Tuple<const Ts&...>;
@@ -1944,7 +2145,8 @@ namespace gpu_array
             };
 
             [this, &alloc_ptr]<std::size_t... N>(std::index_sequence<N...>) {
-                (alloc_ptr(std::get<N>(base::data_), [](const auto& v) -> const auto& { return (std::get<N>(v)); }),
+                (alloc_ptr(gpu_array::get<N>(base::data_),
+                           [](const auto& v) -> const auto& { return (gpu_array::get<N>(v)); }),
                  ...);
             }(std::make_index_sequence<num_arrays>());
         }
@@ -1957,18 +2159,18 @@ namespace gpu_array
         __host__ __device__ auto begin() noexcept { return iterator_type(base::data_); }
         __host__ __device__ auto end() noexcept
         {
-            return std::apply(
+            return gpu_array::apply(
                 [this](auto&... ptrs) { return iterator_type(tuple_pointer_type{(ptrs + base::size_)...}); },
                 base::data_);
         }
         __host__ __device__ auto begin() const noexcept
         {
-            return std::apply([](auto&... ptrs) { return const_iterator_type(tuple_const_pointer_type{(ptrs)...}); },
-                              base::data_);
+            return gpu_array::apply(
+                [](auto&... ptrs) { return const_iterator_type(tuple_const_pointer_type{(ptrs)...}); }, base::data_);
         }
         __host__ __device__ auto end() const noexcept
         {
-            return std::apply(
+            return gpu_array::apply(
                 [this](auto&... ptrs) {
                     return const_iterator_type(tuple_const_pointer_type{(ptrs + base::size_)...});
                 },
@@ -1977,28 +2179,29 @@ namespace gpu_array
         __host__ __device__ auto operator[](size_type i) &
         {
             assert(i < base::size_);
-            return std::apply([i](auto&... ptrs) { return ret_tuple_reference_type{*(ptrs + i)...}; }, base::data_);
+            return gpu_array::apply([i](auto&... ptrs) { return ret_tuple_reference_type{*(ptrs + i)...}; },
+                                    base::data_);
         }
         __host__ __device__ auto operator[](size_type i) const&
         {
             assert(i < base::size_);
-            return std::apply([i](auto&... ptrs) { return ret_tuple_const_reference_type{*(ptrs + i)...}; },
-                              base::data_);
+            return gpu_array::apply([i](auto&... ptrs) { return ret_tuple_const_reference_type{*(ptrs + i)...}; },
+                                    base::data_);
         }
         __host__ __device__ auto operator[](size_type i) &&
         {
             assert(i < base::size_);
-            return std::apply([i](auto&... ptrs) { return ret_tuple_value_type{*(ptrs + i)...}; }, base::data_);
+            return gpu_array::apply([i](auto&... ptrs) { return ret_tuple_value_type{*(ptrs + i)...}; }, base::data_);
         }
         template <std::size_t N>
         __host__ __device__ auto* data() noexcept
         {
-            return std::get<N>(base::data_);
+            return gpu_array::get<N>(base::data_);
         }
         template <std::size_t N>
         __host__ __device__ const auto* data() const noexcept
         {
-            return std::get<N>(base::data_);
+            return gpu_array::get<N>(base::data_);
         }
 
         managed_structure_of_arrays() = default;
@@ -2039,7 +2242,9 @@ namespace gpu_array
             });
 
             [this, &value]<std::size_t... N>(std::index_sequence<N...>) {
-                (std::ranges::uninitialized_fill_n(std::get<N>(base::data_), base::size_, std::get<N>(value)), ...);
+                (std::ranges::uninitialized_fill_n(gpu_array::get<N>(base::data_), base::size_,
+                                                   gpu_array::get<N>(value)),
+                 ...);
             }(std::make_index_sequence<num_arrays>());
         }
 
@@ -2060,7 +2265,8 @@ namespace gpu_array
             };
 
             [this, &alloc_ptr]<std::size_t... N>(std::index_sequence<N...>) {
-                (alloc_ptr(std::get<N>(base::data_), [](const auto& e) -> const auto& { return (std::get<N>(e)); }),
+                (alloc_ptr(gpu_array::get<N>(base::data_),
+                           [](const auto& e) -> const auto& { return (gpu_array::get<N>(e)); }),
                  ...);
             }(std::make_index_sequence<num_arrays>());
         }
@@ -2081,14 +2287,15 @@ namespace gpu_array
             };
 
             [this, &alloc_ptr]<std::size_t... N>(std::index_sequence<N...>) {
-                (alloc_ptr(std::get<N>(base::data_), [](const auto& e) -> const auto& { return (std::get<N>(e)); }),
+                (alloc_ptr(gpu_array::get<N>(base::data_),
+                           [](const auto& e) -> const auto& { return (gpu_array::get<N>(e)); }),
                  ...);
             }(std::make_index_sequence<num_arrays>());
         }
 
         template <detail::array_convertible_for_copy... Ranges>
         requires (sizeof...(Ranges) == num_arrays) &&
-                 detail::assignable_to_tuple<std::tuple<std::ranges::range_value_t<Ranges>...>, Ts...>
+                 detail::assignable_to_tuple<gpu_array::tuple<std::ranges::range_value_t<Ranges>...>, Ts...>
         __host__ explicit managed_structure_of_arrays(const Ranges&... arrays)
             : base(std::max({std::ranges::size(arrays)...}))
         {
@@ -2106,9 +2313,9 @@ namespace gpu_array
                 for (auto i = std::size_t{0}; const auto& v : range) std::ranges::construct_at(ptr + i++, v);
             };
 
-            auto arrays_tuple = std::tuple<const Ranges&...>(arrays...);
+            auto arrays_tuple = gpu_array::tuple<const Ranges&...>(arrays...);
             [this, &arrays_tuple, alloc_ptr]<std::size_t... N>(std::index_sequence<N...>) {
-                (alloc_ptr(std::get<N>(base::data_), std::get<N>(arrays_tuple)), ...);
+                (alloc_ptr(gpu_array::get<N>(base::data_), gpu_array::get<N>(arrays_tuple)), ...);
             }(std::make_index_sequence<num_arrays>());
         }
 
@@ -2129,9 +2336,9 @@ namespace gpu_array
                 for (auto i = std::size_t{0}; const auto& v : range) std::ranges::construct_at(ptr + i++, v);
             };
 
-            auto arrays_tuple = std::tuple<std::initializer_list<Ts>...>(lists...);
+            auto arrays_tuple = gpu_array::tuple<std::initializer_list<Ts>...>(lists...);
             [this, &arrays_tuple, alloc_ptr]<std::size_t... N>(std::index_sequence<N...>) {
-                (alloc_ptr(std::get<N>(base::data_), std::get<N>(arrays_tuple)), ...);
+                (alloc_ptr(gpu_array::get<N>(base::data_), gpu_array::get<N>(arrays_tuple)), ...);
             }(std::make_index_sequence<num_arrays>());
         }
 
@@ -2258,7 +2465,8 @@ namespace gpu_array
 
                 for (size_type i = 0; i < base::size_; ++i)
                 {
-                    std::apply([&result, i](const auto&... bufs) { result.push_back(U{bufs[i]...}); }, base::data_);
+                    gpu_array::apply([&result, i](const auto&... bufs) { result.push_back(U{bufs[i]...}); },
+                                     base::data_);
                 }
 
                 return result;
@@ -2270,7 +2478,7 @@ namespace gpu_array
 
                 for (size_type i = 0; i < base::size_; ++i)
                 {
-                    std::apply([&result, i](const auto&... bufs) { result[i] = U{bufs[i]...}; }, base::data_);
+                    gpu_array::apply([&result, i](const auto&... bufs) { result[i] = U{bufs[i]...}; }, base::data_);
                 }
 
                 return result;
@@ -2296,7 +2504,7 @@ namespace gpu_array
             if (base::size_ > 0) assert(ptr != nullptr);
 
             // reset specified pointer only
-            std::get<N>(base::data_) = base::size_ == 0 ? nullptr : ptr;
+            gpu_array::get<N>(base::data_) = base::size_ == 0 ? nullptr : ptr;
         }
 
         template <std::size_t N, gpu_array_ptr T>
diff --git a/test/test.cpp b/test/test.cpp
index 13cbc77..19a280a 100644
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -6,19 +6,19 @@
 // NOLINTBEGIN
 using namespace gpu_array;
 
-// Example of custom tuple type derived from std::tuple
+// Example of custom tuple type derived from gpu_array::tuple
 // You may need to specialize std::common_type and std::basic_common_reference to satisfy range concepts
 template <typename... Ts>
-class custom_tuple_example : public std::tuple<Ts...>
+class custom_tuple_example : public gpu_array::tuple<Ts...>
 {
-    using base = std::tuple<Ts...>;
+    using base = gpu_array::tuple<Ts...>;
     using base::base;
 
 public:
     template <std::size_t N>
     __host__ decltype(auto) get_string() const
     {
-        return std::to_string(std::get<N>(*this));
+        return std::to_string(gpu_array::get<N>(*this));
     }
     using base::operator=;
     template <typename... Us>
@@ -1038,7 +1038,7 @@ TEST(StructureOfArrays, Construction)
 {
     using tuple_elem_type0 = int;
     using tuple_elem_type1 = double;
-    using tuple_type = std::tuple<tuple_elem_type0, tuple_elem_type1>;
+    using tuple_type = gpu_array::tuple<tuple_elem_type0, tuple_elem_type1>;
     using custom_tuple_type = custom_tuple_example<tuple_elem_type0, tuple_elem_type1>;
 
     // initizalization
@@ -1052,18 +1052,18 @@ TEST(StructureOfArrays, Construction)
         auto vec = soa.to<std::vector>();
         for (std::size_t i = 0; i < vec.size(); ++i)
         {
-            EXPECT_EQ(std::get<0>(vec[i]), 0);
-            EXPECT_EQ(std::get<1>(vec[i]), 0.0);
+            EXPECT_EQ(gpu_array::get<0>(vec[i]), 0);
+            EXPECT_EQ(gpu_array::get<1>(vec[i]), 0.0);
         }
     }
     {
-        auto soa = structure_of_arrays<tuple_elem_type0, tuple_elem_type1>(10, std::tuple(1, 2.5));
+        auto soa = structure_of_arrays<tuple_elem_type0, tuple_elem_type1>(10, gpu_array::tuple(1, 2.5));
         EXPECT_EQ(soa.size(), 10);
         auto vec = soa.to<std::vector>();
         for (std::size_t i = 0; i < vec.size(); ++i)
         {
-            EXPECT_EQ(std::get<0>(vec[i]), 1);
-            EXPECT_EQ(std::get<1>(vec[i]), 2.5);
+            EXPECT_EQ(gpu_array::get<0>(vec[i]), 1);
+            EXPECT_EQ(gpu_array::get<1>(vec[i]), 2.5);
         }
     }
     {
@@ -1080,18 +1080,18 @@ TEST(StructureOfArrays, Construction)
         auto vec = soa.to<std::vector>();
         for (std::size_t i = 0; i < vec.size(); ++i)
         {
-            EXPECT_EQ(std::get<0>(vec[i]), 0);
-            EXPECT_EQ(std::get<1>(vec[i]), 0.0);
+            EXPECT_EQ(gpu_array::get<0>(vec[i]), 0);
+            EXPECT_EQ(gpu_array::get<1>(vec[i]), 0.0);
         }
     }
     {
-        auto soa = structure_of_arrays<tuple_type>(10, std::tuple(1, 2.5));
+        auto soa = structure_of_arrays<tuple_type>(10, gpu_array::tuple(1, 2.5));
         EXPECT_EQ(soa.size(), 10);
         auto vec = soa.to<std::vector>();
         for (std::size_t i = 0; i < vec.size(); ++i)
         {
-            EXPECT_EQ(std::get<0>(vec[i]), 1);
-            EXPECT_EQ(std::get<1>(vec[i]), 2.5);
+            EXPECT_EQ(gpu_array::get<0>(vec[i]), 1);
+            EXPECT_EQ(gpu_array::get<1>(vec[i]), 2.5);
         }
     }
     {
@@ -1108,8 +1108,8 @@ TEST(StructureOfArrays, Construction)
         auto vec = soa.to<std::vector>();
         for (std::size_t i = 0; i < vec.size(); ++i)
         {
-            EXPECT_EQ(std::get<0>(vec[i]), 0);
-            EXPECT_EQ(std::get<1>(vec[i]), 0.0);
+            EXPECT_EQ(gpu_array::get<0>(vec[i]), 0);
+            EXPECT_EQ(gpu_array::get<1>(vec[i]), 0.0);
         }
     }
     {
@@ -1118,8 +1118,8 @@ TEST(StructureOfArrays, Construction)
         auto vec = soa.to<std::vector>();
         for (std::size_t i = 0; i < vec.size(); ++i)
         {
-            EXPECT_EQ(std::get<0>(vec[i]), 1);
-            EXPECT_EQ(std::get<1>(vec[i]), 2.5);
+            EXPECT_EQ(gpu_array::get<0>(vec[i]), 1);
+            EXPECT_EQ(gpu_array::get<1>(vec[i]), 2.5);
         }
     }
     {
@@ -1158,7 +1158,7 @@ TEST(StructureOfArrays, Construction)
         EXPECT_EQ(arr1.use_count(), 1);
     }
 
-    // construction from range of std::tuple
+    // construction from range of gpu_array::tuple
     {
         auto vec = std::vector<tuple_type>();
         for (std::size_t i = 0; i < 10; ++i)
@@ -1171,17 +1171,17 @@ TEST(StructureOfArrays, Construction)
         EXPECT_EQ(soa_vec, vec);
     }
 
-    // construction from initializer_list of std::tuple
+    // construction from initializer_list of gpu_array::tuple
     {
         auto soa = structure_of_arrays<tuple_type>({{0, 0.5}, {1, 1.5}, {2, 2.5}});
         EXPECT_EQ(soa.size(), 3);
         const auto soa_vec = soa.to<std::vector>();
-        EXPECT_EQ(std::get<0>(soa_vec[0]), 0);
-        EXPECT_EQ(std::get<1>(soa_vec[0]), 0.5);
-        EXPECT_EQ(std::get<0>(soa_vec[1]), 1);
-        EXPECT_EQ(std::get<1>(soa_vec[1]), 1.5);
-        EXPECT_EQ(std::get<0>(soa_vec[2]), 2);
-        EXPECT_EQ(std::get<1>(soa_vec[2]), 2.5);
+        EXPECT_EQ(gpu_array::get<0>(soa_vec[0]), 0);
+        EXPECT_EQ(gpu_array::get<1>(soa_vec[0]), 0.5);
+        EXPECT_EQ(gpu_array::get<0>(soa_vec[1]), 1);
+        EXPECT_EQ(gpu_array::get<1>(soa_vec[1]), 1.5);
+        EXPECT_EQ(gpu_array::get<0>(soa_vec[2]), 2);
+        EXPECT_EQ(gpu_array::get<1>(soa_vec[2]), 2.5);
     }
 
     // construction from multiple ranges
@@ -1198,8 +1198,8 @@ TEST(StructureOfArrays, Construction)
         const auto soa_vec = soa.to<std::vector>();
         for (std::size_t i = 0; i < soa_vec.size(); ++i)
         {
-            EXPECT_EQ(std::get<0>(soa_vec[i]), vec0[i]);
-            EXPECT_EQ(std::get<1>(soa_vec[i]), vec1[i]);
+            EXPECT_EQ(gpu_array::get<0>(soa_vec[i]), vec0[i]);
+            EXPECT_EQ(gpu_array::get<1>(soa_vec[i]), vec1[i]);
         }
     }
 
@@ -1208,12 +1208,12 @@ TEST(StructureOfArrays, Construction)
         auto soa = structure_of_arrays<tuple_elem_type0, tuple_elem_type1>({0, 1, 2}, {0.5, 1.5, 2.5});
         EXPECT_EQ(soa.size(), 3);
         const auto soa_vec = soa.to<std::vector>();
-        EXPECT_EQ(std::get<0>(soa_vec[0]), 0);
-        EXPECT_EQ(std::get<1>(soa_vec[0]), 0.5);
-        EXPECT_EQ(std::get<0>(soa_vec[1]), 1);
-        EXPECT_EQ(std::get<1>(soa_vec[1]), 1.5);
-        EXPECT_EQ(std::get<0>(soa_vec[2]), 2);
-        EXPECT_EQ(std::get<1>(soa_vec[2]), 2.5);
+        EXPECT_EQ(gpu_array::get<0>(soa_vec[0]), 0);
+        EXPECT_EQ(gpu_array::get<1>(soa_vec[0]), 0.5);
+        EXPECT_EQ(gpu_array::get<0>(soa_vec[1]), 1);
+        EXPECT_EQ(gpu_array::get<1>(soa_vec[1]), 1.5);
+        EXPECT_EQ(gpu_array::get<0>(soa_vec[2]), 2);
+        EXPECT_EQ(gpu_array::get<1>(soa_vec[2]), 2.5);
     }
 
     // construction from range of custom tuple
@@ -1228,9 +1228,9 @@ TEST(StructureOfArrays, Construction)
         const auto soa_vec = soa.to<std::vector>();
         for (std::size_t i = 0; i < soa_vec.size(); ++i)
         {
-            EXPECT_EQ(std::get<0>(soa_vec[i]), static_cast<tuple_elem_type0>(i));
+            EXPECT_EQ(gpu_array::get<0>(soa_vec[i]), static_cast<tuple_elem_type0>(i));
             EXPECT_EQ(soa_vec[i].get_string<0>(), std::to_string(i));
-            EXPECT_EQ(std::get<1>(soa_vec[i]), static_cast<tuple_elem_type1>(i) + 0.5);
+            EXPECT_EQ(gpu_array::get<1>(soa_vec[i]), static_cast<tuple_elem_type1>(i) + 0.5);
             EXPECT_EQ(soa_vec[i].get_string<1>(), std::to_string(i + 0.5));
         }
     }
@@ -1252,7 +1252,7 @@ TEST(StructureOfArrays, Export)
 {
     using tuple_elem_type0 = int;
     using tuple_elem_type1 = double;
-    using tuple_type = std::tuple<tuple_elem_type0, tuple_elem_type1>;
+    using tuple_type = gpu_array::tuple<tuple_elem_type0, tuple_elem_type1>;
 
     // export to range with same value type
     {
@@ -1278,7 +1278,7 @@ TEST(StructureOfArrays, Export)
 
 TEST(StructureOfArrays, RangeInterface)
 {
-    using tuple_type = std::tuple<int, double>;
+    using tuple_type = gpu_array::tuple<int, double>;
     using soa_type1 = structure_of_arrays<int, double>;
     using soa_type2 = structure_of_arrays<tuple_type>;
     using soa_type3 = structure_of_arrays<custom_tuple_example<int, double>>;
@@ -1350,20 +1350,20 @@ TEST(StructureOfArrays, RangeInterface)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #endif
-        static_assert(std::same_as<decltype(soa[0]), std::tuple<decltype(*soa.data<0>()), decltype(*soa.data<1>())>>);
+        static_assert(std::same_as<decltype(soa[0]), gpu_array::tuple<decltype(*soa.data<0>()), decltype(*soa.data<1>())>>);
         static_assert(
-            std::same_as<decltype(*soa.begin()), std::tuple<decltype(*soa.data<0>()), decltype(*soa.data<1>())>>);
+            std::same_as<decltype(*soa.begin()), gpu_array::tuple<decltype(*soa.data<0>()), decltype(*soa.data<1>())>>);
         static_assert(std::same_as<decltype(*(soa.end() - 1)),
-                                   std::tuple<decltype(*(soa.data<0>() + 9)), decltype(*(soa.data<1>() + 9))>>);
+                                   gpu_array::tuple<decltype(*(soa.data<0>() + 9)), decltype(*(soa.data<1>() + 9))>>);
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
 #endif
-        soa = {std::tuple(0, 0.0), std::tuple(1, 1.0), std::tuple(2, 2.0), std::tuple(3, 3.0), std::tuple(4, 4.0)};
+        soa = {gpu_array::tuple(0, 0.0), gpu_array::tuple(1, 1.0), gpu_array::tuple(2, 2.0), gpu_array::tuple(3, 3.0), gpu_array::tuple(4, 4.0)};
         auto vec = soa.to<std::vector>();
         for (std::size_t i = 0; i < vec.size(); ++i)
         {
-            EXPECT_EQ(std::get<0>(vec[i]), static_cast<int>(i));
-            EXPECT_EQ(std::get<1>(vec[i]), static_cast<double>(i));
+            EXPECT_EQ(gpu_array::get<0>(vec[i]), static_cast<int>(i));
+            EXPECT_EQ(gpu_array::get<1>(vec[i]), static_cast<double>(i));
         }
     }
 }
@@ -1385,7 +1385,7 @@ TEST(ManagedStructureOfArrays, Construction)
 {
     using tuple_elem_type0 = int;
     using tuple_elem_type1 = double;
-    using tuple_type = std::tuple<tuple_elem_type0, tuple_elem_type1>;
+    using tuple_type = gpu_array::tuple<tuple_elem_type0, tuple_elem_type1>;
     using custom_tuple_type = custom_tuple_example<tuple_elem_type0, tuple_elem_type1>;
 
     // initizalization
@@ -1398,17 +1398,17 @@ TEST(ManagedStructureOfArrays, Construction)
         EXPECT_EQ(soa.size(), 10);
         for (const auto& v : soa)
         {
-            EXPECT_EQ(std::get<0>(v), 0);
-            EXPECT_EQ(std::get<1>(v), 0.0);
+            EXPECT_EQ(gpu_array::get<0>(v), 0);
+            EXPECT_EQ(gpu_array::get<1>(v), 0.0);
         }
     }
     {
-        auto soa = managed_structure_of_arrays<tuple_elem_type0, tuple_elem_type1>(10, std::tuple(1, 2.5));
+        auto soa = managed_structure_of_arrays<tuple_elem_type0, tuple_elem_type1>(10, gpu_array::tuple(1, 2.5));
         EXPECT_EQ(soa.size(), 10);
         for (const auto& v : soa)
         {
-            EXPECT_EQ(std::get<0>(v), 1);
-            EXPECT_EQ(std::get<1>(v), 2.5);
+            EXPECT_EQ(gpu_array::get<0>(v), 1);
+            EXPECT_EQ(gpu_array::get<1>(v), 2.5);
         }
     }
     {
@@ -1424,17 +1424,17 @@ TEST(ManagedStructureOfArrays, Construction)
         EXPECT_EQ(soa.size(), 10);
         for (const auto& v : soa)
         {
-            EXPECT_EQ(std::get<0>(v), 0);
-            EXPECT_EQ(std::get<1>(v), 0.0);
+            EXPECT_EQ(gpu_array::get<0>(v), 0);
+            EXPECT_EQ(gpu_array::get<1>(v), 0.0);
         }
     }
     {
-        auto soa = managed_structure_of_arrays<tuple_type>(10, std::tuple(1, 2.5));
+        auto soa = managed_structure_of_arrays<tuple_type>(10, gpu_array::tuple(1, 2.5));
         EXPECT_EQ(soa.size(), 10);
         for (const auto& v : soa)
         {
-            EXPECT_EQ(std::get<0>(v), 1);
-            EXPECT_EQ(std::get<1>(v), 2.5);
+            EXPECT_EQ(gpu_array::get<0>(v), 1);
+            EXPECT_EQ(gpu_array::get<1>(v), 2.5);
         }
     }
     {
@@ -1450,8 +1450,8 @@ TEST(ManagedStructureOfArrays, Construction)
         EXPECT_EQ(soa.size(), 10);
         for (const auto& v : soa)
         {
-            EXPECT_EQ(std::get<0>(v), 0);
-            EXPECT_EQ(std::get<1>(v), 0.0);
+            EXPECT_EQ(gpu_array::get<0>(v), 0);
+            EXPECT_EQ(gpu_array::get<1>(v), 0.0);
         }
     }
     {
@@ -1459,8 +1459,8 @@ TEST(ManagedStructureOfArrays, Construction)
         EXPECT_EQ(soa.size(), 10);
         for (const auto& v : soa)
         {
-            EXPECT_EQ(std::get<0>(v), 1);
-            EXPECT_EQ(std::get<1>(v), 2.5);
+            EXPECT_EQ(gpu_array::get<0>(v), 1);
+            EXPECT_EQ(gpu_array::get<1>(v), 2.5);
         }
     }
     {
@@ -1499,7 +1499,7 @@ TEST(ManagedStructureOfArrays, Construction)
         EXPECT_EQ(arr1.use_count(), 1);
     }
 
-    // construction from range of std::tuple
+    // construction from range of gpu_array::tuple
     {
         auto vec = std::vector<tuple_type>();
         for (std::size_t i = 0; i < 10; ++i)
@@ -1510,21 +1510,21 @@ TEST(ManagedStructureOfArrays, Construction)
         EXPECT_EQ(soa.size(), 10);
         for (std::size_t i = 0; i < 10; ++i)
         {
-            EXPECT_EQ(std::get<0>(soa[i]), std::get<0>(vec[i]));
-            EXPECT_EQ(std::get<1>(soa[i]), std::get<1>(vec[i]));
+            EXPECT_EQ(gpu_array::get<0>(soa[i]), gpu_array::get<0>(vec[i]));
+            EXPECT_EQ(gpu_array::get<1>(soa[i]), gpu_array::get<1>(vec[i]));
         }
     }
 
-    // construction from initializer_list of std::tuple
+    // construction from initializer_list of gpu_array::tuple
     {
         auto soa = managed_structure_of_arrays<tuple_type>({{0, 0.5}, {1, 1.5}, {2, 2.5}});
         EXPECT_EQ(soa.size(), 3);
-        EXPECT_EQ(std::get<0>(soa[0]), 0);
-        EXPECT_EQ(std::get<1>(soa[0]), 0.5);
-        EXPECT_EQ(std::get<0>(soa[1]), 1);
-        EXPECT_EQ(std::get<1>(soa[1]), 1.5);
-        EXPECT_EQ(std::get<0>(soa[2]), 2);
-        EXPECT_EQ(std::get<1>(soa[2]), 2.5);
+        EXPECT_EQ(gpu_array::get<0>(soa[0]), 0);
+        EXPECT_EQ(gpu_array::get<1>(soa[0]), 0.5);
+        EXPECT_EQ(gpu_array::get<0>(soa[1]), 1);
+        EXPECT_EQ(gpu_array::get<1>(soa[1]), 1.5);
+        EXPECT_EQ(gpu_array::get<0>(soa[2]), 2);
+        EXPECT_EQ(gpu_array::get<1>(soa[2]), 2.5);
     }
 
     // construction from multiple ranges
@@ -1540,8 +1540,8 @@ TEST(ManagedStructureOfArrays, Construction)
         EXPECT_EQ(soa.size(), 10);
         for (std::size_t i = 0; const auto& v : soa)
         {
-            EXPECT_EQ(std::get<0>(v), vec0[i]);
-            EXPECT_EQ(std::get<1>(v), vec1[i]);
+            EXPECT_EQ(gpu_array::get<0>(v), vec0[i]);
+            EXPECT_EQ(gpu_array::get<1>(v), vec1[i]);
             ++i;
         }
     }
@@ -1551,12 +1551,12 @@ TEST(ManagedStructureOfArrays, Construction)
         auto soa = managed_structure_of_arrays<tuple_elem_type0, tuple_elem_type1>({0, 1, 2}, {0.5, 1.5, 2.5});
         EXPECT_EQ(soa.size(), 3);
         const auto soa_vec = soa.to<std::vector>();
-        EXPECT_EQ(std::get<0>(soa_vec[0]), 0);
-        EXPECT_EQ(std::get<1>(soa_vec[0]), 0.5);
-        EXPECT_EQ(std::get<0>(soa_vec[1]), 1);
-        EXPECT_EQ(std::get<1>(soa_vec[1]), 1.5);
-        EXPECT_EQ(std::get<0>(soa_vec[2]), 2);
-        EXPECT_EQ(std::get<1>(soa_vec[2]), 2.5);
+        EXPECT_EQ(gpu_array::get<0>(soa_vec[0]), 0);
+        EXPECT_EQ(gpu_array::get<1>(soa_vec[0]), 0.5);
+        EXPECT_EQ(gpu_array::get<0>(soa_vec[1]), 1);
+        EXPECT_EQ(gpu_array::get<1>(soa_vec[1]), 1.5);
+        EXPECT_EQ(gpu_array::get<0>(soa_vec[2]), 2);
+        EXPECT_EQ(gpu_array::get<1>(soa_vec[2]), 2.5);
     }
 
     // construction from range of custom tuple
@@ -1570,9 +1570,9 @@ TEST(ManagedStructureOfArrays, Construction)
         EXPECT_EQ(soa.size(), 10);
         for (std::size_t i = 0; i < soa.size(); ++i)
         {
-            EXPECT_EQ(std::get<0>(soa[i]), static_cast<tuple_elem_type0>(i));
+            EXPECT_EQ(gpu_array::get<0>(soa[i]), static_cast<tuple_elem_type0>(i));
             EXPECT_EQ(soa[i].get_string<0>(), std::to_string(i));
-            EXPECT_EQ(std::get<1>(soa[i]), static_cast<tuple_elem_type1>(i) + 0.5);
+            EXPECT_EQ(gpu_array::get<1>(soa[i]), static_cast<tuple_elem_type1>(i) + 0.5);
             EXPECT_EQ(soa[i].get_string<1>(), std::to_string(i + 0.5));
         }
     }
@@ -1595,7 +1595,7 @@ TEST(ManagedStructureOfArrays, Export)
 {
     using tuple_elem_type0 = int;
     using tuple_elem_type1 = double;
-    using tuple_type = std::tuple<tuple_elem_type0, tuple_elem_type1>;
+    using tuple_type = gpu_array::tuple<tuple_elem_type0, tuple_elem_type1>;
 
     // export to range with same value type
     {
@@ -1621,7 +1621,7 @@ TEST(ManagedStructureOfArrays, Export)
 
 TEST(ManagedStructureOfArrays, RangeInterface)
 {
-    using tuple_type = std::tuple<int, double>;
+    using tuple_type = gpu_array::tuple<int, double>;
     using soa_type1 = managed_structure_of_arrays<int, double>;
     using soa_type2 = managed_structure_of_arrays<tuple_type>;
     using soa_type3 = managed_structure_of_arrays<custom_tuple_example<int, double>>;
@@ -1682,15 +1682,15 @@ TEST(ManagedStructureOfArrays, RangeInterface)
         EXPECT_NE(soa.data<1>(), nullptr);
         EXPECT_EQ(soa.size(), 10);
         EXPECT_FALSE(soa.empty());
-        EXPECT_EQ(soa[0], std::tuple(*soa.data<0>(), *soa.data<1>()));
-        EXPECT_EQ(*soa.begin(), std::tuple(*soa.data<0>(), *soa.data<1>()));
-        EXPECT_EQ(*(soa.end() - 1), std::tuple(*(soa.data<0>() + 9), *(soa.data<1>() + 9)));
+        EXPECT_EQ(soa[0], gpu_array::tuple(*soa.data<0>(), *soa.data<1>()));
+        EXPECT_EQ(*soa.begin(), gpu_array::tuple(*soa.data<0>(), *soa.data<1>()));
+        EXPECT_EQ(*(soa.end() - 1), gpu_array::tuple(*(soa.data<0>() + 9), *(soa.data<1>() + 9)));
 
-        soa = {std::tuple(0, 0.0), std::tuple(1, 1.0), std::tuple(2, 2.0), std::tuple(3, 3.0), std::tuple(4, 4.0)};
+        soa = {gpu_array::tuple(0, 0.0), gpu_array::tuple(1, 1.0), gpu_array::tuple(2, 2.0), gpu_array::tuple(3, 3.0), gpu_array::tuple(4, 4.0)};
         for (std::size_t i = 0; i < soa.size(); ++i)
         {
-            EXPECT_EQ(std::get<0>(soa[i]), static_cast<int>(i));
-            EXPECT_EQ(std::get<1>(soa[i]), static_cast<double>(i));
+            EXPECT_EQ(gpu_array::get<0>(soa[i]), static_cast<int>(i));
+            EXPECT_EQ(gpu_array::get<1>(soa[i]), static_cast<double>(i));
         }
     }
 }
@@ -1711,7 +1711,7 @@ TEST(ManagedStructureOfArrays, SmartPointerInterface)
 TEST(ManagedStructureOfArrays, MemoryManagement)
 {
     // create nested managed_array
-    auto elms = std::vector<std::tuple<int, managed_array<double>>>();
+    auto elms = std::vector<gpu_array::tuple<int, managed_array<double>>>();
     for (std::size_t i = 0; i < 10; ++i) elms.emplace_back(i, managed_array<double>(i, 99));
     auto soa = managed_structure_of_arrays(elms);
 
@@ -1826,7 +1826,7 @@ TEST(JaggedArray, Construction)
 
     // construction from nested containers for jagged structure of arrays
     {
-        using tuple_type = std::tuple<int, double>;
+        using tuple_type = gpu_array::tuple<int, double>;
         auto vec_tpl = std::vector<std::vector<tuple_type>>{
             std::vector<tuple_type>(1, {0, 0.5}), std::vector<tuple_type>(2, {1, 1.5}),
             std::vector<tuple_type>(3, {2, 2.5}), std::vector<tuple_type>(4, {3, 3.5}),
@@ -1891,12 +1891,12 @@ TEST(JaggedArray, Construction)
 
     // construction from container of sizes and flat range (structure of arrays)
     {
-        auto flat_range = std::vector<std::tuple<int, double>>{
+        auto flat_range = std::vector<gpu_array::tuple<int, double>>{
             {0, 0.5}, {1, 1.5}, {2, 2.5},   {3, 3.5},   {4, 4.5},   {5, 5.5},   {6, 6.5},  {7, 7.5},
             {8, 8.5}, {9, 9.5}, {10, 10.5}, {11, 11.5}, {12, 12.5}, {13, 13.5}, {14, 14.5}};
         auto sizes = std::vector<std::uint32_t>{1, 2, 3, 4, 5};
 
-        auto jagged_arr = jagged_array<managed_structure_of_arrays<std::tuple<int, double>>>(
+        auto jagged_arr = jagged_array<managed_structure_of_arrays<gpu_array::tuple<int, double>>>(
             sizes, flat_range);  // no deduction guide
 
         EXPECT_EQ(jagged_arr.size(), 15);
@@ -1905,7 +1905,7 @@ TEST(JaggedArray, Construction)
             EXPECT_EQ(jagged_arr.size(i), sizes[i]);
             for (const auto& v : jagged_arr.row(i))
             {
-                EXPECT_EQ(v, (std::tuple<int, double>(j, static_cast<double>(j) + 0.5)));
+                EXPECT_EQ(v, (gpu_array::tuple<int, double>(j, static_cast<double>(j) + 0.5)));
                 ++j;
             }
         }
@@ -1926,7 +1926,7 @@ TEST(JaggedArray, Construction)
 
     // construction from nested initializer_list (managed structure of arrays)
     {
-        using tuple_type = std::tuple<int, double>;
+        using tuple_type = gpu_array::tuple<int, double>;
         auto jagged_arr = jagged_array<managed_structure_of_arrays<tuple_type>>{
             {{0, 0.5}},
             {{1, 1.5}, {1, 1.5}},
@@ -1967,7 +1967,7 @@ TEST(JaggedArray, Construction)
 
     // wrap managed structure of arrays with sizes
     {
-        using tuple_type = std::tuple<int, double>;
+        using tuple_type = gpu_array::tuple<int, double>;
         auto sizes = std::vector<std::uint32_t>{3, 1, 4, 1, 5};
         auto arr = managed_structure_of_arrays<tuple_type>(14, tuple_type(42, 99.0));
         auto jagged_arr_wrap = jagged_array(sizes, arr);
@@ -1985,8 +1985,8 @@ TEST(JaggedArray, Construction)
             EXPECT_EQ(jagged_arr_wrap.size(i), sizes[i]);
             for (const auto& v : jagged_arr_wrap.row(i))
             {
-                EXPECT_EQ(std::get<0>(v), 42);
-                EXPECT_EQ(std::get<1>(v), 99.0);
+                EXPECT_EQ(gpu_array::get<0>(v), 42);
+                EXPECT_EQ(gpu_array::get<1>(v), 99.0);
             }
         }
     }