Add files using upload-large-folder tool

.gitattributes

@@ -92,3 +92,4 @@ miniCUDA124/bin/nppist64_12.dll filter=lfs diff=lfs merge=lfs -text
 miniCUDA124/bin/nppig64_12.dll filter=lfs diff=lfs merge=lfs -text
 miniCUDA124/bin/ptxas.exe filter=lfs diff=lfs merge=lfs -text
 miniCUDA124/bin/nvprof.exe filter=lfs diff=lfs merge=lfs -text
+miniCUDA124/bin/npps64_12.dll filter=lfs diff=lfs merge=lfs -text

miniCUDA124/bin/npps64_12.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:adca8a91eb74badd854caa136d4dc9d8a6da486ec251c9f6c698132722aa3a18
+size 12743168

miniCUDA124/include/thrust/detail/allocator/allocator_traits.h

@@ -0,0 +1,450 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+// allocator_traits::rebind_alloc and allocator::rebind_traits are from libc++,
+// dual licensed under the MIT and the University of Illinois Open Source
+// Licenses.
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/detail/type_traits/has_nested_type.h>
+#include <thrust/detail/type_traits/has_member_function.h>
+#include <thrust/detail/type_traits.h>
+
+#include <thrust/detail/memory_wrapper.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+// forward declaration for has_member_system
+template<typename Alloc> struct allocator_system;
+
+
+namespace allocator_traits_detail
+{
+
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_value_type, value_type)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_pointer, pointer)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_const_pointer, const_pointer)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_reference, reference)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_const_reference, const_reference)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_void_pointer, void_pointer)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_const_void_pointer, const_void_pointer)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_difference_type, difference_type)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_size_type, size_type)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_propagate_on_container_copy_assignment, propagate_on_container_copy_assignment)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_propagate_on_container_move_assignment, propagate_on_container_move_assignment)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_propagate_on_container_swap, propagate_on_container_swap)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_system_type, system_type)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_is_always_equal, is_always_equal)
+__THRUST_DEFINE_HAS_MEMBER_FUNCTION(has_member_system_impl, system)
+
+template<typename Alloc, typename U>
+  struct has_rebind
+{
+  typedef char yes_type;
+  typedef int  no_type;
+
+  template<typename S>
+  static yes_type test(typename S::template rebind<U>::other*);
+  template<typename S>
+  static no_type  test(...);
+
+  static bool const value = sizeof(test<U>(0)) == sizeof(yes_type);
+
+  typedef thrust::detail::integral_constant<bool, value> type;
+};
+
+// The following fields of std::allocator have been deprecated (since C++17).
+// There's no way to detect it other than explicit specialization.
+#if THRUST_CPP_DIALECT >= 2017
+#define THRUST_SPECIALIZE_DEPRECATED(trait_name)                               \
+template <typename T>                                                          \
+struct trait_name<std::allocator<T>> : false_type {};
+
+THRUST_SPECIALIZE_DEPRECATED(has_is_always_equal)
+THRUST_SPECIALIZE_DEPRECATED(has_pointer)
+THRUST_SPECIALIZE_DEPRECATED(has_const_pointer)
+THRUST_SPECIALIZE_DEPRECATED(has_reference)
+THRUST_SPECIALIZE_DEPRECATED(has_const_reference)
+
+#undef THRUST_SPECIALIZE_DEPRECATED
+
+template<typename T, typename U>
+struct has_rebind<std::allocator<T>, U> : false_type {};
+#endif
+
+template<typename T>
+  struct nested_pointer
+{
+  typedef typename T::pointer type;
+};
+
+template<typename T>
+  struct nested_const_pointer
+{
+  typedef typename T::const_pointer type;
+};
+
+template<typename T>
+  struct nested_reference
+{
+  typedef typename T::reference type;
+};
+
+template<typename T>
+  struct nested_const_reference
+{
+  typedef typename T::const_reference type;
+};
+
+template<typename T>
+  struct nested_void_pointer
+{
+  typedef typename T::void_pointer type;
+};
+
+template<typename T>
+  struct nested_const_void_pointer
+{
+  typedef typename T::const_void_pointer type;
+};
+
+template<typename T>
+  struct nested_difference_type
+{
+  typedef typename T::difference_type type;
+};
+
+template<typename T>
+  struct nested_size_type
+{
+  typedef typename T::size_type type;
+};
+
+template<typename T>
+  struct nested_propagate_on_container_copy_assignment
+{
+  typedef typename T::propagate_on_container_copy_assignment type;
+};
+
+template<typename T>
+  struct nested_propagate_on_container_move_assignment
+{
+  typedef typename T::propagate_on_container_move_assignment type;
+};
+
+template<typename T>
+  struct nested_propagate_on_container_swap
+{
+  typedef typename T::propagate_on_container_swap type;
+};
+
+template<typename T>
+  struct nested_is_always_equal
+{
+  typedef typename T::is_always_equal type;
+};
+
+template<typename T>
+  struct nested_system_type
+{
+  typedef typename T::system_type type;
+};
+
+template<typename Alloc>
+  struct has_member_system
+{
+  typedef typename allocator_system<Alloc>::type system_type;
+
+  typedef typename has_member_system_impl<Alloc, system_type&(void)>::type type;
+  static const bool value = type::value;
+};
+
+template<class Alloc, class U, bool = has_rebind<Alloc, U>::value>
+  struct rebind_alloc
+{
+    typedef typename Alloc::template rebind<U>::other type;
+};
+
+#if THRUST_CPP_DIALECT >= 2011
+template<template<typename, typename...> class Alloc,
+         typename T, typename... Args, typename U>
+  struct rebind_alloc<Alloc<T, Args...>, U, true>
+{
+    typedef typename Alloc<T, Args...>::template rebind<U>::other type;
+};
+
+template<template<typename, typename...> class Alloc,
+         typename T, typename... Args, typename U>
+  struct rebind_alloc<Alloc<T, Args...>, U, false>
+{
+    typedef Alloc<U, Args...> type;
+};
+#else // C++03
+template <template <typename> class Alloc, typename T, typename U>
+  struct rebind_alloc<Alloc<T>, U, true>
+{
+    typedef typename Alloc<T>::template rebind<U>::other type;
+};
+
+template <template <typename> class Alloc, typename T, typename U>
+  struct rebind_alloc<Alloc<T>, U, false>
+{
+    typedef Alloc<U> type;
+};
+
+template<template<typename, typename> class Alloc,
+         typename T, typename A0, typename U>
+  struct rebind_alloc<Alloc<T, A0>, U, true>
+{
+    typedef typename Alloc<T, A0>::template rebind<U>::other type;
+};
+
+template<template<typename, typename> class Alloc,
+         typename T, typename A0, typename U>
+  struct rebind_alloc<Alloc<T, A0>, U, false>
+{
+    typedef Alloc<U, A0> type;
+};
+
+template<template<typename, typename, typename> class Alloc,
+         typename T, typename A0, typename A1, typename U>
+  struct rebind_alloc<Alloc<T, A0, A1>, U, true>
+{
+    typedef typename Alloc<T, A0, A1>::template rebind<U>::other type;
+};
+
+template<template<typename, typename, typename> class Alloc,
+         typename T, typename A0, typename A1, typename U>
+  struct rebind_alloc<Alloc<T, A0, A1>, U, false>
+{
+    typedef Alloc<U, A0, A1> type;
+};
+
+template<template<typename, typename, typename, typename> class Alloc,
+         typename T, typename A0, typename A1, typename A2, typename U>
+  struct rebind_alloc<Alloc<T, A0, A1, A2>, U, true>
+{
+    typedef typename Alloc<T, A0, A1, A2>::template rebind<U>::other type;
+};
+
+template<template<typename, typename, typename, typename> class Alloc,
+         typename T, typename A0, typename A1, typename A2, typename U>
+  struct rebind_alloc<Alloc<T, A0, A1, A2>, U, false>
+{
+    typedef Alloc<U, A0, A1, A2> type;
+};
+#endif
+
+} // end allocator_traits_detail
+
+
+template<typename Alloc>
+  struct allocator_traits
+{
+  typedef Alloc allocator_type;
+
+  typedef typename allocator_type::value_type value_type;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_pointer<allocator_type>::value,
+    allocator_traits_detail::nested_pointer<allocator_type>,
+    identity_<value_type*>
+  >::type pointer;
+
+  private:
+    template<typename T>
+      struct rebind_pointer
+    {
+      typedef typename pointer_traits<pointer>::template rebind<T>::other type;
+    };
+
+  public:
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_const_pointer<allocator_type>::value,
+    allocator_traits_detail::nested_const_pointer<allocator_type>,
+    rebind_pointer<const value_type>
+  >::type const_pointer;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_void_pointer<allocator_type>::value,
+    allocator_traits_detail::nested_void_pointer<allocator_type>,
+    rebind_pointer<void>
+  >::type void_pointer;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_const_void_pointer<allocator_type>::value,
+    allocator_traits_detail::nested_const_void_pointer<allocator_type>,
+    rebind_pointer<const void>
+  >::type const_void_pointer;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_difference_type<allocator_type>::value,
+    allocator_traits_detail::nested_difference_type<allocator_type>,
+    pointer_difference<pointer>
+  >::type difference_type;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_size_type<allocator_type>::value,
+    allocator_traits_detail::nested_size_type<allocator_type>,
+    make_unsigned<difference_type>
+  >::type size_type;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_propagate_on_container_copy_assignment<allocator_type>::value,
+    allocator_traits_detail::nested_propagate_on_container_copy_assignment<allocator_type>,
+    identity_<false_type>
+  >::type propagate_on_container_copy_assignment;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_propagate_on_container_move_assignment<allocator_type>::value,
+    allocator_traits_detail::nested_propagate_on_container_move_assignment<allocator_type>,
+    identity_<false_type>
+  >::type propagate_on_container_move_assignment;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_propagate_on_container_swap<allocator_type>::value,
+    allocator_traits_detail::nested_propagate_on_container_swap<allocator_type>,
+    identity_<false_type>
+  >::type propagate_on_container_swap;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_is_always_equal<allocator_type>::value,
+    allocator_traits_detail::nested_is_always_equal<allocator_type>,
+    is_empty<allocator_type>
+  >::type is_always_equal;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_system_type<allocator_type>::value,
+    allocator_traits_detail::nested_system_type<allocator_type>,
+    thrust::iterator_system<pointer>
+  >::type system_type;
+
+  // XXX rebind and rebind_traits are alias templates
+  //     and so are omitted while c++11 is unavailable
+
+#if THRUST_CPP_DIALECT >= 2011
+  template <typename U>
+  using rebind_alloc =
+    typename allocator_traits_detail::rebind_alloc<allocator_type, U>::type;
+
+  template <typename U>
+  using rebind_traits = allocator_traits<rebind_alloc<U>>;
+
+  // We define this nested type alias for compatibility with the C++03-style
+  // rebind_* mechanisms.
+  using other = allocator_traits;
+#else
+  template <typename U>
+  struct rebind_alloc
+  {
+    typedef typename
+      allocator_traits_detail::rebind_alloc<allocator_type, U>::type other;
+  };
+  template <typename U>
+  struct rebind_traits
+  {
+    typedef allocator_traits<typename rebind_alloc<U>::other> other;
+  };
+#endif
+
+  // Deprecated std::allocator typedefs that we need:
+  typedef typename thrust::detail::pointer_traits<pointer>::reference reference;
+  typedef typename thrust::detail::pointer_traits<const_pointer>::reference const_reference;
+
+  inline __host__ __device__
+  static pointer allocate(allocator_type &a, size_type n);
+
+  inline __host__ __device__
+  static pointer allocate(allocator_type &a, size_type n, const_void_pointer hint);
+
+  inline __host__ __device__
+  static void deallocate(allocator_type &a, pointer p, size_type n);
+
+  // XXX should probably change T* to pointer below and then relax later
+
+  template<typename T>
+  inline __host__ __device__ static void construct(allocator_type &a, T *p);
+
+  template<typename T, typename Arg1>
+  inline __host__ __device__ static void construct(allocator_type &a, T *p, const Arg1 &arg1);
+
+#if THRUST_CPP_DIALECT >= 2011
+  template<typename T, typename... Args>
+  inline __host__ __device__ static void construct(allocator_type &a, T *p, Args&&... args);
+#endif
+
+  template<typename T>
+  inline __host__ __device__ static void destroy(allocator_type &a, T *p);
+
+  inline __host__ __device__
+  static size_type max_size(const allocator_type &a);
+}; // end allocator_traits
+
+
+// we consider a type an allocator if T::value_type exists
+// it doesn't make much sense (containers, which are not allocators, will fulfill this requirement),
+// but allocator_traits is specified to work for any type with that nested typedef
+template<typename T>
+  struct is_allocator
+    : allocator_traits_detail::has_value_type<T>
+{};
+
+
+// XXX consider moving this non-standard functionality inside allocator_traits
+template<typename Alloc>
+  struct allocator_system
+{
+  // the type of the allocator's system
+  typedef typename eval_if<
+    allocator_traits_detail::has_system_type<Alloc>::value,
+    allocator_traits_detail::nested_system_type<Alloc>,
+    thrust::iterator_system<
+      typename allocator_traits<Alloc>::pointer
+    >
+  >::type type;
+
+  // the type that get returns
+  typedef typename eval_if<
+    allocator_traits_detail::has_member_system<Alloc>::value, // if Alloc.system() exists
+    add_reference<type>,                                      // then get() needs to return a reference
+    identity_<type>                                           // else get() needs to return a value
+  >::type get_result_type;
+
+  __host__ __device__
+  inline static get_result_type get(Alloc &a);
+};
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/allocator_traits.inl>
+

miniCUDA124/include/thrust/detail/allocator/allocator_traits.inl

@@ -0,0 +1,473 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/type_traits/is_call_possible.h>
+#include <thrust/detail/integer_traits.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+  #include <thrust/detail/type_deduction.h>
+#endif
+
+#include <thrust/detail/memory_wrapper.h>
+#include <new>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+#if THRUST_CPP_DIALECT >= 2011
+
+// std::allocator's member functions are deprecated in C++17 and removed in
+// C++20, so we can't just use the generic implementation for allocator_traits
+// that calls the allocator's member functions.
+// Instead, specialize allocator_traits for std::allocator and defer to
+// std::allocator_traits<std::allocator> and let the STL do whatever it needs
+// to for the current c++ version. Manually forward the calls to suppress
+// host/device warnings.
+template <typename T>
+struct allocator_traits<std::allocator<T>>
+  : public std::allocator_traits<std::allocator<T>>
+{
+private:
+  using superclass = std::allocator_traits<std::allocator<T>>;
+
+public:
+  using allocator_type = typename superclass::allocator_type;
+  using value_type = typename superclass::value_type;
+  using pointer = typename superclass::pointer;
+  using const_pointer = typename superclass::const_pointer;
+  using void_pointer = typename superclass::void_pointer;
+  using const_void_pointer = typename superclass::const_void_pointer;
+  using difference_type = typename superclass::difference_type;
+  using size_type = typename superclass::size_type;
+  using propagate_on_container_swap = typename superclass::propagate_on_container_swap;
+  using propagate_on_container_copy_assignment =
+    typename superclass::propagate_on_container_copy_assignment;
+  using propagate_on_container_move_assignment =
+    typename superclass::propagate_on_container_move_assignment;
+
+  // std::allocator_traits added this in C++17, but thrust::allocator_traits defines
+  // it unconditionally.
+  using is_always_equal = typename eval_if<
+      allocator_traits_detail::has_is_always_equal<allocator_type>::value,
+      allocator_traits_detail::nested_is_always_equal<allocator_type>,
+      is_empty<allocator_type>
+    >::type;
+
+  // std::allocator_traits doesn't provide these, but
+  // thrust::detail::allocator_traits does. These used to be part of the
+  // std::allocator API but were deprecated in C++17.
+  using reference = typename thrust::detail::pointer_traits<pointer>::reference;
+  using const_reference = typename thrust::detail::pointer_traits<const_pointer>::reference;
+
+  template <typename U>
+  using rebind_alloc = std::allocator<U>;
+  template <typename U>
+  using rebind_traits = allocator_traits<std::allocator<U>>;
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  static pointer allocate(allocator_type &a, size_type n)
+  {
+    return superclass::allocate(a, n);
+  }
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  static pointer allocate(allocator_type &a, size_type n, const_void_pointer hint)
+  {
+    return superclass::allocate(a, n, hint);
+  }
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  static void deallocate(allocator_type &a, pointer p, size_type n)
+  {
+    superclass::deallocate(a, p, n);
+  }
+
+  __thrust_exec_check_disable__
+  template <typename U, typename ...Args>
+  __host__ __device__
+  static void construct(allocator_type &a, U *p, Args&&... args)
+  {
+    superclass::construct(a, p, THRUST_FWD(args)...);
+  }
+
+  __thrust_exec_check_disable__
+  template <typename U>
+  __host__ __device__
+  static void destroy(allocator_type &a, U *p)
+  {
+    superclass::destroy(a, p);
+  }
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  static size_type max_size(const allocator_type &a)
+  {
+    return superclass::max_size(a);
+  }
+};
+
+#endif //  C++11
+
+namespace allocator_traits_detail
+{
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_allocate_with_hint_impl, allocate)
+
+template<typename Alloc>
+  class has_member_allocate_with_hint
+{
+  typedef typename allocator_traits<Alloc>::pointer            pointer;
+  typedef typename allocator_traits<Alloc>::size_type          size_type;
+  typedef typename allocator_traits<Alloc>::const_void_pointer const_void_pointer;
+
+  public:
+    typedef typename has_member_allocate_with_hint_impl<Alloc, pointer(size_type,const_void_pointer)>::type type;
+    static const bool value = type::value;
+};
+
+template<typename Alloc>
+__host__ __device__
+  typename enable_if<
+    has_member_allocate_with_hint<Alloc>::value,
+    typename allocator_traits<Alloc>::pointer
+  >::type
+    allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n, typename allocator_traits<Alloc>::const_void_pointer hint)
+{
+  return a.allocate(n,hint);
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename disable_if<
+    has_member_allocate_with_hint<Alloc>::value,
+    typename allocator_traits<Alloc>::pointer
+  >::type
+    allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n, typename allocator_traits<Alloc>::const_void_pointer)
+{
+  return a.allocate(n);
+}
+
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_construct1_impl, construct)
+
+template<typename Alloc, typename T>
+  struct has_member_construct1
+    : has_member_construct1_impl<Alloc, void(T*)>
+{};
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T>
+  inline __host__ __device__
+    typename enable_if<
+      has_member_construct1<Alloc,T>::value
+    >::type
+      construct(Alloc &a, T *p)
+{
+  a.construct(p);
+}
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T>
+  inline __host__ __device__
+    typename disable_if<
+      has_member_construct1<Alloc,T>::value
+    >::type
+      construct(Alloc &, T *p)
+{
+  ::new(static_cast<void*>(p)) T();
+}
+
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_construct2_impl, construct)
+
+template<typename Alloc, typename T, typename Arg1>
+  struct has_member_construct2
+    : has_member_construct2_impl<Alloc, void(T*,const Arg1 &)>
+{};
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T, typename Arg1>
+  inline __host__ __device__
+    typename enable_if<
+      has_member_construct2<Alloc,T,Arg1>::value
+    >::type
+      construct(Alloc &a, T *p, const Arg1 &arg1)
+{
+  a.construct(p,arg1);
+}
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T, typename Arg1>
+  inline __host__ __device__
+    typename disable_if<
+      has_member_construct2<Alloc,T,Arg1>::value
+    >::type
+      construct(Alloc &, T *p, const Arg1 &arg1)
+{
+  ::new(static_cast<void*>(p)) T(arg1);
+}
+
+#if THRUST_CPP_DIALECT >= 2011
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_constructN_impl, construct)
+
+template<typename Alloc, typename T, typename... Args>
+  struct has_member_constructN
+    : has_member_constructN_impl<Alloc, void(T*, Args...)>
+{};
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T, typename... Args>
+  inline __host__ __device__
+    typename enable_if<
+      has_member_constructN<Alloc, T, Args...>::value
+    >::type
+      construct(Alloc &a, T* p, Args&&... args)
+{
+  a.construct(p, THRUST_FWD(args)...);
+}
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T, typename... Args>
+  inline __host__ __device__
+    typename disable_if<
+      has_member_constructN<Alloc, T, Args...>::value
+    >::type
+      construct(Alloc &, T* p, Args&&... args)
+{
+  ::new(static_cast<void*>(p)) T(THRUST_FWD(args)...);
+}
+
+#endif
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_destroy_impl, destroy)
+
+template<typename Alloc, typename T>
+  struct has_member_destroy
+    : has_member_destroy_impl<Alloc, void(T*)>
+{};
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T>
+  inline __host__ __device__
+    typename enable_if<
+      has_member_destroy<Alloc,T>::value
+    >::type
+      destroy(Alloc &a, T *p)
+{
+  a.destroy(p);
+}
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T>
+  inline __host__ __device__
+    typename disable_if<
+      has_member_destroy<Alloc,T>::value
+    >::type
+      destroy(Alloc &, T *p)
+{
+  p->~T();
+}
+
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_max_size_impl, max_size)
+
+template<typename Alloc>
+  class has_member_max_size
+{
+  typedef typename allocator_traits<Alloc>::size_type size_type;
+
+  public:
+    typedef typename has_member_max_size_impl<Alloc, size_type(void)>::type type;
+    static const bool value = type::value;
+};
+
+template<typename Alloc>
+__host__ __device__
+  typename enable_if<
+    has_member_max_size<Alloc>::value,
+    typename allocator_traits<Alloc>::size_type
+  >::type
+    max_size(const Alloc &a)
+{
+  return a.max_size();
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename disable_if<
+    has_member_max_size<Alloc>::value,
+    typename allocator_traits<Alloc>::size_type
+  >::type
+    max_size(const Alloc &)
+{
+  typedef typename allocator_traits<Alloc>::size_type size_type;
+  return thrust::detail::integer_traits<size_type>::const_max;
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename enable_if<
+    has_member_system<Alloc>::value,
+    typename allocator_system<Alloc>::type &
+  >::type
+    system(Alloc &a)
+{
+  // return the allocator's system
+  return a.system();
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename disable_if<
+    has_member_system<Alloc>::value,
+    typename allocator_system<Alloc>::type
+  >::type
+    system(Alloc &)
+{
+  // return a copy of a value-initialized system
+  return typename allocator_system<Alloc>::type();
+}
+
+
+} // end allocator_traits_detail
+
+
+template<typename Alloc>
+__host__ __device__
+  typename allocator_traits<Alloc>::pointer
+    allocator_traits<Alloc>
+      ::allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n)
+{
+  struct workaround_warnings
+  {
+    __thrust_exec_check_disable__
+    static __host__ __device__
+    typename allocator_traits<Alloc>::pointer
+      allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n)
+    {
+      return a.allocate(n);
+    }
+  };
+
+  return workaround_warnings::allocate(a, n);
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename allocator_traits<Alloc>::pointer
+    allocator_traits<Alloc>
+      ::allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n, typename allocator_traits<Alloc>::const_void_pointer hint)
+{
+  return allocator_traits_detail::allocate(a, n, hint);
+}
+
+template<typename Alloc>
+__host__ __device__
+  void allocator_traits<Alloc>
+    ::deallocate(Alloc &a, typename allocator_traits<Alloc>::pointer p, typename allocator_traits<Alloc>::size_type n)
+{
+  struct workaround_warnings
+  {
+    __thrust_exec_check_disable__
+    static __host__ __device__
+    void deallocate(Alloc &a, typename allocator_traits<Alloc>::pointer p, typename allocator_traits<Alloc>::size_type n)
+    {
+      return a.deallocate(p,n);
+    }
+  };
+
+  return workaround_warnings::deallocate(a,p,n);
+}
+
+template<typename Alloc>
+  template<typename T>
+  __host__ __device__
+    void allocator_traits<Alloc>
+      ::construct(allocator_type &a, T *p)
+{
+  return allocator_traits_detail::construct(a,p);
+}
+
+template<typename Alloc>
+  template<typename T, typename Arg1>
+  __host__ __device__
+    void allocator_traits<Alloc>
+      ::construct(allocator_type &a, T *p, const Arg1 &arg1)
+{
+  return allocator_traits_detail::construct(a,p,arg1);
+}
+
+#if THRUST_CPP_DIALECT >= 2011
+
+template<typename Alloc>
+  template<typename T, typename... Args>
+  __host__ __device__
+    void allocator_traits<Alloc>
+      ::construct(allocator_type &a, T *p, Args&&... args)
+{
+  return allocator_traits_detail::construct(a, p, THRUST_FWD(args)...);
+}
+
+#endif
+
+template<typename Alloc>
+  template<typename T>
+  __host__ __device__
+    void allocator_traits<Alloc>
+      ::destroy(allocator_type &a, T *p)
+{
+  return allocator_traits_detail::destroy(a,p);
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename allocator_traits<Alloc>::size_type
+    allocator_traits<Alloc>
+      ::max_size(const allocator_type &a)
+{
+  return allocator_traits_detail::max_size(a);
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename allocator_system<Alloc>::get_result_type
+    allocator_system<Alloc>
+      ::get(Alloc &a)
+{
+  return allocator_traits_detail::system(a);
+}
+
+
+} // end detail
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/detail/allocator/copy_construct_range.h

@@ -0,0 +1,54 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename System, typename Allocator, typename InputIterator, typename Pointer>
+__host__ __device__
+  Pointer copy_construct_range(thrust::execution_policy<System> &from_system,
+                               Allocator &a,
+                               InputIterator first,
+                               InputIterator last,
+                               Pointer result);
+
+template<typename System, typename Allocator, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  Pointer copy_construct_range_n(thrust::execution_policy<System> &from_system,
+                                 Allocator &a,
+                                 InputIterator first,
+                                 Size n,
+                                 Pointer result);
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/copy_construct_range.inl>
+

miniCUDA124/include/thrust/detail/allocator/copy_construct_range.inl

@@ -0,0 +1,318 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/copy.h>
+#include <thrust/tuple.h>
+#include <thrust/advance.h>
+#include <thrust/distance.h>
+#include <thrust/iterator/zip_iterator.h>
+#include <thrust/for_each.h>
+#include <thrust/detail/memory_wrapper.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace allocator_traits_detail
+{
+
+
+template<typename Allocator, typename InputType, typename OutputType>
+  struct copy_construct_with_allocator
+{
+  Allocator &a;
+
+  __host__ __device__
+  copy_construct_with_allocator(Allocator &a)
+    : a(a)
+  {}
+
+  template<typename Tuple>
+  inline __host__ __device__
+  void operator()(Tuple t)
+  {
+    const InputType &in = thrust::get<0>(t);
+    OutputType &out = thrust::get<1>(t);
+
+    allocator_traits<Allocator>::construct(a, &out, in);
+  }
+};
+
+
+// we need to use allocator_traits<Allocator>::construct() to
+// copy construct a T if either:
+// 1. Allocator has a 2-argument construct() member or
+// 2. T has a non-trivial copy constructor
+template<typename Allocator, typename T>
+  struct needs_copy_construct_via_allocator
+    : integral_constant<
+        bool,
+        (has_member_construct2<Allocator,T,T>::value || !has_trivial_copy_constructor<T>::value)
+      >
+{};
+
+
+// we know that std::allocator::construct's only effect is to call T's
+// copy constructor, so we needn't consider or use its construct() member for copy construction
+template<typename U, typename T>
+  struct needs_copy_construct_via_allocator<std::allocator<U>, T>
+    : integral_constant<
+        bool,
+        !has_trivial_copy_constructor<T>::value
+      >
+{};
+
+
+// XXX it's regrettable that this implementation is copied almost
+//     exactly from system::detail::generic::uninitialized_copy
+//     perhaps generic::uninitialized_copy could call this routine
+//     with a default allocator
+template<typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Pointer>
+__host__ __device__
+  typename enable_if_convertible<
+    FromSystem,
+    ToSystem,
+    Pointer
+  >::type
+    uninitialized_copy_with_allocator(Allocator &a,
+                                      const thrust::execution_policy<FromSystem> &,
+                                      const thrust::execution_policy<ToSystem> &to_system,
+                                      InputIterator first,
+                                      InputIterator last,
+                                      Pointer result)
+{
+  // zip up the iterators
+  typedef thrust::tuple<InputIterator,Pointer> IteratorTuple;
+  typedef thrust::zip_iterator<IteratorTuple>  ZipIterator;
+
+  ZipIterator begin = thrust::make_zip_iterator(thrust::make_tuple(first,result));
+  ZipIterator end = begin;
+
+  // get a zip_iterator pointing to the end
+  const typename thrust::iterator_difference<InputIterator>::type n = thrust::distance(first,last);
+  thrust::advance(end,n);
+
+  // create a functor
+  typedef typename iterator_traits<InputIterator>::value_type InputType;
+  typedef typename iterator_traits<Pointer>::value_type       OutputType;
+
+  // do the for_each
+  // note we use to_system to dispatch the for_each
+  thrust::for_each(to_system, begin, end, copy_construct_with_allocator<Allocator,InputType,OutputType>(a));
+
+  // return the end of the output range
+  return thrust::get<1>(end.get_iterator_tuple());
+}
+
+
+// XXX it's regrettable that this implementation is copied almost
+//     exactly from system::detail::generic::uninitialized_copy_n
+//     perhaps generic::uninitialized_copy_n could call this routine
+//     with a default allocator
+template<typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  typename enable_if_convertible<
+    FromSystem,
+    ToSystem,
+    Pointer
+  >::type
+    uninitialized_copy_with_allocator_n(Allocator &a,
+                                        const thrust::execution_policy<FromSystem> &,
+                                        const thrust::execution_policy<ToSystem> &to_system,
+                                        InputIterator first,
+                                        Size n,
+                                        Pointer result)
+{
+  // zip up the iterators
+  typedef thrust::tuple<InputIterator,Pointer> IteratorTuple;
+  typedef thrust::zip_iterator<IteratorTuple>  ZipIterator;
+
+  ZipIterator begin = thrust::make_zip_iterator(thrust::make_tuple(first,result));
+
+  // create a functor
+  typedef typename iterator_traits<InputIterator>::value_type InputType;
+  typedef typename iterator_traits<Pointer>::value_type       OutputType;
+
+  // do the for_each_n
+  // note we use to_system to dispatch the for_each_n
+  ZipIterator end = thrust::for_each_n(to_system, begin, n, copy_construct_with_allocator<Allocator,InputType,OutputType>(a));
+
+  // return the end of the output range
+  return thrust::get<1>(end.get_iterator_tuple());
+}
+
+
+template<typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Pointer>
+__host__ __device__
+  typename disable_if_convertible<
+    FromSystem,
+    ToSystem,
+    Pointer
+  >::type
+    uninitialized_copy_with_allocator(Allocator &,
+                                      const thrust::execution_policy<FromSystem> &from_system,
+                                      const thrust::execution_policy<ToSystem> &to_system,
+                                      InputIterator first,
+                                      InputIterator last,
+                                      Pointer result)
+{
+  // the systems aren't trivially interoperable
+  // just call two_system_copy and hope for the best
+  return thrust::detail::two_system_copy(from_system, to_system, first, last, result);
+} // end uninitialized_copy_with_allocator()
+
+
+template<typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  typename disable_if_convertible<
+    FromSystem,
+    ToSystem,
+    Pointer
+  >::type
+    uninitialized_copy_with_allocator_n(Allocator &,
+                                        const thrust::execution_policy<FromSystem> &from_system,
+                                        const thrust::execution_policy<ToSystem> &to_system,
+                                        InputIterator first,
+                                        Size n,
+                                        Pointer result)
+{
+  // the systems aren't trivially interoperable
+  // just call two_system_copy_n and hope for the best
+  return thrust::detail::two_system_copy_n(from_system, to_system, first, n, result);
+} // end uninitialized_copy_with_allocator_n()
+
+
+template<typename FromSystem, typename Allocator, typename InputIterator, typename Pointer>
+__host__ __device__
+  typename disable_if<
+    needs_copy_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value,
+    Pointer
+  >::type
+    copy_construct_range(thrust::execution_policy<FromSystem> &from_system,
+                         Allocator &a,
+                         InputIterator first,
+                         InputIterator last,
+                         Pointer result)
+{
+  // just call two_system_copy
+  return thrust::detail::two_system_copy(from_system, allocator_system<Allocator>::get(a), first, last, result);
+}
+
+
+template<typename FromSystem, typename Allocator, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  typename disable_if<
+    needs_copy_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value,
+    Pointer
+  >::type
+    copy_construct_range_n(thrust::execution_policy<FromSystem> &from_system,
+                           Allocator &a,
+                           InputIterator first,
+                           Size n,
+                           Pointer result)
+{
+  // just call two_system_copy_n
+  return thrust::detail::two_system_copy_n(from_system, allocator_system<Allocator>::get(a), first, n, result);
+}
+
+
+template<typename FromSystem, typename Allocator, typename InputIterator, typename Pointer>
+__host__ __device__
+  typename enable_if<
+    needs_copy_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value,
+    Pointer
+  >::type
+    copy_construct_range(thrust::execution_policy<FromSystem> &from_system,
+                         Allocator &a,
+                         InputIterator first,
+                         InputIterator last,
+                         Pointer result)
+{
+  return uninitialized_copy_with_allocator(a, from_system, allocator_system<Allocator>::get(a), first, last, result);
+}
+
+
+template<typename FromSystem, typename Allocator, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  typename enable_if<
+    needs_copy_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value,
+    Pointer
+  >::type
+    copy_construct_range_n(thrust::execution_policy<FromSystem> &from_system,
+                           Allocator &a,
+                           InputIterator first,
+                           Size n,
+                           Pointer result)
+{
+  return uninitialized_copy_with_allocator_n(a, from_system, allocator_system<Allocator>::get(a), first, n, result);
+}
+
+
+} // end allocator_traits_detail
+
+
+template<typename System, typename Allocator, typename InputIterator, typename Pointer>
+__host__ __device__
+  Pointer copy_construct_range(thrust::execution_policy<System> &from_system,
+                               Allocator &a,
+                               InputIterator first,
+                               InputIterator last,
+                               Pointer result)
+{
+  return allocator_traits_detail::copy_construct_range(from_system, a, first, last, result);
+}
+
+
+template<typename System, typename Allocator, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  Pointer copy_construct_range_n(thrust::execution_policy<System> &from_system,
+                                 Allocator &a,
+                                 InputIterator first,
+                                 Size n,
+                                 Pointer result)
+{
+  return allocator_traits_detail::copy_construct_range_n(from_system, a, first, n, result);
+}
+
+
+} // end detail
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/detail/allocator/default_construct_range.h

@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+inline void default_construct_range(Allocator &a, Pointer p, Size n);
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/default_construct_range.inl>
+
+

miniCUDA124/include/thrust/detail/allocator/default_construct_range.inl

@@ -0,0 +1,120 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/for_each.h>
+#include <thrust/uninitialized_fill.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace allocator_traits_detail
+{
+
+
+template<typename Allocator>
+  struct construct1_via_allocator
+{
+  Allocator &a;
+
+  __host__ __device__
+  construct1_via_allocator(Allocator &a)
+    : a(a)
+  {}
+
+  template<typename T>
+  inline __host__ __device__
+  void operator()(T &x)
+  {
+    allocator_traits<Allocator>::construct(a, &x);
+  }
+};
+
+
+// we need to construct T via the allocator if...
+template<typename Allocator, typename T>
+  struct needs_default_construct_via_allocator
+    : thrust::detail::or_<
+        has_member_construct1<Allocator,T>,               // if the Allocator does something interesting
+        thrust::detail::not_<has_trivial_constructor<T> > // or if T's default constructor does something interesting
+      >
+{};
+
+
+// we know that std::allocator::construct's only effect is to call T's
+// default constructor, so we needn't use it for default construction
+// unless T's constructor does something interesting
+template<typename U, typename T>
+  struct needs_default_construct_via_allocator<std::allocator<U>, T>
+    : thrust::detail::not_<has_trivial_constructor<T> >
+{};
+
+
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  typename enable_if<
+    needs_default_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value
+  >::type
+    default_construct_range(Allocator &a, Pointer p, Size n)
+{
+  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, construct1_via_allocator<Allocator>(a));
+}
+
+
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  typename disable_if<
+    needs_default_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value
+  >::type
+    default_construct_range(Allocator &a, Pointer p, Size n)
+{
+  thrust::uninitialized_fill_n(allocator_system<Allocator>::get(a), p, n, typename pointer_element<Pointer>::type());
+}
+
+
+} // end allocator_traits_detail
+
+
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  void default_construct_range(Allocator &a, Pointer p, Size n)
+{
+  return allocator_traits_detail::default_construct_range(a,p,n);
+}
+
+
+} // end detail
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/detail/allocator/destroy_range.h

@@ -0,0 +1,41 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  inline void destroy_range(Allocator &a, Pointer p, Size n);
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/destroy_range.inl>
+

miniCUDA124/include/thrust/detail/allocator/destroy_range.inl

@@ -0,0 +1,175 @@
+/*
+ *  Copyright 2008-2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/detail/allocator/destroy_range.h>
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/for_each.h>
+#include <thrust/detail/memory_wrapper.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace allocator_traits_detail
+{
+
+
+// destroy_range has three cases:
+// if Allocator has an effectful member function destroy:
+//   1. destroy via the allocator
+// else
+//   2. if T has a non-trivial destructor, destroy the range without using the allocator
+//   3. if T has a trivial destructor, do a no-op
+
+template<typename Allocator, typename T>
+  struct has_effectful_member_destroy
+    : has_member_destroy<Allocator,T>
+{};
+
+// std::allocator::destroy's only effect is to invoke its argument's destructor
+template<typename U, typename T>
+  struct has_effectful_member_destroy<std::allocator<U>, T>
+    : thrust::detail::false_type
+{};
+
+// case 1: Allocator has an effectful 1-argument member function "destroy"
+template<typename Allocator, typename Pointer>
+  struct enable_if_destroy_range_case1
+    : thrust::detail::enable_if<
+        has_effectful_member_destroy<
+          Allocator,
+          typename pointer_element<Pointer>::type
+        >::value
+      >
+{};
+
+// case 2: Allocator has no member function "destroy", but T has a non-trivial destructor
+template<typename Allocator, typename Pointer>
+  struct enable_if_destroy_range_case2
+    : thrust::detail::enable_if<
+        !has_effectful_member_destroy<
+          Allocator,
+          typename pointer_element<Pointer>::type
+        >::value &&
+        !has_trivial_destructor<
+          typename pointer_element<Pointer>::type
+        >::value
+      >
+{};
+
+// case 3: Allocator has no member function "destroy", and T has a trivial destructor
+template<typename Allocator, typename Pointer>
+  struct enable_if_destroy_range_case3
+    : thrust::detail::enable_if<
+        !has_effectful_member_destroy<
+          Allocator,
+          typename pointer_element<Pointer>::type
+        >::value &&
+        has_trivial_destructor<
+          typename pointer_element<Pointer>::type
+        >::value
+      >
+{};
+
+
+
+template<typename Allocator>
+  struct destroy_via_allocator
+{
+  Allocator &a;
+
+  __host__ __device__
+  destroy_via_allocator(Allocator &a)
+    : a(a)
+  {}
+
+  template<typename T>
+  inline __host__ __device__
+  void operator()(T &x)
+  {
+    allocator_traits<Allocator>::destroy(a, &x);
+  }
+};
+
+
+// destroy_range case 1: destroy via allocator
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  typename enable_if_destroy_range_case1<Allocator,Pointer>::type
+    destroy_range(Allocator &a, Pointer p, Size n)
+{
+  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, destroy_via_allocator<Allocator>(a));
+}
+
+
+// we must prepare for His coming
+struct gozer
+{
+  __thrust_exec_check_disable__
+  template<typename T>
+  inline __host__ __device__
+  void operator()(T &x)
+  {
+    x.~T();
+  }
+};
+
+// destroy_range case 2: destroy without the allocator
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  typename enable_if_destroy_range_case2<Allocator,Pointer>::type
+    destroy_range(Allocator &a, Pointer p, Size n)
+{
+  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, gozer());
+}
+
+
+// destroy_range case 3: no-op
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  typename enable_if_destroy_range_case3<Allocator,Pointer>::type
+    destroy_range(Allocator &, Pointer, Size)
+{
+  // no op
+}
+
+
+} // end allocator_traits_detail
+
+
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  void destroy_range(Allocator &a, Pointer p, Size n)
+{
+  return allocator_traits_detail::destroy_range(a,p,n);
+}
+
+
+} // end detail
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/detail/complex/c99math.h

@@ -0,0 +1,205 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <math.h>
+#include <cmath>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace complex
+{
+
+// Define basic arithmetic functions so we can use them without explicit scope
+// keeping the code as close as possible to FreeBSDs for ease of maintenance.
+// It also provides an easy way to support compilers with missing C99 functions.
+// When possible, just use the names in the global scope.
+// Some platforms define these as macros, others as free functions.
+// Avoid using the std:: form of these as nvcc may treat std::foo() as __host__ functions.
+
+using ::log;
+using ::acos;
+using ::asin;
+using ::sqrt;
+using ::sinh;
+using ::tan;
+using ::cos;
+using ::sin;
+using ::exp;
+using ::cosh;
+using ::atan;
+
+template <typename T>
+inline __host__ __device__ T infinity();
+
+template <>
+inline __host__ __device__ float infinity<float>()
+{
+  float res;
+  set_float_word(res, 0x7f800000);
+  return res;
+}
+
+
+template <>
+inline __host__ __device__ double infinity<double>()
+{
+  double res;
+  insert_words(res, 0x7ff00000,0);
+  return res;
+}
+
+#if defined _MSC_VER
+__host__ __device__ inline int isinf(float x){
+  return std::abs(x) == infinity<float>();
+}
+
+__host__ __device__ inline int isinf(double x){
+  return std::abs(x) == infinity<double>();
+}
+
+__host__ __device__ inline int isnan(float x){
+  return x != x;
+}
+
+__host__ __device__ inline int isnan(double x){
+  return x != x;
+}
+
+__host__ __device__ inline int signbit(float x){
+  return ((*((uint32_t *)&x)) & 0x80000000) != 0 ? 1 : 0;
+}
+
+__host__ __device__ inline int signbit(double x){
+  return ((*((uint64_t *)&x)) & 0x8000000000000000) != 0ull ? 1 : 0;
+}
+
+__host__ __device__ inline int isfinite(float x){
+  return !isnan(x) && !isinf(x);
+}
+
+__host__ __device__ inline int isfinite(double x){
+  return !isnan(x) && !isinf(x);
+}
+
+#else
+
+#  if defined(__CUDACC__) && !(defined(__CUDA__) && defined(__clang__)) && !defined(_NVHPC_CUDA)
+// NVCC implements at least some signature of these as functions not macros.
+using ::isinf;
+using ::isnan;
+using ::signbit;
+using ::isfinite;
+#  else
+// Some compilers do not provide these in the global scope, because they are
+// supposed to be macros. The versions in `std` are supposed to be functions.
+// Since we're not compiling with nvcc, it's safe to use the functions in std::
+using std::isinf;
+using std::isnan;
+using std::signbit;
+using std::isfinite;
+#  endif // __CUDACC__
+#endif // _MSC_VER
+
+using ::atanh;
+
+#if defined _MSC_VER
+
+__host__ __device__ inline double copysign(double x, double y){
+  uint32_t hx,hy;
+  get_high_word(hx,x);
+  get_high_word(hy,y);
+  set_high_word(x,(hx&0x7fffffff)|(hy&0x80000000));
+  return x;
+}
+
+__host__ __device__ inline float copysignf(float x, float y){
+  uint32_t ix,iy;
+  get_float_word(ix,x);
+  get_float_word(iy,y);
+  set_float_word(x,(ix&0x7fffffff)|(iy&0x80000000));
+  return x;
+}
+
+
+
+#if !defined(__CUDACC__) && !defined(_NVHPC_CUDA)
+
+// Simple approximation to log1p as Visual Studio is lacking one
+inline double log1p(double x){
+  double u = 1.0+x;
+  if(u == 1.0){
+    return x;
+  }else{
+    if(u > 2.0){
+      // Use normal log for large arguments
+      return log(u);
+    }else{
+      return log(u)*(x/(u-1.0));
+    }
+  }
+}
+
+inline float log1pf(float x){
+  float u = 1.0f+x;
+  if(u == 1.0f){
+    return x;
+  }else{
+    if(u > 2.0f){
+      // Use normal log for large arguments
+      return logf(u);
+    }else{
+      return logf(u)*(x/(u-1.0f));
+    }
+  }
+}
+
+#if _MSV_VER <= 1500
+#include <complex>
+
+inline float hypotf(float x, float y){
+	return abs(std::complex<float>(x,y));
+}
+
+inline double hypot(double x, double y){
+	return _hypot(x,y);
+}
+
+#endif // _MSC_VER <= 1500
+
+#endif // __CUDACC__
+
+#endif // _MSC_VER
+
+} // namespace complex
+
+} // namespace detail
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/detail/complex/catrig.h

@@ -0,0 +1,794 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*-
+ * Copyright (c) 2012 Stephen Montgomery-Smith <stephen@FreeBSD.ORG>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Adapted from FreeBSD by Filipe Maia <filipe.c.maia@gmail.com>:
+ *    freebsd/lib/msun/src/catrig.c
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+#include <cfloat>
+#include <cmath>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{
+
+using thrust::complex;
+
+__host__ __device__
+inline void raise_inexact(){
+  const volatile float tiny = 7.888609052210118054117286e-31; /* 0x1p-100; */
+  // needs the volatile to prevent compiler from ignoring it
+  volatile float junk = 1 + tiny;
+  (void)junk;
+}
+
+__host__ __device__ inline complex<double> clog_for_large_values(complex<double> z);
+
+/*
+ * Testing indicates that all these functions are accurate up to 4 ULP.
+ * The functions casin(h) and cacos(h) are about 2.5 times slower than asinh.
+ * The functions catan(h) are a little under 2 times slower than atanh.
+ *
+ * The code for casinh, casin, cacos, and cacosh comes first.  The code is
+ * rather complicated, and the four functions are highly interdependent.
+ *
+ * The code for catanh and catan comes at the end.  It is much simpler than
+ * the other functions, and the code for these can be disconnected from the
+ * rest of the code.
+ */
+
+/*
+ *			================================
+ *			| casinh, casin, cacos, cacosh |
+ *			================================
+ */
+
+/*
+ * The algorithm is very close to that in "Implementing the complex arcsine
+ * and arccosine functions using exception handling" by T. E. Hull, Thomas F.
+ * Fairgrieve, and Ping Tak Peter Tang, published in ACM Transactions on
+ * Mathematical Software, Volume 23 Issue 3, 1997, Pages 299-335,
+ * http://dl.acm.org/citation.cfm?id=275324.
+ *
+ * Throughout we use the convention z = x + I*y.
+ *
+ * casinh(z) = sign(x)*log(A+sqrt(A*A-1)) + I*asin(B)
+ * where
+ * A = (|z+I| + |z-I|) / 2
+ * B = (|z+I| - |z-I|) / 2 = y/A
+ *
+ * These formulas become numerically unstable:
+ *   (a) for Re(casinh(z)) when z is close to the line segment [-I, I] (that
+ *       is, Re(casinh(z)) is close to 0);
+ *   (b) for Im(casinh(z)) when z is close to either of the intervals
+ *       [I, I*infinity) or (-I*infinity, -I] (that is, |Im(casinh(z))| is
+ *       close to PI/2).
+ *
+ * These numerical problems are overcome by defining
+ * f(a, b) = (hypot(a, b) - b) / 2 = a*a / (hypot(a, b) + b) / 2
+ * Then if A < A_crossover, we use
+ *   log(A + sqrt(A*A-1)) = log1p((A-1) + sqrt((A-1)*(A+1)))
+ *   A-1 = f(x, 1+y) + f(x, 1-y)
+ * and if B > B_crossover, we use
+ *   asin(B) = atan2(y, sqrt(A*A - y*y)) = atan2(y, sqrt((A+y)*(A-y)))
+ *   A-y = f(x, y+1) + f(x, y-1)
+ * where without loss of generality we have assumed that x and y are
+ * non-negative.
+ *
+ * Much of the difficulty comes because the intermediate computations may
+ * produce overflows or underflows.  This is dealt with in the paper by Hull
+ * et al by using exception handling.  We do this by detecting when
+ * computations risk underflow or overflow.  The hardest part is handling the
+ * underflows when computing f(a, b).
+ *
+ * Note that the function f(a, b) does not appear explicitly in the paper by
+ * Hull et al, but the idea may be found on pages 308 and 309.  Introducing the
+ * function f(a, b) allows us to concentrate many of the clever tricks in this
+ * paper into one function.
+ */
+
+/*
+ * Function f(a, b, hypot_a_b) = (hypot(a, b) - b) / 2.
+ * Pass hypot(a, b) as the third argument.
+ */
+__host__ __device__
+inline double
+f(double a, double b, double hypot_a_b)
+{
+  if (b < 0)
+    return ((hypot_a_b - b) / 2);
+  if (b == 0)
+    return (a / 2);
+  return (a * a / (hypot_a_b + b) / 2);
+}
+
+/*
+ * All the hard work is contained in this function.
+ * x and y are assumed positive or zero, and less than RECIP_EPSILON.
+ * Upon return:
+ * rx = Re(casinh(z)) = -Im(cacos(y + I*x)).
+ * B_is_usable is set to 1 if the value of B is usable.
+ * If B_is_usable is set to 0, sqrt_A2my2 = sqrt(A*A - y*y), and new_y = y.
+ * If returning sqrt_A2my2 has potential to result in an underflow, it is
+ * rescaled, and new_y is similarly rescaled.
+ */
+__host__ __device__
+inline void
+do_hard_work(double x, double y, double *rx, int *B_is_usable, double *B,
+			double *sqrt_A2my2, double *new_y)
+{
+  double R, S, A; /* A, B, R, and S are as in Hull et al. */
+  double Am1, Amy; /* A-1, A-y. */
+  const double A_crossover = 10; /* Hull et al suggest 1.5, but 10 works better */
+  const double FOUR_SQRT_MIN = 5.966672584960165394632772e-154; /* =0x1p-509; >= 4 * sqrt(DBL_MIN) */
+  const double B_crossover = 0.6417; /* suggested by Hull et al */
+
+  R = hypot(x, y + 1);		/* |z+I| */
+  S = hypot(x, y - 1);		/* |z-I| */
+
+  /* A = (|z+I| + |z-I|) / 2 */
+  A = (R + S) / 2;
+  /*
+   * Mathematically A >= 1.  There is a small chance that this will not
+   * be so because of rounding errors.  So we will make certain it is
+   * so.
+   */
+  if (A < 1)
+    A = 1;
+
+  if (A < A_crossover) {
+    /*
+     * Am1 = fp + fm, where fp = f(x, 1+y), and fm = f(x, 1-y).
+     * rx = log1p(Am1 + sqrt(Am1*(A+1)))
+     */
+    if (y == 1 && x < DBL_EPSILON * DBL_EPSILON / 128) {
+      /*
+       * fp is of order x^2, and fm = x/2.
+       * A = 1 (inexactly).
+       */
+      *rx = sqrt(x);
+    } else if (x >= DBL_EPSILON * fabs(y - 1)) {
+      /*
+       * Underflow will not occur because
+       * x >= DBL_EPSILON^2/128 >= FOUR_SQRT_MIN
+       */
+      Am1 = f(x, 1 + y, R) + f(x, 1 - y, S);
+      *rx = log1p(Am1 + sqrt(Am1 * (A + 1)));
+    } else if (y < 1) {
+      /*
+       * fp = x*x/(1+y)/4, fm = x*x/(1-y)/4, and
+       * A = 1 (inexactly).
+       */
+      *rx = x / sqrt((1 - y) * (1 + y));
+    } else {		/* if (y > 1) */
+      /*
+       * A-1 = y-1 (inexactly).
+       */
+      *rx = log1p((y - 1) + sqrt((y - 1) * (y + 1)));
+    }
+  } else {
+    *rx = log(A + sqrt(A * A - 1));
+  }
+
+  *new_y = y;
+
+  if (y < FOUR_SQRT_MIN) {
+    /*
+     * Avoid a possible underflow caused by y/A.  For casinh this
+     * would be legitimate, but will be picked up by invoking atan2
+     * later on.  For cacos this would not be legitimate.
+     */
+    *B_is_usable = 0;
+    *sqrt_A2my2 = A * (2 / DBL_EPSILON);
+    *new_y = y * (2 / DBL_EPSILON);
+    return;
+  }
+
+  /* B = (|z+I| - |z-I|) / 2 = y/A */
+  *B = y / A;
+  *B_is_usable = 1;
+
+  if (*B > B_crossover) {
+    *B_is_usable = 0;
+    /*
+     * Amy = fp + fm, where fp = f(x, y+1), and fm = f(x, y-1).
+     * sqrt_A2my2 = sqrt(Amy*(A+y))
+     */
+    if (y == 1 && x < DBL_EPSILON / 128) {
+      /*
+       * fp is of order x^2, and fm = x/2.
+       * A = 1 (inexactly).
+       */
+      *sqrt_A2my2 = sqrt(x) * sqrt((A + y) / 2);
+    } else if (x >= DBL_EPSILON * fabs(y - 1)) {
+      /*
+       * Underflow will not occur because
+       * x >= DBL_EPSILON/128 >= FOUR_SQRT_MIN
+       * and
+       * x >= DBL_EPSILON^2 >= FOUR_SQRT_MIN
+       */
+      Amy = f(x, y + 1, R) + f(x, y - 1, S);
+      *sqrt_A2my2 = sqrt(Amy * (A + y));
+    } else if (y > 1) {
+      /*
+       * fp = x*x/(y+1)/4, fm = x*x/(y-1)/4, and
+       * A = y (inexactly).
+       *
+       * y < RECIP_EPSILON.  So the following
+       * scaling should avoid any underflow problems.
+       */
+      *sqrt_A2my2 = x * (4 / DBL_EPSILON / DBL_EPSILON) * y /
+	sqrt((y + 1) * (y - 1));
+      *new_y = y * (4 / DBL_EPSILON / DBL_EPSILON);
+    } else {		/* if (y < 1) */
+      /*
+       * fm = 1-y >= DBL_EPSILON, fp is of order x^2, and
+       * A = 1 (inexactly).
+       */
+      *sqrt_A2my2 = sqrt((1 - y) * (1 + y));
+    }
+  }
+}
+
+/*
+ * casinh(z) = z + O(z^3)   as z -> 0
+ *
+ * casinh(z) = sign(x)*clog(sign(x)*z) + O(1/z^2)   as z -> infinity
+ * The above formula works for the imaginary part as well, because
+ * Im(casinh(z)) = sign(x)*atan2(sign(x)*y, fabs(x)) + O(y/z^3)
+ *    as z -> infinity, uniformly in y
+ */
+__host__ __device__ inline
+complex<double> casinh(complex<double> z)
+{
+  double x, y, ax, ay, rx, ry, B, sqrt_A2my2, new_y;
+  int B_is_usable;
+  complex<double> w;
+  const double RECIP_EPSILON = 1.0 / DBL_EPSILON;
+  const double m_ln2 = 6.9314718055994531e-1; /*  0x162e42fefa39ef.0p-53 */
+  x = z.real();
+  y = z.imag();
+  ax = fabs(x);
+  ay = fabs(y);
+
+  if (isnan(x) || isnan(y)) {
+    /* casinh(+-Inf + I*NaN) = +-Inf + I*NaN */
+    if (isinf(x))
+      return (complex<double>(x, y + y));
+    /* casinh(NaN + I*+-Inf) = opt(+-)Inf + I*NaN */
+    if (isinf(y))
+      return (complex<double>(y, x + x));
+    /* casinh(NaN + I*0) = NaN + I*0 */
+    if (y == 0)
+      return (complex<double>(x + x, y));
+    /*
+     * All other cases involving NaN return NaN + I*NaN.
+     * C99 leaves it optional whether to raise invalid if one of
+     * the arguments is not NaN, so we opt not to raise it.
+     */
+    return (complex<double>(x + 0.0 + (y + 0.0), x + 0.0 + (y + 0.0)));
+  }
+
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) {
+    /* clog...() will raise inexact unless x or y is infinite. */
+    if (signbit(x) == 0)
+      w = clog_for_large_values(z) + m_ln2;
+    else
+      w = clog_for_large_values(-z) + m_ln2;
+    return (complex<double>(copysign(w.real(), x), copysign(w.imag(), y)));
+  }
+
+  /* Avoid spuriously raising inexact for z = 0. */
+  if (x == 0 && y == 0)
+    return (z);
+
+  /* All remaining cases are inexact. */
+  raise_inexact();
+
+  const double SQRT_6_EPSILON = 3.6500241499888571e-8; /*  0x13988e1409212e.0p-77 */
+  if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4)
+    return (z);
+
+  do_hard_work(ax, ay, &rx, &B_is_usable, &B, &sqrt_A2my2, &new_y);
+  if (B_is_usable)
+    ry = asin(B);
+  else
+    ry = atan2(new_y, sqrt_A2my2);
+  return (complex<double>(copysign(rx, x), copysign(ry, y)));
+}
+
+/*
+ * casin(z) = reverse(casinh(reverse(z)))
+ * where reverse(x + I*y) = y + I*x = I*conj(z).
+ */
+__host__ __device__ inline
+complex<double> casin(complex<double> z)
+{
+  complex<double> w = casinh(complex<double>(z.imag(), z.real()));
+
+  return (complex<double>(w.imag(), w.real()));
+}
+
+/*
+ * cacos(z) = PI/2 - casin(z)
+ * but do the computation carefully so cacos(z) is accurate when z is
+ * close to 1.
+ *
+ * cacos(z) = PI/2 - z + O(z^3)   as z -> 0
+ *
+ * cacos(z) = -sign(y)*I*clog(z) + O(1/z^2)   as z -> infinity
+ * The above formula works for the real part as well, because
+ * Re(cacos(z)) = atan2(fabs(y), x) + O(y/z^3)
+ *    as z -> infinity, uniformly in y
+ */
+__host__ __device__ inline
+complex<double> cacos(complex<double> z)
+{
+  double x, y, ax, ay, rx, ry, B, sqrt_A2mx2, new_x;
+  int sx, sy;
+  int B_is_usable;
+  complex<double> w;
+  const double pio2_hi = 1.5707963267948966e0; /*  0x1921fb54442d18.0p-52 */
+  const volatile double pio2_lo = 6.1232339957367659e-17;	/*  0x11a62633145c07.0p-106 */
+  const double m_ln2 = 6.9314718055994531e-1; /*  0x162e42fefa39ef.0p-53 */
+
+  x = z.real();
+  y = z.imag();
+  sx = signbit(x);
+  sy = signbit(y);
+  ax = fabs(x);
+  ay = fabs(y);
+
+  if (isnan(x) || isnan(y)) {
+    /* cacos(+-Inf + I*NaN) = NaN + I*opt(-)Inf */
+    if (isinf(x))
+      return (complex<double>(y + y, -infinity<double>()));
+    /* cacos(NaN + I*+-Inf) = NaN + I*-+Inf */
+    if (isinf(y))
+      return (complex<double>(x + x, -y));
+    /* cacos(0 + I*NaN) = PI/2 + I*NaN with inexact */
+    if (x == 0)
+      return (complex<double>(pio2_hi + pio2_lo, y + y));
+    /*
+     * All other cases involving NaN return NaN + I*NaN.
+     * C99 leaves it optional whether to raise invalid if one of
+     * the arguments is not NaN, so we opt not to raise it.
+     */
+    return (complex<double>(x + 0.0 + (y + 0), x + 0.0 + (y + 0)));
+  }
+
+  const double RECIP_EPSILON = 1.0 / DBL_EPSILON;
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) {
+    /* clog...() will raise inexact unless x or y is infinite. */
+    w = clog_for_large_values(z);
+    rx = fabs(w.imag());
+    ry = w.real() + m_ln2;
+    if (sy == 0)
+      ry = -ry;
+    return (complex<double>(rx, ry));
+  }
+
+  /* Avoid spuriously raising inexact for z = 1. */
+  if (x == 1.0 && y == 0.0)
+    return (complex<double>(0, -y));
+
+  /* All remaining cases are inexact. */
+  raise_inexact();
+
+  const double SQRT_6_EPSILON = 3.6500241499888571e-8; /*  0x13988e1409212e.0p-77 */
+  if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4)
+    return (complex<double>(pio2_hi - (x - pio2_lo), -y));
+
+  do_hard_work(ay, ax, &ry, &B_is_usable, &B, &sqrt_A2mx2, &new_x);
+  if (B_is_usable) {
+    if (sx == 0)
+      rx = acos(B);
+    else
+      rx = acos(-B);
+  } else {
+    if (sx == 0)
+      rx = atan2(sqrt_A2mx2, new_x);
+    else
+      rx = atan2(sqrt_A2mx2, -new_x);
+  }
+  if (sy == 0)
+    ry = -ry;
+  return (complex<double>(rx, ry));
+}
+
+/*
+ * cacosh(z) = I*cacos(z) or -I*cacos(z)
+ * where the sign is chosen so Re(cacosh(z)) >= 0.
+ */
+__host__ __device__ inline
+complex<double> cacosh(complex<double> z)
+{
+  complex<double> w;
+  double rx, ry;
+
+  w = cacos(z);
+  rx = w.real();
+  ry = w.imag();
+  /* cacosh(NaN + I*NaN) = NaN + I*NaN */
+  if (isnan(rx) && isnan(ry))
+    return (complex<double>(ry, rx));
+  /* cacosh(NaN + I*+-Inf) = +Inf + I*NaN */
+  /* cacosh(+-Inf + I*NaN) = +Inf + I*NaN */
+  if (isnan(rx))
+    return (complex<double>(fabs(ry), rx));
+  /* cacosh(0 + I*NaN) = NaN + I*NaN */
+  if (isnan(ry))
+    return (complex<double>(ry, ry));
+  return (complex<double>(fabs(ry), copysign(rx, z.imag())));
+}
+
+/*
+ * Optimized version of clog() for |z| finite and larger than ~RECIP_EPSILON.
+ */
+__host__ __device__ inline
+complex<double> clog_for_large_values(complex<double> z)
+{
+  double x, y;
+  double ax, ay, t;
+  const double m_e = 2.7182818284590452e0; /*  0x15bf0a8b145769.0p-51 */
+
+  x = z.real();
+  y = z.imag();
+  ax = fabs(x);
+  ay = fabs(y);
+  if (ax < ay) {
+    t = ax;
+    ax = ay;
+    ay = t;
+  }
+
+  /*
+   * Avoid overflow in hypot() when x and y are both very large.
+   * Divide x and y by E, and then add 1 to the logarithm.  This depends
+   * on E being larger than sqrt(2).
+   * Dividing by E causes an insignificant loss of accuracy; however
+   * this method is still poor since it is uneccessarily slow.
+   */
+  if (ax > DBL_MAX / 2)
+    return (complex<double>(log(hypot(x / m_e, y / m_e)) + 1, atan2(y, x)));
+
+  /*
+   * Avoid overflow when x or y is large.  Avoid underflow when x or
+   * y is small.
+   */
+  const double QUARTER_SQRT_MAX = 5.966672584960165394632772e-154; /* = 0x1p509; <= sqrt(DBL_MAX) / 4 */
+  const double SQRT_MIN =	1.491668146240041348658193e-154; /* = 0x1p-511; >= sqrt(DBL_MIN) */
+  if (ax > QUARTER_SQRT_MAX || ay < SQRT_MIN)
+    return (complex<double>(log(hypot(x, y)), atan2(y, x)));
+
+  return (complex<double>(log(ax * ax + ay * ay) / 2, atan2(y, x)));
+}
+
+/*
+ *				=================
+ *				| catanh, catan |
+ *				=================
+ */
+
+/*
+   * sum_squares(x,y) = x*x + y*y (or just x*x if y*y would underflow).
+   * Assumes x*x and y*y will not overflow.
+   * Assumes x and y are finite.
+   * Assumes y is non-negative.
+   * Assumes fabs(x) >= DBL_EPSILON.
+   */
+__host__ __device__
+inline double sum_squares(double x, double y)
+{
+  const double SQRT_MIN =	1.491668146240041348658193e-154; /* = 0x1p-511; >= sqrt(DBL_MIN) */
+  /* Avoid underflow when y is small. */
+  if (y < SQRT_MIN)
+    return (x * x);
+
+  return (x * x + y * y);
+}
+
+/*
+ * real_part_reciprocal(x, y) = Re(1/(x+I*y)) = x/(x*x + y*y).
+ * Assumes x and y are not NaN, and one of x and y is larger than
+ * RECIP_EPSILON.  We avoid unwarranted underflow.  It is important to not use
+ * the code creal(1/z), because the imaginary part may produce an unwanted
+ * underflow.
+ * This is only called in a context where inexact is always raised before
+ * the call, so no effort is made to avoid or force inexact.
+ */
+__host__ __device__
+inline double real_part_reciprocal(double x, double y)
+{
+  double scale;
+  uint32_t hx, hy;
+  int32_t ix, iy;
+
+  /*
+   * This code is inspired by the C99 document n1124.pdf, Section G.5.1,
+   * example 2.
+   */
+  get_high_word(hx, x);
+  ix = hx & 0x7ff00000;
+  get_high_word(hy, y);
+  iy = hy & 0x7ff00000;
+  //#define	BIAS	(DBL_MAX_EXP - 1)
+  const int BIAS = DBL_MAX_EXP - 1;
+  /* XXX more guard digits are useful iff there is extra precision. */
+  //#define	CUTOFF	(DBL_MANT_DIG / 2 + 1)	/* just half or 1 guard digit */
+  const int CUTOFF = (DBL_MANT_DIG / 2 + 1);
+  if (ix - iy >= CUTOFF << 20 || isinf(x))
+    return (1 / x);		/* +-Inf -> +-0 is special */
+  if (iy - ix >= CUTOFF << 20)
+    return (x / y / y);	/* should avoid double div, but hard */
+  if (ix <= (BIAS + DBL_MAX_EXP / 2 - CUTOFF) << 20)
+    return (x / (x * x + y * y));
+  scale = 1;
+  set_high_word(scale, 0x7ff00000 - ix);	/* 2**(1-ilogb(x)) */
+  x *= scale;
+  y *= scale;
+  return (x / (x * x + y * y) * scale);
+}
+
+
+/*
+ * catanh(z) = log((1+z)/(1-z)) / 2
+ *           = log1p(4*x / |z-1|^2) / 4
+ *             + I * atan2(2*y, (1-x)*(1+x)-y*y) / 2
+ *
+ * catanh(z) = z + O(z^3)   as z -> 0
+ *
+ * catanh(z) = 1/z + sign(y)*I*PI/2 + O(1/z^3)   as z -> infinity
+ * The above formula works for the real part as well, because
+ * Re(catanh(z)) = x/|z|^2 + O(x/z^4)
+ *    as z -> infinity, uniformly in x
+ */
+#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+__host__ __device__ inline
+complex<double> catanh(complex<double> z)
+{
+  double x, y, ax, ay, rx, ry;
+  const volatile double pio2_lo = 6.1232339957367659e-17; /*  0x11a62633145c07.0p-106 */
+  const double pio2_hi = 1.5707963267948966e0;/*  0x1921fb54442d18.0p-52 */
+
+
+  x = z.real();
+  y = z.imag();
+  ax = fabs(x);
+  ay = fabs(y);
+
+  /* This helps handle many cases. */
+  if (y == 0 && ax <= 1)
+    return (complex<double>(atanh(x), y));
+
+  /* To ensure the same accuracy as atan(), and to filter out z = 0. */
+  if (x == 0)
+    return (complex<double>(x, atan(y)));
+
+  if (isnan(x) || isnan(y)) {
+    /* catanh(+-Inf + I*NaN) = +-0 + I*NaN */
+    if (isinf(x))
+      return (complex<double>(copysign(0.0, x), y + y));
+    /* catanh(NaN + I*+-Inf) = sign(NaN)0 + I*+-PI/2 */
+    if (isinf(y))
+      return (complex<double>(copysign(0.0, x),
+			      copysign(pio2_hi + pio2_lo, y)));
+    /*
+     * All other cases involving NaN return NaN + I*NaN.
+     * C99 leaves it optional whether to raise invalid if one of
+     * the arguments is not NaN, so we opt not to raise it.
+     */
+    return (complex<double>(x + 0.0 + (y + 0), x + 0.0 + (y + 0)));
+  }
+
+  const double RECIP_EPSILON = 1.0 / DBL_EPSILON;
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON)
+    return (complex<double>(real_part_reciprocal(x, y),
+			    copysign(pio2_hi + pio2_lo, y)));
+
+  const double SQRT_3_EPSILON = 2.5809568279517849e-8; /*  0x1bb67ae8584caa.0p-78 */
+  if (ax < SQRT_3_EPSILON / 2 && ay < SQRT_3_EPSILON / 2) {
+    /*
+     * z = 0 was filtered out above.  All other cases must raise
+     * inexact, but this is the only only that needs to do it
+     * explicitly.
+     */
+    raise_inexact();
+    return (z);
+  }
+
+  const double m_ln2 = 6.9314718055994531e-1; /*  0x162e42fefa39ef.0p-53 */
+  if (ax == 1 && ay < DBL_EPSILON)
+    rx = (m_ln2 - log(ay)) / 2;
+  else
+    rx = log1p(4 * ax / sum_squares(ax - 1, ay)) / 4;
+
+  if (ax == 1)
+    ry = atan2(2.0, -ay) / 2;
+  else if (ay < DBL_EPSILON)
+    ry = atan2(2 * ay, (1 - ax) * (1 + ax)) / 2;
+  else
+    ry = atan2(2 * ay, (1 - ax) * (1 + ax) - ay * ay) / 2;
+
+  return (complex<double>(copysign(rx, x), copysign(ry, y)));
+}
+
+/*
+ * catan(z) = reverse(catanh(reverse(z)))
+ * where reverse(x + I*y) = y + I*x = I*conj(z).
+ */
+__host__ __device__ inline
+complex<double>catan(complex<double> z)
+{
+  complex<double> w = catanh(complex<double>(z.imag(), z.real()));
+  return (complex<double>(w.imag(), w.real()));
+}
+
+#endif
+
+} // namespace complex
+
+} // namespace detail
+
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> acos(const complex<ValueType>& z){
+  const complex<ValueType> ret = thrust::asin(z);
+  const ValueType pi = ValueType(3.14159265358979323846);
+  return complex<ValueType>(pi/2 - ret.real(),-ret.imag());
+}
+
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> asin(const complex<ValueType>& z){
+  const complex<ValueType> i(0,1);
+  return -i*asinh(i*z);
+}
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> atan(const complex<ValueType>& z){
+  const complex<ValueType> i(0,1);
+  return -i*thrust::atanh(i*z);
+}
+
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> acosh(const complex<ValueType>& z){
+  thrust::complex<ValueType> ret((z.real() - z.imag()) * (z.real() + z.imag()) - ValueType(1.0),
+				 ValueType(2.0) * z.real() * z.imag());
+  ret = thrust::sqrt(ret);
+  if (z.real() < ValueType(0.0)){
+    ret = -ret;
+  }
+  ret += z;
+  ret = thrust::log(ret);
+  if (ret.real() < ValueType(0.0)){
+    ret = -ret;
+  }
+  return ret;
+}
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> asinh(const complex<ValueType>& z){
+  return thrust::log(thrust::sqrt(z*z+ValueType(1))+z);
+}
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> atanh(const complex<ValueType>& z){
+  ValueType imag2 = z.imag() *  z.imag();
+  ValueType n = ValueType(1.0) + z.real();
+  n = imag2 + n * n;
+
+  ValueType d = ValueType(1.0) - z.real();
+  d = imag2 + d * d;
+  complex<ValueType> ret(ValueType(0.25) * (std::log(n) - std::log(d)),0);
+
+  d = ValueType(1.0) -  z.real() * z.real() - imag2;
+
+  ret.imag(ValueType(0.5) * std::atan2(ValueType(2.0) * z.imag(), d));
+  return ret;
+}
+
+template <>
+__host__ __device__
+inline complex<double> acos(const complex<double>& z){
+  return detail::complex::cacos(z);
+}
+
+template <>
+__host__ __device__
+inline complex<double> asin(const complex<double>& z){
+  return detail::complex::casin(z);
+}
+
+#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+template <>
+__host__ __device__
+inline complex<double> atan(const complex<double>& z){
+  return detail::complex::catan(z);
+}
+#endif
+
+template <>
+__host__ __device__
+inline complex<double> acosh(const complex<double>& z){
+  return detail::complex::cacosh(z);
+}
+
+
+template <>
+__host__ __device__
+inline complex<double> asinh(const complex<double>& z){
+  return detail::complex::casinh(z);
+}
+
+#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+template <>
+__host__ __device__
+inline complex<double> atanh(const complex<double>& z){
+  return detail::complex::catanh(z);
+}
+#endif
+
+THRUST_NAMESPACE_END

miniCUDA124/include/thrust/detail/complex/catrigf.h

@@ -0,0 +1,509 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*-
+ * Copyright (c) 2012 Stephen Montgomery-Smith <stephen@FreeBSD.ORG>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Adapted from FreeBSD by Filipe Maia <filipe.c.maia@gmail.com>:
+ *    freebsd/lib/msun/src/catrig.c
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+#include <cfloat>
+#include <cmath>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{
+
+using thrust::complex;
+
+__host__ __device__ inline
+      complex<float> clog_for_large_values(complex<float> z);
+
+/*
+ * The algorithm is very close to that in "Implementing the complex arcsine
+ * and arccosine functions using exception handling" by T. E. Hull, Thomas F.
+ * Fairgrieve, and Ping Tak Peter Tang, published in ACM Transactions on
+ * Mathematical Software, Volume 23 Issue 3, 1997, Pages 299-335,
+ * http://dl.acm.org/citation.cfm?id=275324.
+ *
+ * See catrig.c for complete comments.
+ *
+ * XXX comments were removed automatically, and even short ones on the right
+ * of statements were removed (all of them), contrary to normal style.  Only
+ * a few comments on the right of declarations remain.
+ */
+
+__host__ __device__
+inline float
+f(float a, float b, float hypot_a_b)
+{
+  if (b < 0.0f)
+    return ((hypot_a_b - b) / 2.0f);
+  if (b == 0.0f)
+    return (a / 2.0f);
+  return (a * a / (hypot_a_b + b) / 2.0f);
+}
+
+/*
+ * All the hard work is contained in this function.
+ * x and y are assumed positive or zero, and less than RECIP_EPSILON.
+ * Upon return:
+ * rx = Re(casinh(z)) = -Im(cacos(y + I*x)).
+ * B_is_usable is set to 1 if the value of B is usable.
+ * If B_is_usable is set to 0, sqrt_A2my2 = sqrt(A*A - y*y), and new_y = y.
+ * If returning sqrt_A2my2 has potential to result in an underflow, it is
+ * rescaled, and new_y is similarly rescaled.
+ */
+__host__ __device__
+inline void
+do_hard_work(float x, float y, float *rx, int *B_is_usable, float *B,
+	     float *sqrt_A2my2, float *new_y)
+{
+  float R, S, A; /* A, B, R, and S are as in Hull et al. */
+  float Am1, Amy; /* A-1, A-y. */
+  const float A_crossover = 10; /* Hull et al suggest 1.5, but 10 works better */
+  const float FOUR_SQRT_MIN = 4.336808689942017736029811e-19f;; /* =0x1p-61; >= 4 * sqrt(FLT_MIN) */
+  const float B_crossover = 0.6417f; /* suggested by Hull et al */
+  R = hypotf(x, y + 1);
+  S = hypotf(x, y - 1);
+
+  A = (R + S) / 2;
+  if (A < 1)
+    A = 1;
+
+  if (A < A_crossover) {
+    if (y == 1 && x < FLT_EPSILON * FLT_EPSILON / 128) {
+      *rx = sqrtf(x);
+    } else if (x >= FLT_EPSILON * fabsf(y - 1)) {
+      Am1 = f(x, 1 + y, R) + f(x, 1 - y, S);
+      *rx = log1pf(Am1 + sqrtf(Am1 * (A + 1)));
+    } else if (y < 1) {
+      *rx = x / sqrtf((1 - y) * (1 + y));
+    } else {
+      *rx = log1pf((y - 1) + sqrtf((y - 1) * (y + 1)));
+    }
+  } else {
+    *rx = logf(A + sqrtf(A * A - 1));
+  }
+
+  *new_y = y;
+
+  if (y < FOUR_SQRT_MIN) {
+    *B_is_usable = 0;
+    *sqrt_A2my2 = A * (2 / FLT_EPSILON);
+    *new_y = y * (2 / FLT_EPSILON);
+    return;
+  }
+
+  *B = y / A;
+  *B_is_usable = 1;
+
+  if (*B > B_crossover) {
+    *B_is_usable = 0;
+    if (y == 1 && x < FLT_EPSILON / 128) {
+      *sqrt_A2my2 = sqrtf(x) * sqrtf((A + y) / 2);
+    } else if (x >= FLT_EPSILON * fabsf(y - 1)) {
+      Amy = f(x, y + 1, R) + f(x, y - 1, S);
+      *sqrt_A2my2 = sqrtf(Amy * (A + y));
+    } else if (y > 1) {
+      *sqrt_A2my2 = x * (4 / FLT_EPSILON / FLT_EPSILON) * y /
+	sqrtf((y + 1) * (y - 1));
+      *new_y = y * (4 / FLT_EPSILON / FLT_EPSILON);
+    } else {
+      *sqrt_A2my2 = sqrtf((1 - y) * (1 + y));
+    }
+  }
+
+}
+
+__host__ __device__ inline
+complex<float>
+casinhf(complex<float> z)
+{
+  float x, y, ax, ay, rx, ry, B, sqrt_A2my2, new_y;
+  int B_is_usable;
+  complex<float> w;
+  const float RECIP_EPSILON = 1.0f / FLT_EPSILON;
+  const float m_ln2 = 6.9314718055994531e-1f; /*  0x162e42fefa39ef.0p-53 */
+  x = z.real();
+  y = z.imag();
+  ax = fabsf(x);
+  ay = fabsf(y);
+
+  if (isnan(x) || isnan(y)) {
+    if (isinf(x))
+      return (complex<float>(x, y + y));
+    if (isinf(y))
+      return (complex<float>(y, x + x));
+    if (y == 0)
+      return (complex<float>(x + x, y));
+    return (complex<float>(x + 0.0f + (y + 0), x + 0.0f + (y + 0)));
+  }
+
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) {
+    if (signbit(x) == 0)
+      w = clog_for_large_values(z) + m_ln2;
+    else
+      w = clog_for_large_values(-z) + m_ln2;
+    return (complex<float>(copysignf(w.real(), x),
+			   copysignf(w.imag(), y)));
+  }
+
+  if (x == 0 && y == 0)
+    return (z);
+
+  raise_inexact();
+
+  const float SQRT_6_EPSILON = 8.4572793338e-4f;	/*  0xddb3d7.0p-34 */
+  if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4)
+    return (z);
+
+  do_hard_work(ax, ay, &rx, &B_is_usable, &B, &sqrt_A2my2, &new_y);
+  if (B_is_usable)
+    ry = asinf(B);
+  else
+    ry = atan2f(new_y, sqrt_A2my2);
+  return (complex<float>(copysignf(rx, x), copysignf(ry, y)));
+}
+
+__host__ __device__ inline
+complex<float> casinf(complex<float> z)
+{
+  complex<float> w = casinhf(complex<float>(z.imag(), z.real()));
+
+  return (complex<float>(w.imag(), w.real()));
+}
+
+__host__ __device__ inline
+complex<float> cacosf(complex<float> z)
+{
+  float x, y, ax, ay, rx, ry, B, sqrt_A2mx2, new_x;
+  int sx, sy;
+  int B_is_usable;
+  complex<float> w;
+  const float pio2_hi = 1.5707963267948966e0f; /*  0x1921fb54442d18.0p-52 */
+  const volatile float pio2_lo = 6.1232339957367659e-17f;	/*  0x11a62633145c07.0p-106 */
+  const float m_ln2 = 6.9314718055994531e-1f; /*  0x162e42fefa39ef.0p-53 */
+
+  x = z.real();
+  y = z.imag();
+  sx = signbit(x);
+  sy = signbit(y);
+  ax = fabsf(x);
+  ay = fabsf(y);
+
+  if (isnan(x) || isnan(y)) {
+    if (isinf(x))
+      return (complex<float>(y + y, -infinity<float>()));
+    if (isinf(y))
+      return (complex<float>(x + x, -y));
+    if (x == 0)
+      return (complex<float>(pio2_hi + pio2_lo, y + y));
+    return (complex<float>(x + 0.0f + (y + 0), x + 0.0f + (y + 0)));
+  }
+
+  const float RECIP_EPSILON = 1.0f / FLT_EPSILON;
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) {
+    w = clog_for_large_values(z);
+    rx = fabsf(w.imag());
+    ry = w.real() + m_ln2;
+    if (sy == 0)
+      ry = -ry;
+    return (complex<float>(rx, ry));
+  }
+
+  if (x == 1 && y == 0)
+    return (complex<float>(0, -y));
+
+  raise_inexact();
+
+  const float SQRT_6_EPSILON = 8.4572793338e-4f;	/*  0xddb3d7.0p-34 */
+  if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4)
+    return (complex<float>(pio2_hi - (x - pio2_lo), -y));
+
+  do_hard_work(ay, ax, &ry, &B_is_usable, &B, &sqrt_A2mx2, &new_x);
+  if (B_is_usable) {
+    if (sx == 0)
+      rx = acosf(B);
+    else
+      rx = acosf(-B);
+  } else {
+    if (sx == 0)
+      rx = atan2f(sqrt_A2mx2, new_x);
+    else
+      rx = atan2f(sqrt_A2mx2, -new_x);
+  }
+  if (sy == 0)
+    ry = -ry;
+  return (complex<float>(rx, ry));
+}
+
+__host__ __device__ inline
+complex<float> cacoshf(complex<float> z)
+{
+  complex<float> w;
+  float rx, ry;
+
+  w = cacosf(z);
+  rx = w.real();
+  ry = w.imag();
+  /* cacosh(NaN + I*NaN) = NaN + I*NaN */
+  if (isnan(rx) && isnan(ry))
+    return (complex<float>(ry, rx));
+  /* cacosh(NaN + I*+-Inf) = +Inf + I*NaN */
+  /* cacosh(+-Inf + I*NaN) = +Inf + I*NaN */
+  if (isnan(rx))
+    return (complex<float>(fabsf(ry), rx));
+  /* cacosh(0 + I*NaN) = NaN + I*NaN */
+  if (isnan(ry))
+    return (complex<float>(ry, ry));
+  return (complex<float>(fabsf(ry), copysignf(rx, z.imag())));
+}
+
+  /*
+   * Optimized version of clog() for |z| finite and larger than ~RECIP_EPSILON.
+   */
+__host__ __device__ inline
+complex<float> clog_for_large_values(complex<float> z)
+{
+  float x, y;
+  float ax, ay, t;
+  const float m_e = 2.7182818284590452e0f; /*  0x15bf0a8b145769.0p-51 */
+
+  x = z.real();
+  y = z.imag();
+  ax = fabsf(x);
+  ay = fabsf(y);
+  if (ax < ay) {
+    t = ax;
+    ax = ay;
+    ay = t;
+  }
+
+  if (ax > FLT_MAX / 2)
+    return (complex<float>(logf(hypotf(x / m_e, y / m_e)) + 1,
+			   atan2f(y, x)));
+
+  const float QUARTER_SQRT_MAX = 2.3058430092136939520000000e+18f; /* = 0x1p61; <= sqrt(FLT_MAX) / 4 */
+  const float SQRT_MIN =	1.084202172485504434007453e-19f; /* 0x1p-63; >= sqrt(FLT_MIN) */
+  if (ax > QUARTER_SQRT_MAX || ay < SQRT_MIN)
+    return (complex<float>(logf(hypotf(x, y)), atan2f(y, x)));
+
+  return (complex<float>(logf(ax * ax + ay * ay) / 2, atan2f(y, x)));
+}
+
+/*
+ *				=================
+ *				| catanh, catan |
+ *				=================
+ */
+
+/*
+ * sum_squares(x,y) = x*x + y*y (or just x*x if y*y would underflow).
+ * Assumes x*x and y*y will not overflow.
+ * Assumes x and y are finite.
+ * Assumes y is non-negative.
+ * Assumes fabsf(x) >= FLT_EPSILON.
+ */
+__host__ __device__
+inline float sum_squares(float x, float y)
+{
+  const float SQRT_MIN =	1.084202172485504434007453e-19f; /* 0x1p-63; >= sqrt(FLT_MIN) */
+  /* Avoid underflow when y is small. */
+  if (y < SQRT_MIN)
+    return (x * x);
+
+  return (x * x + y * y);
+}
+
+__host__ __device__
+inline float real_part_reciprocal(float x, float y)
+{
+  float scale;
+  uint32_t hx, hy;
+  int32_t ix, iy;
+
+  get_float_word(hx, x);
+  ix = hx & 0x7f800000;
+  get_float_word(hy, y);
+  iy = hy & 0x7f800000;
+  //#define	BIAS	(FLT_MAX_EXP - 1)
+  const int BIAS = FLT_MAX_EXP - 1;
+  //#define	CUTOFF	(FLT_MANT_DIG / 2 + 1)
+  const int CUTOFF = (FLT_MANT_DIG / 2 + 1);
+  if (ix - iy >= CUTOFF << 23 || isinf(x))
+    return (1 / x);
+  if (iy - ix >= CUTOFF << 23)
+    return (x / y / y);
+  if (ix <= (BIAS + FLT_MAX_EXP / 2 - CUTOFF) << 23)
+    return (x / (x * x + y * y));
+  set_float_word(scale, 0x7f800000 - ix);
+  x *= scale;
+  y *= scale;
+  return (x / (x * x + y * y) * scale);
+}
+
+#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+__host__ __device__ inline
+complex<float> catanhf(complex<float> z)
+{
+  float x, y, ax, ay, rx, ry;
+  const volatile float pio2_lo = 6.1232339957367659e-17f; /*  0x11a62633145c07.0p-106 */
+  const float pio2_hi = 1.5707963267948966e0f;/*  0x1921fb54442d18.0p-52 */
+
+
+  x = z.real();
+  y = z.imag();
+  ax = fabsf(x);
+  ay = fabsf(y);
+
+
+  if (y == 0 && ax <= 1)
+    return (complex<float>(atanhf(x), y));
+
+  if (x == 0)
+    return (complex<float>(x, atanf(y)));
+
+  if (isnan(x) || isnan(y)) {
+    if (isinf(x))
+      return (complex<float>(copysignf(0, x), y + y));
+    if (isinf(y))
+      return (complex<float>(copysignf(0, x),
+			     copysignf(pio2_hi + pio2_lo, y)));
+    return (complex<float>(x + 0.0f + (y + 0.0f), x + 0.0f + (y + 0.0f)));
+  }
+
+  const float RECIP_EPSILON = 1.0f / FLT_EPSILON;
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON)
+    return (complex<float>(real_part_reciprocal(x, y),
+			   copysignf(pio2_hi + pio2_lo, y)));
+
+  const float SQRT_3_EPSILON = 5.9801995673e-4f; /*  0x9cc471.0p-34 */
+  if (ax < SQRT_3_EPSILON / 2 && ay < SQRT_3_EPSILON / 2) {
+    raise_inexact();
+    return (z);
+  }
+
+  const float m_ln2 = 6.9314718056e-1f; /*  0xb17218.0p-24 */
+  if (ax == 1 && ay < FLT_EPSILON)
+    rx = (m_ln2 - logf(ay)) / 2;
+  else
+    rx = log1pf(4 * ax / sum_squares(ax - 1, ay)) / 4;
+
+  if (ax == 1)
+    ry = atan2f(2, -ay) / 2;
+  else if (ay < FLT_EPSILON)
+    ry = atan2f(2 * ay, (1 - ax) * (1 + ax)) / 2;
+  else
+    ry = atan2f(2 * ay, (1 - ax) * (1 + ax) - ay * ay) / 2;
+
+  return (complex<float>(copysignf(rx, x), copysignf(ry, y)));
+}
+
+__host__ __device__ inline
+complex<float>catanf(complex<float> z){
+  complex<float> w = catanhf(complex<float>(z.imag(), z.real()));
+  return (complex<float>(w.imag(), w.real()));
+}
+#endif
+
+} // namespace complex
+
+} // namespace detail
+
+
+template <>
+__host__ __device__
+inline complex<float> acos(const complex<float>& z){
+  return detail::complex::cacosf(z);
+}
+
+template <>
+__host__ __device__
+inline complex<float> asin(const complex<float>& z){
+  return detail::complex::casinf(z);
+}
+
+#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+template <>
+__host__ __device__
+inline complex<float> atan(const complex<float>& z){
+  return detail::complex::catanf(z);
+}
+#endif
+
+template <>
+__host__ __device__
+inline complex<float> acosh(const complex<float>& z){
+  return detail::complex::cacoshf(z);
+}
+
+
+template <>
+__host__ __device__
+inline complex<float> asinh(const complex<float>& z){
+  return detail::complex::casinhf(z);
+}
+
+#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+template <>
+__host__ __device__
+inline complex<float> atanh(const complex<float>& z){
+  return detail::complex::catanhf(z);
+}
+#endif
+
+THRUST_NAMESPACE_END

miniCUDA124/include/thrust/detail/complex/ccosh.h

@@ -0,0 +1,223 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*-
+ * Copyright (c) 2005 Bruce D. Evans and Steven G. Kargl
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice unmodified, this list of conditions, and the following
+ *    disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* adapted from FreeBSD:
+ *    lib/msun/src/s_ccosh.c
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{
+
+/*
+ * Hyperbolic cosine of a complex argument z = x + i y.
+ *
+ * cosh(z) = cosh(x+iy)
+ *         = cosh(x) cos(y) + i sinh(x) sin(y).
+ *
+ * Exceptional values are noted in the comments within the source code.
+ * These values and the return value were taken from n1124.pdf.
+ */
+
+__host__ __device__ inline
+thrust::complex<double> ccosh(const thrust::complex<double>& z){
+
+
+  const double huge = 8.98846567431157953864652595395e+307; // 0x1p1023
+  double x, y, h;
+  uint32_t hx, hy, ix, iy, lx, ly;
+
+  x = z.real();
+  y = z.imag();
+
+  extract_words(hx, lx, x);
+  extract_words(hy, ly, y);
+
+  ix = 0x7fffffff & hx;
+  iy = 0x7fffffff & hy;
+
+  /* Handle the nearly-non-exceptional cases where x and y are finite. */
+  if (ix < 0x7ff00000 && iy < 0x7ff00000) {
+    if ((iy | ly) == 0)
+      return (thrust::complex<double>(::cosh(x), x * y));
+    if (ix < 0x40360000)	/* small x: normal case */
+      return (thrust::complex<double>(::cosh(x) * ::cos(y), ::sinh(x) * ::sin(y)));
+
+    /* |x| >= 22, so cosh(x) ~= exp(|x|) */
+    if (ix < 0x40862e42) {
+      /* x < 710: exp(|x|) won't overflow */
+      h = ::exp(::fabs(x)) * 0.5;
+      return (thrust::complex<double>(h * cos(y), copysign(h, x) * sin(y)));
+    } else if (ix < 0x4096bbaa) {
+      /* x < 1455: scale to avoid overflow */
+      thrust::complex<double> z_;
+      z_ = ldexp_cexp(thrust::complex<double>(fabs(x), y), -1);
+      return (thrust::complex<double>(z_.real(), z_.imag() * copysign(1.0, x)));
+    } else {
+      /* x >= 1455: the result always overflows */
+      h = huge * x;
+      return (thrust::complex<double>(h * h * cos(y), h * sin(y)));
+    }
+  }
+
+  /*
+   * cosh(+-0 +- I Inf) = dNaN + I sign(d(+-0, dNaN))0.
+   * The sign of 0 in the result is unspecified.  Choice = normally
+   * the same as dNaN.  Raise the invalid floating-point exception.
+   *
+   * cosh(+-0 +- I NaN) = d(NaN) + I sign(d(+-0, NaN))0.
+   * The sign of 0 in the result is unspecified.  Choice = normally
+   * the same as d(NaN).
+   */
+  if ((ix | lx) == 0 && iy >= 0x7ff00000)
+    return (thrust::complex<double>(y - y, copysign(0.0, x * (y - y))));
+
+  /*
+   * cosh(+-Inf +- I 0) = +Inf + I (+-)(+-)0.
+   *
+   * cosh(NaN +- I 0)   = d(NaN) + I sign(d(NaN, +-0))0.
+   * The sign of 0 in the result is unspecified.
+   */
+  if ((iy | ly) == 0 && ix >= 0x7ff00000) {
+    if (((hx & 0xfffff) | lx) == 0)
+      return (thrust::complex<double>(x * x, copysign(0.0, x) * y));
+    return (thrust::complex<double>(x * x, copysign(0.0, (x + x) * y)));
+  }
+
+  /*
+   * cosh(x +- I Inf) = dNaN + I dNaN.
+   * Raise the invalid floating-point exception for finite nonzero x.
+   *
+   * cosh(x + I NaN) = d(NaN) + I d(NaN).
+   * Optionally raises the invalid floating-point exception for finite
+   * nonzero x.  Choice = don't raise (except for signaling NaNs).
+   */
+  if (ix < 0x7ff00000 && iy >= 0x7ff00000)
+    return (thrust::complex<double>(y - y, x * (y - y)));
+
+  /*
+   * cosh(+-Inf + I NaN)  = +Inf + I d(NaN).
+   *
+   * cosh(+-Inf +- I Inf) = +Inf + I dNaN.
+   * The sign of Inf in the result is unspecified.  Choice = always +.
+   * Raise the invalid floating-point exception.
+   *
+   * cosh(+-Inf + I y)   = +Inf cos(y) +- I Inf sin(y)
+   */
+  if (ix >= 0x7ff00000 && ((hx & 0xfffff) | lx) == 0) {
+    if (iy >= 0x7ff00000)
+      return (thrust::complex<double>(x * x, x * (y - y)));
+    return (thrust::complex<double>((x * x) * cos(y), x * sin(y)));
+  }
+
+  /*
+   * cosh(NaN + I NaN)  = d(NaN) + I d(NaN).
+   *
+   * cosh(NaN +- I Inf) = d(NaN) + I d(NaN).
+   * Optionally raises the invalid floating-point exception.
+   * Choice = raise.
+   *
+   * cosh(NaN + I y)    = d(NaN) + I d(NaN).
+   * Optionally raises the invalid floating-point exception for finite
+   * nonzero y.  Choice = don't raise (except for signaling NaNs).
+   */
+  return (thrust::complex<double>((x * x) * (y - y), (x + x) * (y - y)));
+}
+
+
+__host__ __device__ inline
+thrust::complex<double> ccos(const thrust::complex<double>& z){
+  /* ccos(z) = ccosh(I * z) */
+  return (ccosh(thrust::complex<double>(-z.imag(), z.real())));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> cos(const complex<ValueType>& z){
+  const ValueType re = z.real();
+  const ValueType im = z.imag();
+  return complex<ValueType>(std::cos(re) * std::cosh(im),
+			    -std::sin(re) * std::sinh(im));
+}
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> cosh(const complex<ValueType>& z){
+  const ValueType re = z.real();
+  const ValueType im = z.imag();
+  return complex<ValueType>(std::cosh(re) * std::cos(im),
+			    std::sinh(re) * std::sin(im));
+}
+
+template <>
+__host__ __device__
+inline thrust::complex<double> cos(const thrust::complex<double>& z){
+  return detail::complex::ccos(z);
+}
+
+template <>
+__host__ __device__
+inline thrust::complex<double> cosh(const thrust::complex<double>& z){
+  return detail::complex::ccosh(z);
+}
+
+THRUST_NAMESPACE_END

miniCUDA124/include/thrust/detail/complex/ccoshf.h

@@ -0,0 +1,151 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*-
+ * Copyright (c) 2005 Bruce D. Evans and Steven G. Kargl
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice unmodified, this list of conditions, and the following
+ *    disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* adapted from FreeBSD:
+ *    lib/msun/src/s_ccoshf.c
+ */
+
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{
+
+using thrust::complex;
+
+__host__ __device__ inline
+complex<float> ccoshf(const complex<float>& z){
+  float x, y, h;
+  uint32_t hx, hy, ix, iy;
+  const float huge = 1.70141183460469231731687303716e+38; //0x1p127;
+
+
+  x = z.real();
+  y = z.imag();
+
+  get_float_word(hx, x);
+  get_float_word(hy, y);
+
+  ix = 0x7fffffff & hx;
+  iy = 0x7fffffff & hy;
+  if (ix < 0x7f800000 && iy < 0x7f800000) {
+    if (iy == 0){
+      return (complex<float>(coshf(x), x * y));
+    }
+    if (ix < 0x41100000){	/* small x: normal case */
+      return (complex<float>(coshf(x) * cosf(y), sinhf(x) * sinf(y)));
+    }
+    /* |x| >= 9, so cosh(x) ~= exp(|x|) */
+    if (ix < 0x42b17218) {
+      /* x < 88.7: expf(|x|) won't overflow */
+      h = expf(fabsf(x)) * 0.5f;
+      return (complex<float>(h * cosf(y), copysignf(h, x) * sinf(y)));
+    } else if (ix < 0x4340b1e7) {
+      /* x < 192.7: scale to avoid overflow */
+      thrust::complex<float> z_;
+      z_ = ldexp_cexpf(complex<float>(fabsf(x), y), -1);
+      return (complex<float>(z_.real(), z_.imag() * copysignf(1.0f, x)));
+    } else {
+      /* x >= 192.7: the result always overflows */
+      h = huge * x;
+      return (complex<float>(h * h * cosf(y), h * sinf(y)));
+    }
+  }
+
+  if (ix == 0 && iy >= 0x7f800000){
+    return (complex<float>(y - y, copysignf(0.0f, x * (y - y))));
+  }
+  if (iy == 0 && ix >= 0x7f800000) {
+    if ((hx & 0x7fffff) == 0)
+      return (complex<float>(x * x, copysignf(0.0f, x) * y));
+    return (complex<float>(x * x, copysignf(0.0f, (x + x) * y)));
+  }
+
+  if (ix < 0x7f800000 && iy >= 0x7f800000){
+    return (complex<float>(y - y, x * (y - y)));
+  }
+
+  if (ix >= 0x7f800000 && (hx & 0x7fffff) == 0) {
+    if (iy >= 0x7f800000)
+      return (complex<float>(x * x, x * (y - y)));
+    return (complex<float>((x * x) * cosf(y), x * sinf(y)));
+  }
+  return (complex<float>((x * x) * (y - y), (x + x) * (y - y)));
+}
+
+__host__ __device__ inline
+complex<float> ccosf(const complex<float>& z){
+  return (ccoshf(complex<float>(-z.imag(), z.real())));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <>
+__host__ __device__
+inline complex<float> cos(const complex<float>& z){
+  return detail::complex::ccosf(z);
+}
+
+template <>
+__host__ __device__
+inline complex<float> cosh(const complex<float>& z){
+  return detail::complex::ccoshf(z);
+}
+
+THRUST_NAMESPACE_END

miniCUDA124/include/thrust/detail/complex/cexp.h

@@ -0,0 +1,193 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*-
+ * Copyright (c) 2011 David Schultz <das@FreeBSD.ORG>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* adapted from FreeBSD:
+ *    lib/msun/src/s_cexp.c
+ *    lib/msun/src/k_exp.c
+ *
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{
+/*
+ * Compute exp(x), scaled to avoid spurious overflow.  An exponent is
+ * returned separately in 'expt'.
+ *
+ * Input:  ln(DBL_MAX) <= x < ln(2 * DBL_MAX / DBL_MIN_DENORM) ~= 1454.91
+ * Output: 2**1023 <= y < 2**1024
+ */
+__host__ __device__ inline
+	double frexp_exp(double x, int *expt){
+  const uint32_t k = 1799;		/* constant for reduction */
+  const double kln2 =  1246.97177782734161156;	/* k * ln2 */
+
+  double exp_x;
+  uint32_t hx;
+
+  /*
+   * We use exp(x) = exp(x - kln2) * 2**k, carefully chosen to
+   * minimize |exp(kln2) - 2**k|.  We also scale the exponent of
+   * exp_x to MAX_EXP so that the result can be multiplied by
+   * a tiny number without losing accuracy due to denormalization.
+   */
+  exp_x = exp(x - kln2);
+  get_high_word(hx, exp_x);
+  *expt = (hx >> 20) - (0x3ff + 1023) + k;
+  set_high_word(exp_x, (hx & 0xfffff) | ((0x3ff + 1023) << 20));
+  return (exp_x);
+}
+
+
+__host__ __device__ inline
+complex<double>	ldexp_cexp(complex<double> z, int expt){
+  double x, y, exp_x, scale1, scale2;
+  int ex_expt, half_expt;
+
+  x = z.real();
+  y = z.imag();
+  exp_x = frexp_exp(x, &ex_expt);
+  expt += ex_expt;
+
+  /*
+   * Arrange so that scale1 * scale2 == 2**expt.  We use this to
+   * compensate for scalbn being horrendously slow.
+   */
+  half_expt = expt / 2;
+  insert_words(scale1, (0x3ff + half_expt) << 20, 0);
+  half_expt = expt - half_expt;
+  insert_words(scale2, (0x3ff + half_expt) << 20, 0);
+
+  return (complex<double>(cos(y) * exp_x * scale1 * scale2,
+			  sin(y) * exp_x * scale1 * scale2));
+}
+
+
+__host__ __device__ inline
+complex<double> cexp(const complex<double>& z){
+  double x, y, exp_x;
+  uint32_t hx, hy, lx, ly;
+
+  const uint32_t
+    exp_ovfl  = 0x40862e42,			/* high bits of MAX_EXP * ln2 ~= 710 */
+    cexp_ovfl = 0x4096b8e4;			/* (MAX_EXP - MIN_DENORM_EXP) * ln2 */
+
+
+  x = z.real();
+  y = z.imag();
+
+  extract_words(hy, ly, y);
+  hy &= 0x7fffffff;
+
+  /* cexp(x + I 0) = exp(x) + I 0 */
+  if ((hy | ly) == 0)
+    return (complex<double>(exp(x), y));
+  extract_words(hx, lx, x);
+  /* cexp(0 + I y) = cos(y) + I sin(y) */
+  if (((hx & 0x7fffffff) | lx) == 0)
+    return (complex<double>(cos(y), sin(y)));
+
+  if (hy >= 0x7ff00000) {
+    if (lx != 0 || (hx & 0x7fffffff) != 0x7ff00000) {
+      /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */
+      return (complex<double>(y - y, y - y));
+    } else if (hx & 0x80000000) {
+      /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */
+      return (complex<double>(0.0, 0.0));
+    } else {
+      /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */
+      return (complex<double>(x, y - y));
+    }
+  }
+
+  if (hx >= exp_ovfl && hx <= cexp_ovfl) {
+    /*
+     * x is between 709.7 and 1454.3, so we must scale to avoid
+     * overflow in exp(x).
+     */
+    return (ldexp_cexp(z, 0));
+  } else {
+    /*
+     * Cases covered here:
+     *  -  x < exp_ovfl and exp(x) won't overflow (common case)
+     *  -  x > cexp_ovfl, so exp(x) * s overflows for all s > 0
+     *  -  x = +-Inf (generated by exp())
+     *  -  x = NaN (spurious inexact exception from y)
+     */
+    exp_x = std::exp(x);
+    return (complex<double>(exp_x * cos(y), exp_x * sin(y)));
+  }
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> exp(const complex<ValueType>& z){
+  return polar(std::exp(z.real()),z.imag());
+}
+
+template <>
+__host__ __device__
+inline complex<double> exp(const complex<double>& z){
+  return detail::complex::cexp(z);
+}
+
+THRUST_NAMESPACE_END

miniCUDA124/include/thrust/detail/complex/cexpf.h

@@ -0,0 +1,171 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*-
+ * Copyright (c) 2011 David Schultz <das@FreeBSD.ORG>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* adapted from FreeBSD:
+ *    lib/msun/src/s_cexpf.c
+ *    lib/msun/src/k_exp.c
+ *
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{
+
+__host__ __device__ inline
+float frexp_expf(float x, int *expt){
+  const uint32_t k = 235;                 /* constant for reduction */
+  const float kln2 =  162.88958740F;       /* k * ln2 */
+
+  // should this be a double instead?
+  float exp_x;
+  uint32_t hx;
+
+  exp_x = expf(x - kln2);
+  get_float_word(hx, exp_x);
+  *expt = (hx >> 23) - (0x7f + 127) + k;
+  set_float_word(exp_x, (hx & 0x7fffff) | ((0x7f + 127) << 23));
+  return (exp_x);
+}
+
+__host__ __device__ inline
+complex<float>
+ldexp_cexpf(complex<float> z, int expt)
+{
+  float x, y, exp_x, scale1, scale2;
+  int ex_expt, half_expt;
+
+  x = z.real();
+  y = z.imag();
+  exp_x = frexp_expf(x, &ex_expt);
+  expt += ex_expt;
+
+  half_expt = expt / 2;
+  set_float_word(scale1, (0x7f + half_expt) << 23);
+  half_expt = expt - half_expt;
+  set_float_word(scale2, (0x7f + half_expt) << 23);
+
+  return (complex<float>(std::cos(y) * exp_x * scale1 * scale2,
+			 std::sin(y) * exp_x * scale1 * scale2));
+}
+
+__host__ __device__ inline
+complex<float> cexpf(const complex<float>& z){
+  float x, y, exp_x;
+  uint32_t hx, hy;
+
+  const uint32_t
+    exp_ovfl  = 0x42b17218,		/* MAX_EXP * ln2 ~= 88.722839355 */
+    cexp_ovfl = 0x43400074;		/* (MAX_EXP - MIN_DENORM_EXP) * ln2 */
+
+  x = z.real();
+  y = z.imag();
+
+  get_float_word(hy, y);
+  hy &= 0x7fffffff;
+
+  /* cexp(x + I 0) = exp(x) + I 0 */
+  if (hy == 0)
+    return (complex<float>(std::exp(x), y));
+  get_float_word(hx, x);
+  /* cexp(0 + I y) = cos(y) + I sin(y) */
+  if ((hx & 0x7fffffff) == 0){
+    return (complex<float>(std::cos(y), std::sin(y)));
+  }
+  if (hy >= 0x7f800000) {
+    if ((hx & 0x7fffffff) != 0x7f800000) {
+      /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */
+      return (complex<float>(y - y, y - y));
+    } else if (hx & 0x80000000) {
+      /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */
+      return (complex<float>(0.0, 0.0));
+    } else {
+      /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */
+      return (complex<float>(x, y - y));
+    }
+  }
+
+  if (hx >= exp_ovfl && hx <= cexp_ovfl) {
+    /*
+     * x is between 88.7 and 192, so we must scale to avoid
+     * overflow in expf(x).
+     */
+    return (ldexp_cexpf(z, 0));
+  } else {
+    /*
+     * Cases covered here:
+     *  -  x < exp_ovfl and exp(x) won't overflow (common case)
+     *  -  x > cexp_ovfl, so exp(x) * s overflows for all s > 0
+     *  -  x = +-Inf (generated by exp())
+     *  -  x = NaN (spurious inexact exception from y)
+     */
+    exp_x = std::exp(x);
+    return (complex<float>(exp_x * std::cos(y), exp_x * std::sin(y)));
+  }
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <>
+__host__ __device__
+inline complex<float> exp(const complex<float>& z){
+  return detail::complex::cexpf(z);
+}
+
+THRUST_NAMESPACE_END

miniCUDA124/include/thrust/detail/complex/clog.h

@@ -0,0 +1,222 @@
+/*
+ *  Copyright 2008-2021 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*-
+ * Copyright (c) 2012 Stephen Montgomery-Smith <stephen@FreeBSD.ORG>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* adapted from FreeBSDs msun:*/
+
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{
+
+using thrust::complex;
+
+/* round down to 18 = 54/3 bits */
+__host__ __device__ inline
+double trim(double x){
+  uint32_t hi;
+  get_high_word(hi, x);
+  insert_words(x, hi &0xfffffff8, 0);
+  return x;
+}
+
+
+__host__ __device__ inline
+complex<double> clog(const complex<double>& z){
+
+  // Adapted from FreeBSDs msun
+  double x, y;
+  double ax, ay;
+  double x0, y0, x1, y1, x2, y2, t, hm1;
+  double val[12];
+  int i, sorted;
+  const double e = 2.7182818284590452354;
+
+  x = z.real();
+  y = z.imag();
+
+  /* Handle NaNs using the general formula to mix them right. */
+  if (x != x || y != y){
+    return (complex<double>(std::log(norm(z)), std::atan2(y, x)));
+  }
+
+  ax = std::abs(x);
+  ay = std::abs(y);
+  if (ax < ay) {
+    t = ax;
+    ax = ay;
+    ay = t;
+  }
+
+  /*
+   * To avoid unnecessary overflow, if x and y are very large, divide x
+   * and y by M_E, and then add 1 to the logarithm.  This depends on
+   * M_E being larger than sqrt(2).
+   * There is a potential loss of accuracy caused by dividing by M_E,
+   * but this case should happen extremely rarely.
+   */
+  //    if (ay > 5e307){
+  // For high values of ay -> hypotf(DBL_MAX,ay) = inf
+  // We expect that for values at or below ay = 5e307 this should not happen
+  if (ay > 5e307){
+    return (complex<double>(std::log(hypot(x / e, y / e)) + 1.0, std::atan2(y, x)));
+  }
+  if (ax == 1.) {
+    if (ay < 1e-150){
+      return (complex<double>((ay * 0.5) * ay, std::atan2(y, x)));
+    }
+    return (complex<double>(log1p(ay * ay) * 0.5, std::atan2(y, x)));
+  }
+
+  /*
+   * Because atan2 and hypot conform to C99, this also covers all the
+   * edge cases when x or y are 0 or infinite.
+   */
+  if (ax < 1e-50 || ay < 1e-50 || ax > 1e50 || ay > 1e50){
+    return (complex<double>(std::log(hypot(x, y)), std::atan2(y, x)));
+  }
+
+  /*
+   * From this point on, we don't need to worry about underflow or
+   * overflow in calculating ax*ax or ay*ay.
+   */
+
+  /* Some easy cases. */
+
+  if (ax >= 1.0){
+    return (complex<double>(log1p((ax-1)*(ax+1) + ay*ay) * 0.5, atan2(y, x)));
+  }
+
+  if (ax*ax + ay*ay <= 0.7){
+    return (complex<double>(std::log(ax*ax + ay*ay) * 0.5, std::atan2(y, x)));
+  }
+
+  /*
+   * Take extra care so that ULP of real part is small if hypot(x,y) is
+   * moderately close to 1.
+   */
+
+
+  x0 = trim(ax);
+  ax = ax-x0;
+  x1 = trim(ax);
+  x2 = ax-x1;
+  y0 = trim(ay);
+  ay = ay-y0;
+  y1 = trim(ay);
+  y2 = ay-y1;
+
+  val[0] = x0*x0;
+  val[1] = y0*y0;
+  val[2] = 2*x0*x1;
+  val[3] = 2*y0*y1;
+  val[4] = x1*x1;
+  val[5] = y1*y1;
+  val[6] = 2*x0*x2;
+  val[7] = 2*y0*y2;
+  val[8] = 2*x1*x2;
+  val[9] = 2*y1*y2;
+  val[10] = x2*x2;
+  val[11] = y2*y2;
+
+  /* Bubble sort. */
+
+  do {
+    sorted = 1;
+    for (i=0;i<11;i++) {
+      if (val[i] < val[i+1]) {
+	sorted = 0;
+	t = val[i];
+	val[i] = val[i+1];
+	val[i+1] = t;
+      }
+    }
+  } while (!sorted);
+
+  hm1 = -1;
+  for (i=0;i<12;i++){
+    hm1 += val[i];
+  }
+  return (complex<double>(0.5 * log1p(hm1), atan2(y, x)));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> log(const complex<ValueType>& z){
+  return complex<ValueType>(std::log(thrust::abs(z)),thrust::arg(z));
+}
+
+template <>
+__host__ __device__
+inline complex<double> log(const complex<double>& z){
+  return detail::complex::clog(z);
+}
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> log10(const complex<ValueType>& z){
+  // Using the explicit literal prevents compile time warnings in
+  // devices that don't support doubles
+  return thrust::log(z)/ValueType(2.30258509299404568402);
+}
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/detail/transform_scan.inl

@@ -0,0 +1,125 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/scan.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/transform_scan.h>
+#include <thrust/system/detail/adl/transform_scan.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename UnaryFunction,
+         typename AssociativeOperator>
+__host__ __device__
+  OutputIterator transform_inclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                          InputIterator first,
+                                          InputIterator last,
+                                          OutputIterator result,
+                                          UnaryFunction unary_op,
+                                          AssociativeOperator binary_op)
+{
+  using thrust::system::detail::generic::transform_inclusive_scan;
+  return transform_inclusive_scan(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, unary_op, binary_op);
+} // end transform_inclusive_scan()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename UnaryFunction,
+         typename T,
+         typename AssociativeOperator>
+__host__ __device__
+  OutputIterator transform_exclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                          InputIterator first,
+                                          InputIterator last,
+                                          OutputIterator result,
+                                          UnaryFunction unary_op,
+                                          T init,
+                                          AssociativeOperator binary_op)
+{
+  using thrust::system::detail::generic::transform_exclusive_scan;
+  return transform_exclusive_scan(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, unary_op, init, binary_op);
+} // end transform_exclusive_scan()
+
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename UnaryFunction,
+         typename BinaryFunction>
+  OutputIterator transform_inclusive_scan(InputIterator first,
+                                          InputIterator last,
+                                          OutputIterator result,
+                                          UnaryFunction unary_op,
+                                          BinaryFunction binary_op)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::transform_inclusive_scan(select_system(system1,system2), first, last, result, unary_op, binary_op);
+} // end transform_inclusive_scan()
+
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename UnaryFunction,
+         typename T,
+         typename AssociativeOperator>
+  OutputIterator transform_exclusive_scan(InputIterator first,
+                                          InputIterator last,
+                                          OutputIterator result,
+                                          UnaryFunction unary_op,
+                                          T init,
+                                          AssociativeOperator binary_op)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::transform_exclusive_scan(select_system(system1,system2), first, last, result, unary_op, init, binary_op);
+} // end transform_exclusive_scan()
+
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/detail/trivial_sequence.h

@@ -0,0 +1,104 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file trivial_sequence.h
+ *  \brief Container-like class for wrapping sequences.  The wrapped
+ *         sequence always has trivial iterators, even when the input
+ *         sequence does not.
+ */
+
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/type_traits/is_contiguous_iterator.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+// never instantiated
+template<typename Iterator, typename DerivedPolicy, typename is_trivial> struct _trivial_sequence { };
+
+// trivial case
+template<typename Iterator, typename DerivedPolicy>
+struct _trivial_sequence<Iterator, DerivedPolicy, thrust::detail::true_type>
+{
+    typedef Iterator iterator_type;
+    Iterator first, last;
+
+    __host__ __device__
+    _trivial_sequence(thrust::execution_policy<DerivedPolicy> &, Iterator _first, Iterator _last) : first(_first), last(_last)
+    {
+    }
+
+    __host__ __device__
+    iterator_type begin() { return first; }
+
+    __host__ __device__
+    iterator_type end()   { return last; }
+};
+
+// non-trivial case
+template<typename Iterator, typename DerivedPolicy>
+struct _trivial_sequence<Iterator, DerivedPolicy, thrust::detail::false_type>
+{
+    typedef typename thrust::iterator_value<Iterator>::type iterator_value;
+    typedef typename thrust::detail::temporary_array<iterator_value, DerivedPolicy>::iterator iterator_type;
+
+    thrust::detail::temporary_array<iterator_value, DerivedPolicy> buffer;
+
+    __host__ __device__
+    _trivial_sequence(thrust::execution_policy<DerivedPolicy> &exec, Iterator first, Iterator last)
+      : buffer(exec, first, last)
+    {
+    }
+
+    __host__ __device__
+    iterator_type begin() { return buffer.begin(); }
+
+    __host__ __device__
+    iterator_type end()   { return buffer.end(); }
+};
+
+template <typename Iterator, typename DerivedPolicy>
+struct trivial_sequence
+  : detail::_trivial_sequence<Iterator, DerivedPolicy, typename thrust::is_contiguous_iterator<Iterator>::type>
+{
+    typedef _trivial_sequence<Iterator, DerivedPolicy, typename thrust::is_contiguous_iterator<Iterator>::type> super_t;
+
+    __host__ __device__
+    trivial_sequence(thrust::execution_policy<DerivedPolicy> &exec, Iterator first, Iterator last) : super_t(exec, first, last) { }
+};
+
+} // end namespace detail
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/detail/tuple_algorithms.h

@@ -0,0 +1,118 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/detail/type_deduction.h>
+#include <thrust/type_traits/integer_sequence.h>
+
+#include <tuple>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename Tuple, std::size_t... Is>
+auto tuple_subset(Tuple&& t, index_sequence<Is...>)
+THRUST_DECLTYPE_RETURNS(std::make_tuple(std::get<Is>(THRUST_FWD(t))...));
+
+namespace detail
+{
+
+template <typename Tuple, typename F, std::size_t... Is>
+void tuple_for_each_impl(Tuple&& t, F&& f, index_sequence<Is...>)
+{
+  auto l = { (f(std::get<Is>(t)), 0)... };
+  THRUST_UNUSED_VAR(l);
+}
+
+template <typename Tuple, typename F, std::size_t... Is>
+auto tuple_transform_impl(Tuple&& t, F&& f, index_sequence<Is...>)
+THRUST_DECLTYPE_RETURNS(std::make_tuple(f(std::get<Is>(t))...));
+
+} // namespace detail
+
+template <typename... Ts, typename F>
+auto tuple_for_each(std::tuple<Ts...>& t, F&& f)
+THRUST_DECLTYPE_RETURNS(
+  detail::tuple_for_each_impl(
+    t
+  , THRUST_FWD(f)
+  , make_index_sequence<sizeof...(Ts)>{}
+  )
+);
+template <typename... Ts, typename F>
+auto tuple_for_each(std::tuple<Ts...> const& t, F&& f)
+THRUST_DECLTYPE_RETURNS(
+  detail::tuple_for_each_impl(
+    t
+  , THRUST_FWD(f)
+  , make_index_sequence<sizeof...(Ts)>{}
+  )
+);
+template <typename... Ts, typename F>
+auto tuple_for_each(std::tuple<Ts...>&& t, F&& f)
+THRUST_DECLTYPE_RETURNS(
+  detail::tuple_for_each_impl(
+    std::move(t)
+  , THRUST_FWD(f)
+  , make_index_sequence<sizeof...(Ts)>{}
+  )
+);
+
+template <typename... Ts, typename F>
+auto tuple_transform(std::tuple<Ts...>& t, F&& f)
+THRUST_DECLTYPE_RETURNS(
+  detail::tuple_transform_impl(
+    t
+  , THRUST_FWD(f)
+  , make_index_sequence<sizeof...(Ts)>{}
+  )
+);
+template <typename... Ts, typename F>
+auto tuple_transform(std::tuple<Ts...> const& t, F&& f)
+THRUST_DECLTYPE_RETURNS(
+  detail::tuple_transform_impl(
+    t
+  , THRUST_FWD(f)
+  , make_index_sequence<sizeof...(Ts)>{}
+  )
+);
+template <typename... Ts, typename F>
+auto tuple_transform(std::tuple<Ts...>&& t, F&& f)
+THRUST_DECLTYPE_RETURNS(
+  detail::tuple_transform_impl(
+    std::move(t)
+  , THRUST_FWD(f)
+  , make_index_sequence<sizeof...(Ts)>{}
+  )
+);
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
+

miniCUDA124/include/thrust/detail/tuple_meta_transform.h

@@ -0,0 +1,66 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/tuple.h>
+#include <thrust/type_traits/integer_sequence.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+// introduce an intermediate type tuple_meta_transform_WAR_NVCC
+// rather than directly specializing tuple_meta_transform with
+// default argument IndexSequence = thrust::make_index_sequence<thrust::tuple_size<Tuple>::value>
+// to workaround nvcc 11.0 compiler bug
+template<typename Tuple,
+         template<typename> class UnaryMetaFunction,
+         typename IndexSequence>
+  struct tuple_meta_transform_WAR_NVCC;
+
+template<typename Tuple,
+         template<typename> class UnaryMetaFunction,
+         size_t... Is>
+  struct tuple_meta_transform_WAR_NVCC<Tuple, UnaryMetaFunction, thrust::index_sequence<Is...>>
+{
+  typedef thrust::tuple<
+    typename UnaryMetaFunction<typename thrust::tuple_element<Is,Tuple>::type>::type...
+  > type;
+};
+
+template<typename Tuple,
+         template<typename> class UnaryMetaFunction>
+  struct tuple_meta_transform
+{
+  typedef typename tuple_meta_transform_WAR_NVCC<Tuple, UnaryMetaFunction, thrust::make_index_sequence<thrust::tuple_size<Tuple>::value>>::type type;
+};
+
+} // end detail
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/detail/tuple_transform.h

@@ -0,0 +1,92 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/tuple.h>
+#include <thrust/detail/tuple_meta_transform.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template<typename Tuple,
+         template<typename> class UnaryMetaFunction,
+         typename UnaryFunction,
+         typename IndexSequence = thrust::make_index_sequence<thrust::tuple_size<Tuple>::value>>
+  struct tuple_transform_functor;
+
+
+template<typename Tuple,
+         template<typename> class UnaryMetaFunction,
+         typename UnaryFunction,
+         size_t... Is>
+  struct tuple_transform_functor<Tuple,UnaryMetaFunction,UnaryFunction,thrust::index_sequence<Is...>>
+{
+  static __host__
+  typename tuple_meta_transform<Tuple,UnaryMetaFunction>::type
+  do_it_on_the_host(const Tuple &t, UnaryFunction f)
+  {
+    typedef typename tuple_meta_transform<Tuple,UnaryMetaFunction>::type XfrmTuple;
+
+    return XfrmTuple(f(thrust::get<Is>(t))...);
+  }
+
+  static __host__ __device__
+  typename tuple_meta_transform<Tuple,UnaryMetaFunction>::type
+  do_it_on_the_host_or_device(const Tuple &t, UnaryFunction f)
+  {
+    typedef typename tuple_meta_transform<Tuple,UnaryMetaFunction>::type XfrmTuple;
+
+    return XfrmTuple(f(thrust::get<Is>(t))...);
+  }
+};
+
+
+template<template<typename> class UnaryMetaFunction,
+         typename Tuple,
+         typename UnaryFunction>
+typename tuple_meta_transform<Tuple,UnaryMetaFunction>::type
+tuple_host_transform(const Tuple &t, UnaryFunction f)
+{
+  return tuple_transform_functor<Tuple,UnaryMetaFunction,UnaryFunction>::do_it_on_the_host(t,f);
+}
+
+template<template<typename> class UnaryMetaFunction,
+         typename Tuple,
+         typename UnaryFunction>
+typename tuple_meta_transform<Tuple,UnaryMetaFunction>::type
+__host__ __device__
+tuple_host_device_transform(const Tuple &t, UnaryFunction f)
+{
+  return tuple_transform_functor<Tuple,UnaryMetaFunction,UnaryFunction>::do_it_on_the_host_or_device(t,f);
+}
+
+} // end detail
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/detail/type_deduction.h

@@ -0,0 +1,98 @@
+// Copyright (c)      2018 NVIDIA Corporation
+//                         (Bryce Adelstein Lelbach <brycelelbach@gmail.com>)
+// Copyright (c) 2013-2018 Eric Niebler (`THRUST_RETURNS`, etc)
+// Copyright (c) 2016-2018 Casey Carter (`THRUST_RETURNS`, etc)
+//
+// Distributed under the Boost Software License v1.0 (boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/detail/preprocessor.h>
+
+#include <utility>
+#include <type_traits>
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// \def THRUST_FWD(x)
+/// \brief Performs universal forwarding of a universal reference.
+///
+#define THRUST_FWD(x) ::std::forward<decltype(x)>(x)
+
+/// \def THRUST_MVCAP(x)
+/// \brief Capture `x` into a lambda by moving.
+///
+#define THRUST_MVCAP(x) x = ::std::move(x)
+
+/// \def THRUST_RETOF(invocable, ...)
+/// \brief Expands to the type returned by invoking an instance of the invocable
+///        type \a invocable with parameters of type \c __VA_ARGS__. Must
+///        be called with 1 or fewer parameters to the invocable.
+///
+#define THRUST_RETOF(...)   THRUST_PP_DISPATCH(THRUST_RETOF, __VA_ARGS__)
+#define THRUST_RETOF1(C)    decltype(::std::declval<C>()())
+#define THRUST_RETOF2(C, V) decltype(::std::declval<C>()(::std::declval<V>()))
+
+/// \def THRUST_RETURNS(...)
+/// \brief Expands to a function definition that returns the expression
+///        \c __VA_ARGS__.
+///
+#define THRUST_RETURNS(...)                                                   \
+  noexcept(noexcept(__VA_ARGS__))                                             \
+  { return (__VA_ARGS__); }                                                   \
+  /**/
+
+/// \def THRUST_DECLTYPE_RETURNS(...)
+/// \brief Expands to a function definition, including a trailing returning
+///        type, that returns the expression \c __VA_ARGS__.
+///
+// Trailing return types seem to confuse Doxygen, and cause it to interpret
+// parts of the function's body as new function signatures.
+#if defined(THRUST_DOXYGEN)
+  #define THRUST_DECLTYPE_RETURNS(...)                                        \
+  { return (__VA_ARGS__); }                                                   \
+  /**/
+#else
+  #define THRUST_DECLTYPE_RETURNS(...)                                        \
+    noexcept(noexcept(__VA_ARGS__))                                           \
+    -> decltype(__VA_ARGS__)                                                  \
+    { return (__VA_ARGS__); }                                                 \
+    /**/
+#endif
+
+/// \def THRUST_DECLTYPE_RETURNS_WITH_SFINAE_CONDITION(condition, ...)
+/// \brief Expands to a function definition, including a trailing returning
+///        type, that returns the expression \c __VA_ARGS__. It shall only
+///        participate in overload resolution if \c condition is \c true.
+///
+// Trailing return types seem to confuse Doxygen, and cause it to interpret
+// parts of the function's body as new function signatures.
+#if defined(THRUST_DOXYGEN)
+  #define THRUST_DECLTYPE_RETURNS(...)                                        \
+  { return (__VA_ARGS__); }                                                   \
+  /**/
+#else
+  #define THRUST_DECLTYPE_RETURNS_WITH_SFINAE_CONDITION(condition, ...)       \
+    noexcept(noexcept(__VA_ARGS__))                                           \
+    -> typename std::enable_if<condition, decltype(__VA_ARGS__)>::type        \
+    { return (__VA_ARGS__); }                                                 \
+    /**/
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+#endif // THRUST_CPP_DIALECT >= 2011
+

miniCUDA124/include/thrust/detail/type_traits.h

@@ -0,0 +1,701 @@
+/*
+ *  Copyright 2008-2022 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file type_traits.h
+ *  \brief Temporarily define some type traits
+ *         until nvcc can compile tr1::type_traits.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/type_traits>
+
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+
+// forward declaration of device_reference
+template<typename T> class device_reference;
+
+namespace detail
+{
+ /// helper classes [4.3].
+template<typename T, T v>
+using integral_constant = ::cuda::std::integral_constant<T, v>;
+using true_type  = ::cuda::std::true_type;
+using false_type = ::cuda::std::false_type;
+
+//template<typename T> struct is_integral : public std::tr1::is_integral<T> {};
+template<typename T> struct is_integral                           : public false_type {};
+template<>           struct is_integral<bool>                     : public true_type {};
+template<>           struct is_integral<char>                     : public true_type {};
+template<>           struct is_integral<signed char>              : public true_type {};
+template<>           struct is_integral<unsigned char>            : public true_type {};
+template<>           struct is_integral<short>                    : public true_type {};
+template<>           struct is_integral<unsigned short>           : public true_type {};
+template<>           struct is_integral<int>                      : public true_type {};
+template<>           struct is_integral<unsigned int>             : public true_type {};
+template<>           struct is_integral<long>                     : public true_type {};
+template<>           struct is_integral<unsigned long>            : public true_type {};
+template<>           struct is_integral<long long>                : public true_type {};
+template<>           struct is_integral<unsigned long long>       : public true_type {};
+template<>           struct is_integral<const bool>               : public true_type {};
+template<>           struct is_integral<const char>               : public true_type {};
+template<>           struct is_integral<const unsigned char>      : public true_type {};
+template<>           struct is_integral<const short>              : public true_type {};
+template<>           struct is_integral<const unsigned short>     : public true_type {};
+template<>           struct is_integral<const int>                : public true_type {};
+template<>           struct is_integral<const unsigned int>       : public true_type {};
+template<>           struct is_integral<const long>               : public true_type {};
+template<>           struct is_integral<const unsigned long>      : public true_type {};
+template<>           struct is_integral<const long long>          : public true_type {};
+template<>           struct is_integral<const unsigned long long> : public true_type {};
+
+template<typename T> struct is_floating_point              : public false_type {};
+template<>           struct is_floating_point<float>       : public true_type {};
+template<>           struct is_floating_point<double>      : public true_type {};
+template<>           struct is_floating_point<long double> : public true_type {};
+
+template<typename T> struct is_arithmetic               : public is_integral<T> {};
+template<>           struct is_arithmetic<float>        : public true_type {};
+template<>           struct is_arithmetic<double>       : public true_type {};
+template<>           struct is_arithmetic<const float>  : public true_type {};
+template<>           struct is_arithmetic<const double> : public true_type {};
+
+template<typename T> struct is_pointer      : public false_type {};
+template<typename T> struct is_pointer<T *> : public true_type  {};
+
+template<typename T> struct is_device_ptr  : public false_type {};
+
+template<typename T> struct is_void             : public false_type {};
+template<>           struct is_void<void>       : public true_type {};
+template<>           struct is_void<const void> : public true_type {};
+
+template<typename T> struct is_non_bool_integral       : public is_integral<T> {};
+template<>           struct is_non_bool_integral<bool> : public false_type {};
+
+template<typename T> struct is_non_bool_arithmetic       : public is_arithmetic<T> {};
+template<>           struct is_non_bool_arithmetic<bool> : public false_type {};
+
+template<typename T> struct is_pod
+   : public integral_constant<
+       bool,
+       is_void<T>::value || is_pointer<T>::value || is_arithmetic<T>::value
+#if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC || \
+    THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG
+// use intrinsic type traits
+       || __is_pod(T)
+#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC
+// only use the intrinsic for >= 4.3
+#if (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)
+       || __is_pod(T)
+#endif // GCC VERSION
+#endif // THRUST_HOST_COMPILER
+     >
+ {};
+
+
+template <typename T>
+struct has_trivial_constructor
+  : public integral_constant<bool, is_pod<T>::value || ::cuda::std::is_trivially_constructible<T>::value>
+{};
+
+template<typename T>
+struct has_trivial_copy_constructor
+  : public integral_constant<bool, is_pod<T>::value || ::cuda::std::is_trivially_copyable<T>::value>
+{};
+
+template<typename T> struct has_trivial_destructor : public is_pod<T> {};
+
+template<typename T> struct is_const          : public false_type {};
+template<typename T> struct is_const<const T> : public true_type {};
+
+template<typename T> struct is_volatile             : public false_type {};
+template<typename T> struct is_volatile<volatile T> : public true_type {};
+
+template<typename T>
+  struct add_const
+{
+  typedef T const type;
+}; // end add_const
+
+template<typename T>
+  struct remove_const
+{
+  typedef T type;
+}; // end remove_const
+
+template<typename T>
+  struct remove_const<const T>
+{
+  typedef T type;
+}; // end remove_const
+
+template<typename T>
+  struct add_volatile
+{
+  typedef volatile T type;
+}; // end add_volatile
+
+template<typename T>
+  struct remove_volatile
+{
+  typedef T type;
+}; // end remove_volatile
+
+template<typename T>
+  struct remove_volatile<volatile T>
+{
+  typedef T type;
+}; // end remove_volatile
+
+template<typename T>
+  struct add_cv
+{
+  typedef const volatile T type;
+}; // end add_cv
+
+template<typename T>
+  struct remove_cv
+{
+  typedef typename remove_const<typename remove_volatile<T>::type>::type type;
+}; // end remove_cv
+
+
+template<typename T> struct is_reference     : public false_type {};
+template<typename T> struct is_reference<T&> : public true_type {};
+
+template<typename T> struct is_proxy_reference  : public false_type {};
+
+template<typename T> struct is_device_reference                                : public false_type {};
+template<typename T> struct is_device_reference< thrust::device_reference<T> > : public true_type {};
+
+
+// NB: Careful with reference to void.
+template<typename _Tp, bool = (is_void<_Tp>::value || is_reference<_Tp>::value)>
+  struct __add_reference_helper
+  { typedef _Tp&    type; };
+
+template<typename _Tp>
+  struct __add_reference_helper<_Tp, true>
+  { typedef _Tp     type; };
+
+template<typename _Tp>
+  struct add_reference
+    : public __add_reference_helper<_Tp>{};
+
+template<typename T>
+  struct remove_reference
+{
+  typedef T type;
+}; // end remove_reference
+
+template<typename T>
+  struct remove_reference<T&>
+{
+  typedef T type;
+}; // end remove_reference
+
+template<typename T1, typename T2>
+  struct is_same
+    : public false_type
+{
+}; // end is_same
+
+template<typename T>
+  struct is_same<T,T>
+    : public true_type
+{
+}; // end is_same
+
+template<typename T1, typename T2>
+  struct lazy_is_same
+    : is_same<typename T1::type, typename T2::type>
+{
+}; // end lazy_is_same
+
+template<typename T1, typename T2>
+  struct is_different
+    : public true_type
+{
+}; // end is_different
+
+template<typename T>
+  struct is_different<T,T>
+    : public false_type
+{
+}; // end is_different
+
+template<typename T1, typename T2>
+  struct lazy_is_different
+    : is_different<typename T1::type, typename T2::type>
+{
+}; // end lazy_is_different
+
+#if THRUST_CPP_DIALECT >= 2011
+
+template<class From, class To>
+using is_convertible = ::cuda::std::is_convertible<From, To>;
+
+#else
+
+namespace tt_detail
+{
+
+template<typename T>
+  struct is_int_or_cref
+{
+  typedef typename remove_reference<T>::type type_sans_ref;
+  static const bool value = (is_integral<T>::value
+                             || (is_integral<type_sans_ref>::value
+                                 && is_const<type_sans_ref>::value
+                                 && !is_volatile<type_sans_ref>::value));
+}; // end is_int_or_cref
+
+
+THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_BEGIN
+THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING_BEGIN
+
+template<typename From, typename To>
+  struct is_convertible_sfinae
+{
+  private:
+    typedef char                          yes;
+    typedef struct { char two_chars[2]; } no;
+
+    static inline yes   test(To) { return yes(); }
+    static inline no    test(...) { return no(); }
+    static inline typename remove_reference<From>::type& from() { typename remove_reference<From>::type* ptr = 0; return *ptr; }
+
+  public:
+    static const bool value = sizeof(test(from())) == sizeof(yes);
+}; // end is_convertible_sfinae
+
+
+THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING_END
+THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_END
+
+
+template<typename From, typename To>
+  struct is_convertible_needs_simple_test
+{
+  static const bool from_is_void      = is_void<From>::value;
+  static const bool to_is_void        = is_void<To>::value;
+  static const bool from_is_float     = is_floating_point<typename remove_reference<From>::type>::value;
+  static const bool to_is_int_or_cref = is_int_or_cref<To>::value;
+
+  static const bool value = (from_is_void || to_is_void || (from_is_float && to_is_int_or_cref));
+}; // end is_convertible_needs_simple_test
+
+
+template<typename From, typename To,
+         bool = is_convertible_needs_simple_test<From,To>::value>
+  struct is_convertible
+{
+  static const bool value = (is_void<To>::value
+                             || (is_int_or_cref<To>::value
+                                 && !is_void<From>::value));
+}; // end is_convertible
+
+
+template<typename From, typename To>
+  struct is_convertible<From, To, false>
+{
+  static const bool value = (is_convertible_sfinae<typename
+                             add_reference<From>::type, To>::value);
+}; // end is_convertible
+
+
+} // end tt_detail
+
+template<typename From, typename To>
+  struct is_convertible
+    : public integral_constant<bool, tt_detail::is_convertible<From, To>::value>
+{
+}; // end is_convertible
+
+#endif
+
+template<typename T1, typename T2>
+  struct is_one_convertible_to_the_other
+    : public integral_constant<
+        bool,
+        is_convertible<T1,T2>::value || is_convertible<T2,T1>::value
+      >
+{};
+
+
+// mpl stuff
+template<typename... Conditions>
+  struct or_;
+
+template <>
+  struct or_<>
+    : public integral_constant<
+        bool,
+        false_type::value  // identity for or_
+      >
+{
+}; // end or_
+
+template <typename Condition, typename... Conditions>
+  struct or_<Condition, Conditions...>
+    : public integral_constant<
+        bool,
+        Condition::value || or_<Conditions...>::value
+      >
+{
+}; // end or_
+
+template <typename... Conditions>
+  struct and_;
+
+template<>
+  struct and_<>
+    : public integral_constant<
+        bool,
+        true_type::value // identity for and_
+      >
+{
+}; // end and_
+
+template <typename Condition, typename... Conditions>
+  struct and_<Condition, Conditions...>
+    : public integral_constant<
+        bool,
+        Condition::value && and_<Conditions...>::value>
+{
+}; // end and_
+
+template <typename Boolean>
+  struct not_
+    : public integral_constant<bool, !Boolean::value>
+{
+}; // end not_
+
+template<bool B, class T, class F>
+struct conditional { typedef T type; };
+
+template<class T, class F>
+struct conditional<false, T, F> { typedef F type; };
+
+template <bool, typename Then, typename Else>
+  struct eval_if
+{
+}; // end eval_if
+
+template<typename Then, typename Else>
+  struct eval_if<true, Then, Else>
+{
+  typedef typename Then::type type;
+}; // end eval_if
+
+template<typename Then, typename Else>
+  struct eval_if<false, Then, Else>
+{
+  typedef typename Else::type type;
+}; // end eval_if
+
+template<typename T>
+//  struct identity
+//  XXX WAR nvcc's confusion with thrust::identity
+  struct identity_
+{
+  typedef T type;
+}; // end identity
+
+template<bool, typename T = void> struct enable_if {};
+template<typename T>              struct enable_if<true, T> {typedef T type;};
+
+template<bool, typename T> struct lazy_enable_if {};
+template<typename T>       struct lazy_enable_if<true, T> {typedef typename T::type type;};
+
+template<bool condition, typename T = void> struct disable_if : enable_if<!condition, T> {};
+template<bool condition, typename T>        struct lazy_disable_if : lazy_enable_if<!condition, T> {};
+
+
+template<typename T1, typename T2, typename T = void>
+  struct enable_if_convertible
+    : enable_if< is_convertible<T1,T2>::value, T >
+{};
+
+
+template<typename T1, typename T2, typename T = void>
+  struct disable_if_convertible
+    : disable_if< is_convertible<T1,T2>::value, T >
+{};
+
+
+template<typename T1, typename T2, typename Result = void>
+  struct enable_if_different
+    : enable_if<is_different<T1,T2>::value, Result>
+{};
+
+
+template<typename T>
+  struct is_numeric
+    : and_<
+        is_convertible<int,T>,
+        is_convertible<T,int>
+      >
+{
+}; // end is_numeric
+
+
+template<typename> struct is_reference_to_const             : false_type {};
+template<typename T> struct is_reference_to_const<const T&> : true_type {};
+
+
+// make_unsigned follows
+
+namespace tt_detail
+{
+
+template<typename T> struct make_unsigned_simple;
+
+template<> struct make_unsigned_simple<char>                   { typedef unsigned char          type; };
+template<> struct make_unsigned_simple<signed char>            { typedef unsigned char          type; };
+template<> struct make_unsigned_simple<unsigned char>          { typedef unsigned char          type; };
+template<> struct make_unsigned_simple<short>                  { typedef unsigned short         type; };
+template<> struct make_unsigned_simple<unsigned short>         { typedef unsigned short         type; };
+template<> struct make_unsigned_simple<int>                    { typedef unsigned int           type; };
+template<> struct make_unsigned_simple<unsigned int>           { typedef unsigned int           type; };
+template<> struct make_unsigned_simple<long int>               { typedef unsigned long int      type; };
+template<> struct make_unsigned_simple<unsigned long int>      { typedef unsigned long int      type; };
+template<> struct make_unsigned_simple<long long int>          { typedef unsigned long long int type; };
+template<> struct make_unsigned_simple<unsigned long long int> { typedef unsigned long long int type; };
+
+template<typename T>
+  struct make_unsigned_base
+{
+  // remove cv
+  typedef typename remove_cv<T>::type remove_cv_t;
+
+  // get the simple unsigned type
+  typedef typename make_unsigned_simple<remove_cv_t>::type unsigned_remove_cv_t;
+
+  // add back const, volatile, both, or neither to the simple result
+  typedef typename eval_if<
+    is_const<T>::value && is_volatile<T>::value,
+    // add cv back
+    add_cv<unsigned_remove_cv_t>,
+    // check const & volatile individually
+    eval_if<
+      is_const<T>::value,
+      // add c back
+      add_const<unsigned_remove_cv_t>,
+      eval_if<
+        is_volatile<T>::value,
+        // add v back
+        add_volatile<unsigned_remove_cv_t>,
+        // original type was neither cv, return the simple unsigned result
+        identity_<unsigned_remove_cv_t>
+      >
+    >
+  >::type type;
+};
+
+} // end tt_detail
+
+template<typename T>
+  struct make_unsigned
+    : tt_detail::make_unsigned_base<T>
+{};
+
+struct largest_available_float
+{
+  typedef double type;
+};
+
+// T1 wins if they are both the same size
+template<typename T1, typename T2>
+  struct larger_type
+    : thrust::detail::eval_if<
+        (sizeof(T2) > sizeof(T1)),
+        thrust::detail::identity_<T2>,
+        thrust::detail::identity_<T1>
+      >
+{};
+
+#if THRUST_CPP_DIALECT >= 2011
+
+template<class Base, class Derived>
+using is_base_of = ::cuda::std::is_base_of<Base, Derived>;
+
+#else
+
+namespace is_base_of_ns
+{
+
+typedef char                          yes;
+typedef struct { char two_chars[2]; } no;
+
+template<typename Base, typename Derived>
+  struct host
+{
+  operator Base*() const;
+  operator Derived*();
+}; // end host
+
+template<typename Base, typename Derived>
+  struct impl
+{
+  template<typename T> static yes check(Derived *, T);
+  static no check(Base*, int);
+
+  static const bool value = sizeof(check(host<Base,Derived>(), int())) == sizeof(yes);
+}; // end impl
+
+} // end is_base_of_ns
+
+
+template<typename Base, typename Derived>
+  struct is_base_of
+    : integral_constant<
+        bool,
+        is_base_of_ns::impl<Base,Derived>::value
+      >
+{};
+
+#endif
+
+template<typename Base, typename Derived, typename Result = void>
+  struct enable_if_base_of
+    : enable_if<
+        is_base_of<Base,Derived>::value,
+        Result
+      >
+{};
+
+
+namespace is_assignable_ns
+{
+
+template<typename T1, typename T2>
+  class is_assignable
+{
+  typedef char                      yes_type;
+  typedef struct { char array[2]; } no_type;
+
+  template<typename T> static typename add_reference<T>::type declval();
+
+  template<size_t> struct helper { typedef void * type; };
+
+  template<typename U1, typename U2> static yes_type test(typename helper<sizeof(declval<U1>() = declval<U2>())>::type);
+
+  template<typename,typename> static no_type test(...);
+
+  public:
+    static const bool value = sizeof(test<T1,T2>(0)) == 1;
+}; // end is_assignable
+
+} // end is_assignable_ns
+
+
+template<typename T1, typename T2>
+  struct is_assignable
+    : integral_constant<
+        bool,
+        is_assignable_ns::is_assignable<T1,T2>::value
+      >
+{};
+
+
+template<typename T>
+  struct is_copy_assignable
+    : is_assignable<
+        typename add_reference<T>::type,
+        typename add_reference<typename add_const<T>::type>::type
+      >
+{};
+
+
+template<typename T1, typename T2, typename Enable = void> struct promoted_numerical_type;
+
+template<typename T1, typename T2>
+  struct promoted_numerical_type<T1,T2,typename enable_if<and_
+  <typename is_floating_point<T1>::type, typename is_floating_point<T2>::type>
+  ::value>::type>
+  {
+  typedef typename larger_type<T1,T2>::type type;
+  };
+
+template<typename T1, typename T2>
+  struct promoted_numerical_type<T1,T2,typename enable_if<and_
+  <typename is_integral<T1>::type, typename is_floating_point<T2>::type>
+  ::value>::type>
+  {
+  typedef T2 type;
+  };
+
+template<typename T1, typename T2>
+  struct promoted_numerical_type<T1,T2,typename enable_if<and_
+  <typename is_floating_point<T1>::type, typename is_integral<T2>::type>
+  ::value>::type>
+  {
+  typedef T1 type;
+  };
+
+template<typename T>
+  struct is_empty_helper : public T
+  {
+  };
+
+struct is_empty_helper_base
+{
+};
+
+template<typename T>
+  struct is_empty : integral_constant<bool,
+    sizeof(is_empty_helper_base) == sizeof(is_empty_helper<T>)
+  >
+  {
+  };
+
+template <typename Invokable, typename... Args>
+using invoke_result_t =
+#if THRUST_CPP_DIALECT < 2017
+  typename ::cuda::std::result_of<Invokable(Args...)>::type;
+#else // 2017+
+  ::cuda::std::invoke_result_t<Invokable, Args...>;
+#endif
+
+template <class F, class... Us>
+struct invoke_result
+{
+  using type = invoke_result_t<F, Us...>;
+};
+
+} // end detail
+
+using detail::integral_constant;
+using detail::true_type;
+using detail::false_type;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/type_traits/has_trivial_assign.h>

miniCUDA124/include/thrust/detail/uninitialized_copy.inl

@@ -0,0 +1,103 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/uninitialized_copy.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/uninitialized_copy.h>
+#include <thrust/system/detail/adl/uninitialized_copy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename ForwardIterator>
+__host__ __device__
+  ForwardIterator uninitialized_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                     InputIterator first,
+                                     InputIterator last,
+                                     ForwardIterator result)
+{
+  using thrust::system::detail::generic::uninitialized_copy;
+  return uninitialized_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result);
+} // end uninitialized_copy()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename Size, typename ForwardIterator>
+__host__ __device__
+  ForwardIterator uninitialized_copy_n(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       InputIterator first,
+                                       Size n,
+                                       ForwardIterator result)
+{
+  using thrust::system::detail::generic::uninitialized_copy_n;
+  return uninitialized_copy_n(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, n, result);
+} // end uninitialized_copy_n()
+
+
+template<typename InputIterator,
+         typename ForwardIterator>
+  ForwardIterator uninitialized_copy(InputIterator first,
+                                     InputIterator last,
+                                     ForwardIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type   System1;
+  typedef typename thrust::iterator_system<ForwardIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::uninitialized_copy(select_system(system1,system2), first, last, result);
+} // end uninitialized_copy()
+
+
+template<typename InputIterator,
+         typename Size,
+         typename ForwardIterator>
+  ForwardIterator uninitialized_copy_n(InputIterator first,
+                                       Size n,
+                                       ForwardIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type   System1;
+  typedef typename thrust::iterator_system<ForwardIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::uninitialized_copy_n(select_system(system1,system2), first, n, result);
+} // end uninitialized_copy_n()
+
+
+THRUST_NAMESPACE_END
+
+

miniCUDA124/include/thrust/detail/uninitialized_fill.inl

@@ -0,0 +1,98 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/uninitialized_fill.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/uninitialized_fill.h>
+#include <thrust/system/detail/adl/uninitialized_fill.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename T>
+__host__ __device__
+  void uninitialized_fill(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                          ForwardIterator first,
+                          ForwardIterator last,
+                          const T &x)
+{
+  using thrust::system::detail::generic::uninitialized_fill;
+  return uninitialized_fill(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, x);
+} // end uninitialized_fill()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename Size, typename T>
+__host__ __device__
+  ForwardIterator uninitialized_fill_n(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       ForwardIterator first,
+                                       Size n,
+                                       const T &x)
+{
+  using thrust::system::detail::generic::uninitialized_fill_n;
+  return uninitialized_fill_n(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, n, x);
+} // end uninitialized_fill_n()
+
+
+template<typename ForwardIterator,
+         typename T>
+  void uninitialized_fill(ForwardIterator first,
+                          ForwardIterator last,
+                          const T &x)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  thrust::uninitialized_fill(select_system(system), first, last, x);
+} // end uninitialized_fill()
+
+
+template<typename ForwardIterator,
+         typename Size,
+         typename T>
+  ForwardIterator uninitialized_fill_n(ForwardIterator first,
+                                       Size n,
+                                       const T &x)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::uninitialized_fill_n(select_system(system), first, n, x);
+} // end uninitialized_fill_n()
+
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/detail/unique.inl

@@ -0,0 +1,401 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/unique.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/unique.h>
+#include <thrust/system/detail/generic/unique_by_key.h>
+#include <thrust/system/detail/adl/unique.h>
+#include <thrust/system/detail/adl/unique_by_key.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator>
+__host__ __device__
+ForwardIterator unique(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                       ForwardIterator first,
+                       ForwardIterator last)
+{
+  using thrust::system::detail::generic::unique;
+  return unique(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end unique()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename BinaryPredicate>
+__host__ __device__
+ForwardIterator unique(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                       ForwardIterator first,
+                       ForwardIterator last,
+                       BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::unique;
+  return unique(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, binary_pred);
+} // end unique()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator>
+__host__ __device__
+OutputIterator unique_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator first,
+                           InputIterator last,
+                           OutputIterator output)
+{
+  using thrust::system::detail::generic::unique_copy;
+  return unique_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, output);
+} // end unique_copy()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename BinaryPredicate>
+__host__ __device__
+OutputIterator unique_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator first,
+                           InputIterator last,
+                           OutputIterator output,
+                           BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::unique_copy;
+  return unique_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, output, binary_pred);
+} // end unique_copy()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator1,
+         typename ForwardIterator2>
+__host__ __device__
+  thrust::pair<ForwardIterator1,ForwardIterator2>
+  unique_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                ForwardIterator1 keys_first,
+                ForwardIterator1 keys_last,
+                ForwardIterator2 values_first)
+{
+  using thrust::system::detail::generic::unique_by_key;
+  return unique_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first);
+} // end unique_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator1,
+         typename ForwardIterator2,
+         typename BinaryPredicate>
+__host__ __device__
+  thrust::pair<ForwardIterator1,ForwardIterator2>
+  unique_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                ForwardIterator1 keys_first,
+                ForwardIterator1 keys_last,
+                ForwardIterator2 values_first,
+                BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::unique_by_key;
+  return unique_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first, binary_pred);
+} // end unique_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+  unique_by_key_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                     InputIterator1 keys_first,
+                     InputIterator1 keys_last,
+                     InputIterator2 values_first,
+                     OutputIterator1 keys_output,
+                     OutputIterator2 values_output)
+{
+  using thrust::system::detail::generic::unique_by_key_copy;
+  return unique_by_key_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first, keys_output, values_output);
+} // end unique_by_key_copy()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename BinaryPredicate>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+  unique_by_key_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                     InputIterator1 keys_first,
+                     InputIterator1 keys_last,
+                     InputIterator2 values_first,
+                     OutputIterator1 keys_output,
+                     OutputIterator2 values_output,
+                     BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::unique_by_key_copy;
+  return unique_by_key_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first, keys_output, values_output, binary_pred);
+} // end unique_by_key_copy()
+
+
+template<typename ForwardIterator>
+  ForwardIterator unique(ForwardIterator first,
+                         ForwardIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::unique(select_system(system), first, last);
+} // end unique()
+
+
+template<typename ForwardIterator,
+         typename BinaryPredicate>
+  ForwardIterator unique(ForwardIterator first,
+                         ForwardIterator last,
+                         BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::unique(select_system(system), first, last, binary_pred);
+} // end unique()
+
+
+template<typename InputIterator,
+         typename OutputIterator>
+  OutputIterator unique_copy(InputIterator first,
+                             InputIterator last,
+                             OutputIterator output)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::unique_copy(select_system(system1,system2), first, last, output);
+} // end unique_copy()
+
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename BinaryPredicate>
+  OutputIterator unique_copy(InputIterator first,
+                             InputIterator last,
+                             OutputIterator output,
+                             BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::unique_copy(select_system(system1,system2), first, last, output, binary_pred);
+} // end unique_copy()
+
+
+template<typename ForwardIterator1,
+         typename ForwardIterator2>
+  thrust::pair<ForwardIterator1,ForwardIterator2>
+    unique_by_key(ForwardIterator1 keys_first,
+                  ForwardIterator1 keys_last,
+                  ForwardIterator2 values_first)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator1>::type System1;
+  typedef typename thrust::iterator_system<ForwardIterator2>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::unique_by_key(select_system(system1,system2), keys_first, keys_last, values_first);
+} // end unique_by_key()
+
+
+template<typename ForwardIterator1,
+         typename ForwardIterator2,
+         typename BinaryPredicate>
+  thrust::pair<ForwardIterator1,ForwardIterator2>
+    unique_by_key(ForwardIterator1 keys_first,
+                  ForwardIterator1 keys_last,
+                  ForwardIterator2 values_first,
+                  BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator1>::type System1;
+  typedef typename thrust::iterator_system<ForwardIterator2>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::unique_by_key(select_system(system1,system2), keys_first, keys_last, values_first, binary_pred);
+} // end unique_by_key()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    unique_by_key_copy(InputIterator1 keys_first,
+                       InputIterator1 keys_last,
+                       InputIterator2 values_first,
+                       OutputIterator1 keys_output,
+                       OutputIterator2 values_output)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System3;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System4;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+
+  return thrust::unique_by_key_copy(select_system(system1,system2,system3,system4), keys_first, keys_last, values_first, keys_output, values_output);
+} // end unique_by_key_copy()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename BinaryPredicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    unique_by_key_copy(InputIterator1 keys_first,
+                       InputIterator1 keys_last,
+                       InputIterator2 values_first,
+                       OutputIterator1 keys_output,
+                       OutputIterator2 values_output,
+                       BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System3;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System4;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+
+  return thrust::unique_by_key_copy(select_system(system1,system2,system3,system4), keys_first, keys_last, values_first, keys_output, values_output, binary_pred);
+} // end unique_by_key_copy()
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy,
+          typename ForwardIterator,
+          typename BinaryPredicate>
+__host__ __device__
+    typename thrust::iterator_traits<ForwardIterator>::difference_type
+    unique_count(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                 ForwardIterator first,
+                 ForwardIterator last,
+                 BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::unique_count;
+  return unique_count(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, binary_pred);
+} // end unique_count()
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy,
+          typename ForwardIterator>
+__host__ __device__
+    typename thrust::iterator_traits<ForwardIterator>::difference_type
+    unique_count(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                 ForwardIterator first,
+                 ForwardIterator last)
+{
+  using thrust::system::detail::generic::unique_count;
+  return unique_count(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end unique_count()
+
+__thrust_exec_check_disable__
+template <typename ForwardIterator,
+          typename BinaryPredicate>
+__host__ __device__
+    typename thrust::iterator_traits<ForwardIterator>::difference_type
+    unique_count(ForwardIterator first,
+                 ForwardIterator last,
+                 BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::unique_count(select_system(system), first, last, binary_pred);
+} // end unique_count()
+
+__thrust_exec_check_disable__
+template <typename ForwardIterator>
+__host__ __device__
+    typename thrust::iterator_traits<ForwardIterator>::difference_type
+    unique_count(ForwardIterator first,
+                 ForwardIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::unique_count(select_system(system), first, last);
+} // end unique_count()
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/constant_iterator.h

@@ -0,0 +1,258 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/constant_iterator.h
+ *  \brief An iterator which returns a constant value when
+ *         dereferenced
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/iterator/detail/constant_iterator_base.h>
+#include <thrust/iterator/iterator_facade.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p constant_iterator is an iterator which represents a pointer into a range
+ *  of constant values. This iterator is useful for creating a range filled with the same
+ *  value without explicitly storing it in memory. Using \p constant_iterator saves both
+ *  memory capacity and bandwidth.
+ *
+ *  The following code snippet demonstrates how to create a \p constant_iterator whose
+ *  \c value_type is \c int and whose value is \c 10.
+ *
+ *  \code
+ *  #include <thrust/iterator/constant_iterator.h>
+ *
+ *  thrust::constant_iterator<int> iter(10);
+ *
+ *  *iter;    // returns 10
+ *  iter[0];  // returns 10
+ *  iter[1];  // returns 10
+ *  iter[13]; // returns 10
+ *
+ *  // and so on...
+ *  \endcode
+ *
+ *  This next example demonstrates how to use a \p constant_iterator with the
+ *  \p thrust::transform function to increment all elements of a sequence by the
+ *  same value. We will create a temporary \p constant_iterator with the function
+ *  \p make_constant_iterator function in order to avoid explicitly specifying
+ *  its type:
+ *
+ *  \code
+ *  #include <thrust/iterator/constant_iterator.h>
+ *  #include <thrust/transform.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<int> data(4);
+ *    data[0] = 3;
+ *    data[1] = 7;
+ *    data[2] = 2;
+ *    data[3] = 5;
+ *
+ *    // add 10 to all values in data
+ *    thrust::transform(data.begin(), data.end(),
+ *                      thrust::make_constant_iterator(10),
+ *                      data.begin(),
+ *                      thrust::plus<int>());
+ *
+ *    // data is now [13, 17, 12, 15]
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see make_constant_iterator
+ */
+template<typename Value,
+         typename Incrementable = use_default,
+         typename System = use_default>
+  class constant_iterator
+    : public detail::constant_iterator_base<Value, Incrementable, System>::type
+{
+    /*! \cond
+     */
+    friend class thrust::iterator_core_access;
+    typedef typename detail::constant_iterator_base<Value, Incrementable, System>::type          super_t;
+    typedef typename detail::constant_iterator_base<Value, Incrementable, System>::incrementable incrementable;
+    typedef typename detail::constant_iterator_base<Value, Incrementable, System>::base_iterator base_iterator;
+
+  public:
+    typedef typename super_t::reference  reference;
+    typedef typename super_t::value_type value_type;
+
+    /*! \endcond
+     */
+
+    /*! Null constructor initializes this \p constant_iterator's constant using its
+     *  null constructor.
+     */
+    __host__ __device__
+    constant_iterator()
+      : super_t(), m_value() {}
+
+    /*! Copy constructor copies the value of another \p constant_iterator into this
+     *  \p constant_iterator.
+     *
+     *  \p rhs The constant_iterator to copy.
+     */
+    __host__ __device__
+    constant_iterator(constant_iterator const &rhs)
+      : super_t(rhs.base()), m_value(rhs.m_value) {}
+
+    /*! Copy constructor copies the value of another \p constant_iterator with related
+     *  System type.
+     *
+     *  \param rhs The \p constant_iterator to copy.
+     */
+    template<typename OtherSystem>
+    __host__ __device__
+    constant_iterator(constant_iterator<Value,Incrementable,OtherSystem> const &rhs,
+                      typename thrust::detail::enable_if_convertible<
+                        typename thrust::iterator_system<constant_iterator<Value,Incrementable,OtherSystem> >::type,
+                        typename thrust::iterator_system<super_t>::type
+                      >::type * = 0)
+      : super_t(rhs.base()), m_value(rhs.value()) {}
+
+    /*! This constructor receives a value to use as the constant value of this
+     *  \p constant_iterator and an index specifying the location of this
+     *  \p constant_iterator in a sequence.
+     *
+     *  \p v The value of this \p constant_iterator's constant value.
+     *  \p i The index of this \p constant_iterator in a sequence. Defaults to the
+     *       value returned by \c Incrementable's null constructor. For example,
+     *       when <tt>Incrementable == int</tt>, \c 0.
+     */
+    __host__ __device__
+    constant_iterator(value_type const& v, incrementable const &i = incrementable())
+      : super_t(base_iterator(i)), m_value(v) {}
+
+    /*! This constructor is templated to allow construction from a value type and
+     *  incrementable type related this this \p constant_iterator's respective types.
+     *
+     *  \p v The value of this \p constant_iterator's constant value.
+     *  \p i The index of this \p constant_iterator in a sequence. Defaults to the
+     *       value returned by \c Incrementable's null constructor. For example,
+     *       when <tt>Incrementable == int</tt>, \c 0.
+     */
+    template<typename OtherValue, typename OtherIncrementable>
+    __host__ __device__
+    constant_iterator(OtherValue const& v, OtherIncrementable const& i = incrementable())
+      : super_t(base_iterator(i)), m_value(v) {}
+
+    /*! This method returns the value of this \p constant_iterator's constant value.
+     *  \return A \c const reference to this \p constant_iterator's constant value.
+     */
+    __host__ __device__
+    Value const& value() const
+    { return m_value; }
+
+    /*! \cond
+     */
+
+  protected:
+    __host__ __device__
+    Value const& value_reference() const
+    { return m_value; }
+
+    __host__ __device__
+    Value & value_reference()
+    { return m_value; }
+
+  private: // Core iterator interface
+    __host__ __device__
+    reference dereference() const
+    {
+      return m_value;
+    }
+
+  private:
+    Value m_value;
+
+    /*! \endcond
+     */
+}; // end constant_iterator
+
+
+/*! This version of \p make_constant_iterator creates a \p constant_iterator
+ *  from values given for both value and index. The type of \p constant_iterator
+ *  may be inferred by the compiler from the types of its parameters.
+ *
+ *  \param x The value of the returned \p constant_iterator's constant value.
+ *  \param i The index of the returned \p constant_iterator within a sequence.
+ *           The type of this parameter defaults to \c int. In the default case,
+ *           the value of this parameter is \c 0.
+ *
+ *  \return A new \p constant_iterator with constant value & index as given
+ *          by \p x & \p i.
+ *
+ *  \see constant_iterator
+ */
+template<typename ValueT, typename IndexT>
+inline __host__ __device__
+constant_iterator<ValueT, IndexT> make_constant_iterator(ValueT x, IndexT i = int())
+{
+  return constant_iterator<ValueT, IndexT>(x, i);
+} // end make_constant_iterator()
+
+
+/*! This version of \p make_constant_iterator creates a \p constant_iterator
+ *  using only a parameter for the desired constant value. The value of the
+ *  returned \p constant_iterator's index is set to \c 0.
+ *
+ *  \param x The value of the returned \p constant_iterator's constant value.
+ *  \return A new \p constant_iterator with constant value equal to \p x and
+ *          index equal to \c 0.
+ *  \see constant_iterator
+ */
+template<typename V>
+inline __host__ __device__
+constant_iterator<V> make_constant_iterator(V x)
+{
+  return constant_iterator<V>(x, 0);
+} // end make_constant_iterator()
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/counting_iterator.h

@@ -0,0 +1,254 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/counting_iterator.h
+ *  \brief An iterator which returns an increasing incrementable value
+ *         when dereferenced
+ */
+
+/*
+ * Copyright David Abrahams 2003.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/iterator/iterator_adaptor.h>
+#include <thrust/iterator/iterator_facade.h>
+#include <thrust/iterator/iterator_categories.h>
+
+// #include the details first
+#include <thrust/iterator/detail/counting_iterator.inl>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p counting_iterator is an iterator which represents a pointer into a range
+ *  of sequentially changing values. This iterator is useful for creating a range
+ *  filled with a sequence without explicitly storing it in memory. Using
+ *  \p counting_iterator saves memory capacity and bandwidth.
+ *
+ *  The following code snippet demonstrates how to create a \p counting_iterator whose
+ *  \c value_type is \c int and which sequentially increments by \c 1.
+ *
+ *  \code
+ *  #include <thrust/iterator/counting_iterator.h>
+ *  ...
+ *  // create iterators
+ *  thrust::counting_iterator<int> first(10);
+ *  thrust::counting_iterator<int> last = first + 3;
+ *
+ *  first[0]   // returns 10
+ *  first[1]   // returns 11
+ *  first[100] // returns 110
+ *
+ *  // sum of [first, last)
+ *  thrust::reduce(first, last);   // returns 33 (i.e. 10 + 11 + 12)
+ *
+ *  // initialize vector to [0,1,2,..]
+ *  thrust::counting_iterator<int> iter(0);
+ *  thrust::device_vector<int> vec(500);
+ *  thrust::copy(iter, iter + vec.size(), vec.begin());
+ *  \endcode
+ *
+ *  This next example demonstrates how to use a \p counting_iterator with the
+ *  \p thrust::copy_if function to compute the indices of the non-zero elements
+ *  of a \p device_vector. In this example, we use the \p make_counting_iterator
+ *  function to avoid specifying the type of the \p counting_iterator.
+ *
+ *  \code
+ *  #include <thrust/iterator/counting_iterator.h>
+ *  #include <thrust/copy.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  int main()
+ *  {
+ *   // this example computes indices for all the nonzero values in a sequence
+ *
+ *   // sequence of zero and nonzero values
+ *   thrust::device_vector<int> stencil(8);
+ *   stencil[0] = 0;
+ *   stencil[1] = 1;
+ *   stencil[2] = 1;
+ *   stencil[3] = 0;
+ *   stencil[4] = 0;
+ *   stencil[5] = 1;
+ *   stencil[6] = 0;
+ *   stencil[7] = 1;
+ *
+ *   // storage for the nonzero indices
+ *   thrust::device_vector<int> indices(8);
+ *
+ *   // compute indices of nonzero elements
+ *   typedef thrust::device_vector<int>::iterator IndexIterator;
+ *
+ *   // use make_counting_iterator to define the sequence [0, 8)
+ *   IndexIterator indices_end = thrust::copy_if(thrust::make_counting_iterator(0),
+ *                                               thrust::make_counting_iterator(8),
+ *                                               stencil.begin(),
+ *                                               indices.begin(),
+ *                                               thrust::identity<int>());
+ *   // indices now contains [1,2,5,7]
+ *
+ *   return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see make_counting_iterator
+ */
+template<typename Incrementable,
+         typename System = use_default,
+         typename Traversal = use_default,
+         typename Difference = use_default>
+  class counting_iterator
+    : public detail::counting_iterator_base<Incrementable, System, Traversal, Difference>::type
+{
+    /*! \cond
+     */
+    typedef typename detail::counting_iterator_base<Incrementable, System, Traversal, Difference>::type super_t;
+
+    friend class thrust::iterator_core_access;
+
+  public:
+    typedef typename super_t::reference       reference;
+    typedef typename super_t::difference_type difference_type;
+
+    /*! \endcond
+     */
+
+    /*! Default constructor initializes this \p counting_iterator's counter to
+     * `Incrementable{}`.
+     */
+    __host__ __device__
+    counting_iterator() : super_t(Incrementable{}) {}
+
+    /*! Copy constructor copies the value of another \p counting_iterator into a
+     *  new \p counting_iterator.
+     *
+     *  \p rhs The \p counting_iterator to copy.
+     */
+    __host__ __device__
+    counting_iterator(counting_iterator const &rhs):super_t(rhs.base()){}
+
+    /*! Copy constructor copies the value of another counting_iterator
+     *  with related System type.
+     *
+     *  \param rhs The \p counting_iterator to copy.
+     */
+    template<typename OtherSystem>
+    __host__ __device__
+    counting_iterator(counting_iterator<Incrementable, OtherSystem, Traversal, Difference> const &rhs,
+                      typename thrust::detail::enable_if_convertible<
+                        typename thrust::iterator_system<counting_iterator<Incrementable,OtherSystem,Traversal,Difference> >::type,
+                        typename thrust::iterator_system<super_t>::type
+                      >::type * = 0)
+      : super_t(rhs.base()){}
+
+    /*! This \c explicit constructor copies the value of an \c Incrementable
+     *  into a new \p counting_iterator's \c Incrementable counter.
+     *
+     *  \param x The initial value of the new \p counting_iterator's \c Incrementable
+     *         counter.
+     */
+    __host__ __device__
+    explicit counting_iterator(Incrementable x):super_t(x){}
+
+#if THRUST_CPP_DIALECT >= 2011
+    counting_iterator & operator=(const counting_iterator &) = default;
+#endif
+
+    /*! \cond
+     */
+  private:
+    __host__ __device__
+    reference dereference() const
+    {
+      return this->base_reference();
+    }
+
+    // note that we implement equal specially for floating point counting_iterator
+    template <typename OtherIncrementable, typename OtherSystem, typename OtherTraversal, typename OtherDifference>
+    __host__ __device__
+    bool equal(counting_iterator<OtherIncrementable, OtherSystem, OtherTraversal, OtherDifference> const& y) const
+    {
+      typedef thrust::detail::counting_iterator_equal<difference_type,Incrementable,OtherIncrementable> e;
+      return e::equal(this->base(), y.base());
+    }
+
+    template <class OtherIncrementable>
+    __host__ __device__
+    difference_type
+    distance_to(counting_iterator<OtherIncrementable, System, Traversal, Difference> const& y) const
+    {
+      typedef typename
+      thrust::detail::eval_if<
+        thrust::detail::is_numeric<Incrementable>::value,
+        thrust::detail::identity_<thrust::detail::number_distance<difference_type, Incrementable, OtherIncrementable> >,
+        thrust::detail::identity_<thrust::detail::iterator_distance<difference_type, Incrementable, OtherIncrementable> >
+      >::type d;
+
+      return d::distance(this->base(), y.base());
+    }
+
+    /*! \endcond
+     */
+}; // end counting_iterator
+
+
+/*! \p make_counting_iterator creates a \p counting_iterator
+ *  using an initial value for its \c Incrementable counter.
+ *
+ *  \param x The initial value of the new \p counting_iterator's counter.
+ *  \return A new \p counting_iterator whose counter has been initialized to \p x.
+ */
+template <typename Incrementable>
+inline __host__ __device__
+counting_iterator<Incrementable> make_counting_iterator(Incrementable x)
+{
+  return counting_iterator<Incrementable>(x);
+}
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/discard_iterator.h

@@ -0,0 +1,182 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/discard_iterator.h
+ *  \brief An iterator which "discards" (ignores) values assigned to it upon dereference
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/iterator/detail/discard_iterator_base.h>
+#include <thrust/iterator/iterator_facade.h>
+
+THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_BEGIN
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p discard_iterator is an iterator which represents a special kind of pointer that
+ *  ignores values written to it upon dereference. This iterator is useful for ignoring
+ *  the output of certain algorithms without wasting memory capacity or bandwidth.
+ *  \p discard_iterator may also be used to count the size of an algorithm's output which
+ *  may not be known a priori.
+ *
+ *  The following code snippet demonstrates how to use \p discard_iterator to ignore
+ *  ignore one of the output ranges of reduce_by_key
+ *
+ *  \code
+ *  #include <thrust/iterator/discard_iterator.h>
+ *  #include <thrust/reduce.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<int> keys(7), values(7);
+ *
+ *    keys[0] = 1;
+ *    keys[1] = 3;
+ *    keys[2] = 3;
+ *    keys[3] = 3;
+ *    keys[4] = 2;
+ *    keys[5] = 2;
+ *    keys[6] = 1;
+ *
+ *    values[0] = 9;
+ *    values[1] = 8;
+ *    values[2] = 7;
+ *    values[3] = 6;
+ *    values[4] = 5;
+ *    values[5] = 4;
+ *    values[6] = 3;
+ *
+ *    thrust::device_vector<int> result(4);
+ *
+ *    // we are only interested in the reduced values
+ *    // use discard_iterator to ignore the output keys
+ *    thrust::reduce_by_key(keys.begin(), keys.end(),
+ *                          values.begin(),
+ *                          thrust::make_discard_iterator(),
+ *                          result.begin());
+ *
+ *    // result is now [9, 21, 9, 3]
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see make_discard_iterator
+ */
+template<typename System = use_default>
+  class discard_iterator
+    : public detail::discard_iterator_base<System>::type
+{
+    /*! \cond
+     */
+    friend class thrust::iterator_core_access;
+    typedef typename detail::discard_iterator_base<System>::type          super_t;
+    typedef typename detail::discard_iterator_base<System>::incrementable incrementable;
+    typedef typename detail::discard_iterator_base<System>::base_iterator base_iterator;
+
+  public:
+    typedef typename super_t::reference  reference;
+    typedef typename super_t::value_type value_type;
+
+    /*! \endcond
+     */
+
+    /*! Copy constructor copies from a source discard_iterator.
+     *
+     *  \p rhs The discard_iterator to copy.
+     */
+    __host__ __device__
+    discard_iterator(discard_iterator const &rhs)
+      : super_t(rhs.base()) {}
+
+#if THRUST_CPP_DIALECT >= 2011
+    discard_iterator & operator=(const discard_iterator &) = default;
+#endif
+
+    /*! This constructor receives an optional index specifying the position of this
+     *  \p discard_iterator in a range.
+     *
+     *  \p i The index of this \p discard_iterator in a range. Defaults to the
+     *       value returned by \c Incrementable's null constructor. For example,
+     *       when <tt>Incrementable == int</tt>, \c 0.
+     */
+    __host__ __device__
+    discard_iterator(incrementable const &i = incrementable())
+      : super_t(base_iterator(i)) {}
+
+    /*! \cond
+     */
+
+  private: // Core iterator interface
+    __host__ __device__
+    reference dereference() const
+    {
+      return m_element;
+    }
+
+    mutable value_type m_element;
+
+    /*! \endcond
+     */
+}; // end constant_iterator
+
+
+/*! \p make_discard_iterator creates a \p discard_iterator from an optional index parameter.
+ *
+ *  \param i The index of the returned \p discard_iterator within a range.
+ *           In the default case, the value of this parameter is \c 0.
+ *
+ *  \return A new \p discard_iterator with index as given by \p i.
+ *
+ *  \see constant_iterator
+ */
+inline __host__ __device__
+discard_iterator<> make_discard_iterator(discard_iterator<>::difference_type i = discard_iterator<>::difference_type(0))
+{
+  return discard_iterator<>(i);
+} // end make_discard_iterator()
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
+THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_END
+

miniCUDA124/include/thrust/iterator/iterator_adaptor.h

@@ -0,0 +1,249 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/iterator_adaptor.h
+ *  \brief An iterator which adapts a base iterator
+ */
+
+/*
+ * (C) Copyright David Abrahams 2002.
+ * (C) Copyright Jeremy Siek    2002.
+ * (C) Copyright Thomas Witt    2002.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/iterator/iterator_facade.h>
+#include <thrust/detail/use_default.h>
+#include <thrust/iterator/detail/iterator_adaptor_base.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p iterator_adaptor is an iterator which adapts an existing type of iterator to create a new type of
+ *  iterator. Most of Thrust's fancy iterators are defined via inheritance from \p iterator_adaptor.
+ *  While composition of these existing Thrust iterators is often sufficient for expressing the desired
+ *  functionality, it is occasionally more straightforward to derive from \p iterator_adaptor directly.
+ *
+ *  To see how to use \p iterator_adaptor to create a novel iterator type, let's examine how to use it to
+ *  define \p repeat_iterator, a fancy iterator which repeats elements from another range a given number of time:
+ *
+ *  \code
+ *  #include <thrust/iterator/iterator_adaptor.h>
+ *
+ *  // derive repeat_iterator from iterator_adaptor
+ *  template<typename Iterator>
+ *    class repeat_iterator
+ *      : public thrust::iterator_adaptor<
+ *          repeat_iterator<Iterator>, // the first template parameter is the name of the iterator we're creating
+ *          Iterator                   // the second template parameter is the name of the iterator we're adapting
+ *                                     // we can use the default for the additional template parameters
+ *        >
+ *  {
+ *    public:
+ *      // shorthand for the name of the iterator_adaptor we're deriving from
+ *      typedef thrust::iterator_adaptor<
+ *        repeat_iterator<Iterator>,
+ *        Iterator
+ *      > super_t;
+ *
+ *      __host__ __device__
+ *      repeat_iterator(const Iterator &x, int n) : super_t(x), begin(x), n(n) {}
+ *
+ *      // befriend thrust::iterator_core_access to allow it access to the private interface below
+ *      friend class thrust::iterator_core_access;
+ *
+ *    private:
+ *      // repeat each element of the adapted range n times
+ *      unsigned int n;
+ *
+ *      // used to keep track of where we began
+ *      const Iterator begin;
+ *
+ *      // it is private because only thrust::iterator_core_access needs access to it
+ *      __host__ __device__
+ *      typename super_t::reference dereference() const
+ *      {
+ *        return *(begin + (this->base() - begin) / n);
+ *      }
+ *  };
+ *  \endcode
+ *
+ *  Except for the first two, \p iterator_adaptor's template parameters are optional. When omitted, or when the
+ *  user specifies \p thrust::use_default in its place, \p iterator_adaptor will use a default type inferred from \p Base.
+ *
+ *  \p iterator_adaptor's functionality is derived from and generally equivalent to \p boost::iterator_adaptor.
+ *  The exception is Thrust's addition of the template parameter \p System, which is necessary to allow Thrust
+ *  to dispatch an algorithm to one of several parallel backend systems.
+ *
+ *  \p iterator_adaptor is a powerful tool for creating custom iterators directly. However, the large set of iterator semantics which must be satisfied
+ *  for algorithm compatibility can make \p iterator_adaptor difficult to use correctly. Unless you require the full expressivity of \p iterator_adaptor,
+ *  consider building a custom iterator through composition of existing higher-level fancy iterators instead.
+ *
+ *  Interested users may refer to <tt>boost::iterator_adaptor</tt>'s documentation for further usage examples.
+ */
+template<typename Derived,
+         typename Base,
+         typename Value      = use_default,
+         typename System     = use_default,
+         typename Traversal  = use_default,
+         typename Reference  = use_default,
+         typename Difference = use_default>
+  class iterator_adaptor:
+    public detail::iterator_adaptor_base<
+      Derived, Base, Value, System, Traversal, Reference, Difference
+    >::type
+{
+  /*! \cond
+   */
+
+    friend class thrust::iterator_core_access;
+
+  protected:
+    typedef typename detail::iterator_adaptor_base<
+        Derived, Base, Value, System, Traversal, Reference, Difference
+    >::type super_t;
+
+  /*! \endcond
+   */
+
+  public:
+    /*! \p iterator_adaptor's default constructor does nothing.
+     */
+    iterator_adaptor() = default;
+
+    /*! This constructor copies from a given instance of the \p Base iterator.
+     */
+    __thrust_exec_check_disable__
+    __host__ __device__
+    explicit iterator_adaptor(Base const& iter)
+      : m_iterator(iter)
+    {}
+
+    /*! The type of iterator this \p iterator_adaptor's \p adapts.
+     */
+    typedef Base       base_type;
+
+    /*! \cond
+     */
+    typedef typename super_t::reference reference;
+
+    typedef typename super_t::difference_type difference_type;
+    /*! \endcond
+     */
+
+    /*! \return A \p const reference to the \p Base iterator this \p iterator_adaptor adapts.
+     */
+    __host__ __device__
+    Base const& base() const
+    { return m_iterator; }
+
+  protected:
+    /*! \return A \p const reference to the \p Base iterator this \p iterator_adaptor adapts.
+     */
+    __host__ __device__
+    Base const& base_reference() const
+    { return m_iterator; }
+
+    /*! \return A mutable reference to the \p Base iterator this \p iterator_adaptor adapts.
+     */
+    __host__ __device__
+    Base& base_reference()
+    { return m_iterator; }
+
+    /*! \cond
+     */
+  private: // Core iterator interface for iterator_facade
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    typename iterator_adaptor::reference dereference() const
+    { return *m_iterator; }
+
+    __thrust_exec_check_disable__
+    template<typename OtherDerived, typename OtherIterator, typename V, typename S, typename T, typename R, typename D>
+    __host__ __device__
+    bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, S, T, R, D> const& x) const
+    { return m_iterator == x.base(); }
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    void advance(typename iterator_adaptor::difference_type n)
+    {
+      // XXX statically assert on random_access_traversal_tag
+
+      // counting_iterator will pick eg. diff_t=int64 when base=int32.
+      // Explicitly cast to avoid static conversion warnings.
+      m_iterator = static_cast<base_type>(m_iterator + n);
+    }
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    void increment()
+    { ++m_iterator; }
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    void decrement()
+    {
+      // XXX statically assert on bidirectional_traversal_tag
+      --m_iterator;
+    }
+
+    __thrust_exec_check_disable__
+    template<typename OtherDerived, typename OtherIterator, typename V, typename S, typename T, typename R, typename D>
+    __host__ __device__
+    typename iterator_adaptor::difference_type distance_to(iterator_adaptor<OtherDerived, OtherIterator, V, S, T, R, D> const& y) const
+    { return y.base() - m_iterator; }
+
+  private:
+    Base m_iterator;
+
+    /*! \endcond
+     */
+}; // end iterator_adaptor
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/iterator_categories.h

@@ -0,0 +1,231 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/iterator_categories.h
+ *  \brief Types for reasoning about the categories of iterators
+ */
+
+/*
+ * (C) Copyright Jeremy Siek 2002.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/iterator/detail/iterator_category_with_system_and_traversal.h>
+#include <thrust/iterator/detail/iterator_traversal_tags.h>
+#include <thrust/iterator/detail/device_system_tag.h>
+
+// #include this for stl's iterator tags
+#include <iterator>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \addtogroup iterator_tags Iterator Tags
+ *  \ingroup iterators
+ *  \addtogroup iterator_tag_classes Iterator Tag Classes
+ *  \ingroup iterator_tags
+ *  \{
+ */
+
+/*! \p input_device_iterator_tag is an empty class: it has no member functions,
+ *  member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Input Device Iterator concept within the C++ type
+ *  system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags  iterator_traits,
+ *  output_device_iterator_tag, forward_device_iterator_tag,
+ *  bidirectional_device_iterator_tag, random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+struct input_device_iterator_tag
+  : thrust::detail::iterator_category_with_system_and_traversal<
+      std::input_iterator_tag,
+      thrust::device_system_tag,
+      thrust::single_pass_traversal_tag
+    >
+{};
+
+/*! \p output_device_iterator_tag is an empty class: it has no member functions,
+ *  member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Output Device Iterator concept within the C++ type
+ *  system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags  iterator_traits,
+ *  input_device_iterator_tag, forward_device_iterator_tag,
+ *  bidirectional_device_iterator_tag, random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+struct output_device_iterator_tag
+  : thrust::detail::iterator_category_with_system_and_traversal<
+      std::output_iterator_tag,
+      thrust::device_system_tag,
+      thrust::single_pass_traversal_tag
+    >
+{};
+
+/*! \p forward_device_iterator_tag is an empty class: it has no member functions,
+ *  member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Forward Device Iterator concept within the C++ type
+ *  system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags  iterator_traits,
+ *  input_device_iterator_tag, output_device_iterator_tag,
+ *  bidirectional_device_iterator_tag, random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+struct forward_device_iterator_tag
+  : thrust::detail::iterator_category_with_system_and_traversal<
+      std::forward_iterator_tag,
+      thrust::device_system_tag,
+      thrust::forward_traversal_tag
+    >
+{};
+
+/*! \p bidirectional_device_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Bidirectional Device Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+struct bidirectional_device_iterator_tag
+  : thrust::detail::iterator_category_with_system_and_traversal<
+      std::bidirectional_iterator_tag,
+      thrust::device_system_tag,
+      thrust::bidirectional_traversal_tag
+    >
+{};
+
+/*! \p random_access_device_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Random Access Device Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, bidirectional_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+struct random_access_device_iterator_tag
+  : thrust::detail::iterator_category_with_system_and_traversal<
+      std::random_access_iterator_tag,
+      thrust::device_system_tag,
+      thrust::random_access_traversal_tag
+    >
+{};
+
+/*! \p input_host_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Input Host Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, bidirectional_device_iterator_tag,
+ *  random_access_device_iterator_tag,
+ *  output_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+typedef std::input_iterator_tag input_host_iterator_tag;
+
+/*! \p output_host_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Output Host Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, bidirectional_device_iterator_tag,
+ *  random_access_device_iterator_tag,
+ *  input_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+typedef std::output_iterator_tag output_host_iterator_tag;
+
+/*! \p forward_host_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Forward Host Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, bidirectional_device_iterator_tag,
+ *  random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+typedef std::forward_iterator_tag forward_host_iterator_tag;
+
+/*! \p bidirectional_host_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Forward Host Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, bidirectional_device_iterator_tag,
+ *  random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag,
+ *  forward_host_iterator_tag, random_access_host_iterator_tag
+ */
+typedef std::bidirectional_iterator_tag bidirectional_host_iterator_tag;
+
+/*! \p random_access_host_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Forward Host Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, bidirectional_device_iterator_tag,
+ *  random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag,
+ *  forward_host_iterator_tag, bidirectional_host_iterator_tag
+ */
+typedef std::random_access_iterator_tag random_access_host_iterator_tag;
+
+/*! \} // end iterator_tag_classes
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/iterator/detail/universal_categories.h>
+

miniCUDA124/include/thrust/iterator/iterator_facade.h

@@ -0,0 +1,550 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/iterator/iterator_facade.h
+ *  \brief A class which exposes a public interface for iterators
+ */
+
+/*
+ * (C) Copyright David Abrahams 2002.
+ * (C) Copyright Jeremy Siek    2002.
+ * (C) Copyright Thomas Witt    2002.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/iterator_facade_category.h>
+#include <thrust/iterator/detail/distance_from_result.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+
+// This forward declaration is required for the friend declaration
+// in iterator_core_access
+template<typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference> class iterator_facade;
+
+
+/*! \p iterator_core_access is the class which user iterator types derived from \p thrust::iterator_adaptor
+ *  or \p thrust::iterator_facade must befriend to allow it to access their private interface.
+ */
+class iterator_core_access
+{
+    /*! \cond
+     */
+
+    // declare our friends
+    template<typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference> friend class iterator_facade;
+
+    // iterator comparisons are our friends
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator ==(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+                iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator !=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+                iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator <(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+               iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator >(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+               iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator <=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+                iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator >=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+                iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    // iterator difference is our friend
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend
+      typename thrust::detail::distance_from_result<
+        iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1>,
+        iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2>
+      >::type
+    operator-(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+              iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template<typename Facade>
+    __host__ __device__
+    static typename Facade::reference dereference(Facade const& f)
+    {
+      return f.dereference();
+    }
+
+    template<typename Facade>
+    __host__ __device__
+    static void increment(Facade& f)
+    {
+      f.increment();
+    }
+
+    template<typename Facade>
+    __host__ __device__
+    static void decrement(Facade& f)
+    {
+      f.decrement();
+    }
+
+    template <class Facade1, class Facade2>
+    __host__ __device__
+    static bool equal(Facade1 const& f1, Facade2 const& f2)
+    {
+      return f1.equal(f2);
+    }
+
+    // XXX TODO: Investigate whether we need both of these cases
+    //template <class Facade1, class Facade2>
+    //__host__ __device__
+    //static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_)
+    //{
+    //  return f1.equal(f2);
+    //}
+
+    //template <class Facade1, class Facade2>
+    //__host__ __device__
+    //static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_)
+    //{
+    //  return f2.equal(f1);
+    //}
+
+    template <class Facade>
+    __host__ __device__
+    static void advance(Facade& f, typename Facade::difference_type n)
+    {
+      f.advance(n);
+    }
+
+    // Facade2 is convertible to Facade1,
+    // so return Facade1's difference_type
+    template <class Facade1, class Facade2>
+    __host__ __device__
+    static typename Facade1::difference_type
+      distance_from(Facade1 const& f1, Facade2 const& f2, thrust::detail::true_type)
+    {
+      return -f1.distance_to(f2);
+    }
+
+    // Facade2 is not convertible to Facade1,
+    // so return Facade2's difference_type
+    template <class Facade1, class Facade2>
+    __host__ __device__
+    static typename Facade2::difference_type
+      distance_from(Facade1 const& f1, Facade2 const& f2, thrust::detail::false_type)
+    {
+      return f2.distance_to(f1);
+    }
+
+    template <class Facade1, class Facade2>
+    __host__ __device__
+    static typename thrust::detail::distance_from_result<Facade1,Facade2>::type
+      distance_from(Facade1 const& f1, Facade2 const& f2)
+    {
+      // dispatch the implementation of this method upon whether or not
+      // Facade2 is convertible to Facade1
+      return distance_from(f1, f2,
+        typename thrust::detail::is_convertible<Facade2,Facade1>::type());
+    }
+
+    //
+    // Curiously Recurring Template interface.
+    //
+    template <typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference>
+    __host__ __device__
+    static Derived& derived(iterator_facade<Derived,Value,System,Traversal,Reference,Difference>& facade)
+    {
+      return *static_cast<Derived*>(&facade);
+    }
+
+    template <typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference>
+    __host__ __device__
+    static Derived const& derived(iterator_facade<Derived,Value,System,Traversal,Reference,Difference> const& facade)
+    {
+      return *static_cast<Derived const*>(&facade);
+    }
+
+    /*! \endcond
+     */
+}; // end iterator_core_access
+
+
+/*! \p iterator_facade is a template which allows the programmer to define a novel iterator with a standards-conforming interface
+ *  which Thrust can use to reason about algorithm acceleration opportunities.
+ *
+ *  Because most of a standard iterator's interface is defined in terms of a small set of core primitives, \p iterator_facade
+ *  defines the non-primitive portion mechanically. In principle a novel iterator could explicitly provide the entire interface in
+ *  an ad hoc fashion but doing so might be tedious and prone to subtle errors.
+ *
+ *  Often \p iterator_facade is too primitive a tool to use for defining novel iterators. In these cases, \p iterator_adaptor
+ *  or a specific fancy iterator should be used instead.
+ *
+ *  \p iterator_facade's functionality is derived from and generally equivalent to \p boost::iterator_facade.
+ *  The exception is Thrust's addition of the template parameter \p System, which is necessary to allow Thrust
+ *  to dispatch an algorithm to one of several parallel backend systems. An additional exception is Thrust's omission
+ *  of the \c operator-> member function.
+ *
+ *  Interested users may refer to <tt>boost::iterator_facade</tt>'s documentation for usage examples.
+ *
+ *  \note \p iterator_facade's arithmetic operator free functions exist with the usual meanings but are omitted here for brevity.
+ */
+template<typename Derived,
+         typename Value,
+         typename System,
+         typename Traversal,
+         typename Reference,
+         typename Difference = std::ptrdiff_t>
+  class iterator_facade
+{
+  private:
+    /*! \cond
+     */
+
+    //
+    // Curiously Recurring Template interface.
+    //
+    __host__ __device__
+    Derived& derived()
+    {
+      return *static_cast<Derived*>(this);
+    }
+
+    __host__ __device__
+    Derived const& derived() const
+    {
+      return *static_cast<Derived const*>(this);
+    }
+    /*! \endcond
+     */
+
+  public:
+    /*! The type of element pointed to by \p iterator_facade.
+     */
+    typedef typename thrust::detail::remove_const<Value>::type value_type;
+
+    /*! The return type of \p iterator_facade::operator*().
+     */
+    typedef Reference                                          reference;
+
+    /*! The return type of \p iterator_facade's non-existent \c operator->()
+     *  member function. Unlike \c boost::iterator_facade, \p iterator_facade
+     *  disallows access to the \p value_type's members through expressions of the
+     *  form <tt>iter->member</tt>. \p pointer is defined to \c void to indicate
+     *  that these expressions are not allowed. This limitation may be relaxed in a
+     *  future version of Thrust.
+     */
+    typedef void                                               pointer;
+
+    /*! The type of expressions of the form <tt>x - y</tt> where <tt>x</tt> and <tt>y</tt>
+     *  are of type \p iterator_facade.
+     */
+    typedef Difference                                         difference_type;
+
+    /*! The type of iterator category of \p iterator_facade.
+     */
+    typedef typename thrust::detail::iterator_facade_category<
+      System, Traversal, Value, Reference
+    >::type                                                    iterator_category;
+
+    /*! \p operator*() dereferences this \p iterator_facade.
+     *  \return A reference to the element pointed to by this \p iterator_facade.
+     */
+    __host__ __device__
+    reference operator*() const
+    {
+      return iterator_core_access::dereference(this->derived());
+    }
+
+    // XXX unimplemented for now, consider implementing it later
+    //pointer operator->() const
+    //{
+    //  return;
+    //}
+
+    // XXX investigate whether or not we need to go to the lengths
+    //     boost does to determine the return type
+
+    /*! \p operator[] performs indexed dereference.
+     *  \return A reference to the element \p n distance away from this \p iterator_facade.
+     */
+    __host__ __device__
+    reference operator[](difference_type n) const
+    {
+      return *(this->derived() + n);
+    }
+
+    /*! \p operator++ pre-increments this \p iterator_facade to refer to the element in the next position.
+     *  \return <tt>*this</tt>
+     */
+    __host__ __device__
+    Derived& operator++()
+    {
+      iterator_core_access::increment(this->derived());
+      return this->derived();
+    }
+
+    /*! \p operator++ post-increments this \p iterator_facade and returns a new \p iterator_facade referring to the element in the next position.
+     *  \return A copy of <tt>*this</tt> before increment.
+     */
+    __host__ __device__
+    Derived  operator++(int)
+    {
+      Derived tmp(this->derived());
+      ++*this;
+      return tmp;
+    }
+
+    /*! \p operator-- pre-decrements this \p iterator_facade to refer to the element in the previous position.
+     *  \return <tt>*this</tt>
+     */
+    __host__ __device__
+    Derived& operator--()
+    {
+      iterator_core_access::decrement(this->derived());
+      return this->derived();
+    }
+
+    /*! \p operator-- post-decrements this \p iterator_facade and returns a new \p iterator_facade referring to the element in the previous position.
+     *  \return A copy of <tt>*this</tt> before decrement.
+     */
+    __host__ __device__
+    Derived  operator--(int)
+    {
+      Derived tmp(this->derived());
+      --*this;
+      return tmp;
+    }
+
+    /*! \p operator+= increments this \p iterator_facade to refer to an element a given distance after its current position.
+     *  \param n The quantity to increment.
+     *  \return <tt>*this</tt>
+     */
+    __host__ __device__
+    Derived& operator+=(difference_type n)
+    {
+      iterator_core_access::advance(this->derived(), n);
+      return this->derived();
+    }
+
+    /*! \p operator-= decrements this \p iterator_facade to refer to an element a given distance before its current postition.
+     *  \param n The quantity to decrement.
+     *  \return <tt>*this</tt>
+     */
+    __host__ __device__
+    Derived& operator-=(difference_type n)
+    {
+      iterator_core_access::advance(this->derived(), -n);
+      return this->derived();
+    }
+
+    /*! \p operator- subtracts a given quantity from this \p iterator_facade and returns a new \p iterator_facade referring to the element at the given position before this \p iterator_facade.
+     *  \param n The quantity to decrement
+     *  \return An \p iterator_facade pointing \p n elements before this \p iterator_facade.
+     */
+    __host__ __device__
+    Derived  operator-(difference_type n) const
+    {
+      Derived result(this->derived());
+      return result -= n;
+    }
+}; // end iterator_facade
+
+/*! \cond
+ */
+
+// Comparison operators
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator ==(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+            iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return iterator_core_access
+    ::equal(*static_cast<Derived1 const*>(&lhs),
+            *static_cast<Derived2 const*>(&rhs));
+}
+
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator !=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+            iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return !iterator_core_access
+    ::equal(*static_cast<Derived1 const*>(&lhs),
+            *static_cast<Derived2 const*>(&rhs));
+}
+
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator <(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+           iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return 0 > iterator_core_access
+    ::distance_from(*static_cast<Derived1 const*>(&lhs),
+                    *static_cast<Derived2 const*>(&rhs));
+}
+
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator >(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+           iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return 0 < iterator_core_access
+    ::distance_from(*static_cast<Derived1 const*>(&lhs),
+                    *static_cast<Derived2 const*>(&rhs));
+}
+
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator <=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+            iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return 0 >= iterator_core_access
+    ::distance_from(*static_cast<Derived1 const*>(&lhs),
+                    *static_cast<Derived2 const*>(&rhs));
+}
+
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator >=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+            iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return 0 <= iterator_core_access
+    ::distance_from(*static_cast<Derived1 const*>(&lhs),
+                    *static_cast<Derived2 const*>(&rhs));
+}
+
+// Iterator difference
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+
+// divine the type this operator returns
+typename thrust::detail::distance_from_result<
+  iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1>,
+  iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2>
+>::type
+
+operator-(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+          iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return iterator_core_access
+    ::distance_from(*static_cast<Derived1 const*>(&lhs),
+                    *static_cast<Derived2 const*>(&rhs));
+}
+
+// Iterator addition
+template <typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference>
+inline __host__ __device__
+Derived operator+ (iterator_facade<Derived,Value,System,Traversal,Reference,Difference> const& i,
+                   typename Derived::difference_type n)
+{
+  Derived tmp(static_cast<Derived const&>(i));
+  return tmp += n;
+}
+
+template <typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference>
+inline __host__ __device__
+Derived operator+ (typename Derived::difference_type n,
+                   iterator_facade<Derived,Value,System,Traversal,Reference,Difference> const& i)
+{
+  Derived tmp(static_cast<Derived const&>(i));
+  return tmp += n;
+}
+
+/*! \endcond
+ */
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/iterator_traits.h

@@ -0,0 +1,73 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/iterator_traits.h
+ *  \brief Traits and metafunctions for reasoning about the traits of iterators
+ */
+
+/*
+ * (C) Copyright David Abrahams 2003.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/type_traits/void_t.h>
+
+#include <iterator>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \p iterator_traits is a type trait class that provides a uniform
+ *  interface for querying the properties of iterators at compile-time.
+ */
+template <typename T>
+struct iterator_traits : std::iterator_traits<T> {};
+
+template<typename Iterator> struct iterator_value;
+
+template<typename Iterator> struct iterator_pointer;
+
+template<typename Iterator> struct iterator_reference;
+
+template<typename Iterator> struct iterator_difference;
+
+template<typename Iterator> struct iterator_traversal;
+
+template<typename Iterator> struct iterator_system;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/iterator/detail/iterator_traversal_tags.h>
+#include <thrust/iterator/detail/host_system_tag.h>
+#include <thrust/iterator/detail/device_system_tag.h>
+#include <thrust/iterator/detail/any_system_tag.h>
+#include <thrust/iterator/detail/iterator_traits.inl>
+

miniCUDA124/include/thrust/iterator/permutation_iterator.h

@@ -0,0 +1,222 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/iterator/permutation_iterator.h
+ *  \brief An iterator which performs a gather or scatter operation when dereferenced
+ */
+
+/*
+ * (C) Copyright Toon Knapen    2001.
+ * (C) Copyright David Abrahams 2003.
+ * (C) Copyright Roland Richter 2003.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/permutation_iterator_base.h>
+#include <thrust/iterator/iterator_facade.h>
+#include <thrust/iterator/iterator_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p permutation_iterator is an iterator which represents a pointer into a
+ *  reordered view of a given range. \p permutation_iterator is an imprecise name;
+ *  the reordered view need not be a strict permutation. This iterator is useful
+ *  for fusing a scatter or gather operation with other algorithms.
+ *
+ *  This iterator takes two arguments:
+ *
+ *    - an iterator to the range \c V on which the "permutation" will be applied
+ *    - the reindexing scheme that defines how the elements of \c V will be permuted.
+ *
+ *  Note that \p permutation_iterator is not limited to strict permutations of the
+ *  given range \c V. The distance between begin and end of the reindexing iterators
+ *  is allowed to be smaller compared to the size of the range \c V, in which case
+ *  the \p permutation_iterator only provides a "permutation" of a subrange of \c V.
+ *  The indices neither need to be unique. In this same context, it must be noted
+ *  that the past-the-end \p permutation_iterator is completely defined by means of
+ *  the past-the-end iterator to the indices.
+ *
+ *  The following code snippet demonstrates how to create a \p permutation_iterator
+ *  which represents a reordering of the contents of a \p device_vector.
+ *
+ *  \code
+ *  #include <thrust/iterator/permutation_iterator.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<float> values(8);
+ *  values[0] = 10.0f;
+ *  values[1] = 20.0f;
+ *  values[2] = 30.0f;
+ *  values[3] = 40.0f;
+ *  values[4] = 50.0f;
+ *  values[5] = 60.0f;
+ *  values[6] = 70.0f;
+ *  values[7] = 80.0f;
+ *
+ *  thrust::device_vector<int> indices(4);
+ *  indices[0] = 2;
+ *  indices[1] = 6;
+ *  indices[2] = 1;
+ *  indices[3] = 3;
+ *
+ *  typedef thrust::device_vector<float>::iterator ElementIterator;
+ *  typedef thrust::device_vector<int>::iterator   IndexIterator;
+ *
+ *  thrust::permutation_iterator<ElementIterator,IndexIterator> iter(values.begin(), indices.begin());
+ *
+ *  *iter;   // returns 30.0f;
+ *  iter[0]; // returns 30.0f;
+ *  iter[1]; // returns 70.0f;
+ *  iter[2]; // returns 20.0f;
+ *  iter[3]; // returns 40.0f;
+ *
+ *  // iter[4] is an out-of-bounds error
+ *
+ *  *iter   = -1.0f; // sets values[2] to -1.0f;
+ *  iter[0] = -1.0f; // sets values[2] to -1.0f;
+ *  iter[1] = -1.0f; // sets values[6] to -1.0f;
+ *  iter[2] = -1.0f; // sets values[1] to -1.0f;
+ *  iter[3] = -1.0f; // sets values[3] to -1.0f;
+ *
+ *  // values is now {10, -1, -1, -1, 50, 60, -1, 80}
+ *  \endcode
+ *
+ *  \see make_permutation_iterator
+ */
+template <typename ElementIterator,
+          typename IndexIterator>
+  class permutation_iterator
+    : public thrust::detail::permutation_iterator_base<
+        ElementIterator,
+        IndexIterator
+      >::type
+{
+  /*! \cond
+   */
+  private:
+    typedef typename detail::permutation_iterator_base<ElementIterator,IndexIterator>::type super_t;
+
+    friend class thrust::iterator_core_access;
+  /*! \endcond
+   */
+
+  public:
+    /*! Null constructor calls the null constructor of this \p permutation_iterator's
+     *  element iterator.
+     */
+    permutation_iterator() = default;
+
+    /*! Constructor accepts an \c ElementIterator into a range of values and an
+     *  \c IndexIterator into a range of indices defining the indexing scheme on the
+     *  values.
+     *
+     *  \param x An \c ElementIterator pointing this \p permutation_iterator's range of values.
+     *  \param y An \c IndexIterator pointing to an indexing scheme to use on \p x.
+     */
+    __host__ __device__
+    explicit permutation_iterator(ElementIterator x, IndexIterator y)
+      : super_t(y), m_element_iterator(x) {}
+
+    /*! Copy constructor accepts a related \p permutation_iterator.
+     *  \param r A compatible \p permutation_iterator to copy from.
+     */
+    template<typename OtherElementIterator, typename OtherIndexIterator>
+    __host__ __device__
+    permutation_iterator(permutation_iterator<OtherElementIterator,OtherIndexIterator> const &r
+    // XXX remove these guards when we have static_assert
+    , typename detail::enable_if_convertible<OtherElementIterator, ElementIterator>::type* = 0
+    , typename detail::enable_if_convertible<OtherIndexIterator, IndexIterator>::type* = 0
+    )
+      : super_t(r.base()), m_element_iterator(r.m_element_iterator)
+    {}
+
+  /*! \cond
+   */
+  private:
+    // MSVC 2013 and 2015 incorrectly warning about returning a reference to
+    // a local/temporary here.
+    // See goo.gl/LELTNp
+    THRUST_DISABLE_MSVC_WARNING_BEGIN(4172)
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    typename super_t::reference dereference() const
+    {
+      return *(m_element_iterator + *this->base());
+    }
+
+    THRUST_DISABLE_MSVC_WARNING_END(4172)
+
+    // make friends for the copy constructor
+    template<typename,typename> friend class permutation_iterator;
+
+    ElementIterator m_element_iterator;
+  /*! \endcond
+   */
+}; // end permutation_iterator
+
+
+/*! \p make_permutation_iterator creates a \p permutation_iterator
+ *  from an \c ElementIterator pointing to a range of elements to "permute"
+ *  and an \c IndexIterator pointing to a range of indices defining an indexing
+ *  scheme on the values.
+ *
+ *  \param e An \c ElementIterator pointing to a range of values.
+ *  \param i An \c IndexIterator pointing to an indexing scheme to use on \p e.
+ *  \return A new \p permutation_iterator which permutes the range \p e by \p i.
+ *  \see permutation_iterator
+ */
+template<typename ElementIterator, typename IndexIterator>
+__host__ __device__
+permutation_iterator<ElementIterator,IndexIterator> make_permutation_iterator(ElementIterator e, IndexIterator i)
+{
+  return permutation_iterator<ElementIterator,IndexIterator>(e,i);
+}
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/retag.h

@@ -0,0 +1,77 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/iterator/retag.h
+ *  \brief Functionality for altering an iterator's associated system.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/iterator/detail/retag.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+/*! \ingroup iterator_tags
+ *  \{
+ */
+
+#if 0
+/*! \p reinterpret_tag returns a copy of an iterator and changes the type of the result's system tag.
+ *  \tparam Tag Any system tag.
+ *  \tparam Iterator Any iterator type.
+ *  \param iter The iterator of interest.
+ *  \return An iterator of unspecified type whose system tag is \p Tag and whose behavior is otherwise
+ *          equivalent to \p iter.
+ *  \note Unlike \p retag, \p reinterpret_tag does not enforce that the converted-to system tag be
+ *        related to the converted-from system tag.
+ *  \see retag
+ */
+template<typename Tag, typename Iterator>
+__host__ __device__
+unspecified_iterator_type reinterpret_tag(Iterator iter);
+
+/*! \p retag returns a copy of an iterator and changes the type of the result's system tag.
+ *  \tparam Tag \p Tag shall be convertible to <tt>thrust::iterator_system<Iterator>::type</tt>,
+ *              or <tt>thrust::iterator_system<Iterator>::type</tt> is a base type of \p Tag.
+ *  \tparam Iterator Any iterator type.
+ *  \param iter The iterator of interest.
+ *  \return An iterator of unspecified type whose system tag is \p Tag and whose behavior is
+ *          otherwise equivalent to \p iter.
+ *  \note Unlike \p reinterpret_tag, \p retag enforces that the converted-to system tag be
+ *        related to the converted-from system tag.
+ *  \see reinterpret_tag
+ */
+template<typename Tag, typename Iterator>
+__host__ __device__
+unspecified_iterator_type retag(Iterator iter);
+#endif
+
+/*! \} // iterator_tags
+ */
+
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/reverse_iterator.h

@@ -0,0 +1,245 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/reverse_iterator.h
+ *  \brief An iterator adaptor which adapts another iterator to traverse backwards
+ */
+
+/*
+ * (C) Copyright David Abrahams 2002.
+ * (C) Copyright Jeremy Siek    2002.
+ * (C) Copyright Thomas Witt    2002.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/reverse_iterator_base.h>
+#include <thrust/iterator/iterator_facade.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p reverse_iterator is an iterator which represents a pointer into a
+ *  reversed view of a given range. In this way, \p reverse_iterator allows
+ *  backwards iteration through a bidirectional input range.
+ *
+ *  It is important to note that although \p reverse_iterator is constructed
+ *  from a given iterator, it points to the element preceding it. In this way,
+ *  the past-the-end \p reverse_iterator of a given range points to the element
+ *  preceding the first element of the input range. By the same token, the first
+ *  \p reverse_iterator of a given range is constructed from a past-the-end iterator
+ *  of the original range yet points to the last element of the input.
+ *
+ *  The following code snippet demonstrates how to create a \p reverse_iterator
+ *  which represents a reversed view of the contents of a \p device_vector.
+ *
+ *  \code
+ *  #include <thrust/iterator/reverse_iterator.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<float> v(4);
+ *  v[0] = 0.0f;
+ *  v[1] = 1.0f;
+ *  v[2] = 2.0f;
+ *  v[3] = 3.0f;
+ *
+ *  typedef thrust::device_vector<float>::iterator Iterator;
+ *
+ *  // note that we point the iterator to the *end* of the device_vector
+ *  thrust::reverse_iterator<Iterator> iter(values.end());
+ *
+ *  *iter;   // returns 3.0f;
+ *  iter[0]; // returns 3.0f;
+ *  iter[1]; // returns 2.0f;
+ *  iter[2]; // returns 1.0f;
+ *  iter[3]; // returns 0.0f;
+ *
+ *  // iter[4] is an out-of-bounds error
+ *  \endcode
+ *
+ *  Since reversing a range is a common operation, containers like \p device_vector
+ *  have nested typedefs for declaration shorthand and methods for constructing
+ *  reverse_iterators. The following code snippet is equivalent to the previous:
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<float> v(4);
+ *  v[0] = 0.0f;
+ *  v[1] = 1.0f;
+ *  v[2] = 2.0f;
+ *  v[3] = 3.0f;
+ *
+ *  // we use the nested type reverse_iterator to refer to a reversed view of
+ *  // a device_vector and the method rbegin() to create a reverse_iterator pointing
+ *  // to the beginning of the reversed device_vector
+ *  thrust::device_iterator<float>::reverse_iterator iter = values.rbegin();
+ *
+ *  *iter;   // returns 3.0f;
+ *  iter[0]; // returns 3.0f;
+ *  iter[1]; // returns 2.0f;
+ *  iter[2]; // returns 1.0f;
+ *  iter[3]; // returns 0.0f;
+ *
+ *  // iter[4] is an out-of-bounds error
+ *
+ *  // similarly, rend() points to the end of the reversed sequence:
+ *  assert(values.rend() == (iter + 4));
+ *  \endcode
+ *
+ *  Finally, the following code snippet demonstrates how to use reverse_iterator to
+ *  perform a reversed prefix sum operation on the contents of a device_vector:
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/scan.h>
+ *  ...
+ *  thrust::device_vector<int> v(5);
+ *  v[0] = 0;
+ *  v[1] = 1;
+ *  v[2] = 2;
+ *  v[3] = 3;
+ *  v[4] = 4;
+ *
+ *  thrust::device_vector<int> result(5);
+ *
+ *  // exclusive scan v into result in reverse
+ *  thrust::exclusive_scan(v.rbegin(), v.rend(), result.begin());
+ *
+ *  // result is now {0, 4, 7, 9, 10}
+ *  \endcode
+ *
+ *  \see make_reverse_iterator
+ */
+template<typename BidirectionalIterator>
+  class reverse_iterator
+    : public detail::reverse_iterator_base<BidirectionalIterator>::type
+{
+  /*! \cond
+   */
+  private:
+    typedef typename thrust::detail::reverse_iterator_base<
+      BidirectionalIterator
+    >::type super_t;
+
+    friend class thrust::iterator_core_access;
+  /*! \endcond
+   */
+
+  public:
+    /*! Default constructor does nothing.
+     */
+    __host__ __device__
+    reverse_iterator() {}
+
+    /*! \p Constructor accepts a \c BidirectionalIterator pointing to a range
+     *  for this \p reverse_iterator to reverse.
+     *
+     *  \param x A \c BidirectionalIterator pointing to a range to reverse.
+     */
+    __host__ __device__
+    explicit reverse_iterator(BidirectionalIterator x);
+
+    /*! \p Copy constructor allows construction from a related compatible
+     *  \p reverse_iterator.
+     *
+     *  \param r A \p reverse_iterator to copy from.
+     */
+    template<typename OtherBidirectionalIterator>
+    __host__ __device__
+    reverse_iterator(reverse_iterator<OtherBidirectionalIterator> const &r
+// XXX msvc screws this up
+// XXX remove these guards when we have static_assert
+#if THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+                     , typename thrust::detail::enable_if<
+                         thrust::detail::is_convertible<
+                           OtherBidirectionalIterator,
+                           BidirectionalIterator
+                         >::value
+                       >::type * = 0
+#endif // MSVC
+                     );
+
+  /*! \cond
+   */
+  private:
+    __thrust_exec_check_disable__
+    __host__ __device__
+    typename super_t::reference dereference() const;
+
+    __host__ __device__
+    void increment();
+
+    __host__ __device__
+    void decrement();
+
+    __host__ __device__
+    void advance(typename super_t::difference_type n);
+
+    template<typename OtherBidirectionalIterator>
+    __host__ __device__
+    typename super_t::difference_type
+    distance_to(reverse_iterator<OtherBidirectionalIterator> const &y) const;
+  /*! \endcond
+   */
+}; // end reverse_iterator
+
+
+/*! \p make_reverse_iterator creates a \p reverse_iterator
+ *  from a \c BidirectionalIterator pointing to a range of elements to reverse.
+ *
+ *  \param x A \c BidirectionalIterator pointing to a range to reverse.
+ *  \return A new \p reverse_iterator which reverses the range \p x.
+ */
+template<typename BidirectionalIterator>
+__host__ __device__
+reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x);
+
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/iterator/detail/reverse_iterator.inl>
+

miniCUDA124/include/thrust/iterator/transform_input_output_iterator.h

@@ -0,0 +1,172 @@
+/*
+ *  Copyright 2020 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/iterator/transform_input_output_iterator.h
+ *  \brief An iterator which adapts another iterator by applying transform
+ *         functions when reading and writing dereferenced values.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/iterator/detail/transform_input_output_iterator.inl>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p transform_input_output_iterator is a special kind of iterator which applies
+ * transform functions when reading from or writing to dereferenced values.
+ * This iterator is useful for algorithms that operate on a type that needs to
+ * be serialized/deserialized from values in another iterator, avoiding the
+ * need to materialize intermediate results in memory. This also enables the
+ * transform functions to be fused with the operations that read and write to
+ * the `transform_input_output_iterator`.
+ *
+ * The following code snippet demonstrates how to create a
+ * \p transform_input_output_iterator which performs different transformations when
+ * reading from and writing to the iterator.
+ *
+ * \code
+ * #include <thrust/iterator/transform_input_output_iterator.h>
+ * #include <thrust/device_vector.h>
+ *
+ *  int main()
+ *  {
+ *    const size_t size = 4;
+ *    thrust::device_vector<float> v(size);
+ *
+ *    // Write 1.0f, 2.0f, 3.0f, 4.0f to vector
+ *    thrust::sequence(v.begin(), v.end(), 1);
+ *
+ *    // Iterator that returns negated values and writes squared values
+ *    auto iter = thrust::make_transform_input_output_iterator(v.begin(),
+ *        thrust::negate<float>{}, thrust::square<float>{});
+ *
+ *    // Iterator negates values when reading
+ *    std::cout << iter[0] << " ";  // -1.0f;
+ *    std::cout << iter[1] << " ";  // -2.0f;
+ *    std::cout << iter[2] << " ";  // -3.0f;
+ *    std::cout << iter[3] << "\n"; // -4.0f;
+ *
+ *    // Write 1.0f, 2.0f, 3.0f, 4.0f to iterator
+ *    thrust::sequence(iter, iter + size, 1);
+ *
+ *    // Values were squared before writing to vector
+ *    std::cout << v[0] << " ";  // 1.0f;
+ *    std::cout << v[1] << " ";  // 4.0f;
+ *    std::cout << v[2] << " ";  // 9.0f;
+ *    std::cout << v[3] << "\n"; // 16.0f;
+ *
+ *  }
+ * \endcode
+ *
+ * \see make_transform_input_output_iterator
+ */
+
+template <typename InputFunction, typename OutputFunction, typename Iterator>
+  class transform_input_output_iterator
+    : public detail::transform_input_output_iterator_base<InputFunction, OutputFunction, Iterator>::type
+{
+
+  /*! \cond
+   */
+
+  public:
+
+    typedef typename
+    detail::transform_input_output_iterator_base<InputFunction, OutputFunction, Iterator>::type
+    super_t;
+
+    friend class thrust::iterator_core_access;
+  /*! \endcond
+   */
+
+  transform_input_output_iterator() = default;
+
+  /*! This constructor takes as argument a \c Iterator an \c InputFunction and an
+   * \c OutputFunction and copies them to a new \p transform_input_output_iterator
+   *
+   * \param io An \c Iterator pointing to where the input to \c InputFunction
+   *           will be read from and the result of \c OutputFunction will be written to
+   * \param input_function An \c InputFunction to be executed on values read from the iterator
+   * \param output_function An \c OutputFunction to be executed on values written to the iterator
+   */
+    __host__ __device__
+    transform_input_output_iterator(Iterator const& io, InputFunction input_function, OutputFunction output_function)
+      : super_t(io), input_function(input_function), output_function(output_function)
+    {
+    }
+
+    /*! \cond
+     */
+  private:
+
+    __host__ __device__
+    typename super_t::reference dereference() const
+    {
+      return detail::transform_input_output_iterator_proxy<
+        InputFunction, OutputFunction, Iterator
+      >(this->base_reference(), input_function, output_function);
+    }
+
+    InputFunction input_function;
+    OutputFunction output_function;
+
+    /*! \endcond
+     */
+}; // end transform_input_output_iterator
+
+/*! \p make_transform_input_output_iterator creates a \p transform_input_output_iterator from
+ *  an \c Iterator a \c InputFunction and a \c OutputFunction
+ *
+ * \param io An \c Iterator pointing to where the input to \c InputFunction
+ *           will be read from and the result of \c OutputFunction will be written to
+ * \param input_function An \c InputFunction to be executed on values read from the iterator
+ * \param output_function An \c OutputFunction to be executed on values written to the iterator
+ *  \see transform_input_output_iterator
+ */
+template <typename InputFunction, typename OutputFunction, typename Iterator>
+transform_input_output_iterator<InputFunction, OutputFunction, Iterator>
+__host__ __device__
+make_transform_input_output_iterator(Iterator io, InputFunction input_function, OutputFunction output_function)
+{
+    return transform_input_output_iterator<InputFunction, OutputFunction, Iterator>(io, input_function, output_function);
+} // end make_transform_input_output_iterator
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/transform_iterator.h

@@ -0,0 +1,362 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/transform_iterator.h
+ *  \brief An iterator which adapts another iterator by applying a function to the result of its dereference
+ */
+
+/*
+ * (C) Copyright David Abrahams 2002.
+ * (C) Copyright Jeremy Siek    2002.
+ * (C) Copyright Thomas Witt    2002.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// #include the details first
+#include <thrust/iterator/detail/transform_iterator.inl>
+#include <thrust/iterator/iterator_facade.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p transform_iterator is an iterator which represents a pointer into a range
+ *  of values after transformation by a function. This iterator is useful for
+ *  creating a range filled with the result of applying an operation to another range
+ *  without either explicitly storing it in memory, or explicitly executing the transformation.
+ *  Using \p transform_iterator facilitates kernel fusion by deferring the execution
+ *  of a transformation until the value is needed while saving both memory capacity
+ *  and bandwidth.
+ *
+ *  The following code snippet demonstrates how to create a \p transform_iterator
+ *  which represents the result of \c sqrtf applied to the contents of a \p device_vector.
+ *
+ *  \code
+ *  #include <thrust/iterator/transform_iterator.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  // note: functor inherits from unary_function
+ *  struct square_root : public thrust::unary_function<float,float>
+ *  {
+ *    __host__ __device__
+ *    float operator()(float x) const
+ *    {
+ *      return sqrtf(x);
+ *    }
+ *  };
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<float> v(4);
+ *    v[0] = 1.0f;
+ *    v[1] = 4.0f;
+ *    v[2] = 9.0f;
+ *    v[3] = 16.0f;
+ *
+ *    typedef thrust::device_vector<float>::iterator FloatIterator;
+ *
+ *    thrust::transform_iterator<square_root, FloatIterator> iter(v.begin(), square_root());
+ *
+ *    *iter;   // returns 1.0f
+ *    iter[0]; // returns 1.0f;
+ *    iter[1]; // returns 2.0f;
+ *    iter[2]; // returns 3.0f;
+ *    iter[3]; // returns 4.0f;
+ *
+ *    // iter[4] is an out-of-bounds error
+ *  }
+ *  \endcode
+ *
+ *  This next example demonstrates how to use a \p transform_iterator with the
+ *  \p thrust::reduce function to compute the sum of squares of a sequence.
+ *  We will create temporary \p transform_iterators with the
+ *  \p make_transform_iterator function in order to avoid explicitly specifying their type:
+ *
+ *  \code
+ *  #include <thrust/iterator/transform_iterator.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/reduce.h>
+ *  #include <iostream>
+ *
+ *  // note: functor inherits from unary_function
+ *  struct square : public thrust::unary_function<float,float>
+ *  {
+ *    __host__ __device__
+ *    float operator()(float x) const
+ *    {
+ *      return x * x;
+ *    }
+ *  };
+ *
+ *  int main()
+ *  {
+ *    // initialize a device array
+ *    thrust::device_vector<float> v(4);
+ *    v[0] = 1.0f;
+ *    v[1] = 2.0f;
+ *    v[2] = 3.0f;
+ *    v[3] = 4.0f;
+ *
+ *    float sum_of_squares =
+ *     thrust::reduce(thrust::make_transform_iterator(v.begin(), square()),
+ *                    thrust::make_transform_iterator(v.end(),   square()));
+ *
+ *    std::cout << "sum of squares: " << sum_of_squares << std::endl;
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  Note that in the previous two examples the transform functor (namely \c square_root
+ *  and \c square) inherits from \c thrust::unary_function.  Inheriting from
+ *  \c thrust::unary_function ensures that a functor is a valid \c AdaptableUnaryFunction
+ *  and provides all the necessary \c typedef declarations.  The \p transform_iterator
+ *  can also be applied to a \c UnaryFunction that does not inherit from
+ *  \c thrust::unary_function using an optional template argument.  The following example
+ *  illustrates how to use the third template argument to specify the \c result_type of
+ *  the function.
+ *
+ *  \code
+ *  #include <thrust/iterator/transform_iterator.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  // note: functor *does not* inherit from unary_function
+ *  struct square_root
+ *  {
+ *    __host__ __device__
+ *    float operator()(float x) const
+ *    {
+ *      return sqrtf(x);
+ *    }
+ *  };
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<float> v(4);
+ *    v[0] = 1.0f;
+ *    v[1] = 4.0f;
+ *    v[2] = 9.0f;
+ *    v[3] = 16.0f;
+ *
+ *    typedef thrust::device_vector<float>::iterator FloatIterator;
+ *
+ *    // note: float result_type is specified explicitly
+ *    thrust::transform_iterator<square_root, FloatIterator, float> iter(v.begin(), square_root());
+ *
+ *    *iter;   // returns 1.0f
+ *    iter[0]; // returns 1.0f;
+ *    iter[1]; // returns 2.0f;
+ *    iter[2]; // returns 3.0f;
+ *    iter[3]; // returns 4.0f;
+ *
+ *    // iter[4] is an out-of-bounds error
+ *  }
+ *  \endcode
+ *
+ *  \see make_transform_iterator
+ */
+template <class AdaptableUnaryFunction, class Iterator, class Reference = use_default, class Value = use_default>
+  class transform_iterator
+    : public detail::transform_iterator_base<AdaptableUnaryFunction, Iterator, Reference, Value>::type
+{
+  /*! \cond
+   */
+  public:
+    typedef typename
+    detail::transform_iterator_base<AdaptableUnaryFunction, Iterator, Reference, Value>::type
+    super_t;
+
+    friend class thrust::iterator_core_access;
+  /*! \endcond
+   */
+
+  public:
+    /*! Null constructor does nothing.
+     */
+    transform_iterator() = default;
+
+#if THRUST_CPP_DIALECT >= 2011
+    transform_iterator(transform_iterator const&) = default;
+#endif
+
+    /*! This constructor takes as arguments an \c Iterator and an \c AdaptableUnaryFunction
+     *  and copies them to a new \p transform_iterator.
+     *
+     *  \param x An \c Iterator pointing to the input to this \p transform_iterator's \c AdaptableUnaryFunction.
+     *  \param f An \c AdaptableUnaryFunction used to transform the objects pointed to by \p x.
+     */
+    __host__ __device__
+    transform_iterator(Iterator const& x, AdaptableUnaryFunction f)
+      : super_t(x), m_f(f) {
+    }
+
+    /*! This explicit constructor copies the value of a given \c Iterator and creates
+     *  this \p transform_iterator's \c AdaptableUnaryFunction using its null constructor.
+     *
+     *  \param x An \c Iterator to copy.
+     */
+    __host__ __device__
+    explicit transform_iterator(Iterator const& x)
+      : super_t(x) { }
+
+    /*! This copy constructor creates a new \p transform_iterator from another
+     *  \p transform_iterator.
+     *
+     *  \param other The \p transform_iterator to copy.
+     */
+    template<typename OtherAdaptableUnaryFunction,
+             typename OtherIterator,
+             typename OtherReference,
+             typename OtherValue>
+    __host__ __device__
+    transform_iterator(const transform_iterator<OtherAdaptableUnaryFunction, OtherIterator, OtherReference, OtherValue> &other,
+                       typename thrust::detail::enable_if_convertible<OtherIterator, Iterator>::type* = 0,
+                       typename thrust::detail::enable_if_convertible<OtherAdaptableUnaryFunction, AdaptableUnaryFunction>::type* = 0)
+      : super_t(other.base()), m_f(other.functor()) {}
+
+    /*! Copy assignment operator copies from another \p transform_iterator.
+     *  \p other The other \p transform_iterator to copy
+     *  \return <tt>*this</tt>
+     *
+     *  \note If the type of this \p transform_iterator's functor is not copy assignable
+     *        (for example, if it is a lambda) it is not an error to call this function.
+     *        In this case, however, the functor will not be modified.
+     *
+     *        In any case, this \p transform_iterator's underlying iterator will be copy assigned.
+     */
+    __host__ __device__
+    transform_iterator &operator=(const transform_iterator &other)
+    {
+      return do_assign(other,
+      // XXX gcc 4.2.1 crashes on is_copy_assignable; just assume the functor is assignable as a WAR
+#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC) && (THRUST_GCC_VERSION <= 40201)
+          thrust::detail::true_type()
+#else
+          typename thrust::detail::is_copy_assignable<AdaptableUnaryFunction>::type()
+#endif // THRUST_HOST_COMPILER
+      );
+    }
+
+    /*! This method returns a copy of this \p transform_iterator's \c AdaptableUnaryFunction.
+     *  \return A copy of this \p transform_iterator's \c AdaptableUnaryFunction.
+     */
+    __host__ __device__
+    AdaptableUnaryFunction functor() const
+      { return m_f; }
+
+    /*! \cond
+     */
+  private:
+    __host__ __device__
+    transform_iterator &do_assign(const transform_iterator &other, thrust::detail::true_type)
+    {
+      super_t::operator=(other);
+
+      // do assign to m_f
+      m_f = other.functor();
+
+      return *this;
+    }
+
+    __host__ __device__
+    transform_iterator &do_assign(const transform_iterator &other, thrust::detail::false_type)
+    {
+      super_t::operator=(other);
+
+      // don't assign to m_f
+
+      return *this;
+    }
+
+    // MSVC 2013 and 2015 incorrectly warning about returning a reference to
+    // a local/temporary here.
+    // See goo.gl/LELTNp
+    THRUST_DISABLE_MSVC_WARNING_BEGIN(4172)
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    typename super_t::reference dereference() const
+    {
+      // Create a temporary to allow iterators with wrapped references to
+      // convert to their value type before calling m_f. Note that this
+      // disallows non-constant operations through m_f.
+      typename thrust::iterator_value<Iterator>::type const& x = *this->base();
+      return m_f(x);
+    }
+
+    THRUST_DISABLE_MSVC_WARNING_END(4172)
+
+    // tag this as mutable per Dave Abrahams in this thread:
+    // http://lists.boost.org/Archives/boost/2004/05/65332.php
+    mutable AdaptableUnaryFunction m_f;
+
+    /*! \endcond
+     */
+}; // end transform_iterator
+
+
+/*! \p make_transform_iterator creates a \p transform_iterator
+ *  from an \c Iterator and \c AdaptableUnaryFunction.
+ *
+ *  \param it The \c Iterator pointing to the input range of the
+ *            newly created \p transform_iterator.
+ *  \param fun The \c AdaptableUnaryFunction used to transform the range pointed
+ *             to by \p it in the newly created \p transform_iterator.
+ *  \return A new \p transform_iterator which transforms the range at
+ *          \p it by \p fun.
+ *  \see transform_iterator
+ */
+template <class AdaptableUnaryFunction, class Iterator>
+inline __host__ __device__
+transform_iterator<AdaptableUnaryFunction, Iterator>
+make_transform_iterator(Iterator it, AdaptableUnaryFunction fun)
+{
+  return transform_iterator<AdaptableUnaryFunction, Iterator>(it, fun);
+} // end make_transform_iterator
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/transform_output_iterator.h

@@ -0,0 +1,172 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/iterator/transform_output_iterator.h
+ *  \brief An output iterator which adapts another output iterator by applying a
+ *         function to the result of its dereference before writing it.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/iterator/detail/transform_output_iterator.inl>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p transform_output_iterator is a special kind of output iterator which
+ * transforms a value written upon dereference. This iterator is useful
+ * for transforming an output from algorithms without explicitly storing the
+ * intermediate result in the memory and applying subsequent transformation,
+ * thereby avoiding wasting memory capacity and bandwidth.
+ * Using \p transform_iterator facilitates kernel fusion by deferring execution
+ * of transformation until the value is written while saving both memory
+ * capacity and bandwidth.
+ *
+ * The following code snippet demonstrated how to create a
+ * \p transform_output_iterator which applies \c sqrtf to the assigning value.
+ *
+ * \code
+ * #include <thrust/iterator/transform_output_iterator.h>
+ * #include <thrust/device_vector.h>
+ *
+ * // note: functor inherits form unary function
+ *  // note: functor inherits from unary_function
+ *  struct square_root : public thrust::unary_function<float,float>
+ *  {
+ *    __host__ __device__
+ *    float operator()(float x) const
+ *    {
+ *      return sqrtf(x);
+ *    }
+ *  };
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<float> v(4);
+ *
+ *    typedef thrust::device_vector<float>::iterator FloatIterator;
+ *    thrust::transform_output_iterator<square_root, FloatIterator> iter(v.begin(), square_root());
+ *
+ *    iter[0] =  1.0f;    // stores sqrtf( 1.0f)
+ *    iter[1] =  4.0f;    // stores sqrtf( 4.0f)
+ *    iter[2] =  9.0f;    // stores sqrtf( 9.0f)
+ *    iter[3] = 16.0f;    // stores sqrtf(16.0f)
+ *    // iter[4] is an out-of-bounds error
+ *
+ *    v[0]; // returns 1.0f;
+ *    v[1]; // returns 2.0f;
+ *    v[2]; // returns 3.0f;
+ *    v[3]; // returns 4.0f;
+ *
+ *  }
+ *  \endcode
+ *
+ *  \see make_transform_output_iterator
+ */
+
+template <typename UnaryFunction, typename OutputIterator>
+  class transform_output_iterator
+    : public detail::transform_output_iterator_base<UnaryFunction, OutputIterator>::type
+{
+
+  /*! \cond
+   */
+
+  public:
+
+    typedef typename
+    detail::transform_output_iterator_base<UnaryFunction, OutputIterator>::type
+    super_t;
+
+    friend class thrust::iterator_core_access;
+  /*! \endcond
+   */
+
+  transform_output_iterator() = default;
+
+  /*! This constructor takes as argument an \c OutputIterator and an \c
+   * UnaryFunction and copies them to a new \p transform_output_iterator
+   *
+   * \param out An \c OutputIterator pointing to the output range whereto the result of
+   *            \p transform_output_iterator's \c UnaryFunction will be written.
+   * \param fun An \c UnaryFunction used to transform the objects assigned to
+   *            this \p transform_output_iterator.
+   */
+    __host__ __device__
+    transform_output_iterator(OutputIterator const& out, UnaryFunction fun) : super_t(out), fun(fun)
+    {
+    }
+
+    /*! \cond
+     */
+  private:
+
+    __host__ __device__
+    typename super_t::reference dereference() const
+    {
+      return detail::transform_output_iterator_proxy<
+        UnaryFunction, OutputIterator
+      >(this->base_reference(), fun);
+    }
+
+    UnaryFunction fun;
+
+    /*! \endcond
+     */
+}; // end transform_output_iterator
+
+/*! \p make_transform_output_iterator creates a \p transform_output_iterator from
+ *  an \c OutputIterator and \c UnaryFunction.
+ *
+ *  \param out The \c OutputIterator pointing to the output range of the newly
+ *            created \p transform_output_iterator
+ *  \param fun The \c UnaryFunction transform the object before assigning it to
+ *            \c out by the newly created \p transform_output_iterator
+ *  \see transform_output_iterator
+ */
+template <typename UnaryFunction, typename OutputIterator>
+transform_output_iterator<UnaryFunction, OutputIterator>
+__host__ __device__
+make_transform_output_iterator(OutputIterator out, UnaryFunction fun)
+{
+    return transform_output_iterator<UnaryFunction, OutputIterator>(out, fun);
+} // end make_transform_output_iterator
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/zip_iterator.h

@@ -0,0 +1,266 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/zip_iterator.h
+ *  \brief An iterator which returns a tuple of the result of dereferencing
+ *         a tuple of iterators when dereferenced
+ */
+
+/*
+ * Copyright David Abrahams and Thomas Becker 2000-2006.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/iterator/detail/zip_iterator_base.h>
+#include <thrust/iterator/iterator_facade.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p zip_iterator is an iterator which represents a pointer into a range
+ *  of \p tuples whose elements are themselves taken from a \p tuple of input
+ *  iterators. This iterator is useful for creating a virtual array of structures
+ *  while achieving the same performance and bandwidth as the structure of arrays
+ *  idiom. \p zip_iterator also facilitates kernel fusion by providing a convenient
+ *  means of amortizing the execution of the same operation over multiple ranges.
+ *
+ *  The following code snippet demonstrates how to create a \p zip_iterator
+ *  which represents the result of "zipping" multiple ranges together.
+ *
+ *  \code
+ *  #include <thrust/iterator/zip_iterator.h>
+ *  #include <thrust/tuple.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> int_v(3);
+ *  int_v[0] = 0; int_v[1] = 1; int_v[2] = 2;
+ *
+ *  thrust::device_vector<float> float_v(3);
+ *  float_v[0] = 0.0f; float_v[1] = 1.0f; float_v[2] = 2.0f;
+ *
+ *  thrust::device_vector<char> char_v(3);
+ *  char_v[0] = 'a'; char_v[1] = 'b'; char_v[2] = 'c';
+ *
+ *  // typedef these iterators for shorthand
+ *  typedef thrust::device_vector<int>::iterator   IntIterator;
+ *  typedef thrust::device_vector<float>::iterator FloatIterator;
+ *  typedef thrust::device_vector<char>::iterator  CharIterator;
+ *
+ *  // typedef a tuple of these iterators
+ *  typedef thrust::tuple<IntIterator, FloatIterator, CharIterator> IteratorTuple;
+ *
+ *  // typedef the zip_iterator of this tuple
+ *  typedef thrust::zip_iterator<IteratorTuple> ZipIterator;
+ *
+ *  // finally, create the zip_iterator
+ *  ZipIterator iter(thrust::make_tuple(int_v.begin(), float_v.begin(), char_v.begin()));
+ *
+ *  *iter;   // returns (0, 0.0f, 'a')
+ *  iter[0]; // returns (0, 0.0f, 'a')
+ *  iter[1]; // returns (1, 1.0f, 'b')
+ *  iter[2]; // returns (2, 2.0f, 'c')
+ *
+ *  thrust::get<0>(iter[2]); // returns 2
+ *  thrust::get<1>(iter[0]); // returns 0.0f
+ *  thrust::get<2>(iter[1]); // returns 'b'
+ *
+ *  // iter[3] is an out-of-bounds error
+ *  \endcode
+ *
+ *  Defining the type of a \p zip_iterator can be complex. The next code example demonstrates
+ *  how to use the \p make_zip_iterator function with the \p make_tuple function to avoid
+ *  explicitly specifying the type of the \p zip_iterator. This example shows how to use
+ *  \p zip_iterator to copy multiple ranges with a single call to \p thrust::copy.
+ *
+ *  \code
+ *  #include <thrust/zip_iterator.h>
+ *  #include <thrust/tuple.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<int> int_in(3), int_out(3);
+ *    int_in[0] = 0;
+ *    int_in[1] = 1;
+ *    int_in[2] = 2;
+ *
+ *    thrust::device_vector<float> float_in(3), float_out(3);
+ *    float_in[0] =  0.0f;
+ *    float_in[1] = 10.0f;
+ *    float_in[2] = 20.0f;
+ *
+ *    thrust::copy(thrust::make_zip_iterator(thrust::make_tuple(int_in.begin(), float_in.begin())),
+ *                 thrust::make_zip_iterator(thrust::make_tuple(int_in.end(),   float_in.end())),
+ *                 thrust::make_zip_iterator(thrust::make_tuple(int_out.begin(),float_out.begin())));
+ *
+ *    // int_out is now [0, 1, 2]
+ *    // float_out is now [0.0f, 10.0f, 20.0f]
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see make_zip_iterator
+ *  \see make_tuple
+ *  \see tuple
+ *  \see get
+ */
+template <typename IteratorTuple>
+  class zip_iterator
+    : public detail::zip_iterator_base<IteratorTuple>::type
+{
+  public:
+    /*! Null constructor does nothing.
+     */
+    inline __host__ __device__
+    zip_iterator();
+
+    /*! This constructor creates a new \p zip_iterator from a
+     *  \p tuple of iterators.
+     *
+     *  \param iterator_tuple The \p tuple of iterators to copy from.
+     */
+    inline __host__ __device__
+    zip_iterator(IteratorTuple iterator_tuple);
+
+    /*! This copy constructor creates a new \p zip_iterator from another
+     *  \p zip_iterator.
+     *
+     *  \param other The \p zip_iterator to copy.
+     */
+    template<typename OtherIteratorTuple>
+    inline __host__ __device__
+    zip_iterator(const zip_iterator<OtherIteratorTuple> &other,
+                 typename thrust::detail::enable_if_convertible<
+                   OtherIteratorTuple,
+                   IteratorTuple
+                 >::type * = 0);
+
+    /*! This method returns a \c const reference to this \p zip_iterator's
+     *  \p tuple of iterators.
+     *
+     *  \return A \c const reference to this \p zip_iterator's \p tuple
+     *          of iterators.
+     */
+    inline __host__ __device__
+    const IteratorTuple &get_iterator_tuple() const;
+
+    /*! \cond
+     */
+  private:
+    typedef typename
+    detail::zip_iterator_base<IteratorTuple>::type super_t;
+
+    friend class thrust::iterator_core_access;
+
+    // Dereferencing returns a tuple built from the dereferenced
+    // iterators in the iterator tuple.
+    __host__ __device__
+    typename super_t::reference dereference() const;
+
+    // Two zip_iterators are equal if the two first iterators of the
+    // tuple are equal. Note this differs from Boost's implementation, which
+    // considers the entire tuple.
+    template<typename OtherIteratorTuple>
+    inline __host__ __device__
+    bool equal(const zip_iterator<OtherIteratorTuple> &other) const;
+
+    // Advancing a zip_iterator means to advance all iterators in the tuple
+    inline __host__ __device__
+    void advance(typename super_t::difference_type n);
+
+    // Incrementing a zip iterator means to increment all iterators in the tuple
+    inline __host__ __device__
+    void increment();
+
+    // Decrementing a zip iterator means to decrement all iterators in the tuple
+    inline __host__ __device__
+    void decrement();
+
+    // Distance is calculated using the first iterator in the tuple.
+    template<typename OtherIteratorTuple>
+    inline __host__ __device__
+      typename super_t::difference_type
+        distance_to(const zip_iterator<OtherIteratorTuple> &other) const;
+
+    // The iterator tuple.
+    IteratorTuple m_iterator_tuple;
+
+    /*! \endcond
+     */
+}; // end zip_iterator
+
+/*! \p make_zip_iterator creates a \p zip_iterator from a \p tuple
+ *  of iterators.
+ *
+ *  \param t The \p tuple of iterators to copy.
+ *  \return A newly created \p zip_iterator which zips the iterators encapsulated in \p t.
+ *
+ *  \see zip_iterator
+ */
+template<typename... Iterators>
+inline __host__ __device__
+zip_iterator<thrust::tuple<Iterators...>> make_zip_iterator(thrust::tuple<Iterators...> t);
+
+
+/*! \p make_zip_iterator creates a \p zip_iterator from
+ *  iterators.
+ *
+ *  \param its The iterators to copy.
+ *  \return A newly created \p zip_iterator which zips the iterators.
+ *
+ *  \see zip_iterator
+ */
+template<typename... Iterators>
+inline __host__ __device__
+zip_iterator<thrust::tuple<Iterators...>> make_zip_iterator(Iterators... its);
+
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/iterator/detail/zip_iterator.inl>
+

miniCUDA124/include/thrust/mr/allocator.h

@@ -0,0 +1,262 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief Allocator types usable with \ref Memory Resources.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <limits>
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/config/memory_resource.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+
+#include <thrust/mr/validator.h>
+#include <thrust/mr/polymorphic_adaptor.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/*! \addtogroup allocators Allocators
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! An \p mr::allocator is a template that fulfills the C++ requirements for Allocators,
+ *  allowing to use the NPA-based memory resources where an Allocator is required. Unlike
+ *  memory resources, but like other allocators, \p mr::allocator is typed and bound to
+ *  allocate object of a specific type, however it can be freely rebound to other types.
+ *
+ *  \tparam T the type that will be allocated by this allocator.
+ *  \tparam MR the upstream memory resource to use for memory allocation. Must derive from
+ *      \p thrust::mr::memory_resource and must be \p final (in C++11 and beyond).
+ */
+template<typename T, class MR>
+class allocator : private validator<MR>
+{
+public:
+    /*! The pointer to void type of this allocator. */
+    typedef typename MR::pointer void_pointer;
+
+    /*! The value type allocated by this allocator. Equivalent to \p T. */
+    typedef T value_type;
+    /*! The pointer type allocated by this allocator. Equivaled to the pointer type of \p MR rebound to \p T. */
+    typedef typename thrust::detail::pointer_traits<void_pointer>::template rebind<T>::other pointer;
+    /*! The pointer to const type. Equivalent to a pointer type of \p MR rebound to <tt>const T</tt>. */
+    typedef typename thrust::detail::pointer_traits<void_pointer>::template rebind<const T>::other const_pointer;
+    /*! The reference to the type allocated by this allocator. Supports smart references. */
+    typedef typename thrust::detail::pointer_traits<pointer>::reference reference;
+    /*! The const reference to the type allocated by this allocator. Supports smart references. */
+    typedef typename thrust::detail::pointer_traits<const_pointer>::reference const_reference;
+    /*! The size type of this allocator. Always \p std::size_t. */
+    typedef std::size_t size_type;
+    /*! The difference type between pointers allocated by this allocator. */
+    typedef typename thrust::detail::pointer_traits<pointer>::difference_type difference_type;
+
+    /*! Specifies that the allocator shall be propagated on container copy assignment. */
+    typedef detail::true_type propagate_on_container_copy_assignment;
+    /*! Specifies that the allocator shall be propagated on container move assignment. */
+    typedef detail::true_type propagate_on_container_move_assignment;
+    /*! Specifies that the allocator shall be propagated on container swap. */
+    typedef detail::true_type propagate_on_container_swap;
+
+    /*! The \p rebind metafunction provides the type of an \p allocator instantiated with another type.
+     *
+     *  \tparam U the other type to use for instantiation.
+     */
+    template<typename U>
+    struct rebind
+    {
+        /*! The typedef \p other gives the type of the rebound \p allocator.
+         */
+        typedef allocator<U, MR> other;
+    };
+
+    /*! Calculates the maximum number of elements allocated by this allocator.
+     *
+     *  \return the maximum value of \p std::size_t, divided by the size of \p T.
+     */
+    __thrust_exec_check_disable__
+    __host__ __device__
+    size_type max_size() const
+    {
+        return (std::numeric_limits<size_type>::max)() / sizeof(T);
+    }
+
+    /*! Constructor.
+     *
+     *  \param resource the resource to be used to allocate raw memory.
+     */
+    __host__ __device__
+    allocator(MR * resource) : mem_res(resource)
+    {
+    }
+
+    /*! Copy constructor. Copies the resource pointer. */
+    template<typename U>
+    __host__ __device__
+    allocator(const allocator<U, MR> & other) : mem_res(other.resource())
+    {
+    }
+
+    /*! Allocates objects of type \p T.
+     *
+     *  \param n number of elements to allocate
+     *  \return a pointer to the newly allocated storage.
+     */
+    THRUST_NODISCARD
+    __host__
+    pointer allocate(size_type n)
+    {
+        return static_cast<pointer>(mem_res->do_allocate(n * sizeof(T), THRUST_ALIGNOF(T)));
+    }
+
+    /*! Deallocates objects of type \p T.
+     *
+     *  \param p pointer returned by a previous call to \p allocate
+     *  \param n number of elements, passed as an argument to the \p allocate call that produced \p p
+     */
+    __host__
+    void deallocate(pointer p, size_type n)
+    {
+        return mem_res->do_deallocate(p, n * sizeof(T), THRUST_ALIGNOF(T));
+    }
+
+    /*! Extracts the memory resource used by this allocator.
+     *
+     *  \return the memory resource used by this allocator.
+     */
+    __host__ __device__
+    MR * resource() const
+    {
+        return mem_res;
+    }
+
+private:
+    MR * mem_res;
+};
+
+/*! Compares the allocators for equality by comparing the underlying memory resources. */
+template<typename T, typename MR>
+__host__ __device__
+bool operator==(const allocator<T, MR> & lhs, const allocator<T, MR> & rhs) noexcept
+{
+    return *lhs.resource() == *rhs.resource();
+}
+
+/*! Compares the allocators for inequality by comparing the underlying memory resources. */
+template<typename T, typename MR>
+__host__ __device__
+bool operator!=(const allocator<T, MR> & lhs, const allocator<T, MR> & rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+#if THRUST_CPP_DIALECT >= 2011
+
+template<typename T, typename Pointer>
+using polymorphic_allocator = allocator<T, polymorphic_adaptor_resource<Pointer> >;
+
+#else // C++11
+
+template<typename T, typename Pointer>
+class polymorphic_allocator : public allocator<T, polymorphic_adaptor_resource<Pointer> >
+{
+    typedef allocator<T, polymorphic_adaptor_resource<Pointer> > base;
+
+public:
+    /*! Initializes the base class with the parameter \p resource.
+     */
+    polymorphic_allocator(polymorphic_adaptor_resource<Pointer>  * resource) : base(resource)
+    {
+    }
+};
+
+#endif // C++11
+
+/*! A helper allocator class that uses global instances of a given upstream memory resource. Requires the memory resource
+ *      to be default constructible.
+ *
+ *  \tparam T the type that will be allocated by this allocator.
+ *  \tparam Upstream the upstream memory resource to use for memory allocation. Must derive from
+ *      \p thrust::mr::memory_resource and must be \p final (in C++11 and beyond).
+ */
+template<typename T, typename Upstream>
+class stateless_resource_allocator : public thrust::mr::allocator<T, Upstream>
+{
+    typedef thrust::mr::allocator<T, Upstream> base;
+
+public:
+    /*! The \p rebind metafunction provides the type of an \p stateless_resource_allocator instantiated with another type.
+     *
+     *  \tparam U the other type to use for instantiation.
+     */
+    template<typename U>
+    struct rebind
+    {
+        /*! The typedef \p other gives the type of the rebound \p stateless_resource_allocator.
+         */
+        typedef stateless_resource_allocator<U, Upstream> other;
+    };
+
+    /*! Default constructor. Uses \p get_global_resource to get the global instance of \p Upstream and initializes the
+     *      \p allocator base subobject with that resource.
+     */
+    __thrust_exec_check_disable__
+    __host__ __device__
+    stateless_resource_allocator() : base(get_global_resource<Upstream>())
+    {
+    }
+
+    /*! Copy constructor. Copies the memory resource pointer. */
+    __host__ __device__
+    stateless_resource_allocator(const stateless_resource_allocator & other)
+        : base(other) {}
+
+    /*! Conversion constructor from an allocator of a different type. Copies the memory resource pointer. */
+    template<typename U>
+    __host__ __device__
+    stateless_resource_allocator(const stateless_resource_allocator<U, Upstream> & other)
+        : base(other) {}
+
+#if THRUST_CPP_DIALECT >= 2011
+    stateless_resource_allocator & operator=(const stateless_resource_allocator &) = default;
+#endif
+
+    /*! Destructor. */
+    __host__ __device__
+    ~stateless_resource_allocator() {}
+};
+
+/*! \} // allocators
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/mr/device_memory_resource.h

@@ -0,0 +1,46 @@
+/*
+ *  Copyright 2018-2020 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// #include the device system's memory_resource header
+#define __THRUST_DEVICE_SYSTEM_MEMORY_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/memory_resource.h>
+#include __THRUST_DEVICE_SYSTEM_MEMORY_HEADER
+#undef __THRUST_DEVICE_SYSTEM_MEMORY_HEADER
+
+THRUST_NAMESPACE_BEGIN
+
+
+typedef thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::memory_resource
+    device_memory_resource;
+typedef thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::universal_memory_resource
+    universal_memory_resource;
+typedef thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::universal_host_pinned_memory_resource
+    universal_host_pinned_memory_resource;
+
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/mr/disjoint_pool.h

@@ -0,0 +1,499 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief A caching and pooling memory resource adaptor which uses separate upstream resources for memory allocation
+ *      and bookkeeping.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/detail/algorithm_wrapper.h>
+#include <thrust/detail/config.h>
+
+#include <thrust/host_vector.h>
+#include <thrust/binary_search.h>
+#include <thrust/detail/seq.h>
+
+#include <thrust/mr/memory_resource.h>
+#include <thrust/mr/allocator.h>
+#include <thrust/mr/pool_options.h>
+
+#include <cassert>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/** \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! A memory resource adaptor allowing for pooling and caching allocations from \p Upstream, using \p Bookkeeper for
+ *      management of that cached and pooled memory, allowing to cache portions of memory inaccessible from the host.
+ *
+ *  On a typical memory resource, calls to \p allocate and \p deallocate actually allocate and deallocate memory. Pooling
+ *      memory resources only allocate and deallocate memory from an external resource (the upstream memory resource) when
+ *      there's no suitable memory currently cached; otherwise, they use memory they have acquired beforehand, to make
+ *      memory allocation faster and more efficient.
+ *
+ *  The disjoint version of the pool resources uses a separate upstream memory resource, \p Bookkeeper, to allocate memory
+ *      necessary to manage the cached memory. There may be many reasons to do that; the canonical one is that \p Upstream
+ *      allocates memory that is inaccessible to the code of the pool resource, which means that it cannot embed the necessary
+ *      information in memory obtained from \p Upstream; for instance, \p Upstream can be a CUDA non-managed memory
+ *      resource, or a CUDA managed memory resource whose memory we would prefer to not migrate back and forth between
+ *      host and device when executing bookkeeping code.
+ *
+ *  This is not the only case where it makes sense to use a disjoint pool resource, though. In a multi-core environment
+ *      it may be beneficial to avoid stealing cache lines from other cores by writing over bookkeeping information
+ *      embedded in an allocated block of memory. In such a case, one can imagine wanting to use a disjoint pool where
+ *      both the upstream and the bookkeeper are of the same type, to allocate memory consistently, but separately for
+ *      those two purposes.
+ *
+ *  \tparam Upstream the type of memory resources that will be used for allocating memory blocks to be handed off to the user
+ *  \tparam Bookkeeper the type of memory resources that will be used for allocating bookkeeping memory
+ */
+template<typename Upstream, typename Bookkeeper>
+class disjoint_unsynchronized_pool_resource final
+    : public memory_resource<typename Upstream::pointer>,
+        private validator2<Upstream, Bookkeeper>
+{
+public:
+    /*! Get the default options for a disjoint pool. These are meant to be a sensible set of values for many use cases,
+     *      and as such, may be tuned in the future. This function is exposed so that creating a set of options that are
+     *      just a slight departure from the defaults is easy.
+     */
+    static pool_options get_default_options()
+    {
+        pool_options ret;
+
+        ret.min_blocks_per_chunk = 16;
+        ret.min_bytes_per_chunk = 1024;
+        ret.max_blocks_per_chunk = static_cast<std::size_t>(1) << 20;
+        ret.max_bytes_per_chunk = static_cast<std::size_t>(1) << 30;
+
+        ret.smallest_block_size = THRUST_MR_DEFAULT_ALIGNMENT;
+        ret.largest_block_size = static_cast<std::size_t>(1) << 20;
+
+        ret.alignment = THRUST_MR_DEFAULT_ALIGNMENT;
+
+        ret.cache_oversized = true;
+
+        ret.cached_size_cutoff_factor = 16;
+        ret.cached_alignment_cutoff_factor = 16;
+
+        return ret;
+    }
+
+    /*! Constructor.
+     *
+     *  \param upstream the upstream memory resource for allocations
+     *  \param bookkeeper the upstream memory resource for bookkeeping
+     *  \param options pool options to use
+     */
+    disjoint_unsynchronized_pool_resource(Upstream * upstream, Bookkeeper * bookkeeper,
+        pool_options options = get_default_options())
+        : m_upstream(upstream),
+        m_bookkeeper(bookkeeper),
+        m_options(options),
+        m_smallest_block_log2(detail::log2_ri(m_options.smallest_block_size)),
+        m_pools(m_bookkeeper),
+        m_allocated(m_bookkeeper),
+        m_cached_oversized(m_bookkeeper),
+        m_oversized(m_bookkeeper)
+    {
+        assert(m_options.validate());
+
+        pointer_vector free(m_bookkeeper);
+        pool p(free);
+        m_pools.resize(detail::log2_ri(m_options.largest_block_size) - m_smallest_block_log2 + 1, p);
+    }
+
+    // TODO: C++11: use delegating constructors
+
+    /*! Constructor. Upstream and bookkeeping resources are obtained by calling \p get_global_resource for their types.
+     *
+     *  \param options pool options to use
+     */
+    disjoint_unsynchronized_pool_resource(pool_options options = get_default_options())
+        : m_upstream(get_global_resource<Upstream>()),
+        m_bookkeeper(get_global_resource<Bookkeeper>()),
+        m_options(options),
+        m_smallest_block_log2(detail::log2_ri(m_options.smallest_block_size)),
+        m_pools(m_bookkeeper),
+        m_allocated(m_bookkeeper),
+        m_cached_oversized(m_bookkeeper),
+        m_oversized(m_bookkeeper)
+    {
+        assert(m_options.validate());
+
+        pointer_vector free(m_bookkeeper);
+        pool p(free);
+        m_pools.resize(detail::log2_ri(m_options.largest_block_size) - m_smallest_block_log2 + 1, p);
+    }
+
+    /*! Destructor. Releases all held memory to upstream.
+     */
+    ~disjoint_unsynchronized_pool_resource()
+    {
+        release();
+    }
+
+private:
+    typedef typename Upstream::pointer void_ptr;
+    typedef typename thrust::detail::pointer_traits<void_ptr>::template rebind<char>::other char_ptr;
+
+    struct chunk_descriptor
+    {
+        std::size_t size;
+        void_ptr pointer;
+    };
+
+    typedef thrust::host_vector<
+        chunk_descriptor,
+        allocator<chunk_descriptor, Bookkeeper>
+    > chunk_vector;
+
+    struct oversized_block_descriptor
+    {
+        std::size_t size;
+        std::size_t alignment;
+        void_ptr pointer;
+
+        __host__ __device__
+        bool operator==(const oversized_block_descriptor & other) const
+        {
+            return size == other.size && alignment == other.alignment && pointer == other.pointer;
+        }
+
+        __host__ __device__
+        bool operator<(const oversized_block_descriptor & other) const
+        {
+            return size < other.size || (size == other.size && alignment < other.alignment);
+        }
+    };
+
+    struct equal_pointers
+    {
+    public:
+        __host__ __device__
+        equal_pointers(void_ptr p) : p(p)
+        {
+        }
+
+        __host__ __device__
+        bool operator()(const oversized_block_descriptor & desc) const
+        {
+            return desc.pointer == p;
+        }
+
+    private:
+        void_ptr p;
+    };
+
+    struct matching_alignment
+    {
+    public:
+        __host__ __device__
+        matching_alignment(std::size_t requested) : requested(requested)
+        {
+        }
+
+        __host__ __device__
+        bool operator()(const oversized_block_descriptor & desc) const
+        {
+            return desc.alignment >= requested;
+        }
+
+    private:
+        std::size_t requested;
+    };
+
+    typedef thrust::host_vector<
+        oversized_block_descriptor,
+        allocator<oversized_block_descriptor, Bookkeeper>
+    > oversized_block_vector;
+
+    typedef thrust::host_vector<
+        void_ptr,
+        allocator<void_ptr, Bookkeeper>
+    > pointer_vector;
+
+    struct pool
+    {
+        __host__
+        pool(const pointer_vector & free)
+            : free_blocks(free),
+            previous_allocated_count(0)
+        {
+        }
+
+        __host__
+        pool(const pool & other)
+            : free_blocks(other.free_blocks),
+            previous_allocated_count(other.previous_allocated_count)
+        {
+        }
+
+#if THRUST_CPP_DIALECT >= 2011
+        pool & operator=(const pool &) = default;
+#endif
+
+        __host__
+        ~pool() {}
+
+        pointer_vector free_blocks;
+        std::size_t previous_allocated_count;
+    };
+
+    typedef thrust::host_vector<
+        pool,
+        allocator<pool, Bookkeeper>
+    > pool_vector;
+
+    Upstream * m_upstream;
+    Bookkeeper * m_bookkeeper;
+
+    pool_options m_options;
+    std::size_t m_smallest_block_log2;
+
+    // buckets containing free lists for each pooled size
+    pool_vector m_pools;
+    // list of all allocations from upstream for the above
+    chunk_vector m_allocated;
+    // list of all cached oversized/overaligned blocks that have been returned to the pool to cache
+    oversized_block_vector m_cached_oversized;
+    // list of all oversized/overaligned allocations from upstream
+    oversized_block_vector m_oversized;
+
+public:
+    /*! Releases all held memory to upstream.
+     */
+    void release()
+    {
+        // reset the buckets
+        for (std::size_t i = 0; i < m_pools.size(); ++i)
+        {
+            m_pools[i].free_blocks.clear();
+            m_pools[i].previous_allocated_count = 0;
+        }
+
+        // deallocate memory allocated for the buckets
+        for (std::size_t i = 0; i < m_allocated.size(); ++i)
+        {
+            m_upstream->do_deallocate(
+                m_allocated[i].pointer,
+                m_allocated[i].size,
+                m_options.alignment);
+        }
+
+        // deallocate cached oversized/overaligned memory
+        for (std::size_t i = 0; i < m_oversized.size(); ++i)
+        {
+            m_upstream->do_deallocate(
+                m_oversized[i].pointer,
+                m_oversized[i].size,
+                m_oversized[i].alignment);
+        }
+
+        m_allocated.clear();
+        m_oversized.clear();
+        m_cached_oversized.clear();
+    }
+
+    THRUST_NODISCARD virtual void_ptr do_allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        bytes = (std::max)(bytes, m_options.smallest_block_size);
+        assert(detail::is_power_of_2(alignment));
+
+        // an oversized and/or overaligned allocation requested; needs to be allocated separately
+        if (bytes > m_options.largest_block_size || alignment > m_options.alignment)
+        {
+            oversized_block_descriptor oversized;
+            oversized.size = bytes;
+            oversized.alignment = alignment;
+
+            if (m_options.cache_oversized && !m_cached_oversized.empty())
+            {
+                typename oversized_block_vector::iterator it = thrust::lower_bound(
+                    thrust::seq,
+                    m_cached_oversized.begin(),
+                    m_cached_oversized.end(),
+                    oversized);
+
+                // if the size is bigger than the requested size by a factor
+                // bigger than or equal to the specified cutoff for size,
+                // allocate a new block
+                if (it != m_cached_oversized.end())
+                {
+                    std::size_t size_factor = (*it).size / bytes;
+                    if (size_factor >= m_options.cached_size_cutoff_factor)
+                    {
+                        it = m_cached_oversized.end();
+                    }
+                }
+
+                if (it != m_cached_oversized.end() && (*it).alignment < alignment)
+                {
+                    it = find_if(it + 1, m_cached_oversized.end(), matching_alignment(alignment));
+                }
+
+                // if the alignment is bigger than the requested one by a factor
+                // bigger than or equal to the specified cutoff for alignment,
+                // allocate a new block
+                if (it != m_cached_oversized.end())
+                {
+                    std::size_t alignment_factor = (*it).alignment / alignment;
+                    if (alignment_factor >= m_options.cached_alignment_cutoff_factor)
+                    {
+                        it = m_cached_oversized.end();
+                    }
+                }
+
+                if (it != m_cached_oversized.end())
+                {
+                    oversized.pointer = (*it).pointer;
+                    m_cached_oversized.erase(it);
+                    return oversized.pointer;
+                }
+            }
+
+            // no fitting cached block found; allocate a new one that's just up to the specs
+            oversized.pointer = m_upstream->do_allocate(bytes, alignment);
+            m_oversized.push_back(oversized);
+
+            return oversized.pointer;
+        }
+
+        // the request is NOT for oversized and/or overaligned memory
+        // allocate a block from an appropriate bucket
+        std::size_t bytes_log2 = thrust::detail::log2_ri(bytes);
+        std::size_t bucket_idx = bytes_log2 - m_smallest_block_log2;
+        pool & bucket = m_pools[bucket_idx];
+
+        // if the free list of the bucket has no elements, allocate a new chunk
+        // and split it into blocks pushed to the free list
+        if (bucket.free_blocks.empty())
+        {
+            std::size_t bucket_size = static_cast<std::size_t>(1) << bytes_log2;
+
+            std::size_t n = bucket.previous_allocated_count;
+            if (n == 0)
+            {
+                n = m_options.min_blocks_per_chunk;
+                if (n < (m_options.min_bytes_per_chunk >> bytes_log2))
+                {
+                    n = m_options.min_bytes_per_chunk >> bytes_log2;
+                }
+            }
+            else
+            {
+                n = n * 3 / 2;
+                if (n > (m_options.max_bytes_per_chunk >> bytes_log2))
+                {
+                    n = m_options.max_bytes_per_chunk >> bytes_log2;
+                }
+                if (n > m_options.max_blocks_per_chunk)
+                {
+                    n = m_options.max_blocks_per_chunk;
+                }
+            }
+
+            bytes = n << bytes_log2;
+
+            assert(n >= m_options.min_blocks_per_chunk);
+            assert(n <= m_options.max_blocks_per_chunk);
+            assert(bytes >= m_options.min_bytes_per_chunk);
+            assert(bytes <= m_options.max_bytes_per_chunk);
+
+            chunk_descriptor allocated;
+            allocated.size = bytes;
+            allocated.pointer = m_upstream->do_allocate(bytes, m_options.alignment);
+            m_allocated.push_back(allocated);
+            bucket.previous_allocated_count = n;
+
+            for (std::size_t i = 0; i < n; ++i)
+            {
+                bucket.free_blocks.push_back(
+                    static_cast<void_ptr>(
+                        static_cast<char_ptr>(allocated.pointer) + i * bucket_size
+                    )
+                );
+            }
+        }
+
+        // allocate a block from the front of the bucket's free list
+        void_ptr ret = bucket.free_blocks.back();
+        bucket.free_blocks.pop_back();
+        return ret;
+    }
+
+    virtual void do_deallocate(void_ptr p, std::size_t n, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        n = (std::max)(n, m_options.smallest_block_size);
+        assert(detail::is_power_of_2(alignment));
+
+        // verify that the pointer is at least as aligned as claimed
+        assert(reinterpret_cast<detail::intmax_t>(detail::pointer_traits<void_ptr>::get(p)) % alignment == 0);
+
+        // the deallocated block is oversized and/or overaligned
+        if (n > m_options.largest_block_size || alignment > m_options.alignment)
+        {
+            typename oversized_block_vector::iterator it = find_if(m_oversized.begin(), m_oversized.end(), equal_pointers(p));
+            assert(it != m_oversized.end());
+
+            oversized_block_descriptor oversized = *it;
+
+            if (m_options.cache_oversized)
+            {
+                typename oversized_block_vector::iterator position = lower_bound(m_cached_oversized.begin(), m_cached_oversized.end(), oversized);
+                m_cached_oversized.insert(position, oversized);
+                return;
+            }
+
+            m_oversized.erase(it);
+
+            m_upstream->do_deallocate(p, oversized.size, oversized.alignment);
+
+            return;
+        }
+
+        // push the block to the front of the appropriate bucket's free list
+        std::size_t n_log2 = thrust::detail::log2_ri(n);
+        std::size_t bucket_idx = n_log2 - m_smallest_block_log2;
+        pool & bucket = m_pools[bucket_idx];
+
+        bucket.free_blocks.push_back(p);
+    }
+};
+
+/*! \} // memory_resource
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/mr/disjoint_sync_pool.h

@@ -0,0 +1,125 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief A mutex-synchronized version of \p disjoint_unsynchronized_pool_resource.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <mutex>
+
+#include <thrust/mr/disjoint_pool.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/*! \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! A mutex-synchronized version of \p disjoint_unsynchronized_pool_resource. Uses \p std::mutex, and therefore requires C++11.
+ *
+ *  \tparam Upstream the type of memory resources that will be used for allocating memory blocks to be handed off to the user
+ *  \tparam Bookkeeper the type of memory resources that will be used for allocating bookkeeping memory
+ */
+template<typename Upstream, typename Bookkeeper>
+struct disjoint_synchronized_pool_resource : public memory_resource<typename Upstream::pointer>
+{
+    typedef disjoint_unsynchronized_pool_resource<Upstream, Bookkeeper> unsync_pool;
+    typedef std::lock_guard<std::mutex> lock_t;
+
+    typedef typename Upstream::pointer void_ptr;
+
+public:
+    /*! Get the default options for a disjoint pool. These are meant to be a sensible set of values for many use cases,
+     *      and as such, may be tuned in the future. This function is exposed so that creating a set of options that are
+     *      just a slight departure from the defaults is easy.
+     */
+    static pool_options get_default_options()
+    {
+        return unsync_pool::get_default_options();
+    }
+
+    /*! Constructor.
+     *
+     *  \param upstream the upstream memory resource for allocations
+     *  \param bookkeeper the upstream memory resource for bookkeeping
+     *  \param options pool options to use
+     */
+    disjoint_synchronized_pool_resource(Upstream * upstream, Bookkeeper * bookkeeper,
+        pool_options options = get_default_options())
+        : upstream_pool(upstream, bookkeeper, options)
+    {
+    }
+
+    /*! Constructor. Upstream and bookkeeping resources are obtained by calling \p get_global_resource for their types.
+     *
+     *  \param options pool options to use
+     */
+    disjoint_synchronized_pool_resource(pool_options options = get_default_options())
+        : upstream_pool(get_global_resource<Upstream>(), get_global_resource<Bookkeeper>(), options)
+    {
+    }
+
+    /*! Releases all held memory to upstream.
+     */
+    void release()
+    {
+        lock_t lock(mtx);
+        upstream_pool.release();
+    }
+
+    THRUST_NODISCARD virtual void_ptr do_allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        lock_t lock(mtx);
+        return upstream_pool.do_allocate(bytes, alignment);
+    }
+
+    virtual void do_deallocate(void_ptr p, std::size_t n, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        lock_t lock(mtx);
+        upstream_pool.do_deallocate(p, n, alignment);
+    }
+
+private:
+    std::mutex mtx;
+    unsync_pool upstream_pool;
+};
+
+/*! \} // memory_resources
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
+

miniCUDA124/include/thrust/mr/disjoint_tls_pool.h

@@ -0,0 +1,77 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file disjoint_tls_pool.h
+ *  \brief A function wrapping a thread local instance of a \p disjoint_unsynchronized_pool_resource.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/mr/disjoint_pool.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/*! \addtogroup memory_management Memory Management
+ *  \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_resources
+ *  \{
+ */
+
+/*! Potentially constructs, if not yet created, and then returns the address of a thread-local
+ *      \p disjoint_unsynchronized_pool_resource,
+ *
+ *  \tparam Upstream the first template argument to the pool template
+ *  \tparam Bookkeeper the second template argument to the pool template
+ *  \param upstream the first argument to the constructor, if invoked
+ *  \param bookkeeper the second argument to the constructor, if invoked
+ */
+template<typename Upstream, typename Bookkeeper>
+__host__
+thrust::mr::disjoint_unsynchronized_pool_resource<Upstream, Bookkeeper> & tls_disjoint_pool(
+    Upstream * upstream = NULL,
+    Bookkeeper * bookkeeper = NULL)
+{
+    static thread_local auto adaptor = [&]{
+        assert(upstream && bookkeeper);
+        return thrust::mr::disjoint_unsynchronized_pool_resource<Upstream, Bookkeeper>(upstream, bookkeeper);
+    }();
+
+    return adaptor;
+}
+
+/*! \}
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
+

miniCUDA124/include/thrust/mr/fancy_pointer_resource.h

@@ -0,0 +1,69 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+#include <thrust/detail/type_traits/pointer_traits.h>
+
+#include <thrust/mr/memory_resource.h>
+#include <thrust/mr/validator.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+template<typename Upstream, typename Pointer>
+class fancy_pointer_resource final : public memory_resource<Pointer>, private validator<Upstream>
+{
+public:
+    fancy_pointer_resource() : m_upstream(get_global_resource<Upstream>())
+    {
+    }
+
+    fancy_pointer_resource(Upstream * upstream) : m_upstream(upstream)
+    {
+    }
+
+    THRUST_NODISCARD
+    virtual Pointer do_allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        return static_cast<Pointer>(m_upstream->do_allocate(bytes, alignment));
+    }
+
+    virtual void do_deallocate(Pointer p, std::size_t bytes, std::size_t alignment) override
+    {
+        return m_upstream->do_deallocate(
+            static_cast<typename Upstream::pointer>(
+                thrust::detail::pointer_traits<Pointer>::get(p)),
+            bytes, alignment);
+    }
+
+private:
+    Upstream * m_upstream;
+};
+
+} // end mr
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/mr/host_memory_resource.h

@@ -0,0 +1,40 @@
+/*
+ *  Copyright 2018-2020 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// #include the host system's memory_resource header
+#define __THRUST_HOST_SYSTEM_MEMORY_HEADER <__THRUST_HOST_SYSTEM_ROOT/memory_resource.h>
+#include __THRUST_HOST_SYSTEM_MEMORY_HEADER
+#undef __THRUST_HOST_SYSTEM_MEMORY_HEADER
+
+THRUST_NAMESPACE_BEGIN
+
+typedef thrust::system::__THRUST_HOST_SYSTEM_NAMESPACE::memory_resource
+    host_memory_resource;
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/mr/memory_resource.h

@@ -0,0 +1,226 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief A base class for the memory resource system, similar to
+ *  std::memory_resource, and related utilities.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <thrust/detail/config/memory_resource.h>
+#ifdef THRUST_MR_STD_MR_HEADER
+#  include THRUST_MR_STD_MR_HEADER
+#endif
+
+THRUST_NAMESPACE_BEGIN
+/*! \brief \p thrust::mr is the namespace containing system agnostic types and functions for \p memory_resource related functionalities.
+ */
+namespace mr
+{
+
+/** \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! \p memory_resource is the base class for all other memory resources.
+ *
+ *  \tparam Pointer the pointer type that is allocated and deallocated by the memory resource
+ *      derived from this base class. If this is <tt>void *</tt>, this class derives from
+ *      <tt>std::pmr::memory_resource</tt>.
+ */
+template<typename Pointer = void *>
+class memory_resource
+{
+public:
+    /*! Alias for the template parameter.
+     */
+    typedef Pointer pointer;
+
+    /*! Virtual destructor, defaulted when possible.
+     */
+    virtual ~memory_resource() = default;
+
+    /*! Allocates memory of size at least \p bytes and alignment at least \p alignment.
+     *
+     *  \param bytes size, in bytes, that is requested from this allocation
+     *  \param alignment alignment that is requested from this allocation
+     *  \throws thrust::bad_alloc when no memory with requested size and alignment can be allocated.
+     *  \return A pointer to void to the newly allocated memory.
+     */
+    THRUST_NODISCARD
+    pointer allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT)
+    {
+        return do_allocate(bytes, alignment);
+    }
+
+    /*! Deallocates memory pointed to by \p p.
+     *
+     *  \param p pointer to be deallocated
+     *  \param bytes the size of the allocation. This must be equivalent to the value of \p bytes that
+     *      was passed to the allocation function that returned \p p.
+     *  \param alignment the alignment of the allocation. This must be equivalent to the value of \p alignment
+     *      that was passed to the allocation function that returned \p p.
+     */
+    void deallocate(pointer p, std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT)
+    {
+        do_deallocate(p, bytes, alignment);
+    }
+
+    /*! Compares this resource to the other one. The default implementation uses identity comparison,
+     *      which is often the right thing to do and doesn't require RTTI involvement.
+     *
+     *  \param other the other resource to compare this resource to
+     *  \return whether the two resources are equivalent.
+     */
+    __host__ __device__
+    bool is_equal(const memory_resource & other) const noexcept
+    {
+        return do_is_equal(other);
+    }
+
+    /*! Allocates memory of size at least \p bytes and alignment at least \p alignment.
+     *
+     *  \param bytes size, in bytes, that is requested from this allocation
+     *  \param alignment alignment that is requested from this allocation
+     *  \throws thrust::bad_alloc when no memory with requested size and alignment can be allocated.
+     *  \return A pointer to void to the newly allocated memory.
+     */
+    virtual pointer do_allocate(std::size_t bytes, std::size_t alignment) = 0;
+
+    /*! Deallocates memory pointed to by \p p.
+     *
+     *  \param p pointer to be deallocated
+     *  \param bytes the size of the allocation. This must be equivalent to the value of \p bytes that
+     *      was passed to the allocation function that returned \p p.
+     *  \param alignment the size of the allocation. This must be equivalent to the value of \p alignment
+     *      that was passed to the allocation function that returned \p p.
+     */
+    virtual void do_deallocate(pointer p, std::size_t bytes, std::size_t alignment) = 0;
+
+    /*! Compares this resource to the other one. The default implementation uses identity comparison,
+     *      which is often the right thing to do and doesn't require RTTI involvement.
+     *
+     *  \param other the other resource to compare this resource to
+     *  \return whether the two resources are equivalent.
+     */
+    __host__ __device__
+    virtual bool do_is_equal(const memory_resource & other) const noexcept
+    {
+        return this == &other;
+    }
+};
+
+template<>
+class memory_resource<void *>
+#ifdef THRUST_STD_MR_NS
+    : THRUST_STD_MR_NS::memory_resource
+#endif
+{
+public:
+    typedef void * pointer;
+
+    virtual ~memory_resource() = default;
+
+    THRUST_NODISCARD
+    pointer allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT)
+    {
+        return do_allocate(bytes, alignment);
+    }
+
+    void deallocate(pointer p, std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT)
+    {
+        do_deallocate(p, bytes, alignment);
+    }
+
+    __host__ __device__
+    bool is_equal(const memory_resource & other) const noexcept
+    {
+        return do_is_equal(other);
+    }
+
+    virtual pointer do_allocate(std::size_t bytes, std::size_t alignment) = 0;
+    virtual void do_deallocate(pointer p, std::size_t bytes, std::size_t alignment) = 0;
+    __host__ __device__
+    virtual bool do_is_equal(const memory_resource & other) const noexcept
+    {
+        return this == &other;
+    }
+
+#ifdef THRUST_STD_MR_NS
+    // the above do_is_equal is a different function than the one from the standard memory resource
+    // can't implement this reasonably without RTTI though; it's reasonable to assume false otherwise
+
+    virtual bool do_is_equal(const THRUST_STD_MR_NS::memory_resource & other) const noexcept override
+    {
+#  ifdef THRUST_HAS_DYNAMIC_CAST
+        auto mr_resource = dynamic_cast<memory_resource<> *>(&other);
+        return mr_resource && do_is_equal(*mr_resource);
+#  else
+        return this == &other;
+#  endif
+    }
+#endif
+};
+
+/*! Compares the memory resources for equality, first by identity, then by \p is_equal.
+ */
+template<typename Pointer>
+__host__ __device__
+bool operator==(const memory_resource<Pointer> & lhs, const memory_resource<Pointer> & rhs) noexcept
+{
+    return &lhs == &rhs || rhs.is_equal(rhs);
+}
+
+/*! Compares the memory resources for inequality, first by identity, then by \p is_equal.
+ */
+template<typename Pointer>
+__host__ __device__
+bool operator!=(const memory_resource<Pointer> & lhs, const memory_resource<Pointer> & rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+/*! Returns a global instance of \p MR, created as a function local static variable.
+ *
+ *  \tparam MR type of a memory resource to get an instance from. Must be \p DefaultConstructible.
+ *  \return a pointer to a global instance of \p MR.
+ */
+template<typename MR>
+__host__
+MR * get_global_resource()
+{
+    static MR resource;
+    return &resource;
+}
+
+/*! \} // memory_resource
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+