Add files using upload-large-folder tool

.gitattributes

@@ -93,3 +93,5 @@ 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/nvrtc64_120_0.dll filter=lfs diff=lfs merge=lfs -text
+miniCUDA124/bin/nvrtc-builtins64_124.dll filter=lfs diff=lfs merge=lfs -text

miniCUDA124/bin/nvrtc-builtins64_124.dll

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

miniCUDA124/bin/nvrtc64_120_0.dll

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

miniCUDA124/include/thrust/iterator/detail/discard_iterator_base.h

@@ -0,0 +1,72 @@
+/*
+ *  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/iterator/counting_iterator.h>
+#include <thrust/iterator/iterator_adaptor.h>
+#include <thrust/iterator/detail/any_assign.h>
+#include <cstddef> // for std::ptrdiff_t
+
+THRUST_NAMESPACE_BEGIN
+
+// forward declaration of discard_iterator
+template<typename> class discard_iterator;
+
+namespace detail
+{
+
+
+template<typename System>
+  struct discard_iterator_base
+{
+  // XXX value_type should actually be void
+  //     but this interferes with zip_iterator<discard_iterator>
+  typedef any_assign         value_type;
+  typedef any_assign&        reference;
+  typedef std::ptrdiff_t     incrementable;
+
+  typedef typename thrust::counting_iterator<
+    incrementable,
+    System,
+    thrust::random_access_traversal_tag
+  > base_iterator;
+
+  typedef typename thrust::iterator_adaptor<
+    discard_iterator<System>,
+    base_iterator,
+    value_type,
+    typename thrust::iterator_system<base_iterator>::type,
+    typename thrust::iterator_traversal<base_iterator>::type,
+    reference
+  > type;
+}; // end discard_iterator_base
+
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
+

miniCUDA124/include/thrust/iterator/detail/distance_from_result.h

@@ -0,0 +1,49 @@
+/*
+ *  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/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+// since both arguments are known to be specializations of iterator_facade,
+// it's legal to access IteratorFacade2::difference_type
+template<typename IteratorFacade1, typename IteratorFacade2>
+  struct distance_from_result
+    : eval_if<
+        is_convertible<IteratorFacade2,IteratorFacade1>::value,
+        identity_<typename IteratorFacade1::difference_type>,
+        identity_<typename IteratorFacade2::difference_type>
+      >
+{};
+
+} // end detail
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/detail/host_system_tag.h

@@ -0,0 +1,38 @@
+/*
+ *  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 the host system's execution_policy header
+#define __THRUST_HOST_SYSTEM_TAG_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/execution_policy.h>
+#include __THRUST_HOST_SYSTEM_TAG_HEADER
+#undef __THRUST_HOST_SYSTEM_TAG_HEADER
+
+THRUST_NAMESPACE_BEGIN
+
+typedef thrust::system::__THRUST_HOST_SYSTEM_NAMESPACE::tag host_system_tag;
+
+THRUST_NAMESPACE_END

miniCUDA124/include/thrust/iterator/detail/is_iterator_category.h

@@ -0,0 +1,67 @@
+/*
+ *  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/iterator/iterator_categories.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template <typename T>
+  struct is_host_iterator_category
+    : thrust::detail::or_<
+        thrust::detail::is_convertible<T, thrust::input_host_iterator_tag>,
+        thrust::detail::is_convertible<T, thrust::output_host_iterator_tag>
+      >
+{
+}; // end is_host_iterator_category
+
+template <typename T>
+  struct is_device_iterator_category
+    : thrust::detail::or_<
+        thrust::detail::is_convertible<T, thrust::input_device_iterator_tag>,
+        thrust::detail::is_convertible<T, thrust::output_device_iterator_tag>
+      >
+{
+}; // end is_device_iterator_category
+
+
+template <typename T>
+  struct is_iterator_category
+    : thrust::detail::or_<
+        is_host_iterator_category<T>,
+        is_device_iterator_category<T>
+      >
+{
+}; // end is_iterator_category
+
+} // end detail
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/detail/iterator_adaptor_base.h

@@ -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/type_traits.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/use_default.h>
+#include <thrust/iterator/iterator_facade.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+// forward declaration of iterator_adaptor for iterator_adaptor_base below
+template<typename Derived,
+         typename Base,
+         typename Value,
+         typename System,
+         typename Traversal,
+         typename Reference,
+         typename Difference
+>
+class iterator_adaptor;
+
+
+namespace detail
+{
+
+// If T is use_default, return the result of invoking
+// DefaultNullaryFn, otherwise return T.
+// XXX rename to dflt_help
+template <class T, class DefaultNullaryFn>
+struct ia_dflt_help
+  : thrust::detail::eval_if<
+        thrust::detail::is_same<T, thrust::use_default>::value
+      , DefaultNullaryFn
+      , thrust::detail::identity_<T>
+    >
+{
+}; // end ia_dflt_help
+
+
+// A metafunction which computes an iterator_adaptor's base class,
+// a specialization of iterator_facade.
+template<typename Derived,
+         typename Base,
+         typename Value,
+         typename System,
+         typename Traversal,
+         typename Reference,
+         typename Difference
+>
+  struct iterator_adaptor_base
+{
+  typedef typename ia_dflt_help<
+    Value,
+    iterator_value<Base>
+  >::type value;
+
+  typedef typename ia_dflt_help<
+    System,
+    thrust::iterator_system<Base>
+  >::type system;
+
+  typedef typename ia_dflt_help<
+    Traversal,
+    thrust::iterator_traversal<Base>
+  >::type traversal;
+
+  typedef typename ia_dflt_help<
+    Reference,
+    thrust::detail::eval_if<
+      thrust::detail::is_same<Value,use_default>::value,
+      thrust::iterator_reference<Base>,
+      thrust::detail::add_reference<Value>
+    >
+  >::type reference;
+
+  typedef typename ia_dflt_help<
+    Difference,
+    iterator_difference<Base>
+  >::type difference;
+
+  typedef thrust::iterator_facade<
+    Derived,
+    value,
+    system,
+    traversal,
+    reference,
+    difference
+  > type;
+}; // end iterator_adaptor_base
+
+
+} // end detail
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/detail/iterator_category_to_system.h

@@ -0,0 +1,87 @@
+/*
+ *  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/iterator/iterator_categories.h>
+#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/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+// forward declaration
+template <typename> struct is_iterator_system;
+
+template <typename> struct device_iterator_category_to_backend_system;
+
+// XXX this should work entirely differently
+// we should just specialize this metafunction for iterator_category_with_system_and_traversal
+template<typename Category>
+  struct iterator_category_to_system
+    // convertible to host iterator?
+    : eval_if<
+        or_<
+          is_convertible<Category, thrust::input_host_iterator_tag>,
+          is_convertible<Category, thrust::output_host_iterator_tag>
+        >::value,
+
+        detail::identity_<thrust::host_system_tag>,
+
+        // convertible to device iterator?
+        eval_if<
+          or_<
+            is_convertible<Category, thrust::input_device_iterator_tag>,
+            is_convertible<Category, thrust::output_device_iterator_tag>
+          >::value,
+
+          detail::identity_<thrust::device_system_tag>,
+
+          // unknown system
+          detail::identity_<void>
+        > // if device
+      > // if host
+{
+}; // end iterator_category_to_system
+
+
+template<typename CategoryOrTraversal>
+  struct iterator_category_or_traversal_to_system
+    : eval_if<
+        is_iterator_system<CategoryOrTraversal>::value,
+        detail::identity_<CategoryOrTraversal>,
+        iterator_category_to_system<CategoryOrTraversal>
+      >
+{
+}; // end iterator_category_or_traversal_to_system
+
+} // end detail
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/detail/iterator_category_to_traversal.h

@@ -0,0 +1,138 @@
+/*
+ *  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/iterator/iterator_categories.h>
+#include <thrust/iterator/detail/iterator_traversal_tags.h>
+#include <thrust/iterator/detail/iterator_category_to_system.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+// forward declarations
+template <typename> struct is_iterator_system;
+template <typename> struct is_iterator_traversal;
+
+template <typename Category>
+  struct host_system_category_to_traversal
+    : eval_if<
+        is_convertible<Category, random_access_host_iterator_tag>::value,
+        detail::identity_<random_access_traversal_tag>,
+        eval_if<
+          is_convertible<Category, bidirectional_host_iterator_tag>::value,
+          detail::identity_<bidirectional_traversal_tag>,
+          eval_if<
+            is_convertible<Category, forward_host_iterator_tag>::value,
+            detail::identity_<forward_traversal_tag>,
+            eval_if<
+              is_convertible<Category, input_host_iterator_tag>::value,
+              detail::identity_<single_pass_traversal_tag>,
+              eval_if<
+                is_convertible<Category, output_host_iterator_tag>::value,
+                detail::identity_<incrementable_traversal_tag>,
+                detail::identity_<void>
+              >
+            >
+          >
+        >
+      >
+{
+}; // end host_system_category_to_traversal
+
+
+
+template <typename Category>
+  struct device_system_category_to_traversal
+    : eval_if<
+        is_convertible<Category, random_access_device_iterator_tag>::value,
+        detail::identity_<random_access_traversal_tag>,
+        eval_if<
+          is_convertible<Category, bidirectional_device_iterator_tag>::value,
+          detail::identity_<bidirectional_traversal_tag>,
+          eval_if<
+            is_convertible<Category, forward_device_iterator_tag>::value,
+            detail::identity_<forward_traversal_tag>,
+            eval_if<
+              is_convertible<Category, input_device_iterator_tag>::value,
+              detail::identity_<single_pass_traversal_tag>,
+              eval_if<
+                is_convertible<Category, output_device_iterator_tag>::value,
+                detail::identity_<incrementable_traversal_tag>,
+                detail::identity_<void>
+              >
+            >
+          >
+        >
+      >
+{
+}; // end device_system_category_to_traversal
+
+
+template<typename Category>
+  struct category_to_traversal
+      // check for host system
+    : eval_if<
+        or_<
+          is_convertible<Category, thrust::input_host_iterator_tag>,
+          is_convertible<Category, thrust::output_host_iterator_tag>
+        >::value,
+
+        host_system_category_to_traversal<Category>,
+
+        // check for device system
+        eval_if<
+          or_<
+            is_convertible<Category, thrust::input_device_iterator_tag>,
+            is_convertible<Category, thrust::output_device_iterator_tag>
+          >::value,
+
+          device_system_category_to_traversal<Category>,
+
+          // unknown category
+          detail::identity_<void>
+        >
+      >
+{};
+
+
+template <typename CategoryOrTraversal>
+  struct iterator_category_to_traversal
+    : eval_if<
+        is_iterator_traversal<CategoryOrTraversal>::value,
+        detail::identity_<CategoryOrTraversal>,
+        category_to_traversal<CategoryOrTraversal>
+      >
+{
+}; // end iterator_category_to_traversal
+
+
+} // end detail
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/detail/iterator_category_with_system_and_traversal.h

@@ -0,0 +1,64 @@
+/*
+ *  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 Category, typename System, typename Traversal>
+  struct iterator_category_with_system_and_traversal
+    : Category
+{
+}; // end iterator_category_with_system_and_traversal
+
+
+// specialize iterator_category_to_system for iterator_category_with_system_and_traversal
+template<typename Category> struct iterator_category_to_system;
+
+template<typename Category, typename System, typename Traversal>
+  struct iterator_category_to_system<iterator_category_with_system_and_traversal<Category,System,Traversal> >
+{
+  typedef System type;
+}; // end iterator_category_to_system
+
+
+// specialize iterator_category_to_traversal for iterator_category_with_system_and_traversal
+template<typename Category> struct iterator_category_to_traversal;
+
+template<typename Category, typename System, typename Traversal>
+  struct iterator_category_to_traversal<iterator_category_with_system_and_traversal<Category,System,Traversal> >
+{
+  typedef Traversal type;
+}; // end iterator_category_to_traversal
+
+
+
+} // end detail
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/detail/iterator_facade_category.h

@@ -0,0 +1,260 @@
+/*
+ *  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/type_traits.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/iterator_categories.h>
+#include <thrust/iterator/detail/iterator_traversal_tags.h>
+#include <thrust/iterator/detail/is_iterator_category.h>
+#include <thrust/iterator/detail/iterator_category_with_system_and_traversal.h>
+#include <thrust/iterator/detail/iterator_category_to_traversal.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+
+// adapted from http://www.boost.org/doc/libs/1_37_0/libs/iterator/doc/iterator_facade.html#iterator-category
+//
+// in our implementation, R need not be a reference type to result in a category
+// derived from forward_XXX_iterator_tag
+//
+// iterator-category(T,V,R) :=
+//   if(T is convertible to input_host_iterator_tag
+//      || T is convertible to output_host_iterator_tag
+//      || T is convertible to input_device_iterator_tag
+//      || T is convertible to output_device_iterator_tag
+//   )
+//     return T
+//
+//   else if (T is not convertible to incrementable_traversal_tag)
+//     the program is ill-formed
+//
+//   else return a type X satisfying the following two constraints:
+//
+//     1. X is convertible to X1, and not to any more-derived
+//        type, where X1 is defined by:
+//
+//        if (T is convertible to forward_traversal_tag)
+//        {
+//          if (T is convertible to random_access_traversal_tag)
+//            X1 = random_access_host_iterator_tag
+//          else if (T is convertible to bidirectional_traversal_tag)
+//            X1 = bidirectional_host_iterator_tag
+//          else
+//            X1 = forward_host_iterator_tag
+//        }
+//        else
+//        {
+//          if (T is convertible to single_pass_traversal_tag
+//              && R is convertible to V)
+//            X1 = input_host_iterator_tag
+//          else
+//            X1 = T
+//        }
+//
+//     2. category-to-traversal(X) is convertible to the most
+//        derived traversal tag type to which X is also convertible,
+//        and not to any more-derived traversal tag type.
+
+
+template<typename System, typename Traversal, typename ValueParam, typename Reference>
+  struct iterator_facade_default_category;
+
+
+// Thrust's implementation of iterator_facade_default_category is slightly
+// different from Boost's equivalent.
+// Thrust does not check is_convertible<Reference, ValueParam> because Reference
+// may not be a complete type at this point, and implementations of is_convertible
+// typically require that both types be complete.
+// Instead, it simply assumes that if is_convertible<Traversal, single_pass_traversal_tag>,
+// then the category is input_iterator_tag
+
+
+// this is the function for standard system iterators
+template<typename Traversal, typename ValueParam, typename Reference>
+  struct iterator_facade_default_category_std :
+    thrust::detail::eval_if<
+      thrust::detail::is_convertible<Traversal, thrust::forward_traversal_tag>::value,
+      thrust::detail::eval_if<
+        thrust::detail::is_convertible<Traversal, thrust::random_access_traversal_tag>::value,
+        thrust::detail::identity_<std::random_access_iterator_tag>,
+        thrust::detail::eval_if<
+          thrust::detail::is_convertible<Traversal, thrust::bidirectional_traversal_tag>::value,
+          thrust::detail::identity_<std::bidirectional_iterator_tag>,
+          thrust::detail::identity_<std::forward_iterator_tag>
+        >
+      >,
+      thrust::detail::eval_if< // XXX note we differ from Boost here
+        thrust::detail::is_convertible<Traversal, thrust::single_pass_traversal_tag>::value,
+        thrust::detail::identity_<std::input_iterator_tag>,
+        thrust::detail::identity_<Traversal>
+      >
+    >
+{
+}; // end iterator_facade_default_category_std
+
+
+// this is the function for host system iterators
+template<typename Traversal, typename ValueParam, typename Reference>
+  struct iterator_facade_default_category_host :
+    thrust::detail::eval_if<
+      thrust::detail::is_convertible<Traversal, thrust::forward_traversal_tag>::value,
+      thrust::detail::eval_if<
+        thrust::detail::is_convertible<Traversal, thrust::random_access_traversal_tag>::value,
+        thrust::detail::identity_<thrust::random_access_host_iterator_tag>,
+        thrust::detail::eval_if<
+          thrust::detail::is_convertible<Traversal, thrust::bidirectional_traversal_tag>::value,
+          thrust::detail::identity_<thrust::bidirectional_host_iterator_tag>,
+          thrust::detail::identity_<thrust::forward_host_iterator_tag>
+        >
+      >,
+      thrust::detail::eval_if< // XXX note we differ from Boost here
+        thrust::detail::is_convertible<Traversal, thrust::single_pass_traversal_tag>::value,
+        thrust::detail::identity_<thrust::input_host_iterator_tag>,
+        thrust::detail::identity_<Traversal>
+      >
+    >
+{
+}; // end iterator_facade_default_category_host
+
+
+// this is the function for device system iterators
+template<typename Traversal, typename ValueParam, typename Reference>
+  struct iterator_facade_default_category_device :
+    thrust::detail::eval_if<
+      thrust::detail::is_convertible<Traversal, thrust::forward_traversal_tag>::value,
+      thrust::detail::eval_if<
+        thrust::detail::is_convertible<Traversal, thrust::random_access_traversal_tag>::value,
+        thrust::detail::identity_<thrust::random_access_device_iterator_tag>,
+        thrust::detail::eval_if<
+          thrust::detail::is_convertible<Traversal, thrust::bidirectional_traversal_tag>::value,
+          thrust::detail::identity_<thrust::bidirectional_device_iterator_tag>,
+          thrust::detail::identity_<thrust::forward_device_iterator_tag>
+        >
+      >,
+      thrust::detail::eval_if<
+        thrust::detail::is_convertible<Traversal, thrust::single_pass_traversal_tag>::value, // XXX note we differ from Boost here
+        thrust::detail::identity_<thrust::input_device_iterator_tag>,
+        thrust::detail::identity_<Traversal>
+      >
+    >
+{
+}; // end iterator_facade_default_category_device
+
+
+// this is the function for any system iterators
+template<typename Traversal, typename ValueParam, typename Reference>
+  struct iterator_facade_default_category_any
+{
+  typedef thrust::detail::iterator_category_with_system_and_traversal<
+    typename iterator_facade_default_category_std<Traversal, ValueParam, Reference>::type,
+    thrust::any_system_tag,
+    Traversal
+  > type;
+}; // end iterator_facade_default_category_any
+
+
+template<typename System, typename Traversal, typename ValueParam, typename Reference>
+  struct iterator_facade_default_category
+      // check for any system
+    : thrust::detail::eval_if<
+        thrust::detail::is_convertible<System, thrust::any_system_tag>::value,
+        iterator_facade_default_category_any<Traversal, ValueParam, Reference>,
+
+        // check for host system
+        thrust::detail::eval_if<
+          thrust::detail::is_convertible<System, thrust::host_system_tag>::value,
+          iterator_facade_default_category_host<Traversal, ValueParam, Reference>,
+
+          // check for device system
+          thrust::detail::eval_if<
+            thrust::detail::is_convertible<System, thrust::device_system_tag>::value,
+            iterator_facade_default_category_device<Traversal, ValueParam, Reference>,
+
+            // if we don't recognize the system, get a standard iterator category
+            // and combine it with System & Traversal
+            thrust::detail::identity_<
+              thrust::detail::iterator_category_with_system_and_traversal<
+                typename iterator_facade_default_category_std<Traversal, ValueParam, Reference>::type,
+                System,
+                Traversal
+              >
+            >
+          >
+        >
+      >
+{};
+
+
+template<typename System, typename Traversal, typename ValueParam, typename Reference>
+  struct iterator_facade_category_impl
+{
+  typedef typename iterator_facade_default_category<
+    System,Traversal,ValueParam,Reference
+  >::type category;
+
+  // we must be able to deduce both Traversal & System from category
+  // otherwise, munge them all together
+  typedef typename thrust::detail::eval_if<
+    thrust::detail::and_<
+      thrust::detail::is_same<
+        Traversal,
+        typename thrust::detail::iterator_category_to_traversal<category>::type
+      >,
+      thrust::detail::is_same<
+        System,
+        typename thrust::detail::iterator_category_to_system<category>::type
+      >
+    >::value,
+    thrust::detail::identity_<category>,
+    thrust::detail::identity_<thrust::detail::iterator_category_with_system_and_traversal<category,System,Traversal> >
+  >::type type;
+}; // end iterator_facade_category_impl
+
+
+template<typename CategoryOrSystem,
+         typename CategoryOrTraversal,
+         typename ValueParam,
+         typename Reference>
+  struct iterator_facade_category
+{
+  typedef typename
+  thrust::detail::eval_if<
+    thrust::detail::is_iterator_category<CategoryOrTraversal>::value,
+    thrust::detail::identity_<CategoryOrTraversal>, // categories are fine as-is
+    iterator_facade_category_impl<CategoryOrSystem, CategoryOrTraversal, ValueParam, Reference>
+  >::type type;
+}; // end iterator_facade_category
+
+
+} // end detail
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/detail/iterator_traits.inl

@@ -0,0 +1,144 @@
+/*
+ *  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/iterator/iterator_categories.h>
+#include <thrust/iterator/detail/iterator_category_to_traversal.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/type_traits/void_t.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template<typename Iterator>
+  struct iterator_value
+{
+  typedef typename thrust::iterator_traits<Iterator>::value_type type;
+}; // end iterator_value
+
+template <typename Iterator>
+using iterator_value_t = typename iterator_value<Iterator>::type;
+
+template<typename Iterator>
+  struct iterator_pointer
+{
+  typedef typename thrust::iterator_traits<Iterator>::pointer type;
+}; // end iterator_pointer
+
+template <typename Iterator>
+using iterator_pointer_t = typename iterator_pointer<Iterator>::type;
+
+template<typename Iterator>
+  struct iterator_reference
+{
+  typedef typename iterator_traits<Iterator>::reference type;
+}; // end iterator_reference
+
+template <typename Iterator>
+using iterator_reference_t = typename iterator_reference<Iterator>::type;
+
+template<typename Iterator>
+  struct iterator_difference
+{
+  typedef typename thrust::iterator_traits<Iterator>::difference_type type;
+}; // end iterator_difference
+
+template <typename Iterator>
+using iterator_difference_t = typename iterator_difference<Iterator>::type;
+
+namespace detail
+{
+
+template <typename Iterator, typename = void>
+struct iterator_system_impl {};
+
+template <typename Iterator>
+struct iterator_system_impl<
+  Iterator
+, typename voider<
+    typename iterator_traits<Iterator>::iterator_category
+  >::type
+>
+  : detail::iterator_category_to_system<
+      typename iterator_traits<Iterator>::iterator_category
+    >
+{};
+
+} // namespace detail
+
+template <typename Iterator>
+struct iterator_system : detail::iterator_system_impl<Iterator> {};
+
+// specialize iterator_system for void *, which has no category
+template<>
+  struct iterator_system<void *>
+{
+  typedef thrust::iterator_system<int*>::type type;
+}; // end iterator_system<void*>
+
+template<>
+  struct iterator_system<const void *>
+{
+  typedef thrust::iterator_system<const int*>::type type;
+}; // end iterator_system<void*>
+
+template <typename Iterator>
+using iterator_system_t = typename iterator_system<Iterator>::type;
+
+template <typename Iterator>
+  struct iterator_traversal
+    : detail::iterator_category_to_traversal<
+        typename thrust::iterator_traits<Iterator>::iterator_category
+      >
+{
+}; // end iterator_traversal
+
+namespace detail
+{
+
+template <typename T>
+  struct is_iterator_traversal
+    : thrust::detail::is_convertible<T, incrementable_traversal_tag>
+{
+}; // end is_iterator_traversal
+
+
+template<typename T>
+  struct is_iterator_system
+    : detail::or_<
+        detail::is_convertible<T, any_system_tag>,
+        detail::or_<
+          detail::is_convertible<T, host_system_tag>,
+          detail::is_convertible<T, device_system_tag>
+        >
+      >
+{
+}; // end is_iterator_system
+
+
+} // end namespace detail
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/detail/minimum_system.h

@@ -0,0 +1,89 @@
+/*
+ *  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/type_traits.h>
+#include <thrust/detail/type_traits/is_metafunction_defined.h>
+#include <thrust/detail/type_traits/minimum_type.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+template<typename T1,
+         typename T2  = void,
+         typename T3  = void,
+         typename T4  = void,
+         typename T5  = void,
+         typename T6  = void,
+         typename T7  = void,
+         typename T8  = void,
+         typename T9  = void,
+         typename T10 = void,
+         typename T11 = void,
+         typename T12 = void,
+         typename T13 = void,
+         typename T14 = void,
+         typename T15 = void,
+         typename T16 = void>
+  struct unrelated_systems {};
+
+
+// if a minimum system exists for these arguments, return it
+// otherwise, collect the arguments and report them as unrelated
+template<typename T1,
+         typename T2  = minimum_type_detail::any_conversion,
+         typename T3  = minimum_type_detail::any_conversion,
+         typename T4  = minimum_type_detail::any_conversion,
+         typename T5  = minimum_type_detail::any_conversion,
+         typename T6  = minimum_type_detail::any_conversion,
+         typename T7  = minimum_type_detail::any_conversion,
+         typename T8  = minimum_type_detail::any_conversion,
+         typename T9  = minimum_type_detail::any_conversion,
+         typename T10 = minimum_type_detail::any_conversion,
+         typename T11 = minimum_type_detail::any_conversion,
+         typename T12 = minimum_type_detail::any_conversion,
+         typename T13 = minimum_type_detail::any_conversion,
+         typename T14 = minimum_type_detail::any_conversion,
+         typename T15 = minimum_type_detail::any_conversion,
+         typename T16 = minimum_type_detail::any_conversion>
+  struct minimum_system
+    : thrust::detail::eval_if<
+        is_metafunction_defined<
+          minimum_type<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>
+        >::value,
+        minimum_type<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>,
+        thrust::detail::identity_<
+          unrelated_systems<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>
+        >
+      >
+{}; // end minimum_system
+
+
+} // end detail
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/detail/normal_iterator.h

@@ -0,0 +1,87 @@
+/*
+ *  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 normal_iterator.h
+ *  \brief Defines the interface to an iterator class
+ *         which adapts a pointer type.
+ */
+
+#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/detail/type_traits.h>
+#include <thrust/type_traits/is_contiguous_iterator.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+template<typename Pointer>
+  class normal_iterator
+    : public iterator_adaptor<
+        normal_iterator<Pointer>,
+        Pointer
+      >
+{
+  typedef iterator_adaptor<normal_iterator<Pointer>, Pointer> super_t;
+
+  public:
+    __host__ __device__
+    normal_iterator() {}
+
+    __host__ __device__
+    normal_iterator(Pointer p)
+      : super_t(p) {}
+
+    template<typename OtherPointer>
+    __host__ __device__
+    normal_iterator(const normal_iterator<OtherPointer> &other,
+                    typename thrust::detail::enable_if_convertible<
+                      OtherPointer,
+                      Pointer
+                    >::type * = 0)
+      : super_t(other.base()) {}
+
+}; // end normal_iterator
+
+
+template<typename Pointer>
+  inline __host__ __device__ normal_iterator<Pointer> make_normal_iterator(Pointer ptr)
+{
+  return normal_iterator<Pointer>(ptr);
+}
+
+} // end detail
+
+template <typename T>
+struct proclaim_contiguous_iterator<
+  thrust::detail::normal_iterator<T>
+> : true_type {};
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/detail/permutation_iterator_base.h

@@ -0,0 +1,62 @@
+/*
+ *  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/iterator/iterator_adaptor.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/minimum_system.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template<typename,typename> class permutation_iterator;
+
+
+namespace detail
+{
+
+template<typename ElementIterator,
+         typename IndexIterator>
+  struct permutation_iterator_base
+{
+  typedef typename thrust::iterator_system<ElementIterator>::type System1;
+  typedef typename thrust::iterator_system<IndexIterator>::type System2;
+
+  typedef thrust::iterator_adaptor<
+    permutation_iterator<ElementIterator,IndexIterator>,
+    IndexIterator,
+    typename thrust::iterator_value<ElementIterator>::type,
+    typename detail::minimum_system<System1,System2>::type,
+    thrust::use_default,
+    typename thrust::iterator_reference<ElementIterator>::type
+  > type;
+}; // end permutation_iterator_base
+
+} // end detail
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/detail/retag.h

@@ -0,0 +1,155 @@
+/*
+ *  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/type_traits.h>
+#include <thrust/iterator/detail/tagged_iterator.h>
+#include <thrust/detail/pointer.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+// we can retag an iterator if FromTag converts to ToTag
+// or vice versa
+template<typename FromTag, typename ToTag>
+  struct is_retaggable
+    : integral_constant<
+        bool,
+        (is_convertible<FromTag,ToTag>::value || is_convertible<ToTag,FromTag>::value)
+      >
+{};
+
+
+template<typename FromTag, typename ToTag, typename Result>
+  struct enable_if_retaggable
+    : enable_if<
+        is_retaggable<FromTag,ToTag>::value,
+        Result
+      >
+{}; // end enable_if_retaggable
+
+
+} // end detail
+
+
+template<typename Tag, typename Iterator>
+__host__ __device__
+  thrust::detail::tagged_iterator<Iterator,Tag>
+    reinterpret_tag(Iterator iter)
+{
+  return thrust::detail::tagged_iterator<Iterator,Tag>(iter);
+} // end reinterpret_tag()
+
+
+// specialization for raw pointer
+template<typename Tag, typename T>
+__host__ __device__
+  thrust::pointer<T,Tag>
+    reinterpret_tag(T *ptr)
+{
+  return thrust::pointer<T,Tag>(ptr);
+} // end reinterpret_tag()
+
+
+// specialization for thrust::pointer
+template<typename Tag, typename T, typename OtherTag, typename Reference, typename Derived>
+__host__ __device__
+  thrust::pointer<T,Tag>
+    reinterpret_tag(thrust::pointer<T,OtherTag,Reference,Derived> ptr)
+{
+  return reinterpret_tag<Tag>(ptr.get());
+} // end reinterpret_tag()
+
+
+// avoid deeply-nested tagged_iterator
+template<typename Tag, typename BaseIterator, typename OtherTag>
+__host__ __device__
+  thrust::detail::tagged_iterator<BaseIterator,Tag>
+    reinterpret_tag(thrust::detail::tagged_iterator<BaseIterator,OtherTag> iter)
+{
+  return reinterpret_tag<Tag>(iter.base());
+} // end reinterpret_tag()
+
+
+template<typename Tag, typename Iterator>
+__host__ __device__
+  typename thrust::detail::enable_if_retaggable<
+    typename thrust::iterator_system<Iterator>::type,
+    Tag,
+    thrust::detail::tagged_iterator<Iterator,Tag>
+  >::type
+    retag(Iterator iter)
+{
+  return reinterpret_tag<Tag>(iter);
+} // end retag()
+
+
+// specialization for raw pointer
+template<typename Tag, typename T>
+__host__ __device__
+  typename thrust::detail::enable_if_retaggable<
+    typename thrust::iterator_system<T*>::type,
+    Tag,
+    thrust::pointer<T,Tag>
+  >::type
+    retag(T *ptr)
+{
+  return reinterpret_tag<Tag>(ptr);
+} // end retag()
+
+
+// specialization for thrust::pointer
+template<typename Tag, typename T, typename OtherTag>
+__host__ __device__
+  typename thrust::detail::enable_if_retaggable<
+    OtherTag,
+    Tag,
+    thrust::pointer<T,Tag>
+  >::type
+    retag(thrust::pointer<T,OtherTag> ptr)
+{
+  return reinterpret_tag<Tag>(ptr);
+} // end retag()
+
+
+// avoid deeply-nested tagged_iterator
+template<typename Tag, typename BaseIterator, typename OtherTag>
+__host__ __device__
+  typename thrust::detail::enable_if_retaggable<
+    OtherTag,
+    Tag,
+    thrust::detail::tagged_iterator<BaseIterator,Tag>
+  >::type
+    retag(thrust::detail::tagged_iterator<BaseIterator,OtherTag> iter)
+{
+  return reinterpret_tag<Tag>(iter);
+} // end retag()
+
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/detail/reverse_iterator.inl

@@ -0,0 +1,126 @@
+/*
+ *  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/iterator/reverse_iterator.h>
+#include <thrust/iterator/iterator_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+__thrust_exec_check_disable__
+template<typename Iterator>
+  __host__ __device__
+  Iterator prior(Iterator x)
+{
+  return --x;
+} // end prior()
+
+} // end detail
+
+template<typename BidirectionalIterator>
+  __host__ __device__
+  reverse_iterator<BidirectionalIterator>
+    ::reverse_iterator(BidirectionalIterator x)
+      :super_t(x)
+{
+} // end reverse_iterator::reverse_iterator()
+
+template<typename BidirectionalIterator>
+  template<typename OtherBidirectionalIterator>
+    __host__ __device__
+    reverse_iterator<BidirectionalIterator>
+      ::reverse_iterator(reverse_iterator<OtherBidirectionalIterator> const &r
+// XXX msvc screws this up
+#if THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+                     , typename thrust::detail::enable_if<
+                         thrust::detail::is_convertible<
+                           OtherBidirectionalIterator,
+                           BidirectionalIterator
+                         >::value
+                       >::type *
+#endif // MSVC
+                     )
+        :super_t(r.base())
+{
+} // end reverse_iterator::reverse_iterator()
+
+template<typename BidirectionalIterator>
+  __host__ __device__
+  typename reverse_iterator<BidirectionalIterator>::super_t::reference
+    reverse_iterator<BidirectionalIterator>
+      ::dereference() const
+{
+  return *thrust::detail::prior(this->base());
+} // end reverse_iterator::increment()
+
+template<typename BidirectionalIterator>
+  __host__ __device__
+  void reverse_iterator<BidirectionalIterator>
+    ::increment()
+{
+  --this->base_reference();
+} // end reverse_iterator::increment()
+
+template<typename BidirectionalIterator>
+  __host__ __device__
+  void reverse_iterator<BidirectionalIterator>
+    ::decrement()
+{
+  ++this->base_reference();
+} // end reverse_iterator::decrement()
+
+template<typename BidirectionalIterator>
+  __host__ __device__
+  void reverse_iterator<BidirectionalIterator>
+    ::advance(typename super_t::difference_type n)
+{
+  this->base_reference() += -n;
+} // end reverse_iterator::advance()
+
+template<typename BidirectionalIterator>
+  template<typename OtherBidirectionalIterator>
+    __host__ __device__
+    typename reverse_iterator<BidirectionalIterator>::super_t::difference_type
+      reverse_iterator<BidirectionalIterator>
+        ::distance_to(reverse_iterator<OtherBidirectionalIterator> const &y) const
+{
+  return this->base_reference() - y.base();
+} // end reverse_iterator::distance_to()
+
+template<typename BidirectionalIterator>
+__host__ __device__
+reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x)
+{
+  return reverse_iterator<BidirectionalIterator>(x);
+} // end make_reverse_iterator()
+
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/detail/reverse_iterator_base.h

@@ -0,0 +1,51 @@
+/*
+ *  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/iterator/iterator_adaptor.h>
+#include <thrust/iterator/iterator_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename> class reverse_iterator;
+
+namespace detail
+{
+
+template<typename BidirectionalIterator>
+  struct reverse_iterator_base
+{
+  typedef thrust::iterator_adaptor<
+    thrust::reverse_iterator<BidirectionalIterator>,
+    BidirectionalIterator
+  > type;
+}; // end reverse_iterator_base
+
+} // end detail
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/detail/tagged_iterator.h

@@ -0,0 +1,93 @@
+/*
+ *  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/iterator/iterator_adaptor.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/use_default.h>
+#include <thrust/type_traits/is_contiguous_iterator.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename,typename> class tagged_iterator;
+
+template<typename Iterator, typename Tag>
+  struct tagged_iterator_base
+{
+  typedef thrust::iterator_adaptor<
+    tagged_iterator<Iterator,Tag>,
+    Iterator,
+    typename thrust::iterator_value<Iterator>::type,
+    Tag,
+    typename thrust::iterator_traversal<Iterator>::type,
+    typename thrust::iterator_reference<Iterator>::type,
+    typename thrust::iterator_difference<Iterator>::type
+  > type;
+}; // end tagged_iterator_base
+
+template<typename Iterator, typename Tag>
+  class tagged_iterator
+    : public tagged_iterator_base<Iterator,Tag>::type
+{
+  private:
+    typedef typename tagged_iterator_base<Iterator,Tag>::type super_t;
+
+  public:
+    __host__ __device__
+    tagged_iterator() {}
+
+    __host__ __device__
+    explicit tagged_iterator(Iterator x)
+      : super_t(x) {}
+}; // end tagged_iterator
+
+/*! \p make_tagged_iterator creates a \p tagged_iterator
+ *  from a \c Iterator with system tag \c Tag.
+ *
+ *  \tparam Tag Any system tag.
+ *  \tparam Iterator Any iterator type.
+ *  \param iter The iterator of interest.
+ *  \return An iterator whose system tag is \p Tag and whose behavior is otherwise
+ *          equivalent to \p iter.
+ */
+template <typename Tag, typename Iterator>
+inline auto make_tagged_iterator(Iterator iter) -> tagged_iterator<Iterator, Tag>
+{
+  return tagged_iterator<Iterator, Tag>(iter);
+}
+
+} // end detail
+
+// tagged_iterator is trivial if its base iterator is.
+template <typename BaseIterator, typename Tag>
+struct proclaim_contiguous_iterator<
+  detail::tagged_iterator<BaseIterator, Tag>
+> : is_contiguous_iterator<BaseIterator> {};
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/detail/transform_input_output_iterator.inl

@@ -0,0 +1,115 @@
+/*
+ *  Copyright 2020-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/iterator/iterator_adaptor.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename InputFunction, typename OutputFunction, typename Iterator>
+  class transform_input_output_iterator;
+
+namespace detail
+{
+
+// Proxy reference that invokes InputFunction when reading from and
+// OutputFunction when writing to the dereferenced iterator
+template <typename InputFunction, typename OutputFunction, typename Iterator>
+  class transform_input_output_iterator_proxy
+{
+  using iterator_value_type = typename thrust::iterator_value<Iterator>::type;
+
+  using Value = invoke_result_t<InputFunction, iterator_value_type>;
+
+  public:
+    __host__ __device__
+    transform_input_output_iterator_proxy(const Iterator& io, InputFunction input_function, OutputFunction output_function)
+      : io(io), input_function(input_function), output_function(output_function)
+    {
+    }
+
+    transform_input_output_iterator_proxy(const transform_input_output_iterator_proxy&) = default;
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    operator Value const() const
+    {
+      return input_function(*io);
+    }
+
+    __thrust_exec_check_disable__
+    template <typename T>
+    __host__ __device__
+    transform_input_output_iterator_proxy operator=(const T& x)
+    {
+      *io = output_function(x);
+      return *this;
+    }
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    transform_input_output_iterator_proxy operator=(const transform_input_output_iterator_proxy& x)
+    {
+      *io = output_function(x);
+      return *this;
+    }
+
+  private:
+    Iterator io;
+    InputFunction input_function;
+    OutputFunction output_function;
+};
+
+// Compute the iterator_adaptor instantiation to be used for transform_input_output_iterator
+template <typename InputFunction, typename OutputFunction, typename Iterator>
+struct transform_input_output_iterator_base
+{
+private:
+  using iterator_value_type = typename thrust::iterator_value<Iterator>::type;
+
+public:
+    typedef thrust::iterator_adaptor
+    <
+        transform_input_output_iterator<InputFunction, OutputFunction, Iterator>
+      , Iterator
+      , detail::invoke_result_t<InputFunction, iterator_value_type>
+      , thrust::use_default
+      , thrust::use_default
+      , transform_input_output_iterator_proxy<InputFunction, OutputFunction, Iterator>
+    > type;
+};
+
+// Register transform_input_output_iterator_proxy with 'is_proxy_reference' from
+// type_traits to enable its use with algorithms.
+template <typename InputFunction, typename OutputFunction, typename Iterator>
+struct is_proxy_reference<
+    transform_input_output_iterator_proxy<InputFunction, OutputFunction, Iterator> >
+    : public thrust::detail::true_type {};
+
+} // end detail
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/detail/transform_iterator.inl

@@ -0,0 +1,77 @@
+/*
+ *  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/type_traits.h>
+#include <thrust/detail/type_traits/result_of_adaptable_function.h>
+#include <thrust/iterator/iterator_adaptor.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/iterator/transform_iterator.h>
+#include <thrust/type_traits/remove_cvref.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template <class UnaryFunction, class Iterator, class Reference, class Value>
+  class transform_iterator;
+
+namespace detail
+{
+
+// Compute the iterator_adaptor instantiation to be used for transform_iterator
+template <class UnaryFunc, class Iterator, class Reference, class Value>
+struct transform_iterator_base
+{
+ private:
+    // By default, dereferencing the iterator yields the same as the function.
+    typedef typename thrust::detail::ia_dflt_help<
+      Reference,
+      thrust::detail::result_of_adaptable_function<UnaryFunc(typename thrust::iterator_value<Iterator>::type)>
+    >::type reference;
+
+    // To get the default for Value: remove cvref on the result type.
+    using value_type =
+      typename thrust::detail::ia_dflt_help<Value, thrust::remove_cvref<reference>>::type;
+
+  public:
+    typedef thrust::iterator_adaptor
+    <
+        transform_iterator<UnaryFunc, Iterator, Reference, Value>
+      , Iterator
+      , value_type
+      , thrust::use_default   // Leave the system alone
+        //, thrust::use_default   // Leave the traversal alone
+        // use the Iterator's category to let any system iterators remain random access even though
+        // transform_iterator's reference type may not be a reference
+        // XXX figure out why only iterators whose reference types are true references are random access
+        , typename thrust::iterator_traits<Iterator>::iterator_category
+      , reference
+    > type;
+};
+
+
+} // end detail
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/detail/transform_output_iterator.inl

@@ -0,0 +1,89 @@
+/*
+ *  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/iterator/transform_output_iterator.h>
+#include <thrust/iterator/iterator_adaptor.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename UnaryFunction, typename OutputIterator>
+  class transform_output_iterator;
+
+namespace detail
+{
+
+// Proxy reference that uses Unary Function to transform the rhs of assigment
+// operator before writing the result to OutputIterator
+template <typename UnaryFunction, typename OutputIterator>
+  class transform_output_iterator_proxy
+{
+  public:
+    __host__ __device__
+    transform_output_iterator_proxy(const OutputIterator& out, UnaryFunction fun) : out(out), fun(fun)
+    {
+    }
+
+    __thrust_exec_check_disable__
+    template <typename T>
+    __host__ __device__
+    transform_output_iterator_proxy operator=(const T& x)
+    {
+      *out = fun(x);
+      return *this;
+    }
+
+  private:
+    OutputIterator out;
+    UnaryFunction fun;
+};
+
+// Compute the iterator_adaptor instantiation to be used for transform_output_iterator
+template <typename UnaryFunction, typename OutputIterator>
+struct transform_output_iterator_base
+{
+    typedef thrust::iterator_adaptor
+    <
+        transform_output_iterator<UnaryFunction, OutputIterator>
+      , OutputIterator
+      , thrust::use_default
+      , thrust::use_default
+      , thrust::use_default
+      , transform_output_iterator_proxy<UnaryFunction, OutputIterator>
+    > type;
+};
+
+// Register transform_output_iterator_proxy with 'is_proxy_reference' from
+// type_traits to enable its use with algorithms.
+template <class UnaryFunction, class OutputIterator>
+struct is_proxy_reference<
+    transform_output_iterator_proxy<UnaryFunction, OutputIterator> >
+    : public thrust::detail::true_type {};
+
+} // end detail
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/detail/tuple_of_iterator_references.h

@@ -0,0 +1,160 @@
+/*
+ *  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 <cuda/std/type_traits>
+#include <cuda/std/tuple>
+
+#include <thrust/tuple.h>
+#include <thrust/pair.h>
+#include <thrust/detail/reference_forward_declaration.h>
+#include <thrust/detail/raw_reference_cast.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template<
+  typename... Ts
+>
+  class tuple_of_iterator_references : public thrust::tuple<Ts...>
+{
+  public:
+    using super_t = thrust::tuple<Ts...>;
+    using super_t::super_t;
+
+    inline __host__ __device__
+    tuple_of_iterator_references()
+      : super_t()
+    {}
+
+    // allow implicit construction from tuple<refs>
+    inline __host__ __device__
+    tuple_of_iterator_references(const super_t& other)
+      : super_t(other)
+    {}
+
+    inline __host__ __device__
+    tuple_of_iterator_references(super_t&& other)
+      : super_t(::cuda::std::move(other))
+    {}
+
+    // allow assignment from tuples
+    // XXX might be worthwhile to guard this with an enable_if is_assignable
+    __thrust_exec_check_disable__
+    template<typename... Us>
+    inline __host__ __device__
+    tuple_of_iterator_references &operator=(const thrust::tuple<Us...> &other)
+    {
+      super_t::operator=(other);
+      return *this;
+    }
+
+    // allow assignment from pairs
+    // XXX might be worthwhile to guard this with an enable_if is_assignable
+    __thrust_exec_check_disable__
+    template<typename U1, typename U2>
+    inline __host__ __device__
+    tuple_of_iterator_references &operator=(const thrust::pair<U1,U2> &other)
+    {
+      super_t::operator=(other);
+      return *this;
+    }
+
+    // allow assignment from reference<tuple>
+    // XXX perhaps we should generalize to reference<T>
+    //     we could captures reference<pair> this way
+    __thrust_exec_check_disable__
+    template<typename Pointer, typename Derived, typename... Us>
+    inline __host__ __device__
+    tuple_of_iterator_references&
+    operator=(const thrust::reference<thrust::tuple<Us...>, Pointer, Derived> &other)
+    {
+      typedef thrust::tuple<Us...> tuple_type;
+
+      // XXX perhaps this could be accelerated
+      super_t::operator=(tuple_type{other});
+      return *this;
+    }
+
+    template<class... Us, ::cuda::std::__enable_if_t<sizeof...(Us) == sizeof...(Ts), int> = 0>
+    inline __host__ __device__
+    constexpr operator thrust::tuple<Us...>() const {
+      return to_tuple<Us...>(typename ::cuda::std::__make_tuple_indices<sizeof...(Ts)>::type{});
+    }
+
+    // this overload of swap() permits swapping tuple_of_iterator_references returned as temporaries from
+    // iterator dereferences
+    template<class... Us>
+    inline __host__ __device__
+    friend void swap(tuple_of_iterator_references&& x, tuple_of_iterator_references<Us...>&& y)
+    {
+      x.swap(y);
+    }
+
+private:
+    template<class... Us, size_t... Id>
+    inline __host__ __device__
+    constexpr thrust::tuple<Us...> to_tuple(::cuda::std::__tuple_indices<Id...>) const {
+      return {get<Id>(*this)...};
+    }
+};
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// define tuple_size, tuple_element, etc.
+template <class... Ts>
+struct tuple_size<THRUST_NS_QUALIFIER::detail::tuple_of_iterator_references<Ts...>>
+    : integral_constant<size_t, sizeof...(Ts)>
+{};
+
+template <size_t Id, class... Ts>
+struct tuple_element<Id, THRUST_NS_QUALIFIER::detail::tuple_of_iterator_references<Ts...>>
+    : _CUDA_VSTD::tuple_element<Id, _CUDA_VSTD::tuple<Ts...>>
+{};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+// structured bindings suppport
+namespace std {
+
+template <class... Ts>
+struct tuple_size<THRUST_NS_QUALIFIER::detail::tuple_of_iterator_references<Ts...>>
+    : integral_constant<size_t, sizeof...(Ts)>
+{};
+
+template <size_t Id, class... Ts>
+struct tuple_element<Id, THRUST_NS_QUALIFIER::detail::tuple_of_iterator_references<Ts...>>
+    : _CUDA_VSTD::tuple_element<Id, _CUDA_VSTD::tuple<Ts...>>
+{};
+
+} // namespace std

miniCUDA124/include/thrust/iterator/detail/universal_categories.h

@@ -0,0 +1,94 @@
+/*
+ *  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/iterator/iterator_categories.h>
+
+// XXX eliminate this file
+
+THRUST_NAMESPACE_BEGIN
+
+// define these types without inheritance to avoid ambiguous conversion to base classes
+
+struct input_universal_iterator_tag
+{
+  operator input_host_iterator_tag () {return input_host_iterator_tag();}
+
+  operator input_device_iterator_tag () {return input_device_iterator_tag();}
+};
+
+struct output_universal_iterator_tag
+{
+  operator output_host_iterator_tag () {return output_host_iterator_tag();}
+
+  operator output_device_iterator_tag () {return output_device_iterator_tag();}
+};
+
+struct forward_universal_iterator_tag
+  : input_universal_iterator_tag
+{
+  operator forward_host_iterator_tag () {return forward_host_iterator_tag();};
+
+  operator forward_device_iterator_tag () {return forward_device_iterator_tag();};
+};
+
+struct bidirectional_universal_iterator_tag
+  : forward_universal_iterator_tag
+{
+  operator bidirectional_host_iterator_tag () {return bidirectional_host_iterator_tag();};
+
+  operator bidirectional_device_iterator_tag () {return bidirectional_device_iterator_tag();};
+};
+
+
+namespace detail
+{
+
+// create this struct to control conversion precedence in random_access_universal_iterator_tag
+template<typename T>
+struct one_degree_of_separation
+  : T
+{
+};
+
+} // end detail
+
+
+struct random_access_universal_iterator_tag
+{
+  // these conversions are all P0
+  operator random_access_host_iterator_tag () {return random_access_host_iterator_tag();};
+
+  operator random_access_device_iterator_tag () {return random_access_device_iterator_tag();};
+
+  // bidirectional_universal_iterator_tag is P1
+  operator detail::one_degree_of_separation<bidirectional_universal_iterator_tag> () {return detail::one_degree_of_separation<bidirectional_universal_iterator_tag>();}
+
+};
+
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/detail/zip_iterator.inl

@@ -0,0 +1,160 @@
+/*
+ *  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/iterator/zip_iterator.h>
+#include <thrust/detail/tuple_transform.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+template<typename IteratorTuple>
+__host__ __device__
+  zip_iterator<IteratorTuple>
+    ::zip_iterator()
+{
+} // end zip_iterator::zip_iterator()
+
+
+template<typename IteratorTuple>
+__host__ __device__
+  zip_iterator<IteratorTuple>
+    ::zip_iterator(IteratorTuple iterator_tuple)
+      :m_iterator_tuple(iterator_tuple)
+{
+} // end zip_iterator::zip_iterator()
+
+
+template<typename IteratorTuple>
+  template<typename OtherIteratorTuple>
+  __host__ __device__
+    zip_iterator<IteratorTuple>
+      ::zip_iterator(const zip_iterator<OtherIteratorTuple> &other,
+                     typename thrust::detail::enable_if_convertible<
+                       OtherIteratorTuple,
+                       IteratorTuple
+                     >::type *)
+        :m_iterator_tuple(other.get_iterator_tuple())
+{
+} // end zip_iterator::zip_iterator()
+
+
+template<typename IteratorTuple>
+__host__ __device__
+const IteratorTuple &zip_iterator<IteratorTuple>
+  ::get_iterator_tuple() const
+{
+  return m_iterator_tuple;
+} // end zip_iterator::get_iterator_tuple()
+
+
+template<typename IteratorTuple>
+  typename zip_iterator<IteratorTuple>::super_t::reference
+  __host__ __device__
+    zip_iterator<IteratorTuple>
+      ::dereference() const
+{
+  using namespace detail::tuple_impl_specific;
+
+  return thrust::detail::tuple_host_device_transform<
+    detail::dereference_iterator::template apply
+  >(get_iterator_tuple(), detail::dereference_iterator());
+} // end zip_iterator::dereference()
+
+
+__thrust_exec_check_disable__
+template<typename IteratorTuple>
+  template<typename OtherIteratorTuple>
+  __host__ __device__
+    bool zip_iterator<IteratorTuple>
+      ::equal(const zip_iterator<OtherIteratorTuple> &other) const
+{
+  return get<0>(get_iterator_tuple()) == get<0>(other.get_iterator_tuple());
+} // end zip_iterator::equal()
+
+
+template<typename IteratorTuple>
+__host__ __device__
+  void zip_iterator<IteratorTuple>
+    ::advance(typename super_t::difference_type n)
+{
+  using namespace detail::tuple_impl_specific;
+  tuple_for_each(m_iterator_tuple,
+                 detail::advance_iterator<typename super_t::difference_type>(n));
+} // end zip_iterator::advance()
+
+
+template<typename IteratorTuple>
+__host__ __device__
+  void zip_iterator<IteratorTuple>
+    ::increment()
+{
+  using namespace detail::tuple_impl_specific;
+  tuple_for_each(m_iterator_tuple, detail::increment_iterator());
+} // end zip_iterator::increment()
+
+
+template<typename IteratorTuple>
+__host__ __device__
+  void zip_iterator<IteratorTuple>
+    ::decrement()
+{
+  using namespace detail::tuple_impl_specific;
+  tuple_for_each(m_iterator_tuple, detail::decrement_iterator());
+} // end zip_iterator::decrement()
+
+
+__thrust_exec_check_disable__
+template<typename IteratorTuple>
+  template <typename OtherIteratorTuple>
+  __host__ __device__
+    typename zip_iterator<IteratorTuple>::super_t::difference_type
+      zip_iterator<IteratorTuple>
+        ::distance_to(const zip_iterator<OtherIteratorTuple> &other) const
+{
+  return get<0>(other.get_iterator_tuple()) - get<0>(get_iterator_tuple());
+} // end zip_iterator::distance_to()
+
+
+template<typename... Iterators>
+__host__ __device__
+  zip_iterator<thrust::tuple<Iterators...>> make_zip_iterator(thrust::tuple<Iterators...> t)
+{
+  return zip_iterator<thrust::tuple<Iterators...>>(t);
+} // end make_zip_iterator()
+
+
+template<typename... Iterators>
+__host__ __device__
+  zip_iterator<thrust::tuple<Iterators...>> make_zip_iterator(Iterators... its)
+{
+  return make_zip_iterator(thrust::make_tuple(its...));
+} // end make_zip_iterator()
+
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/iterator/detail/zip_iterator_base.h

@@ -0,0 +1,361 @@
+/*
+ *  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/advance.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/iterator/iterator_facade.h>
+#include <thrust/iterator/iterator_categories.h>
+#include <thrust/iterator/detail/minimum_category.h>
+#include <thrust/iterator/detail/minimum_system.h>
+#include <thrust/type_traits/integer_sequence.h>
+#include <thrust/tuple.h>
+#include <thrust/detail/tuple_meta_transform.h>
+#include <thrust/detail/tuple_transform.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/tuple_of_iterator_references.h>
+
+THRUST_NAMESPACE_BEGIN
+
+// forward declare zip_iterator for zip_iterator_base
+template<typename IteratorTuple> class zip_iterator;
+
+namespace detail
+{
+
+
+// Functors to be used with tuple algorithms
+//
+template<typename DiffType>
+class advance_iterator
+{
+public:
+  inline __host__ __device__
+  advance_iterator(DiffType step) : m_step(step) {}
+
+  __thrust_exec_check_disable__
+  template<typename Iterator>
+  inline __host__ __device__
+  void operator()(Iterator& it) const
+  { thrust::advance(it, m_step); }
+
+private:
+  DiffType m_step;
+}; // end advance_iterator
+
+
+struct increment_iterator
+{
+  __thrust_exec_check_disable__
+  template<typename Iterator>
+  inline __host__ __device__
+  void operator()(Iterator& it)
+  { ++it; }
+}; // end increment_iterator
+
+
+struct decrement_iterator
+{
+  __thrust_exec_check_disable__
+  template<typename Iterator>
+  inline __host__ __device__
+  void operator()(Iterator& it)
+  { --it; }
+}; // end decrement_iterator
+
+
+struct dereference_iterator
+{
+  template<typename Iterator>
+  struct apply
+  {
+    typedef typename
+      iterator_traits<Iterator>::reference
+    type;
+  }; // end apply
+
+  // XXX silence warnings of the form "calling a __host__ function from a __host__ __device__ function is not allowed
+  __thrust_exec_check_disable__
+  template<typename Iterator>
+  __host__ __device__
+    typename apply<Iterator>::type operator()(Iterator const& it)
+  {
+    return *it;
+  }
+}; // end dereference_iterator
+
+
+// The namespace tuple_impl_specific provides two meta-
+// algorithms and two algorithms for tuples.
+namespace tuple_impl_specific
+{
+
+// define apply1 for tuple_meta_transform_impl
+template<typename UnaryMetaFunctionClass, class Arg>
+  struct apply1
+    : UnaryMetaFunctionClass::template apply<Arg>
+{
+}; // end apply1
+
+
+// define apply2 for tuple_meta_accumulate_impl
+template<typename UnaryMetaFunctionClass, class Arg1, class Arg2>
+  struct apply2
+    : UnaryMetaFunctionClass::template apply<Arg1,Arg2>
+{
+}; // end apply2
+
+
+// Meta-accumulate algorithm for tuples. Note: The template
+// parameter StartType corresponds to the initial value in
+// ordinary accumulation.
+//
+template<class Tuple, class BinaryMetaFun, class StartType>
+  struct tuple_meta_accumulate;
+
+template<
+    class BinaryMetaFun
+  , typename StartType
+>
+  struct tuple_meta_accumulate<thrust::tuple<>,BinaryMetaFun,StartType>
+{
+   typedef typename thrust::detail::identity_<StartType>::type type;
+};
+
+
+template<
+    class BinaryMetaFun
+  , typename StartType
+  , typename    T
+  , typename... Ts
+>
+  struct tuple_meta_accumulate<thrust::tuple<T,Ts...>,BinaryMetaFun,StartType>
+{
+   typedef typename apply2<
+       BinaryMetaFun
+     , T
+     , typename tuple_meta_accumulate<
+           thrust::tuple<Ts...>
+         , BinaryMetaFun
+         , StartType
+       >::type
+   >::type type;
+};
+
+
+template<typename Fun>
+inline __host__ __device__
+Fun tuple_for_each_helper(Fun f)
+{
+  return f;
+}
+
+template<typename Fun, typename T, typename... Ts>
+inline __host__ __device__
+Fun tuple_for_each_helper(Fun f, T& t, Ts&... ts)
+{
+  f(t);
+  return tuple_for_each_helper(f, ts...);
+}
+
+// for_each algorithm for tuples.
+
+template<typename Fun, typename... Ts, size_t... Is>
+inline __host__ __device__
+Fun tuple_for_each(thrust::tuple<Ts...>& t, Fun f, thrust::index_sequence<Is...>)
+{
+  return tuple_for_each_helper(f, thrust::get<Is>(t)...);
+} // end tuple_for_each()
+
+// for_each algorithm for tuples.
+template<typename Fun, typename... Ts>
+inline __host__ __device__
+Fun tuple_for_each(thrust::tuple<Ts...>& t, Fun f)
+{
+  return tuple_for_each(t, f, thrust::make_index_sequence<thrust::tuple_size<thrust::tuple<Ts...>>::value>{});
+}
+
+
+} // end tuple_impl_specific
+
+
+// Metafunction to obtain the type of the tuple whose element types
+// are the value_types of an iterator tupel.
+//
+template<typename IteratorTuple>
+  struct tuple_of_value_types
+    : tuple_meta_transform<
+          IteratorTuple,
+          iterator_value
+        >
+{
+}; // end tuple_of_value_types
+
+
+struct minimum_category_lambda
+{
+  template<typename T1, typename T2>
+    struct apply : minimum_category<T1,T2>
+  {};
+};
+
+
+
+// Metafunction to obtain the minimal traversal tag in a tuple
+// of iterators.
+//
+template<typename IteratorTuple>
+struct minimum_traversal_category_in_iterator_tuple
+{
+  typedef typename tuple_meta_transform<
+      IteratorTuple
+    , thrust::iterator_traversal
+  >::type tuple_of_traversal_tags;
+
+  typedef typename tuple_impl_specific::tuple_meta_accumulate<
+      tuple_of_traversal_tags
+    , minimum_category_lambda
+    , thrust::random_access_traversal_tag
+  >::type type;
+};
+
+
+struct minimum_system_lambda
+{
+  template<typename T1, typename T2>
+    struct apply : minimum_system<T1,T2>
+  {};
+};
+
+
+
+// Metafunction to obtain the minimal system tag in a tuple
+// of iterators.
+template<typename IteratorTuple>
+struct minimum_system_in_iterator_tuple
+{
+  typedef typename thrust::detail::tuple_meta_transform<
+    IteratorTuple,
+    thrust::iterator_system
+  >::type tuple_of_system_tags;
+
+  typedef typename tuple_impl_specific::tuple_meta_accumulate<
+    tuple_of_system_tags,
+    minimum_system_lambda,
+    thrust::any_system_tag
+  >::type type;
+};
+
+namespace zip_iterator_base_ns
+{
+
+
+template<typename Tuple, typename IndexSequence>
+  struct tuple_of_iterator_references_helper;
+
+
+template<typename Tuple, size_t... Is>
+  struct tuple_of_iterator_references_helper<Tuple, thrust::index_sequence<Is...>>
+{
+  typedef thrust::detail::tuple_of_iterator_references<
+    typename thrust::tuple_element<Is,Tuple>::type...
+  > type;
+};
+
+
+template<typename IteratorTuple>
+  struct tuple_of_iterator_references
+{
+  // get a thrust::tuple of the iterators' references
+  typedef typename tuple_meta_transform<
+    IteratorTuple,
+    iterator_reference
+  >::type tuple_of_references;
+
+  // map thrust::tuple<T...> to tuple_of_iterator_references<T...>
+  typedef typename tuple_of_iterator_references_helper<
+    tuple_of_references,
+    thrust::make_index_sequence<thrust::tuple_size<tuple_of_references>::value>
+  >::type type;
+};
+
+
+} // end zip_iterator_base_ns
+
+///////////////////////////////////////////////////////////////////
+//
+// Class zip_iterator_base
+//
+// Builds and exposes the iterator facade type from which the zip
+// iterator will be derived.
+//
+template<typename IteratorTuple>
+  struct zip_iterator_base
+{
+ //private:
+    // reference type is the type of the tuple obtained from the
+    // iterators' reference types.
+    typedef typename zip_iterator_base_ns::tuple_of_iterator_references<IteratorTuple>::type reference;
+
+    // Boost's Value type is the same as reference type.
+    //typedef reference value_type;
+    typedef typename tuple_of_value_types<IteratorTuple>::type value_type;
+
+    // Difference type is the first iterator's difference type
+    typedef typename thrust::iterator_traits<
+      typename thrust::tuple_element<0, IteratorTuple>::type
+    >::difference_type difference_type;
+
+    // Iterator system is the minimum system tag in the
+    // iterator tuple
+    typedef typename
+    minimum_system_in_iterator_tuple<IteratorTuple>::type system;
+
+    // Traversal category is the minimum traversal category in the
+    // iterator tuple
+    typedef typename
+    minimum_traversal_category_in_iterator_tuple<IteratorTuple>::type traversal_category;
+
+ public:
+
+    // The iterator facade type from which the zip iterator will
+    // be derived.
+    typedef thrust::iterator_facade<
+        zip_iterator<IteratorTuple>,
+        value_type,
+        system,
+        traversal_category,
+        reference,
+        difference_type
+    > type;
+}; // end zip_iterator_base
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
+

miniCUDA124/include/thrust/random/detail/discard_block_engine.inl

@@ -0,0 +1,223 @@
+/*
+ *  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/random/discard_block_engine.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+
+template<typename Engine, size_t p, size_t r>
+  __host__ __device__
+  discard_block_engine<Engine,p,r>
+    ::discard_block_engine()
+      : m_e(), m_n(0)
+{}
+
+
+template<typename Engine, size_t p, size_t r>
+  __host__ __device__
+  discard_block_engine<Engine,p,r>
+    ::discard_block_engine(result_type s)
+      : m_e(s), m_n(0)
+{}
+
+
+template<typename Engine, size_t p, size_t r>
+  __host__ __device__
+  discard_block_engine<Engine,p,r>
+    ::discard_block_engine(const base_type &urng)
+      : m_e(urng), m_n(0)
+{}
+
+
+template<typename Engine, size_t p, size_t r>
+  __host__ __device__
+  void discard_block_engine<Engine,p,r>
+    ::seed(void)
+{
+  m_e.seed();
+  m_n = 0;
+}
+
+
+template<typename Engine, size_t p, size_t r>
+  __host__ __device__
+  void discard_block_engine<Engine,p,r>
+    ::seed(result_type s)
+{
+  m_e.seed(s);
+  m_n = 0;
+}
+
+
+template<typename Engine, size_t p, size_t r>
+  __host__ __device__
+  typename discard_block_engine<Engine,p,r>::result_type
+    discard_block_engine<Engine,p,r>
+      ::operator()(void)
+{
+  if(m_n >= used_block)
+  {
+    m_e.discard(block_size - m_n);
+//    for(; m_n < block_size; ++m_n)
+//      m_e();
+    m_n = 0;
+  }
+
+  ++m_n;
+
+  return m_e();
+}
+
+
+template<typename Engine, size_t p, size_t r>
+  __host__ __device__
+  void discard_block_engine<Engine,p,r>
+    ::discard(unsigned long long z)
+{
+  // XXX this should be accelerated
+  for(; z > 0; --z)
+  {
+    this->operator()();
+  } // end for
+}
+
+
+template<typename Engine, size_t p, size_t r>
+  __host__ __device__
+  const typename discard_block_engine<Engine,p,r>::base_type &
+    discard_block_engine<Engine,p,r>
+      ::base(void) const
+{
+  return m_e;
+}
+
+
+template<typename Engine, size_t p, size_t r>
+  template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& discard_block_engine<Engine,p,r>
+      ::stream_out(std::basic_ostream<CharT,Traits> &os) const
+{
+  typedef std::basic_ostream<CharT,Traits> ostream_type;
+  typedef typename ostream_type::ios_base  ios_base;
+
+  // save old flags & fill character
+  const typename ios_base::fmtflags flags = os.flags();
+  const CharT fill = os.fill();
+
+  const CharT space = os.widen(' ');
+  os.flags(ios_base::dec | ios_base::fixed | ios_base::left);
+  os.fill(space);
+
+  // output the base engine followed by n
+  os << m_e << space << m_n;
+
+  // restore flags & fill character
+  os.flags(flags);
+  os.fill(fill);
+
+  return os;
+}
+
+
+template<typename Engine, size_t p, size_t r>
+  template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& discard_block_engine<Engine,p,r>
+      ::stream_in(std::basic_istream<CharT,Traits> &is)
+{
+  typedef std::basic_istream<CharT,Traits> istream_type;
+  typedef typename istream_type::ios_base  ios_base;
+
+  // save old flags
+  const typename ios_base::fmtflags flags = is.flags();
+
+  is.flags(ios_base::skipws);
+
+  // input the base engine and then n
+  is >> m_e >> m_n;
+
+  // restore old flags
+  is.flags(flags);
+  return is;
+}
+
+
+template<typename Engine, size_t p, size_t r>
+  __host__ __device__
+  bool discard_block_engine<Engine,p,r>
+    ::equal(const discard_block_engine<Engine,p,r> &rhs) const
+{
+  return (m_e == rhs.m_e) && (m_n == rhs.m_n);
+}
+
+
+template<typename Engine, size_t p, size_t r,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const discard_block_engine<Engine,p,r> &e)
+{
+  return thrust::random::detail::random_core_access::stream_out(os,e);
+}
+
+
+template<typename Engine, size_t p, size_t r,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           discard_block_engine<Engine,p,r> &e)
+{
+  return thrust::random::detail::random_core_access::stream_in(is,e);
+}
+
+
+template<typename Engine, size_t p, size_t r>
+__host__ __device__
+bool operator==(const discard_block_engine<Engine,p,r> &lhs,
+                const discard_block_engine<Engine,p,r> &rhs)
+{
+  return thrust::random::detail::random_core_access::equal(lhs,rhs);
+}
+
+
+template<typename Engine, size_t p, size_t r>
+__host__ __device__
+bool operator!=(const discard_block_engine<Engine,p,r> &lhs,
+                const discard_block_engine<Engine,p,r> &rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // end random
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/random/detail/linear_congruential_engine.inl

@@ -0,0 +1,180 @@
+/*
+ *  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/random/linear_congruential_engine.h>
+#include <thrust/random/detail/mod.h>
+#include <thrust/random/detail/random_core_access.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+
+template<typename UIntType, UIntType a, UIntType c, UIntType m>
+  __host__ __device__
+  linear_congruential_engine<UIntType,a,c,m>
+    ::linear_congruential_engine(result_type s)
+{
+  seed(s);
+} // end linear_congruential_engine::linear_congruential_engine()
+
+
+template<typename UIntType, UIntType a, UIntType c, UIntType m>
+  __host__ __device__
+  void linear_congruential_engine<UIntType,a,c,m>
+    ::seed(result_type s)
+{
+  if((detail::mod<UIntType, 1, 0, m>(c) == 0) &&
+     (detail::mod<UIntType, 1, 0, m>(s) == 0))
+    m_x = detail::mod<UIntType, 1, 0, m>(1);
+  else
+    m_x = detail::mod<UIntType, 1, 0, m>(s);
+} // end linear_congruential_engine::seed()
+
+
+template<typename UIntType, UIntType a, UIntType c, UIntType m>
+  __host__ __device__
+  typename linear_congruential_engine<UIntType,a,c,m>::result_type
+    linear_congruential_engine<UIntType,a,c,m>
+      ::operator()(void)
+{
+  m_x = detail::mod<UIntType,a,c,m>(m_x);
+  return m_x;
+} // end linear_congruential_engine::operator()()
+
+
+template<typename UIntType, UIntType a, UIntType c, UIntType m>
+  __host__ __device__
+  void linear_congruential_engine<UIntType,a,c,m>
+    ::discard(unsigned long long z)
+{
+  thrust::random::detail::linear_congruential_engine_discard::discard(*this,z);
+} // end linear_congruential_engine::discard()
+
+
+template<typename UIntType, UIntType a, UIntType c, UIntType m>
+  template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& linear_congruential_engine<UIntType,a,c,m>
+      ::stream_out(std::basic_ostream<CharT,Traits> &os) const
+{
+  typedef std::basic_ostream<CharT,Traits> ostream_type;
+  typedef typename ostream_type::ios_base  ios_base;
+
+  // save old flags & fill character
+  const typename ios_base::fmtflags flags = os.flags();
+  const CharT fill = os.fill();
+
+  os.flags(ios_base::dec | ios_base::fixed | ios_base::left);
+  os.fill(os.widen(' '));
+
+  // output one word of state
+  os << m_x;
+
+  // restore flags & fill character
+  os.flags(flags);
+  os.fill(fill);
+
+  return os;
+}
+
+
+template<typename UIntType, UIntType a, UIntType c, UIntType m>
+  template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& linear_congruential_engine<UIntType,a,c,m>
+      ::stream_in(std::basic_istream<CharT,Traits> &is)
+{
+  typedef std::basic_istream<CharT,Traits> istream_type;
+  typedef typename istream_type::ios_base     ios_base;
+
+  // save old flags
+  const typename ios_base::fmtflags flags = is.flags();
+
+  is.flags(ios_base::dec);
+
+  // input one word of state
+  is >> m_x;
+
+  // restore flags
+  is.flags(flags);
+
+  return is;
+}
+
+
+template<typename UIntType, UIntType a, UIntType c, UIntType m>
+__host__ __device__
+bool linear_congruential_engine<UIntType,a,c,m>
+  ::equal(const linear_congruential_engine<UIntType,a,c,m> &rhs) const
+{
+  return m_x == rhs.m_x;
+}
+
+
+template<typename UIntType_, UIntType_ a_, UIntType_ c_, UIntType_ m_>
+__host__ __device__
+bool operator==(const linear_congruential_engine<UIntType_,a_,c_,m_> &lhs,
+                const linear_congruential_engine<UIntType_,a_,c_,m_> &rhs)
+{
+  return detail::random_core_access::equal(lhs,rhs);
+}
+
+
+template<typename UIntType, UIntType a, UIntType c, UIntType m>
+__host__ __device__
+bool operator!=(const linear_congruential_engine<UIntType,a,c,m> &lhs,
+                const linear_congruential_engine<UIntType,a,c,m> &rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+template<typename UIntType_, UIntType_ a_, UIntType_ c_, UIntType_ m_,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const linear_congruential_engine<UIntType_,a_,c_,m_> &e)
+{
+  return detail::random_core_access::stream_out(os,e);
+}
+
+
+template<typename UIntType_, UIntType_ a_, UIntType_ c_, UIntType_ m_,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           linear_congruential_engine<UIntType_,a_,c_,m_> &e)
+{
+  return detail::random_core_access::stream_in(is,e);
+}
+
+
+} // end random
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/random/detail/linear_congruential_engine_discard.h

@@ -0,0 +1,116 @@
+/*
+ *  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/cstdint.h>
+#include <thrust/random/detail/mod.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+namespace detail
+{
+
+
+template<typename UIntType, UIntType a, unsigned long long c, UIntType m>
+  struct linear_congruential_engine_discard_implementation
+{
+  __host__ __device__
+  static void discard(UIntType &state, unsigned long long z)
+  {
+    for(; z > 0; --z)
+    {
+      state = detail::mod<UIntType,a,c,m>(state);
+    }
+  }
+}; // end linear_congruential_engine_discard
+
+
+// specialize for small integers and c == 0
+// XXX figure out a robust implemenation of this for any unsigned integer type later
+template<thrust::detail::uint32_t a, thrust::detail::uint32_t m>
+  struct linear_congruential_engine_discard_implementation<thrust::detail::uint32_t,a,0,m>
+{
+  __host__ __device__
+  static void discard(thrust::detail::uint32_t &state, unsigned long long z)
+  {
+    const thrust::detail::uint32_t modulus = m;
+
+    // XXX we need to use unsigned long long here or we will encounter overflow in the
+    //     multiplies below
+    //     figure out a robust implementation of this later
+    unsigned long long multiplier = a;
+    unsigned long long multiplier_to_z = 1;
+
+    // see http://en.wikipedia.org/wiki/Modular_exponentiation
+    while(z > 0)
+    {
+      if(z & 1)
+      {
+        // multiply in this bit's contribution while using modulus to keep result small
+        multiplier_to_z = (multiplier_to_z * multiplier) % modulus;
+      }
+
+      // move to the next bit of the exponent, square (and mod) the base accordingly
+      z >>= 1;
+      multiplier = (multiplier * multiplier) % modulus;
+    }
+
+    state = static_cast<thrust::detail::uint32_t>((multiplier_to_z * state) % modulus);
+  }
+}; // end linear_congruential_engine_discard
+
+
+struct linear_congruential_engine_discard
+{
+  template<typename LinearCongruentialEngine>
+  __host__ __device__
+  static void discard(LinearCongruentialEngine &lcg, unsigned long long z)
+  {
+    typedef typename LinearCongruentialEngine::result_type result_type;
+    const result_type c = LinearCongruentialEngine::increment;
+    const result_type a = LinearCongruentialEngine::multiplier;
+    const result_type m = LinearCongruentialEngine::modulus;
+
+    // XXX WAR unused variable warnings
+    (void) c;
+    (void) a;
+    (void) m;
+
+    linear_congruential_engine_discard_implementation<result_type,a,c,m>::discard(lcg.m_x, z);
+  }
+}; // end linear_congruential_engine_discard
+
+
+} // end detail
+
+} // end random
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/random/detail/linear_feedback_shift_engine.inl

@@ -0,0 +1,176 @@
+/*
+ *  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/random/linear_feedback_shift_engine.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
+  __host__ __device__
+  linear_feedback_shift_engine<UIntType,w,k,q,s>
+    ::linear_feedback_shift_engine(result_type value)
+{
+  seed(value);
+} // end linear_feedback_shift_engine::linear_feedback_shift_engine()
+
+template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
+  __host__ __device__
+  void linear_feedback_shift_engine<UIntType,w,k,q,s>
+    ::seed(result_type value)
+{
+  m_value = value;
+} // end linear_feedback_shift_engine::seed()
+
+template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
+  __host__ __device__
+  typename linear_feedback_shift_engine<UIntType,w,k,q,s>::result_type
+    linear_feedback_shift_engine<UIntType,w,k,q,s>
+      ::operator()(void)
+{
+  const UIntType b = (((m_value << q) ^ m_value) & wordmask) >> (k-s);
+  const UIntType mask = ( (~static_cast<UIntType>(0)) << (w-k) ) & wordmask;
+  m_value = ((m_value & mask) << s) ^ b;
+  return m_value;
+} // end linear_feedback_shift_engine::operator()()
+
+
+template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
+  __host__ __device__
+  void linear_feedback_shift_engine<UIntType,w,k,q,s>
+    ::discard(unsigned long long z)
+{
+  for(; z > 0; --z)
+  {
+    this->operator()();
+  } // end for
+} // end linear_feedback_shift_engine::discard()
+
+
+template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
+  template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& linear_feedback_shift_engine<UIntType,w,k,q,s>
+      ::stream_out(std::basic_ostream<CharT,Traits> &os) const
+{
+  typedef std::basic_ostream<CharT,Traits> ostream_type;
+  typedef typename ostream_type::ios_base  ios_base;
+
+  // save old flags & fill character
+  const typename ios_base::fmtflags flags = os.flags();
+  const CharT fill = os.fill();
+
+  os.flags(ios_base::dec | ios_base::fixed | ios_base::left);
+  os.fill(os.widen(' '));
+
+  // output one word of state
+  os << m_value;
+
+  // restore flags & fill character
+  os.flags(flags);
+  os.fill(fill);
+
+  return os;
+}
+
+
+template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
+  template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& linear_feedback_shift_engine<UIntType,w,k,q,s>
+      ::stream_in(std::basic_istream<CharT,Traits> &is)
+{
+  typedef std::basic_istream<CharT,Traits> istream_type;
+  typedef typename istream_type::ios_base     ios_base;
+
+  // save old flags
+  const typename ios_base::fmtflags flags = is.flags();
+
+  is.flags(ios_base::skipws);
+
+  // input one word of state
+  is >> m_value;
+
+  // restore flags
+  is.flags(flags);
+
+  return is;
+}
+
+
+template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
+  __host__ __device__
+  bool linear_feedback_shift_engine<UIntType,w,k,q,s>
+    ::equal(const linear_feedback_shift_engine<UIntType,w,k,q,s> &rhs) const
+{
+  return m_value == rhs.m_value;
+}
+
+
+template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
+__host__ __device__
+bool operator==(const linear_feedback_shift_engine<UIntType,w,k,q,s> &lhs,
+                const linear_feedback_shift_engine<UIntType,w,k,q,s> &rhs)
+{
+  return thrust::random::detail::random_core_access::equal(lhs,rhs);
+}
+
+
+template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
+__host__ __device__
+bool operator!=(const linear_feedback_shift_engine<UIntType,w,k,q,s> &lhs,
+                const linear_feedback_shift_engine<UIntType,w,k,q,s> &rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+template<typename UIntType_, size_t w_, size_t k_, size_t q_, size_t s_,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &e)
+{
+  return thrust::random::detail::random_core_access::stream_out(os,e);
+}
+
+
+template<typename UIntType_, size_t w_, size_t k_, size_t q_, size_t s_,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &e)
+{
+  return thrust::random::detail::random_core_access::stream_in(is,e);
+}
+
+
+} // end random
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/random/detail/linear_feedback_shift_engine_wordmask.h

@@ -0,0 +1,56 @@
+/*
+ *  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 random
+{
+
+namespace detail
+{
+
+template<typename T, int w, int i = w-1>
+  struct linear_feedback_shift_engine_wordmask
+{
+  static const T value =
+    (T(1u) << i) |
+    linear_feedback_shift_engine_wordmask<T, w, i-1>::value;
+}; // end linear_feedback_shift_engine_wordmask
+
+template<typename T, int w>
+  struct linear_feedback_shift_engine_wordmask<T, w, 0>
+{
+  static const T value = 0;
+}; // end linear_feedback_shift_engine_wordmask
+
+} // end detail
+
+} // end random
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/random/detail/mod.h

@@ -0,0 +1,106 @@
+/*
+ *  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 random
+{
+
+namespace detail
+{
+
+template<typename T, T a, T c, T m, bool = (m == 0)>
+  struct static_mod
+{
+  static const T q = m / a;
+  static const T r = m % a;
+
+  __host__ __device__
+  T operator()(T x) const
+  {
+    THRUST_IF_CONSTEXPR(a == 1)
+    {
+      x %= m;
+    }
+    else
+    {
+      T t1 = a * (x % q);
+      T t2 = r * (x / q);
+      if(t1 >= t2)
+      {
+        x = t1 - t2;
+      }
+      else
+      {
+        x = m - t2 + t1;
+      }
+    }
+
+    THRUST_IF_CONSTEXPR(c != 0)
+    {
+      const T d = m - x;
+      if(d > c)
+      {
+        x += c;
+      }
+      else
+      {
+        x = c - d;
+      }
+    }
+
+    return x;
+  }
+}; // end static_mod
+
+
+// Rely on machine overflow handling
+template<typename T, T a, T c, T m>
+  struct static_mod<T,a,c,m,true>
+{
+  __host__ __device__
+  T operator()(T x) const
+  {
+    return a * x + c;
+  }
+}; // end static_mod
+
+template<typename T, T a, T c, T m>
+__host__ __device__
+  T mod(T x)
+{
+  static_mod<T,a,c,m> f;
+  return f(x);
+} // end static_mod
+
+} // end detail
+
+} // end random
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/random/detail/normal_distribution.inl

@@ -0,0 +1,265 @@
+/*
+ *  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/random/normal_distribution.h>
+#include <thrust/random/uniform_real_distribution.h>
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/integer_traits.h>
+
+// for floating point infinity
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <math_constants.h>
+#else
+#include <limits>
+#endif
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+
+template<typename RealType>
+  __host__ __device__
+  normal_distribution<RealType>
+    ::normal_distribution(RealType a, RealType b)
+      :super_t(),m_param(a,b)
+{
+} // end normal_distribution::normal_distribution()
+
+
+template<typename RealType>
+  __host__ __device__
+  normal_distribution<RealType>
+    ::normal_distribution(const param_type &parm)
+      :super_t(),m_param(parm)
+{
+} // end normal_distribution::normal_distribution()
+
+
+template<typename RealType>
+  __host__ __device__
+  void normal_distribution<RealType>
+    ::reset(void)
+{
+  super_t::reset();
+} // end normal_distribution::reset()
+
+
+template<typename RealType>
+  template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    typename normal_distribution<RealType>::result_type
+      normal_distribution<RealType>
+        ::operator()(UniformRandomNumberGenerator &urng)
+{
+  return operator()(urng, m_param);
+} // end normal_distribution::operator()()
+
+
+template<typename RealType>
+  template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    typename normal_distribution<RealType>::result_type
+      normal_distribution<RealType>
+        ::operator()(UniformRandomNumberGenerator &urng,
+                     const param_type &parm)
+{
+  return super_t::sample(urng, parm.first, parm.second);
+} // end normal_distribution::operator()()
+
+
+template<typename RealType>
+  __host__ __device__
+  typename normal_distribution<RealType>::param_type
+    normal_distribution<RealType>
+      ::param(void) const
+{
+  return m_param;
+} // end normal_distribution::param()
+
+
+template<typename RealType>
+  __host__ __device__
+  void normal_distribution<RealType>
+    ::param(const param_type &parm)
+{
+  m_param = parm;
+} // end normal_distribution::param()
+
+
+template<typename RealType>
+  __host__ __device__
+  typename normal_distribution<RealType>::result_type
+    normal_distribution<RealType>
+      ::min THRUST_PREVENT_MACRO_SUBSTITUTION (void) const
+{
+  return -this->max THRUST_PREVENT_MACRO_SUBSTITUTION ();
+} // end normal_distribution::min()
+
+
+template<typename RealType>
+  __host__ __device__
+  typename normal_distribution<RealType>::result_type
+    normal_distribution<RealType>
+      ::max THRUST_PREVENT_MACRO_SUBSTITUTION (void) const
+{
+  // XXX this solution is pretty terrible
+  // we can't use numeric_traits<RealType>::max because nvcc will
+  // complain that it is a __host__ function
+  union
+  {
+    thrust::detail::uint32_t inf_as_int;
+    float result;
+  } hack;
+
+  hack.inf_as_int = 0x7f800000u;
+
+  return hack.result;
+} // end normal_distribution::max()
+
+
+template<typename RealType>
+  __host__ __device__
+  typename normal_distribution<RealType>::result_type
+    normal_distribution<RealType>
+      ::mean(void) const
+{
+  return m_param.first;
+} // end normal_distribution::mean()
+
+
+template<typename RealType>
+  __host__ __device__
+  typename normal_distribution<RealType>::result_type
+    normal_distribution<RealType>
+      ::stddev(void) const
+{
+  return m_param.second;
+} // end normal_distribution::stddev()
+
+
+template<typename RealType>
+  __host__ __device__
+  bool normal_distribution<RealType>
+    ::equal(const normal_distribution &rhs) const
+{
+  return m_param == rhs.param();
+}
+
+
+template<typename RealType>
+  template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>&
+      normal_distribution<RealType>
+        ::stream_out(std::basic_ostream<CharT,Traits> &os) const
+{
+  typedef std::basic_ostream<CharT,Traits> ostream_type;
+  typedef typename ostream_type::ios_base  ios_base;
+
+  // save old flags and fill character
+  const typename ios_base::fmtflags flags = os.flags();
+  const CharT fill = os.fill();
+
+  const CharT space = os.widen(' ');
+  os.flags(ios_base::dec | ios_base::fixed | ios_base::left);
+  os.fill(space);
+
+  os << mean() << space << stddev();
+
+  // restore old flags and fill character
+  os.flags(flags);
+  os.fill(fill);
+  return os;
+}
+
+
+template<typename RealType>
+  template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>&
+      normal_distribution<RealType>
+        ::stream_in(std::basic_istream<CharT,Traits> &is)
+{
+  typedef std::basic_istream<CharT,Traits> istream_type;
+  typedef typename istream_type::ios_base  ios_base;
+
+  // save old flags
+  const typename ios_base::fmtflags flags = is.flags();
+
+  is.flags(ios_base::skipws);
+
+  is >> m_param.first >> m_param.second;
+
+  // restore old flags
+  is.flags(flags);
+  return is;
+}
+
+
+template<typename RealType>
+__host__ __device__
+bool operator==(const normal_distribution<RealType> &lhs,
+                const normal_distribution<RealType> &rhs)
+{
+  return thrust::random::detail::random_core_access::equal(lhs,rhs);
+}
+
+
+template<typename RealType>
+__host__ __device__
+bool operator!=(const normal_distribution<RealType> &lhs,
+                const normal_distribution<RealType> &rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+template<typename RealType,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const normal_distribution<RealType> &d)
+{
+  return thrust::random::detail::random_core_access::stream_out(os,d);
+}
+
+
+template<typename RealType,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           normal_distribution<RealType> &d)
+{
+  return thrust::random::detail::random_core_access::stream_in(is,d);
+}
+
+
+} // end random
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/random/detail/normal_distribution_base.h

@@ -0,0 +1,156 @@
+/*
+ *  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.
+ */
+
+/*
+ * Copyright Jens Maurer 2000-2001
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.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/pair.h>
+#include <thrust/random/uniform_real_distribution.h>
+#include <limits>
+#include <cmath>
+
+THRUST_NAMESPACE_BEGIN
+namespace random
+{
+namespace detail
+{
+
+// this version samples the normal distribution directly
+// and uses the non-standard math function erfcinv
+template<typename RealType>
+  class normal_distribution_nvcc
+{
+  protected:
+    template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    RealType sample(UniformRandomNumberGenerator &urng, const RealType mean, const RealType stddev)
+    {
+      using uint_type = typename UniformRandomNumberGenerator::result_type;
+      constexpr uint_type urng_range = UniformRandomNumberGenerator::max - UniformRandomNumberGenerator::min;
+
+      // Constants for conversion
+      constexpr RealType S1 = static_cast<RealType>(1. / static_cast<double>(urng_range));
+      constexpr RealType S2 = S1 / 2;
+
+      RealType S3 = static_cast<RealType>(-1.4142135623730950488016887242097); // -sqrt(2)
+
+      // Get the integer value
+      uint_type u = urng() - UniformRandomNumberGenerator::min;
+
+      // Ensure the conversion to float will give a value in the range [0,0.5)
+      if(u > (urng_range / 2))
+      {
+        u = urng_range - u;
+        S3 = -S3;
+      }
+
+      // Convert to floating point in [0,0.5)
+      RealType p = u*S1 + S2;
+
+      // Apply inverse error function
+      return mean + stddev * S3 * erfcinv(2 * p);
+    }
+
+    // no-op
+    __host__ __device__
+    void reset() {}
+};
+
+// this version samples the normal distribution using
+// Marsaglia's "polar method"
+template<typename RealType>
+  class normal_distribution_portable
+{
+  protected:
+    normal_distribution_portable()
+      : m_r1(), m_r2(), m_cached_rho(), m_valid(false)
+    {}
+
+    normal_distribution_portable(const normal_distribution_portable &other)
+      : m_r1(other.m_r1), m_r2(other.m_r2), m_cached_rho(other.m_cached_rho), m_valid(other.m_valid)
+    {}
+
+    void reset()
+    {
+      m_valid = false;
+    }
+
+    // note that we promise to call this member function with the same mean and stddev
+    template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    RealType sample(UniformRandomNumberGenerator &urng, const RealType mean, const RealType stddev)
+    {
+      // implementation from Boost
+      // allow for Koenig lookup
+      using std::sqrt; using std::log; using std::sin; using std::cos;
+
+      if(!m_valid)
+      {
+        uniform_real_distribution<RealType> u01;
+        m_r1 = u01(urng);
+        m_r2 = u01(urng);
+        m_cached_rho = sqrt(-RealType(2) * log(RealType(1)-m_r2));
+
+        m_valid = true;
+      }
+      else
+      {
+        m_valid = false;
+      }
+
+      const RealType pi = RealType(3.14159265358979323846);
+
+      RealType result = m_cached_rho * (m_valid ?
+                          cos(RealType(2)*pi*m_r1) :
+                          sin(RealType(2)*pi*m_r1));
+
+      return mean + stddev * result;
+    }
+
+  private:
+    RealType m_r1, m_r2, m_cached_rho;
+    bool m_valid;
+};
+
+template<typename RealType>
+  struct normal_distribution_base
+{
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC && !defined(_NVHPC_CUDA)
+  typedef normal_distribution_nvcc<RealType> type;
+#else
+  typedef normal_distribution_portable<RealType> type;
+#endif
+};
+
+} // end detail
+} // end random
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/random/detail/random_core_access.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
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+namespace detail
+{
+
+struct random_core_access
+{
+
+template<typename OStream, typename EngineOrDistribution>
+static OStream &stream_out(OStream &os, const EngineOrDistribution &x)
+{
+  return x.stream_out(os);
+}
+
+template<typename IStream, typename EngineOrDistribution>
+static IStream &stream_in(IStream &is, EngineOrDistribution &x)
+{
+  return x.stream_in(is);
+}
+
+template<typename EngineOrDistribution>
+__host__ __device__
+static bool equal(const EngineOrDistribution &lhs, const EngineOrDistribution &rhs)
+{
+  return lhs.equal(rhs);
+}
+
+}; // end random_core_access
+
+} // end detail
+
+} // end random
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/random/detail/subtract_with_carry_engine.inl

@@ -0,0 +1,221 @@
+/*
+ *  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/random/linear_congruential_engine.h>
+#include <thrust/random/subtract_with_carry_engine.h>
+#include <thrust/random/detail/mod.h>
+#include <thrust/random/detail/random_core_access.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+
+template<typename UIntType, size_t w, size_t s, size_t r>
+  __host__ __device__
+  subtract_with_carry_engine<UIntType,w,s,r>
+    ::subtract_with_carry_engine(result_type value)
+{
+  seed(value);
+} // end subtract_with_carry_engine::subtract_with_carry_engine()
+
+
+template<typename UIntType, size_t w, size_t s, size_t r>
+  __host__ __device__
+  void subtract_with_carry_engine<UIntType,w,s,r>
+    ::seed(result_type value)
+{
+  thrust::random::linear_congruential_engine<result_type,
+    40014u, 0u, 2147483563u> e(value == 0u ? default_seed : value);
+
+  // initialize state
+  for(size_t i = 0; i < long_lag; ++i)
+  {
+    m_x[i] = detail::mod<UIntType, 1, 0, modulus>(e());
+  } // end for i
+
+  m_carry = (m_x[long_lag-1] == 0);
+  m_k = 0;
+} // end subtract_with_carry_engine::seed()
+
+
+template<typename UIntType, size_t w, size_t s, size_t r>
+  __host__ __device__
+  typename subtract_with_carry_engine<UIntType,w,s,r>::result_type
+    subtract_with_carry_engine<UIntType,w,s,r>
+      ::operator()(void)
+{
+  // XXX we probably need to cache these m_x[m_k] in a register
+  //     maybe we need to cache the use of all member variables
+  int short_index = m_k - short_lag;
+  if(short_index < 0)
+    short_index += long_lag;
+  result_type xi;
+  if (m_x[short_index] >= m_x[m_k] + m_carry)
+  {
+    // x(n) >= 0
+    xi =  m_x[short_index] - m_x[m_k] - m_carry;
+    m_carry = 0;
+  }
+  else
+  {
+    // x(n) < 0
+    xi = modulus - m_x[m_k] - m_carry + m_x[short_index];
+    m_carry = 1;
+  }
+  m_x[m_k] = xi;
+  ++m_k;
+  if(m_k >= long_lag)
+    m_k = 0;
+  return xi;
+} // end subtract_with_carry_engine::operator()()
+
+
+template<typename UIntType, size_t w, size_t s, size_t r>
+  __host__ __device__
+  void subtract_with_carry_engine<UIntType,w,s,r>
+    ::discard(unsigned long long z)
+{
+  for(; z > 0; --z)
+  {
+    this->operator()();
+  } // end for
+} // end subtract_with_carry_engine::discard()
+
+
+template<typename UIntType, size_t w, size_t s, size_t r>
+  template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& subtract_with_carry_engine<UIntType,w,s,r>
+      ::stream_out(std::basic_ostream<CharT,Traits> &os) const
+{
+  typedef std::basic_ostream<CharT,Traits> ostream_type;
+  typedef typename ostream_type::ios_base     ios_base;
+
+  const typename ios_base::fmtflags flags = os.flags();
+  const CharT fill  = os.fill();
+  const CharT space = os.widen(' ');
+  os.flags(ios_base::dec | ios_base::fixed | ios_base::left);
+  os.fill(space);
+
+  const UIntType long_lag_ = r;
+
+  for(size_t i = 0; i < r; ++i)
+    os << m_x[(i + m_k) % long_lag_] << space;
+  os << m_carry;
+
+  os.flags(flags);
+  os.fill(fill);
+  return os;
+}
+
+
+template<typename UIntType, size_t w, size_t s, size_t r>
+  template<typename CharType, typename Traits>
+    std::basic_istream<CharType,Traits>& subtract_with_carry_engine<UIntType,w,s,r>
+      ::stream_in(std::basic_istream<CharType,Traits> &is)
+{
+  typedef std::basic_istream<CharType,Traits> istream_type;
+  typedef typename istream_type::ios_base     ios_base;
+
+  const typename ios_base::fmtflags flags = is.flags();
+  is.flags(ios_base::dec | ios_base::skipws);
+
+  for(size_t i = 0; i < r; ++i)
+    is >> m_x[i];
+  is >> m_carry;
+
+  m_k = 0;
+
+  is.flags(flags);
+  return is;
+}
+
+
+template<typename UIntType, size_t w, size_t s, size_t r>
+  __host__ __device__
+  bool subtract_with_carry_engine<UIntType,w,s,r>
+    ::equal(const subtract_with_carry_engine<UIntType,w,s,r> &rhs) const
+{
+  const UIntType long_lag_ = r;
+
+  bool result = true;
+  for(size_t i = 0; i < r; ++i)
+  {
+    result &= (m_x[(i + m_k) % long_lag_] == rhs.m_x[(i + rhs.m_k) % long_lag_]);
+  }
+
+  // XXX not sure if this last check is necessary
+  result &= (m_carry == rhs.m_carry);
+
+  return result;
+}
+
+
+template<typename UIntType, size_t w, size_t s, size_t r,
+         typename CharT, typename Traits>
+  std::basic_ostream<CharT,Traits>&
+    operator<<(std::basic_ostream<CharT,Traits> &os,
+               const subtract_with_carry_engine<UIntType,w,s,r> &e)
+{
+  return thrust::random::detail::random_core_access::stream_out(os,e);
+}
+
+
+template<typename UIntType, size_t w, size_t s, size_t r,
+         typename CharType, typename Traits>
+  std::basic_istream<CharType,Traits>&
+    operator>>(std::basic_istream<CharType,Traits> &is,
+               subtract_with_carry_engine<UIntType,w,s,r> &e)
+{
+  return thrust::random::detail::random_core_access::stream_in(is,e);
+}
+
+
+template<typename UIntType, size_t w, size_t s, size_t r>
+  __host__ __device__
+  bool operator==(const subtract_with_carry_engine<UIntType,w,s,r> &lhs,
+                  const subtract_with_carry_engine<UIntType,w,s,r> &rhs)
+{
+  return thrust::random::detail::random_core_access::equal(lhs,rhs);
+}
+
+
+template<typename UIntType, size_t w, size_t s, size_t r>
+  __host__ __device__
+  bool operator!=(const subtract_with_carry_engine<UIntType,w,s,r> &lhs,
+                  const subtract_with_carry_engine<UIntType,w,s,r> &rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // end random
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/random/detail/uniform_int_distribution.inl

@@ -0,0 +1,257 @@
+/*
+ *  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/random/uniform_int_distribution.h>
+#include <thrust/random/uniform_real_distribution.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+
+template<typename IntType>
+  __host__ __device__
+  uniform_int_distribution<IntType>
+    ::uniform_int_distribution(IntType a, IntType b)
+      :m_param(a,b)
+{
+} // end uniform_int_distribution::uniform_int_distribution()
+
+
+template<typename IntType>
+  __host__ __device__
+  uniform_int_distribution<IntType>
+    ::uniform_int_distribution(const param_type &parm)
+      :m_param(parm)
+{
+} // end uniform_int_distribution::uniform_int_distribution()
+
+
+template<typename IntType>
+  __host__ __device__
+  void uniform_int_distribution<IntType>
+    ::reset(void)
+{
+} // end uniform_int_distribution::reset()
+
+
+template<typename IntType>
+  template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    typename uniform_int_distribution<IntType>::result_type
+      uniform_int_distribution<IntType>
+        ::operator()(UniformRandomNumberGenerator &urng)
+{
+  return operator()(urng, m_param);
+} // end uniform_int_distribution::operator()()
+
+
+template<typename IntType>
+  template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    typename uniform_int_distribution<IntType>::result_type
+      uniform_int_distribution<IntType>
+        ::operator()(UniformRandomNumberGenerator &urng, const param_type &parm)
+{
+  // XXX this implementation is somewhat hacky and will skip
+  //     values if the range of the RNG is smaller than the range of the distribution
+  //     we should improve this implementation in a later version
+
+  typedef typename thrust::detail::largest_available_float::type float_type;
+
+  const float_type real_min(static_cast<float_type>(parm.first));
+  const float_type real_max(static_cast<float_type>(parm.second));
+
+  // add one to the right end of the interval because it is half-open
+  // XXX adding 1.0 to a potentially large floating point number seems like a bad idea
+  uniform_real_distribution<float_type> real_dist(real_min, real_max + float_type(1));
+
+  return static_cast<result_type>(real_dist(urng));
+} // end uniform_int_distribution::operator()()
+
+
+template<typename IntType>
+  __host__ __device__
+  typename uniform_int_distribution<IntType>::result_type
+    uniform_int_distribution<IntType>
+      ::a(void) const
+{
+  return m_param.first;
+} // end uniform_int_distribution<IntType>::a()
+
+
+template<typename IntType>
+  __host__ __device__
+  typename uniform_int_distribution<IntType>::result_type
+    uniform_int_distribution<IntType>
+      ::b(void) const
+{
+  return m_param.second;
+} // end uniform_int_distribution::b()
+
+
+template<typename IntType>
+  __host__ __device__
+  typename uniform_int_distribution<IntType>::param_type
+    uniform_int_distribution<IntType>
+      ::param(void) const
+{
+  return m_param;
+} // end uniform_int_distribution::param()
+
+
+template<typename IntType>
+  __host__ __device__
+  void uniform_int_distribution<IntType>
+    ::param(const param_type &parm)
+{
+  m_param = parm;
+} // end uniform_int_distribution::param()
+
+
+template<typename IntType>
+  __host__ __device__
+  typename uniform_int_distribution<IntType>::result_type
+    uniform_int_distribution<IntType>
+      ::min THRUST_PREVENT_MACRO_SUBSTITUTION (void) const
+{
+  return a();
+} // end uniform_int_distribution::min()
+
+
+template<typename IntType>
+  __host__ __device__
+  typename uniform_int_distribution<IntType>::result_type
+    uniform_int_distribution<IntType>
+      ::max THRUST_PREVENT_MACRO_SUBSTITUTION (void) const
+{
+  return b();
+} // end uniform_int_distribution::max()
+
+
+template<typename IntType>
+  __host__ __device__
+  bool uniform_int_distribution<IntType>
+    ::equal(const uniform_int_distribution &rhs) const
+{
+  return param() == rhs.param();
+}
+
+
+template<typename IntType>
+  template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>&
+      uniform_int_distribution<IntType>
+        ::stream_out(std::basic_ostream<CharT,Traits> &os) const
+{
+  typedef std::basic_ostream<CharT,Traits> ostream_type;
+  typedef typename ostream_type::ios_base  ios_base;
+
+  // save old flags and fill character
+  const typename ios_base::fmtflags flags = os.flags();
+  const CharT fill = os.fill();
+
+  const CharT space = os.widen(' ');
+  os.flags(ios_base::dec | ios_base::fixed | ios_base::left);
+  os.fill(space);
+
+  os << a() << space << b();
+
+  // restore old flags and fill character
+  os.flags(flags);
+  os.fill(fill);
+  return os;
+}
+
+
+template<typename IntType>
+  template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>&
+      uniform_int_distribution<IntType>
+        ::stream_in(std::basic_istream<CharT,Traits> &is)
+{
+  typedef std::basic_istream<CharT,Traits> istream_type;
+  typedef typename istream_type::ios_base  ios_base;
+
+  // save old flags
+  const typename ios_base::fmtflags flags = is.flags();
+
+  is.flags(ios_base::skipws);
+
+  is >> m_param.first >> m_param.second;
+
+  // restore old flags
+  is.flags(flags);
+  return is;
+}
+
+
+template<typename IntType>
+__host__ __device__
+bool operator==(const uniform_int_distribution<IntType> &lhs,
+                const uniform_int_distribution<IntType> &rhs)
+{
+  return thrust::random::detail::random_core_access::equal(lhs,rhs);
+}
+
+
+template<typename IntType>
+__host__ __device__
+bool operator!=(const uniform_int_distribution<IntType> &lhs,
+                const uniform_int_distribution<IntType> &rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+template<typename IntType,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const uniform_int_distribution<IntType> &d)
+{
+  return thrust::random::detail::random_core_access::stream_out(os,d);
+}
+
+
+template<typename IntType,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           uniform_int_distribution<IntType> &d)
+{
+  return thrust::random::detail::random_core_access::stream_in(is,d);
+}
+
+
+} // end random
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/random/detail/uniform_real_distribution.inl

@@ -0,0 +1,242 @@
+/*
+ *  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/random/uniform_real_distribution.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+
+template<typename RealType>
+  __host__ __device__
+  uniform_real_distribution<RealType>
+    ::uniform_real_distribution(RealType a, RealType b)
+      :m_param(a,b)
+{
+} // end uniform_real_distribution::uniform_real_distribution()
+
+template<typename RealType>
+  __host__ __device__
+  uniform_real_distribution<RealType>
+    ::uniform_real_distribution(const param_type &parm)
+      :m_param(parm)
+{
+} // end uniform_real_distribution::uniform_real_distribution()
+
+template<typename RealType>
+  __host__ __device__
+  void uniform_real_distribution<RealType>
+    ::reset(void)
+{
+} // end uniform_real_distribution::reset()
+
+template<typename RealType>
+  template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    typename uniform_real_distribution<RealType>::result_type
+      uniform_real_distribution<RealType>
+        ::operator()(UniformRandomNumberGenerator &urng)
+{
+  return operator()(urng, m_param);
+} // end uniform_real::operator()()
+
+template<typename RealType>
+  template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    typename uniform_real_distribution<RealType>::result_type
+      uniform_real_distribution<RealType>
+        ::operator()(UniformRandomNumberGenerator &urng,
+                     const param_type &parm)
+{
+  // call the urng & map its result to [0,1)
+  result_type result = static_cast<result_type>(urng() - UniformRandomNumberGenerator::min);
+
+  // adding one to the denominator ensures that the interval is half-open at 1.0
+  // XXX adding 1.0 to a potentially large floating point number seems like a bad idea
+  // XXX OTOH adding 1 to what is potentially UINT_MAX also seems like a bad idea
+  // XXX we could statically check if 1u + (max - min) is representable and do that, otherwise use the current implementation
+  result /= (result_type(1) + static_cast<result_type>(UniformRandomNumberGenerator::max - UniformRandomNumberGenerator::min));
+
+  return (result * (parm.second - parm.first)) + parm.first;
+} // end uniform_real::operator()()
+
+template<typename RealType>
+  __host__ __device__
+  typename uniform_real_distribution<RealType>::result_type
+    uniform_real_distribution<RealType>
+      ::a(void) const
+{
+  return m_param.first;
+} // end uniform_real::a()
+
+template<typename RealType>
+  __host__ __device__
+  typename uniform_real_distribution<RealType>::result_type
+    uniform_real_distribution<RealType>
+      ::b(void) const
+{
+  return m_param.second;
+} // end uniform_real_distribution::b()
+
+template<typename RealType>
+  __host__ __device__
+  typename uniform_real_distribution<RealType>::param_type
+    uniform_real_distribution<RealType>
+      ::param(void) const
+{
+  return m_param;;
+} // end uniform_real_distribution::param()
+
+template<typename RealType>
+  __host__ __device__
+  void uniform_real_distribution<RealType>
+    ::param(const param_type &parm)
+{
+  m_param = parm;
+} // end uniform_real_distribution::param()
+
+template<typename RealType>
+  __host__ __device__
+  typename uniform_real_distribution<RealType>::result_type
+    uniform_real_distribution<RealType>
+      ::min THRUST_PREVENT_MACRO_SUBSTITUTION (void) const
+{
+  return a();
+} // end uniform_real_distribution::min()
+
+template<typename RealType>
+  __host__ __device__
+  typename uniform_real_distribution<RealType>::result_type
+    uniform_real_distribution<RealType>
+      ::max THRUST_PREVENT_MACRO_SUBSTITUTION (void) const
+{
+  return b();
+} // end uniform_real_distribution::max()
+
+
+template<typename RealType>
+  __host__ __device__
+  bool uniform_real_distribution<RealType>
+    ::equal(const uniform_real_distribution &rhs) const
+{
+  return m_param == rhs.param();
+}
+
+
+template<typename RealType>
+  template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>&
+      uniform_real_distribution<RealType>
+        ::stream_out(std::basic_ostream<CharT,Traits> &os) const
+{
+  typedef std::basic_ostream<CharT,Traits> ostream_type;
+  typedef typename ostream_type::ios_base  ios_base;
+
+  // save old flags and fill character
+  const typename ios_base::fmtflags flags = os.flags();
+  const CharT fill = os.fill();
+
+  const CharT space = os.widen(' ');
+  os.flags(ios_base::dec | ios_base::fixed | ios_base::left);
+  os.fill(space);
+
+  os << a() << space << b();
+
+  // restore old flags and fill character
+  os.flags(flags);
+  os.fill(fill);
+  return os;
+}
+
+
+template<typename RealType>
+  template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>&
+      uniform_real_distribution<RealType>
+        ::stream_in(std::basic_istream<CharT,Traits> &is)
+{
+  typedef std::basic_istream<CharT,Traits> istream_type;
+  typedef typename istream_type::ios_base  ios_base;
+
+  // save old flags
+  const typename ios_base::fmtflags flags = is.flags();
+
+  is.flags(ios_base::skipws);
+
+  is >> m_param.first >> m_param.second;
+
+  // restore old flags
+  is.flags(flags);
+  return is;
+}
+
+
+template<typename RealType>
+__host__ __device__
+bool operator==(const uniform_real_distribution<RealType> &lhs,
+                const uniform_real_distribution<RealType> &rhs)
+{
+  return thrust::random::detail::random_core_access::equal(lhs,rhs);
+}
+
+
+template<typename RealType>
+__host__ __device__
+bool operator!=(const uniform_real_distribution<RealType> &lhs,
+                const uniform_real_distribution<RealType> &rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+template<typename RealType,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const uniform_real_distribution<RealType> &d)
+{
+  return thrust::random::detail::random_core_access::stream_out(os,d);
+}
+
+
+template<typename RealType,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           uniform_real_distribution<RealType> &d)
+{
+  return thrust::random::detail::random_core_access::stream_in(is,d);
+}
+
+
+} // end random
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/random/detail/xor_combine_engine.inl

@@ -0,0 +1,226 @@
+/*
+ *  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/random/xor_combine_engine.h>
+#include <thrust/random/detail/random_core_access.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+template<typename Engine1, size_t s1,
+         typename Engine2, size_t s2>
+  __host__ __device__
+  xor_combine_engine<Engine1,s1,Engine2,s2>
+    ::xor_combine_engine(void)
+      :m_b1(),m_b2()
+{
+} // end xor_combine_engine::xor_combine_engine()
+
+template<typename Engine1, size_t s1,
+         typename Engine2, size_t s2>
+  __host__ __device__
+  xor_combine_engine<Engine1,s1,Engine2,s2>
+    ::xor_combine_engine(const base1_type &urng1, const base2_type &urng2)
+      :m_b1(urng1),m_b2(urng2)
+{
+} // end xor_combine_engine::xor_combine_engine()
+
+template<typename Engine1, size_t s1,
+         typename Engine2, size_t s2>
+  __host__ __device__
+  xor_combine_engine<Engine1,s1,Engine2,s2>
+    ::xor_combine_engine(result_type s)
+      :m_b1(s),m_b2(s)
+{
+} // end xor_combine_engine::xor_combine_engine()
+
+template<typename Engine1, size_t s1,
+         typename Engine2, size_t s2>
+  __host__ __device__
+  void xor_combine_engine<Engine1,s1,Engine2,s2>
+    ::seed(void)
+{
+  m_b1.seed();
+  m_b2.seed();
+} // end xor_combine_engine::seed()
+
+template<typename Engine1, size_t s1,
+         typename Engine2, size_t s2>
+  __host__ __device__
+  void xor_combine_engine<Engine1,s1,Engine2,s2>
+    ::seed(result_type s)
+{
+  m_b1.seed(s);
+  m_b2.seed(s);
+} // end xor_combine_engine::seed()
+
+template<typename Engine1, size_t s1,
+         typename Engine2, size_t s2>
+  __host__ __device__
+  const typename xor_combine_engine<Engine1,s1,Engine2,s2>::base1_type &
+    xor_combine_engine<Engine1,s1,Engine2,s2>
+      ::base1(void) const
+{
+  return m_b1;
+} // end xor_combine_engine::base1()
+
+template<typename Engine1, size_t s1,
+         typename Engine2, size_t s2>
+  __host__ __device__
+  const typename xor_combine_engine<Engine1,s1,Engine2,s2>::base2_type &
+    xor_combine_engine<Engine1,s1,Engine2,s2>
+      ::base2(void) const
+{
+  return m_b2;
+} // end xor_combine_engine::base2()
+
+template<typename Engine1, size_t s1,
+         typename Engine2, size_t s2>
+  __host__ __device__
+  typename xor_combine_engine<Engine1,s1,Engine2,s2>::result_type
+    xor_combine_engine<Engine1,s1,Engine2,s2>
+      ::operator()(void)
+{
+  return (result_type(m_b1() - base1_type::min) << shift1) ^
+         (result_type(m_b2() - base2_type::min) << shift2);
+} // end xor_combine_engine::operator()()
+
+template<typename Engine1, size_t s1,
+         typename Engine2, size_t s2>
+  __host__ __device__
+  void xor_combine_engine<Engine1, s1, Engine2, s2>
+    ::discard(unsigned long long z)
+{
+  for(; z > 0; --z)
+  {
+    this->operator()();
+  } // end for
+} // end xor_combine_engine::discard()
+
+
+template<typename Engine1, size_t s1, typename Engine2, size_t s2>
+  template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& xor_combine_engine<Engine1,s1,Engine2,s2>
+      ::stream_out(std::basic_ostream<CharT,Traits> &os) const
+{
+  typedef std::basic_ostream<CharT,Traits> ostream_type;
+  typedef typename ostream_type::ios_base  ios_base;
+
+  // save old flags and fill character
+  const typename ios_base::fmtflags flags = os.flags();
+  const CharT fill = os.fill();
+
+  const CharT space = os.widen(' ');
+  os.flags(ios_base::dec | ios_base::fixed | ios_base::left);
+  os.fill(space);
+
+  // output each base engine in turn
+  os << base1() << space << base2();
+
+  // restore old flags and fill character
+  os.flags(flags);
+  os.fill(fill);
+  return os;
+}
+
+
+template<typename Engine1, size_t s1, typename Engine2, size_t s2>
+  template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& xor_combine_engine<Engine1,s1,Engine2,s2>
+      ::stream_in(std::basic_istream<CharT,Traits> &is)
+{
+  typedef std::basic_istream<CharT,Traits> istream_type;
+  typedef typename istream_type::ios_base  ios_base;
+
+  // save old flags
+  const typename ios_base::fmtflags flags = is.flags();
+
+  is.flags(ios_base::skipws);
+
+  // input each base engine in turn
+  is >> m_b1 >> m_b2;
+
+  // restore old flags
+  is.flags(flags);
+  return is;
+}
+
+
+template<typename Engine1, size_t s1, typename Engine2, size_t s2>
+  __host__ __device__
+  bool xor_combine_engine<Engine1,s1,Engine2,s2>
+    ::equal(const xor_combine_engine<Engine1,s1,Engine2,s2> &rhs) const
+{
+  return (m_b1 == rhs.m_b1) && (m_b2 == rhs.m_b2);
+}
+
+
+template<typename Engine1, size_t s1, typename Engine2, size_t s2,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const xor_combine_engine<Engine1,s1,Engine2,s2> &e)
+{
+  return thrust::random::detail::random_core_access::stream_out(os,e);
+}
+
+
+template<typename Engine1, size_t s1, typename Engine2, size_t s2,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           xor_combine_engine<Engine1,s1,Engine2,s2> &e)
+{
+  return thrust::random::detail::random_core_access::stream_in(is,e);
+}
+
+
+template<typename Engine1, size_t s1, typename Engine2, size_t s2>
+__host__ __device__
+bool operator==(const xor_combine_engine<Engine1,s1,Engine2,s2> &lhs,
+                const xor_combine_engine<Engine1,s1,Engine2,s2> &rhs)
+{
+  return thrust::random::detail::random_core_access::equal(lhs,rhs);
+}
+
+
+template<typename Engine1, size_t s1, typename Engine2, size_t s2>
+__host__ __device__
+bool operator!=(const xor_combine_engine<Engine1,s1,Engine2,s2> &lhs,
+                const xor_combine_engine<Engine1,s1,Engine2,s2> &rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // end random
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/random/detail/xor_combine_engine_max.h

@@ -0,0 +1,333 @@
+/*
+ *  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/type_traits.h>
+#include <thrust/detail/mpl/math.h>
+#include <limits>
+#include <cstddef>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+namespace detail
+{
+
+
+namespace math = thrust::detail::mpl::math;
+
+
+namespace detail
+{
+
+// two cases for this function avoids compile-time warnings of overflow
+template<typename UIntType, UIntType w,
+         UIntType lhs, UIntType rhs,
+         bool shift_will_overflow>
+  struct lshift_w
+{
+  static const UIntType value = 0;
+};
+
+
+template<typename UIntType, UIntType w,
+         UIntType lhs, UIntType rhs>
+  struct lshift_w<UIntType,w,lhs,rhs,false>
+{
+  static const UIntType value = lhs << rhs;
+};
+
+} // end detail
+
+
+template<typename UIntType, UIntType w,
+         UIntType lhs, UIntType rhs>
+  struct lshift_w
+{
+  static const bool shift_will_overflow = rhs >= w;
+
+  static const UIntType value = detail::lshift_w<UIntType, w, lhs, rhs, shift_will_overflow>::value;
+};
+
+
+template<typename UIntType, UIntType lhs, UIntType rhs>
+  struct lshift
+    : lshift_w<UIntType, std::numeric_limits<UIntType>::digits, lhs, rhs>
+{};
+
+
+template<typename UIntType, int p>
+  struct two_to_the_power
+    : lshift<UIntType, 1, p>
+{};
+
+
+template<typename result_type, result_type a, result_type b, int d>
+  class xor_combine_engine_max_aux_constants
+{
+  public:
+    static const result_type two_to_the_d = two_to_the_power<result_type, d>::value;
+    static const result_type c = lshift<result_type, a, d>::value;
+
+    static const result_type t =
+      math::max<
+        result_type,
+        c,
+        b
+      >::value;
+
+    static const result_type u =
+      math::min<
+        result_type,
+        c,
+        b
+      >::value;
+
+    static const result_type p            = math::log2<u>::value;
+    static const result_type two_to_the_p = two_to_the_power<result_type, p>::value;
+
+    static const result_type k = math::div<result_type, t, two_to_the_p>::value;
+};
+
+
+template<typename result_type, result_type, result_type, int> struct xor_combine_engine_max_aux;
+
+
+template<typename result_type, result_type a, result_type b, int d>
+  struct xor_combine_engine_max_aux_case4
+{
+  typedef xor_combine_engine_max_aux_constants<result_type,a,b,d> constants;
+
+  static const result_type k_plus_1_times_two_to_the_p =
+    lshift<
+      result_type,
+      math::plus<result_type,constants::k,1>::value,
+      constants::p
+    >::value;
+
+  static const result_type M =
+    xor_combine_engine_max_aux<
+      result_type,
+      math::div<
+        result_type,
+        math::mod<
+          result_type,
+          constants::u,
+          constants::two_to_the_p
+        >::value,
+        constants::two_to_the_p
+      >::value,
+      math::mod<
+        result_type,
+        constants::t,
+        constants::two_to_the_p
+      >::value,
+      d
+    >::value;
+
+  static const result_type value = math::plus<result_type, k_plus_1_times_two_to_the_p, M>::value;
+};
+
+
+template<typename result_type, result_type a, result_type b, int d>
+  struct xor_combine_engine_max_aux_case3
+{
+  typedef xor_combine_engine_max_aux_constants<result_type,a,b,d> constants;
+
+  static const result_type k_plus_1_times_two_to_the_p =
+    lshift<
+      result_type,
+      math::plus<result_type,constants::k,1>::value,
+      constants::p
+    >::value;
+
+  static const result_type M =
+    xor_combine_engine_max_aux<
+      result_type,
+      math::div<
+        result_type,
+        math::mod<
+          result_type,
+          constants::t,
+          constants::two_to_the_p
+        >::value,
+        constants::two_to_the_p
+      >::value,
+      math::mod<
+        result_type,
+        constants::u,
+        constants::two_to_the_p
+      >::value,
+      d
+    >::value;
+
+  static const result_type value = math::plus<result_type, k_plus_1_times_two_to_the_p, M>::value;
+};
+
+
+
+template<typename result_type, result_type a, result_type b, int d>
+  struct xor_combine_engine_max_aux_case2
+{
+  typedef xor_combine_engine_max_aux_constants<result_type,a,b,d> constants;
+
+  static const result_type k_plus_1_times_two_to_the_p =
+    lshift<
+      result_type,
+      math::plus<result_type,constants::k,1>::value,
+      constants::p
+    >::value;
+
+  static const result_type value =
+    math::minus<
+      result_type,
+      k_plus_1_times_two_to_the_p,
+      1
+    >::value;
+};
+
+
+template<typename result_type, result_type a, result_type b, int d>
+  struct xor_combine_engine_max_aux_case1
+{
+  static const result_type c     = lshift<result_type, a, d>::value;
+
+  static const result_type value = math::plus<result_type,c,b>::value;
+};
+
+
+template<typename result_type, result_type a, result_type b, int d>
+  struct xor_combine_engine_max_aux_2
+{
+  typedef xor_combine_engine_max_aux_constants<result_type,a,b,d> constants;
+
+  static const result_type value =
+    thrust::detail::eval_if<
+      // if k is odd...
+      math::is_odd<result_type, constants::k>::value,
+      thrust::detail::identity_<
+        thrust::detail::integral_constant<
+          result_type,
+          xor_combine_engine_max_aux_case2<result_type,a,b,d>::value
+        >
+      >,
+      thrust::detail::eval_if<
+        // otherwise if a * 2^3 >= b, then case 3
+        a * constants::two_to_the_d >= b,
+        thrust::detail::identity_<
+          thrust::detail::integral_constant<
+            result_type,
+            xor_combine_engine_max_aux_case3<result_type,a,b,d>::value
+          >
+        >,
+        // otherwise, case 4
+        thrust::detail::identity_<
+          thrust::detail::integral_constant<
+            result_type,
+            xor_combine_engine_max_aux_case4<result_type,a,b,d>::value
+          >
+        >
+      >
+    >::type::value;
+};
+
+
+template<typename result_type,
+         result_type a,
+         result_type b,
+         int d,
+         bool use_case1 = (a == 0) || (b < two_to_the_power<result_type,d>::value)>
+  struct xor_combine_engine_max_aux_1
+    : xor_combine_engine_max_aux_case1<result_type,a,b,d>
+{};
+
+
+template<typename result_type,
+         result_type a,
+         result_type b,
+         int d>
+  struct xor_combine_engine_max_aux_1<result_type,a,b,d,false>
+    : xor_combine_engine_max_aux_2<result_type,a,b,d>
+{};
+
+
+template<typename result_type,
+         result_type a,
+         result_type b,
+         int d>
+  struct xor_combine_engine_max_aux
+    : xor_combine_engine_max_aux_1<result_type,a,b,d>
+{};
+
+
+template<typename Engine1, size_t s1, typename Engine2, size_t s2, typename result_type>
+  struct xor_combine_engine_max
+{
+  static const size_t w = std::numeric_limits<result_type>::digits;
+
+  static const result_type m1 =
+    math::min<
+      result_type,
+      result_type(Engine1::max - Engine1::min),
+      two_to_the_power<result_type, w-s1>::value - 1
+    >::value;
+
+  static const result_type m2 =
+    math::min<
+      result_type,
+      result_type(Engine2::max - Engine2::min),
+      two_to_the_power<result_type, w-s2>::value - 1
+    >::value;
+
+  static const result_type s = s1 - s2;
+
+  static const result_type M =
+    xor_combine_engine_max_aux<
+      result_type,
+      m1,
+      m2,
+      s
+    >::value;
+
+  // the value is M(m1,m2,s) lshift_w s2
+  static const result_type value =
+    lshift_w<
+      result_type,
+      w,
+      M,
+      s2
+    >::value;
+}; // end xor_combine_engine_max
+
+} // end detail
+
+} // end random
+
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/system/cpp/detail/adjacent_difference.h

@@ -0,0 +1,31 @@
+/*
+ *  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
+
+// this system inherits adjacent_difference
+#include <thrust/system/detail/sequential/adjacent_difference.h>
+

miniCUDA124/include/thrust/system/cpp/detail/assign_value.h

@@ -0,0 +1,31 @@
+/*
+ *  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
+
+// this system inherits assign_value
+#include <thrust/system/detail/sequential/assign_value.h>
+

miniCUDA124/include/thrust/system/cpp/detail/binary_search.h

@@ -0,0 +1,33 @@
+/*
+ *  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/system/cpp/detail/execution_policy.h>
+
+// this system inherits the binary search algorithms
+#include <thrust/system/detail/sequential/binary_search.h>
+

miniCUDA124/include/thrust/system/cpp/detail/copy.h

@@ -0,0 +1,31 @@
+/*
+ *  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
+
+// this system inherits copy
+#include <thrust/system/detail/sequential/copy.h>
+

miniCUDA124/include/thrust/system/cpp/detail/copy_if.h

@@ -0,0 +1,31 @@
+/*
+ *  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
+
+// this system inherits copy_if
+#include <thrust/system/detail/sequential/copy_if.h>
+

miniCUDA124/include/thrust/system/cpp/detail/count.h

@@ -0,0 +1,30 @@
+/*
+ *  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
+
+// this system has no special version of this algorithm
+

miniCUDA124/include/thrust/system/cpp/detail/equal.h

@@ -0,0 +1,30 @@
+/*
+ *  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
+
+// this system has no special version of this algorithm
+

miniCUDA124/include/thrust/system/cpp/detail/execution_policy.h

@@ -0,0 +1,88 @@
+/*
+ *  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/system/detail/sequential/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+// put the canonical tag in the same ns as the backend's entry points
+namespace cpp
+{
+namespace detail
+{
+
+// this awkward sequence of definitions arise
+// from the desire both for tag to derive
+// from execution_policy and for execution_policy
+// to convert to tag (when execution_policy is not
+// an ancestor of tag)
+
+// forward declaration of tag
+struct tag;
+
+// forward declaration of execution_policy
+template<typename> struct execution_policy;
+
+// specialize execution_policy for tag
+template<>
+  struct execution_policy<tag>
+    : thrust::system::detail::sequential::execution_policy<tag>
+{};
+
+// tag's definition comes before the
+// generic definition of execution_policy
+struct tag : execution_policy<tag> {};
+
+// allow conversion to tag when it is not a successor
+template<typename Derived>
+  struct execution_policy
+    : thrust::system::detail::sequential::execution_policy<Derived>
+{
+  typedef tag tag_type;
+  operator tag() const { return tag(); }
+};
+
+} // end detail
+
+// alias execution_policy and tag here
+using thrust::system::cpp::detail::execution_policy;
+using thrust::system::cpp::detail::tag;
+
+} // end cpp
+} // end system
+
+// alias items at top-level
+namespace cpp
+{
+
+using thrust::system::cpp::execution_policy;
+using thrust::system::cpp::tag;
+
+} // end cpp
+THRUST_NAMESPACE_END
+

miniCUDA124/include/thrust/system/cpp/execution_policy.h

@@ -0,0 +1,164 @@
+/*
+ *  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/system/cpp/execution_policy.h
+ *  \brief Execution policies for Thrust's Standard C++ 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
+
+// get the execution policies definitions first
+#include <thrust/system/cpp/detail/execution_policy.h>
+
+// get the definition of par
+#include <thrust/system/cpp/detail/par.h>
+
+// now get all the algorithm definitions
+
+#include <thrust/system/cpp/detail/adjacent_difference.h>
+#include <thrust/system/cpp/detail/assign_value.h>
+#include <thrust/system/cpp/detail/binary_search.h>
+#include <thrust/system/cpp/detail/copy.h>
+#include <thrust/system/cpp/detail/copy_if.h>
+#include <thrust/system/cpp/detail/count.h>
+#include <thrust/system/cpp/detail/equal.h>
+#include <thrust/system/cpp/detail/extrema.h>
+#include <thrust/system/cpp/detail/fill.h>
+#include <thrust/system/cpp/detail/find.h>
+#include <thrust/system/cpp/detail/for_each.h>
+#include <thrust/system/cpp/detail/gather.h>
+#include <thrust/system/cpp/detail/generate.h>
+#include <thrust/system/cpp/detail/get_value.h>
+#include <thrust/system/cpp/detail/inner_product.h>
+#include <thrust/system/cpp/detail/iter_swap.h>
+#include <thrust/system/cpp/detail/logical.h>
+#include <thrust/system/cpp/detail/malloc_and_free.h>
+#include <thrust/system/cpp/detail/merge.h>
+#include <thrust/system/cpp/detail/mismatch.h>
+#include <thrust/system/cpp/detail/partition.h>
+#include <thrust/system/cpp/detail/reduce.h>
+#include <thrust/system/cpp/detail/reduce_by_key.h>
+#include <thrust/system/cpp/detail/remove.h>
+#include <thrust/system/cpp/detail/replace.h>
+#include <thrust/system/cpp/detail/reverse.h>
+#include <thrust/system/cpp/detail/scan.h>
+#include <thrust/system/cpp/detail/scan_by_key.h>
+#include <thrust/system/cpp/detail/scatter.h>
+#include <thrust/system/cpp/detail/sequence.h>
+#include <thrust/system/cpp/detail/set_operations.h>
+#include <thrust/system/cpp/detail/sort.h>
+#include <thrust/system/cpp/detail/swap_ranges.h>
+#include <thrust/system/cpp/detail/tabulate.h>
+#include <thrust/system/cpp/detail/transform.h>
+#include <thrust/system/cpp/detail/transform_reduce.h>
+#include <thrust/system/cpp/detail/transform_scan.h>
+#include <thrust/system/cpp/detail/uninitialized_copy.h>
+#include <thrust/system/cpp/detail/uninitialized_fill.h>
+#include <thrust/system/cpp/detail/unique.h>
+#include <thrust/system/cpp/detail/unique_by_key.h>
+
+
+// define these entities here for the purpose of Doxygenating them
+// they are actually defined elsewhere
+#if 0
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace cpp
+{
+
+
+/*! \addtogroup execution_policies
+ *  \{
+ */
+
+
+/*! \p thrust::system::cpp::execution_policy is the base class for all Thrust parallel execution
+ *  policies which are derived from Thrust's standard C++ backend system.
+ */
+template<typename DerivedPolicy>
+struct execution_policy : thrust::execution_policy<DerivedPolicy>
+{};
+
+
+/*! \p thrust::system::cpp::tag is a type representing Thrust's standard C++ backend system in C++'s type system.
+ *  Iterators "tagged" with a type which is convertible to \p cpp::tag assert that they may be
+ *  "dispatched" to algorithm implementations in the \p cpp system.
+ */
+struct tag : thrust::system::cpp::execution_policy<tag> { unspecified };
+
+
+/*!
+ *  \p thrust::system::cpp::par is the parallel execution policy associated with Thrust's standard
+ *  C++ backend system.
+ *
+ *  Instead of relying on implicit algorithm dispatch through iterator system tags, users may
+ *  directly target Thrust's C++ backend system by providing \p thrust::cpp::par as an algorithm
+ *  parameter.
+ *
+ *  Explicit dispatch can be useful in avoiding the introduction of data copies into containers such
+ *  as \p thrust::cpp::vector.
+ *
+ *  The type of \p thrust::cpp::par is implementation-defined.
+ *
+ *  The following code snippet demonstrates how to use \p thrust::cpp::par to explicitly dispatch an
+ *  invocation of \p thrust::for_each to the standard C++ backend system:
+ *
+ *  \code
+ *  #include <thrust/for_each.h>
+ *  #include <thrust/system/cpp/execution_policy.h>
+ *  #include <cstdio>
+ *
+ *  struct printf_functor
+ *  {
+ *    __host__ __device__
+ *    void operator()(int x)
+ *    {
+ *      printf("%d\n", x);
+ *    }
+ *  };
+ *  ...
+ *  int vec[3];
+ *  vec[0] = 0; vec[1] = 1; vec[2] = 2;
+ *
+ *  thrust::for_each(thrust::cpp::par, vec.begin(), vec.end(), printf_functor());
+ *
+ *  // 0 1 2 is printed to standard output in some unspecified order
+ *  \endcode
+ */
+static const unspecified par;
+
+
+/*! \}
+ */
+
+
+} // end cpp
+} // end system
+THRUST_NAMESPACE_END
+#endif
+
+