Thrust
Namespaces | Classes | Typedefs | Functions | Variables
thrust Namespace Reference

thrust is the top-level namespace which contains all Thrust functions and types. More...

Namespaces

 cpp
 thrust::cpp is a top-level alias for thrust::system::cpp.
 
 cuda
 thrust::cuda is a top-level alias for thrust::system::cuda.
 
 detail
 
 
 mr
 thrust::mr is the namespace containing system agnostic types and functions for memory_resource related functionalities.
 
 omp
 thrust::omp is a top-level alias for thrust::system::omp.
 
 placeholders
 Facilities for constructing simple functions inline.
 
 random
 thrust::random is the namespace which contains random number engine class templates, random number engine adaptor class templates, engines with predefined parameters, and random number distribution class templates. They are provided in a separate namespace for import convenience but are also aliased in the top-level thrust namespace for easy access.
 
 system
 thrust::system is the namespace which contains specific Thrust backend systems. It also contains functionality for reporting error conditions originating from the operating system or other low-level application program interfaces such as the CUDA runtime. They are provided in a separate namespace for import convenience but are also aliased in the top-level thrust namespace for easy access.
 
 tbb
 thrust::tbb is a top-level alias for thrust::system::tbb.
 

Classes

struct  bidirectional_device_iterator_tag
 
struct  binary_function
 
struct  binary_negate
 
struct  bit_and
 
struct  bit_or
 
struct  bit_xor
 
struct  complex
 
struct  conjunction_value
 std::integral_constant whose value is (... && Bs). More...
 
class  constant_iterator
 
class  counting_iterator
 
class  device_allocator
 An allocator which creates new elements in memory accessible by devices. More...
 
struct  device_execution_policy
 
class  device_malloc_allocator
 
class  device_new_allocator
 
class  device_ptr
 device_ptr is a pointer-like object which points to an object that resides in memory associated with the device system. More...
 
class  device_ptr_memory_resource
 
class  device_reference
 
class  device_vector
 
class  discard_iterator
 
struct  disjunction_value
 std::integral_constant whose value is (... || Bs). More...
 
struct  divides
 
struct  equal_to
 
struct  forward_device_iterator_tag
 
struct  greater
 
struct  greater_equal
 
struct  host_execution_policy
 
class  host_vector
 
struct  identity
 
struct  in_place_t
 A tag type to tell optional to construct its value in-place. More...
 
struct  input_device_iterator_tag
 
class  iterator_adaptor
 
class  iterator_core_access
 
class  iterator_facade
 
struct  iterator_traits
 
struct  less
 
struct  less_equal
 
struct  logical_and
 
struct  logical_not
 
struct  logical_or
 
struct  maximum
 
struct  minimum
 
struct  minus
 
struct  modulus
 
class  monostate
 Used to represent an optional with no data; essentially a bool. More...
 
struct  multiplies
 
struct  negate
 
struct  negation_value
 std::integral_constant whose value is !Bs. More...
 
struct  not_equal_to
 
struct  nullopt_t
 A tag type to represent an empty optional. More...
 
class  optional
 An optional object is an object that contains the storage for another object and manages the lifetime of this contained object, if any. More...
 
class  optional< T & >
 Specialization for when T is a reference. More...
 
struct  output_device_iterator_tag
 
struct  pair
 
class  per_device_allocator
 
class  permutation_iterator
 
struct  plus
 
struct  proclaim_contiguous_iterator
 Customization point that can be customized to indicate that an iterator type Iterator satisfies ContiguousIterator, aka it points to elements that are contiguous in memory. More...
 
struct  project1st
 
struct  project2nd
 
struct  random_access_device_iterator_tag
 
struct  remove_cvref
 UnaryTypeTrait that removes const-volatile qualifiers and references from T. Equivalent to remove_cv_t<remove_reference_t<T>>. More...
 
class  reverse_iterator
 
struct  square
 
class  transform_input_output_iterator
 
class  transform_iterator
 
class  transform_output_iterator
 
class  tuple
 tuple is a class template that can be instantiated with up to ten arguments. Each template argument specifies the type of element in the tuple. Consequently, tuples are heterogeneous, fixed-size collections of values. An instantiation of tuple with two arguments is similar to an instantiation of pair with the same two arguments. Individual elements of a tuple may be accessed with the get function. More...
 
struct  tuple_element
 
struct  tuple_size
 
struct  unary_function
 
struct  unary_negate
 
class  zip_function
 
class  zip_iterator
 

Typedefs

template<typename T , typename Allocator >
using uninitialized_allocator_delete = allocator_delete< T, Allocator, true >
 
template<typename T , typename Allocator >
using uninitialized_array_allocator_delete = array_allocator_delete< T, Allocator, true >
 
template<typename System >
using unique_eager_event = unique_eager_event_type_detail::select< System >
 
template<typename System >
using event = unique_eager_event< System >
 
template<typename System , typename T >
using unique_eager_future = unique_eager_future_type_detail::select< System, T >
 
template<typename System , typename T >
using future = unique_eager_future< System, T >
 
using device_unique_eager_event = unique_eager_event_type_detail::select< thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::tag >
 
using device_event = device_unique_eager_event
 
template<typename T >
using device_unique_eager_future = unique_eager_future_type_detail::select< thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::tag, T >
 
template<typename T >
using device_future = device_unique_eager_future< T >
 
typedef std::input_iterator_tag input_host_iterator_tag
 
typedef std::output_iterator_tag output_host_iterator_tag
 
typedef std::forward_iterator_tag forward_host_iterator_tag
 
typedef std::bidirectional_iterator_tag bidirectional_host_iterator_tag
 
typedef std::random_access_iterator_tag random_access_host_iterator_tag
 
typedef thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::memory_resource device_memory_resource
 
typedef thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::universal_memory_resource universal_memory_resource
 
typedef thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::universal_host_pinned_memory_resource universal_host_pinned_memory_resource
 
typedef thrust::system::__THRUST_HOST_SYSTEM_NAMESPACE::memory_resource host_memory_resource
 
template<typename T , T... Is>
using integer_sequence = std::integer_sequence< T, Is... >
 A compile-time sequence of integral constants of type T with values Is.... More...
 
template<std::size_t... Is>
using index_sequence = std::index_sequence< Is... >
 A compile-time sequence of type std::size_t with values Is.... More...
 
template<typename T , std::size_t N>
using make_integer_sequence = std::make_integer_sequence< T, N >
 Create a new integer_sequence with elements 0, 1, 2, ..., N - 1 of type T. More...
 
template<std::size_t N>
using make_index_sequence = std::make_index_sequence< N >
 Create a new integer_sequence with elements 0, 1, 2, ..., N - 1 of type std::size_t. More...
 
template<typename T , std::size_t N>
using make_reversed_integer_sequence = typename detail::make_reversed_integer_sequence_impl< T, N >::type
 Create a new integer_sequence with elements N - 1, N - 2, N - 3, ..., 0. More...
 
template<std::size_t N>
using make_reversed_index_sequence = make_reversed_integer_sequence< std::size_t, N >
 Create a new index_sequence with elements N - 1, N - 2, N - 3, ..., 0. More...
 
template<typename T , T Value, typename Sequence >
using integer_sequence_push_front = typename detail::integer_sequence_push_front_impl< T, Value, Sequence >::type
 Add a new element to the front of an integer_sequence. More...
 
template<typename T , T Value, typename Sequence >
using integer_sequence_push_back = typename detail::integer_sequence_push_back_impl< T, Value, Sequence >::type
 Add a new element to the back of an integer_sequence. More...
 
template<typename Iterator >
using is_contiguous_iterator = detail::is_contiguous_iterator_impl< Iterator >
 UnaryTypeTrait that returns true_type if Iterator satisfies ContiguousIterator, aka it points to elements that are contiguous in memory, and false_type otherwise. More...
 
template<typename T >
using is_execution_policy = detail::is_base_of< detail::execution_policy_marker, T >
 UnaryTypeTrait that returns true_type if T is an ExecutionPolicy and false_type otherwise.
 
template<typename T >
using is_operator_less_function_object = detail::is_operator_less_function_object_impl< T >
 UnaryTypeTrait that returns true_type if T is a BinaryPredicate equivalent to operator<, and false_type otherwise. More...
 
template<typename T >
using is_operator_greater_function_object = detail::is_operator_greater_function_object_impl< T >
 UnaryTypeTrait that returns true_type if T is a BinaryPredicate equivalent to operator>, and false_type otherwise. More...
 
template<typename T >
using is_operator_less_or_greater_function_object = integral_constant< bool, detail::is_operator_less_function_object_impl< T >::value||detail::is_operator_greater_function_object_impl< T >::value >
 UnaryTypeTrait that returns true_type if T is a BinaryPredicate equivalent to operator< or operator>, and false_type otherwise. More...
 
template<typename T >
using is_operator_plus_function_object = detail::is_operator_plus_function_object_impl< T >
 UnaryTypeTrait that returns true_type if T is a FunctionObject equivalent to operator+, and false_type otherwise. More...
 
template<typename... Ts>
using conjunction = std::conjunction< Ts... >
 std::integral_constant whose value is (... && Ts::value). More...
 
template<typename... Ts>
using disjunction = std::disjunction< Ts... >
 std::integral_constant whose value is (... || Ts::value). More...
 
template<typename T >
using negation = std::negation< T >
 std::integral_constant whose value is !Ts::value. More...
 
template<typename T >
using remove_cvref_t = typename remove_cvref< T >::type
 Type alias that removes const-volatile qualifiers and references from T. Equivalent to remove_cv_t<remove_reference_t<T>>. More...
 
template<typename T >
using universal_ptr = thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::universal_pointer< T >
 

Functions

template<typename T >
__host__ __device__ T * addressof (T &arg)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator >
__host__ __device__ OutputIterator adjacent_difference (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator , typename BinaryFunction >
__host__ __device__ OutputIterator adjacent_difference (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result, BinaryFunction binary_op)
 
template<typename InputIterator , typename OutputIterator >
OutputIterator adjacent_difference (InputIterator first, InputIterator last, OutputIterator result)
 
template<typename InputIterator , typename OutputIterator , typename BinaryFunction >
OutputIterator adjacent_difference (InputIterator first, InputIterator last, OutputIterator result, BinaryFunction binary_op)
 
template<typename InputIterator , typename Distance >
__host__ __device__ void advance (InputIterator &i, Distance n)
 
template<typename Pointer , typename Lambda >
__host__ __device__ tagged_deleter< Pointer, Lambda > make_tagged_deleter (Lambda &&l)
 
template<typename T , typename Allocator , typename... Args>
__host__ std::unique_ptr< T, allocator_delete< T, typename detail::allocator_traits< typename std::remove_cv< typename std::remove_reference< Allocator >::type >::type >::template rebind_traits< T >::allocator_type >> allocate_unique (Allocator const &alloc, Args &&... args)
 
template<typename T , typename Allocator >
__host__ std::unique_ptr< T, uninitialized_allocator_delete< T, typename detail::allocator_traits< typename std::remove_cv< typename std::remove_reference< Allocator >::type >::type >::template rebind_traits< T >::allocator_type >> uninitialized_allocate_unique (Allocator const &alloc)
 
template<typename T , typename Allocator , typename Size , typename... Args>
__host__ std::unique_ptr< T[], array_allocator_delete< T, typename detail::allocator_traits< typename std::remove_cv< typename std::remove_reference< Allocator >::type >::type >::template rebind_traits< T >::allocator_type >> allocate_unique_n (Allocator const &alloc, Size n, Args &&... args)
 
template<typename T , typename Allocator , typename Size >
__host__ std::unique_ptr< T[], uninitialized_array_allocator_delete< T, typename detail::allocator_traits< typename std::remove_cv< typename std::remove_reference< Allocator >::type >::type >::template rebind_traits< T >::allocator_type >> uninitialized_allocate_unique_n (Allocator const &alloc, Size n)
 
template<typename DerivedPolicy , typename ForwardIterator , typename LessThanComparable >
__host__ __device__ ForwardIterator lower_bound (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, const LessThanComparable &value)
 
template<class ForwardIterator , class LessThanComparable >
ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last, const LessThanComparable &value)
 
template<typename DerivedPolicy , typename ForwardIterator , typename T , typename StrictWeakOrdering >
__host__ __device__ ForwardIterator lower_bound (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, const T &value, StrictWeakOrdering comp)
 
template<class ForwardIterator , class T , class StrictWeakOrdering >
ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last, const T &value, StrictWeakOrdering comp)
 
template<typename DerivedPolicy , typename ForwardIterator , typename LessThanComparable >
__host__ __device__ ForwardIterator upper_bound (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, const LessThanComparable &value)
 
template<class ForwardIterator , class LessThanComparable >
ForwardIterator upper_bound (ForwardIterator first, ForwardIterator last, const LessThanComparable &value)
 
template<typename DerivedPolicy , typename ForwardIterator , typename T , typename StrictWeakOrdering >
__host__ __device__ ForwardIterator upper_bound (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, const T &value, StrictWeakOrdering comp)
 
template<class ForwardIterator , class T , class StrictWeakOrdering >
ForwardIterator upper_bound (ForwardIterator first, ForwardIterator last, const T &value, StrictWeakOrdering comp)
 
template<typename DerivedPolicy , typename ForwardIterator , typename LessThanComparable >
__host__ __device__ bool binary_search (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, const LessThanComparable &value)
 
template<class ForwardIterator , class LessThanComparable >
bool binary_search (ForwardIterator first, ForwardIterator last, const LessThanComparable &value)
 
template<typename DerivedPolicy , typename ForwardIterator , typename T , typename StrictWeakOrdering >
__host__ __device__ bool binary_search (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, const T &value, StrictWeakOrdering comp)
 
template<class ForwardIterator , class T , class StrictWeakOrdering >
bool binary_search (ForwardIterator first, ForwardIterator last, const T &value, StrictWeakOrdering comp)
 
template<typename DerivedPolicy , typename ForwardIterator , typename LessThanComparable >
__host__ __device__ thrust::pair< ForwardIterator, ForwardIterator > equal_range (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, const LessThanComparable &value)
 
template<class ForwardIterator , class LessThanComparable >
thrust::pair< ForwardIterator, ForwardIterator > equal_range (ForwardIterator first, ForwardIterator last, const LessThanComparable &value)
 
template<typename DerivedPolicy , typename ForwardIterator , typename T , typename StrictWeakOrdering >
__host__ __device__ thrust::pair< ForwardIterator, ForwardIterator > equal_range (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, const T &value, StrictWeakOrdering comp)
 
template<class ForwardIterator , class T , class StrictWeakOrdering >
thrust::pair< ForwardIterator, ForwardIterator > equal_range (ForwardIterator first, ForwardIterator last, const T &value, StrictWeakOrdering comp)
 
template<typename DerivedPolicy , typename ForwardIterator , typename InputIterator , typename OutputIterator >
__host__ __device__ OutputIterator lower_bound (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, InputIterator values_first, InputIterator values_last, OutputIterator result)
 
template<class ForwardIterator , class InputIterator , class OutputIterator >
OutputIterator lower_bound (ForwardIterator first, ForwardIterator last, InputIterator values_first, InputIterator values_last, OutputIterator result)
 
template<typename DerivedPolicy , typename ForwardIterator , typename InputIterator , typename OutputIterator , typename StrictWeakOrdering >
__host__ __device__ OutputIterator lower_bound (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, InputIterator values_first, InputIterator values_last, OutputIterator result, StrictWeakOrdering comp)
 
template<class ForwardIterator , class InputIterator , class OutputIterator , class StrictWeakOrdering >
OutputIterator lower_bound (ForwardIterator first, ForwardIterator last, InputIterator values_first, InputIterator values_last, OutputIterator result, StrictWeakOrdering comp)
 
template<typename DerivedPolicy , typename ForwardIterator , typename InputIterator , typename OutputIterator >
__host__ __device__ OutputIterator upper_bound (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, InputIterator values_first, InputIterator values_last, OutputIterator result)
 
template<class ForwardIterator , class InputIterator , class OutputIterator >
OutputIterator upper_bound (ForwardIterator first, ForwardIterator last, InputIterator values_first, InputIterator values_last, OutputIterator result)
 
template<typename DerivedPolicy , typename ForwardIterator , typename InputIterator , typename OutputIterator , typename StrictWeakOrdering >
__host__ __device__ OutputIterator upper_bound (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, InputIterator values_first, InputIterator values_last, OutputIterator result, StrictWeakOrdering comp)
 
template<class ForwardIterator , class InputIterator , class OutputIterator , class StrictWeakOrdering >
OutputIterator upper_bound (ForwardIterator first, ForwardIterator last, InputIterator values_first, InputIterator values_last, OutputIterator result, StrictWeakOrdering comp)
 
template<typename DerivedPolicy , typename ForwardIterator , typename InputIterator , typename OutputIterator >
__host__ __device__ OutputIterator binary_search (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, InputIterator values_first, InputIterator values_last, OutputIterator result)
 
template<class ForwardIterator , class InputIterator , class OutputIterator >
OutputIterator binary_search (ForwardIterator first, ForwardIterator last, InputIterator values_first, InputIterator values_last, OutputIterator result)
 
template<typename DerivedPolicy , typename ForwardIterator , typename InputIterator , typename OutputIterator , typename StrictWeakOrdering >
__host__ __device__ OutputIterator binary_search (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, InputIterator values_first, InputIterator values_last, OutputIterator result, StrictWeakOrdering comp)
 
template<class ForwardIterator , class InputIterator , class OutputIterator , class StrictWeakOrdering >
OutputIterator binary_search (ForwardIterator first, ForwardIterator last, InputIterator values_first, InputIterator values_last, OutputIterator result, StrictWeakOrdering comp)
 
template<typename T >
__host__ __device__ T abs (const complex< T > &z)
 
template<typename T >
__host__ __device__ T arg (const complex< T > &z)
 
template<typename T >
__host__ __device__ T norm (const complex< T > &z)
 
template<typename T >
__host__ __device__ complex< T > conj (const complex< T > &z)
 
template<typename T0 , typename T1 >
__host__ __device__ complex< typename detail::promoted_numerical_type< T0, T1 >::type > polar (const T0 &m, const T1 &theta=T1())
 
template<typename T >
__host__ __device__ complex< T > proj (const T &z)
 
template<typename T0 , typename T1 >
__host__ __device__ complex< typename detail::promoted_numerical_type< T0, T1 >::type > operator+ (const complex< T0 > &x, const complex< T1 > &y)
 
template<typename T0 , typename T1 >
__host__ __device__ complex< typename detail::promoted_numerical_type< T0, T1 >::type > operator+ (const complex< T0 > &x, const T1 &y)
 
template<typename T0 , typename T1 >
__host__ __device__ complex< typename detail::promoted_numerical_type< T0, T1 >::type > operator+ (const T0 &x, const complex< T1 > &y)
 
template<typename T0 , typename T1 >
__host__ __device__ complex< typename detail::promoted_numerical_type< T0, T1 >::type > operator- (const complex< T0 > &x, const complex< T1 > &y)
 
template<typename T0 , typename T1 >
__host__ __device__ complex< typename detail::promoted_numerical_type< T0, T1 >::type > operator- (const complex< T0 > &x, const T1 &y)
 
template<typename T0 , typename T1 >
__host__ __device__ complex< typename detail::promoted_numerical_type< T0, T1 >::type > operator- (const T0 &x, const complex< T1 > &y)
 
template<typename T0 , typename T1 >
__host__ __device__ complex< typename detail::promoted_numerical_type< T0, T1 >::type > operator* (const complex< T0 > &x, const complex< T1 > &y)
 
template<typename T0 , typename T1 >
__host__ __device__ complex< typename detail::promoted_numerical_type< T0, T1 >::type > operator* (const complex< T0 > &x, const T1 &y)
 
template<typename T0 , typename T1 >
__host__ __device__ complex< typename detail::promoted_numerical_type< T0, T1 >::type > operator* (const T0 &x, const complex< T1 > &y)
 
template<typename T0 , typename T1 >
__host__ __device__ complex< typename detail::promoted_numerical_type< T0, T1 >::type > operator/ (const complex< T0 > &x, const complex< T1 > &y)
 
template<typename T0 , typename T1 >
__host__ __device__ complex< typename detail::promoted_numerical_type< T0, T1 >::type > operator/ (const complex< T0 > &x, const T1 &y)
 
template<typename T0 , typename T1 >
__host__ __device__ complex< typename detail::promoted_numerical_type< T0, T1 >::type > operator/ (const T0 &x, const complex< T1 > &y)
 
template<typename T >
__host__ __device__ complex< T > operator+ (const complex< T > &y)
 
template<typename T >
__host__ __device__ complex< T > operator- (const complex< T > &y)
 
template<typename T >
__host__ __device__ complex< T > exp (const complex< T > &z)
 
template<typename T >
__host__ __device__ complex< T > log (const complex< T > &z)
 
template<typename T >
__host__ __device__ complex< T > log10 (const complex< T > &z)
 
template<typename T0 , typename T1 >
__host__ __device__ complex< typename detail::promoted_numerical_type< T0, T1 >::type > pow (const complex< T0 > &x, const complex< T1 > &y)
 
template<typename T0 , typename T1 >
__host__ __device__ complex< typename detail::promoted_numerical_type< T0, T1 >::type > pow (const complex< T0 > &x, const T1 &y)
 
template<typename T0 , typename T1 >
__host__ __device__ complex< typename detail::promoted_numerical_type< T0, T1 >::type > pow (const T0 &x, const complex< T1 > &y)
 
template<typename T >
__host__ __device__ complex< T > sqrt (const complex< T > &z)
 
template<typename T >
__host__ __device__ complex< T > cos (const complex< T > &z)
 
template<typename T >
__host__ __device__ complex< T > sin (const complex< T > &z)
 
template<typename T >
__host__ __device__ complex< T > tan (const complex< T > &z)
 
template<typename T >
__host__ __device__ complex< T > cosh (const complex< T > &z)
 
template<typename T >
__host__ __device__ complex< T > sinh (const complex< T > &z)
 
template<typename T >
__host__ __device__ complex< T > tanh (const complex< T > &z)
 
template<typename T >
__host__ __device__ complex< T > acos (const complex< T > &z)
 
template<typename T >
__host__ __device__ complex< T > asin (const complex< T > &z)
 
template<typename T >
__host__ __device__ complex< T > atan (const complex< T > &z)
 
template<typename T >
__host__ __device__ complex< T > acosh (const complex< T > &z)
 
template<typename T >
__host__ __device__ complex< T > asinh (const complex< T > &z)
 
template<typename T >
__host__ __device__ complex< T > atanh (const complex< T > &z)
 
template<typename T , typename CharT , typename Traits >
std::basic_ostream< CharT, Traits > & operator<< (std::basic_ostream< CharT, Traits > &os, const complex< T > &z)
 
template<typename T , typename CharT , typename Traits >
__host__ std::basic_istream< CharT, Traits > & operator>> (std::basic_istream< CharT, Traits > &is, complex< T > &z)
 
template<typename T0 , typename T1 >
__host__ __device__ bool operator== (const complex< T0 > &x, const complex< T1 > &y)
 
template<typename T0 , typename T1 >
__host__ __device__ bool operator== (const complex< T0 > &x, const std::complex< T1 > &y)
 
template<typename T0 , typename T1 >
__host__ __device__ bool operator== (const std::complex< T0 > &x, const complex< T1 > &y)
 
template<typename T0 , typename T1 >
__host__ __device__ bool operator== (const T0 &x, const complex< T1 > &y)
 
template<typename T0 , typename T1 >
__host__ __device__ bool operator== (const complex< T0 > &x, const T1 &y)
 
template<typename T0 , typename T1 >
__host__ __device__ bool operator!= (const complex< T0 > &x, const complex< T1 > &y)
 
template<typename T0 , typename T1 >
__host__ __device__ bool operator!= (const complex< T0 > &x, const std::complex< T1 > &y)
 
template<typename T0 , typename T1 >
__host__ __device__ bool operator!= (const std::complex< T0 > &x, const complex< T1 > &y)
 
template<typename T0 , typename T1 >
__host__ __device__ bool operator!= (const T0 &x, const complex< T1 > &y)
 
template<typename T0 , typename T1 >
__host__ __device__ bool operator!= (const complex< T0 > &x, const T1 &y)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator >
__host__ __device__ OutputIterator copy (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result)
 
template<typename DerivedPolicy , typename InputIterator , typename Size , typename OutputIterator >
__host__ __device__ OutputIterator copy_n (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, Size n, OutputIterator result)
 
template<typename InputIterator , typename OutputIterator >
OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result)
 
template<typename InputIterator , typename Size , typename OutputIterator >
OutputIterator copy_n (InputIterator first, Size n, OutputIterator result)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator , typename Predicate >
__host__ __device__ OutputIterator copy_if (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result, Predicate pred)
 
template<typename InputIterator , typename OutputIterator , typename Predicate >
OutputIterator copy_if (InputIterator first, InputIterator last, OutputIterator result, Predicate pred)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename Predicate >
__host__ __device__ OutputIterator copy_if (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator result, Predicate pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename Predicate >
OutputIterator copy_if (InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator result, Predicate pred)
 
template<typename DerivedPolicy , typename InputIterator , typename EqualityComparable >
__host__ __device__ thrust::iterator_traits< InputIterator >::difference_type count (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, const EqualityComparable &value)
 
template<typename InputIterator , typename EqualityComparable >
thrust::iterator_traits< InputIterator >::difference_type count (InputIterator first, InputIterator last, const EqualityComparable &value)
 
template<typename DerivedPolicy , typename InputIterator , typename Predicate >
__host__ __device__ thrust::iterator_traits< InputIterator >::difference_type count_if (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, Predicate pred)
 
template<typename InputIterator , typename Predicate >
thrust::iterator_traits< InputIterator >::difference_type count_if (InputIterator first, InputIterator last, Predicate pred)
 
template<typename T >
void device_delete (thrust::device_ptr< T > ptr, const size_t n=1)
 
void device_free (thrust::device_ptr< void > ptr)
 
template<typename T , typename... Args>
__host__ auto device_make_unique (Args &&... args) THRUST_TRAILING_RETURN(decltype(uninitialized_allocate_unique< T >(device_allocator< T >
 
thrust::device_ptr< void > device_malloc (const std::size_t n)
 
template<typename T >
device_ptr< T > device_new (device_ptr< void > p, const size_t n=1)
 
template<typename T >
device_ptr< T > device_new (device_ptr< void > p, const T &exemplar, const size_t n=1)
 
template<typename T >
device_ptr< T > device_new (const size_t n=1)
 
template<typename T , typename CharT , typename Traits >
__host__ std::basic_ostream< CharT, Traits > & operator<< (std::basic_ostream< CharT, Traits > &os, device_ptr< T > const &dp)
 
template<typename T >
__host__ __device__ device_ptr< T > device_pointer_cast (T *ptr)
 Create a device_ptr from a raw pointer. More...
 
template<typename T >
__host__ __device__ device_ptr< T > device_pointer_cast (device_ptr< T > const &dptr)
 Create a device_ptr from another device_ptr. More...
 
template<typename T >
__host__ __device__ void swap (device_reference< T > &x, device_reference< T > &y)
 
template<typename T , typename charT , typename traits >
std::basic_ostream< charT, traits > & operator<< (std::basic_ostream< charT, traits > &os, const device_reference< T > &y)
 
template<typename T , typename Alloc >
void swap (device_vector< T, Alloc > &a, device_vector< T, Alloc > &b)
 
template<typename InputIterator >
__host__ __device__ thrust::iterator_traits< InputIterator >::difference_type distance (InputIterator first, InputIterator last)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 >
__host__ __device__ bool equal (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
 
template<typename InputIterator1 , typename InputIterator2 >
bool equal (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename BinaryPredicate >
__host__ __device__ bool equal (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate binary_pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename BinaryPredicate >
bool equal (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate binary_pred)
 
template<typename T , typename BinaryPredicate >
__host__ __device__ T min THRUST_PREVENT_MACRO_SUBSTITUTION (const T &lhs, const T &rhs, BinaryPredicate comp)
 
template<typename T >
__host__ __device__ T min THRUST_PREVENT_MACRO_SUBSTITUTION (const T &lhs, const T &rhs)
 
template<typename T , typename BinaryPredicate >
__host__ __device__ T max THRUST_PREVENT_MACRO_SUBSTITUTION (const T &lhs, const T &rhs, BinaryPredicate comp)
 
template<typename T >
__host__ __device__ T max THRUST_PREVENT_MACRO_SUBSTITUTION (const T &lhs, const T &rhs)
 
template<typename DerivedPolicy , typename ForwardIterator >
__host__ __device__ ForwardIterator min_element (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last)
 
template<typename ForwardIterator >
ForwardIterator min_element (ForwardIterator first, ForwardIterator last)
 
template<typename DerivedPolicy , typename ForwardIterator , typename BinaryPredicate >
__host__ __device__ ForwardIterator min_element (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, BinaryPredicate comp)
 
template<typename ForwardIterator , typename BinaryPredicate >
ForwardIterator min_element (ForwardIterator first, ForwardIterator last, BinaryPredicate comp)
 
template<typename DerivedPolicy , typename ForwardIterator >
__host__ __device__ ForwardIterator max_element (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last)
 
template<typename ForwardIterator >
ForwardIterator max_element (ForwardIterator first, ForwardIterator last)
 
template<typename DerivedPolicy , typename ForwardIterator , typename BinaryPredicate >
__host__ __device__ ForwardIterator max_element (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, BinaryPredicate comp)
 
template<typename ForwardIterator , typename BinaryPredicate >
ForwardIterator max_element (ForwardIterator first, ForwardIterator last, BinaryPredicate comp)
 
template<typename DerivedPolicy , typename ForwardIterator >
__host__ __device__ thrust::pair< ForwardIterator, ForwardIterator > minmax_element (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last)
 
template<typename ForwardIterator >
thrust::pair< ForwardIterator, ForwardIterator > minmax_element (ForwardIterator first, ForwardIterator last)
 
template<typename DerivedPolicy , typename ForwardIterator , typename BinaryPredicate >
__host__ __device__ thrust::pair< ForwardIterator, ForwardIterator > minmax_element (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, BinaryPredicate comp)
 
template<typename ForwardIterator , typename BinaryPredicate >
thrust::pair< ForwardIterator, ForwardIterator > minmax_element (ForwardIterator first, ForwardIterator last, BinaryPredicate comp)
 
template<typename DerivedPolicy , typename ForwardIterator , typename T >
__host__ __device__ void fill (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, const T &value)
 
template<typename ForwardIterator , typename T >
__host__ __device__ void fill (ForwardIterator first, ForwardIterator last, const T &value)
 
template<typename DerivedPolicy , typename OutputIterator , typename Size , typename T >
__host__ __device__ OutputIterator fill_n (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, OutputIterator first, Size n, const T &value)
 
template<typename OutputIterator , typename Size , typename T >
__host__ __device__ OutputIterator fill_n (OutputIterator first, Size n, const T &value)
 
template<typename DerivedPolicy , typename InputIterator , typename T >
__host__ __device__ InputIterator find (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, const T &value)
 
template<typename InputIterator , typename T >
InputIterator find (InputIterator first, InputIterator last, const T &value)
 
template<typename DerivedPolicy , typename InputIterator , typename Predicate >
__host__ __device__ InputIterator find_if (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, Predicate pred)
 
template<typename InputIterator , typename Predicate >
InputIterator find_if (InputIterator first, InputIterator last, Predicate pred)
 
template<typename DerivedPolicy , typename InputIterator , typename Predicate >
__host__ __device__ InputIterator find_if_not (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, Predicate pred)
 
template<typename InputIterator , typename Predicate >
InputIterator find_if_not (InputIterator first, InputIterator last, Predicate pred)
 
template<typename DerivedPolicy , typename InputIterator , typename UnaryFunction >
__host__ __device__ InputIterator for_each (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, UnaryFunction f)
 
template<typename DerivedPolicy , typename InputIterator , typename Size , typename UnaryFunction >
__host__ __device__ InputIterator for_each_n (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, Size n, UnaryFunction f)
 
template<typename InputIterator , typename UnaryFunction >
InputIterator for_each (InputIterator first, InputIterator last, UnaryFunction f)
 
template<typename InputIterator , typename Size , typename UnaryFunction >
InputIterator for_each_n (InputIterator first, Size n, UnaryFunction f)
 
template<typename Predicate >
__host__ __device__ unary_negate< Predicate > not1 (const Predicate &pred)
 
template<typename BinaryPredicate >
__host__ __device__ binary_negate< BinaryPredicate > not2 (const BinaryPredicate &pred)
 
template<typename DerivedPolicy , typename InputIterator , typename RandomAccessIterator , typename OutputIterator >
__host__ __device__ OutputIterator gather (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator map_first, InputIterator map_last, RandomAccessIterator input_first, OutputIterator result)
 
template<typename InputIterator , typename RandomAccessIterator , typename OutputIterator >
OutputIterator gather (InputIterator map_first, InputIterator map_last, RandomAccessIterator input_first, OutputIterator result)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename RandomAccessIterator , typename OutputIterator >
__host__ __device__ OutputIterator gather_if (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 map_first, InputIterator1 map_last, InputIterator2 stencil, RandomAccessIterator input_first, OutputIterator result)
 
template<typename InputIterator1 , typename InputIterator2 , typename RandomAccessIterator , typename OutputIterator >
OutputIterator gather_if (InputIterator1 map_first, InputIterator1 map_last, InputIterator2 stencil, RandomAccessIterator input_first, OutputIterator result)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename RandomAccessIterator , typename OutputIterator , typename Predicate >
__host__ __device__ OutputIterator gather_if (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 map_first, InputIterator1 map_last, InputIterator2 stencil, RandomAccessIterator input_first, OutputIterator result, Predicate pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename RandomAccessIterator , typename OutputIterator , typename Predicate >
OutputIterator gather_if (InputIterator1 map_first, InputIterator1 map_last, InputIterator2 stencil, RandomAccessIterator input_first, OutputIterator result, Predicate pred)
 
template<typename DerivedPolicy , typename ForwardIterator , typename Generator >
__host__ __device__ void generate (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, Generator gen)
 
template<typename ForwardIterator , typename Generator >
void generate (ForwardIterator first, ForwardIterator last, Generator gen)
 
template<typename DerivedPolicy , typename OutputIterator , typename Size , typename Generator >
__host__ __device__ OutputIterator generate_n (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, OutputIterator first, Size n, Generator gen)
 
template<typename OutputIterator , typename Size , typename Generator >
OutputIterator generate_n (OutputIterator first, Size n, Generator gen)
 
template<typename T , typename Alloc >
void swap (host_vector< T, Alloc > &a, host_vector< T, Alloc > &b)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputType >
__host__ __device__ OutputType inner_product (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputType init)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputType >
OutputType inner_product (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputType init)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputType , typename BinaryFunction1 , typename BinaryFunction2 >
__host__ __device__ OutputType inner_product (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputType init, BinaryFunction1 binary_op1, BinaryFunction2 binary_op2)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputType , typename BinaryFunction1 , typename BinaryFunction2 >
OutputType inner_product (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputType init, BinaryFunction1 binary_op1, BinaryFunction2 binary_op2)
 
template<typename ValueT , typename IndexT >
__host__ __device__ constant_iterator< ValueT, IndexT > make_constant_iterator (ValueT x, IndexT i=int())
 
template<typename V >
__host__ __device__ constant_iterator< V > make_constant_iterator (V x)
 
template<typename Incrementable >
__host__ __device__ counting_iterator< Incrementable > make_counting_iterator (Incrementable x)
 
__host__ __device__ discard_iterator make_discard_iterator (discard_iterator<>::difference_type i=discard_iterator<>::difference_type(0))
 
template<typename ElementIterator , typename IndexIterator >
__host__ __device__ permutation_iterator< ElementIterator, IndexIterator > make_permutation_iterator (ElementIterator e, IndexIterator i)
 
template<typename BidirectionalIterator >
__host__ __device__ reverse_iterator< BidirectionalIterator > make_reverse_iterator (BidirectionalIterator x)
 
template<typename InputFunction , typename OutputFunction , typename Iterator >
transform_input_output_iterator< InputFunction, OutputFunction, Iterator > __host__ __device__ make_transform_input_output_iterator (Iterator io, InputFunction input_function, OutputFunction output_function)
 
template<class AdaptableUnaryFunction , class Iterator >
__host__ __device__ transform_iterator< AdaptableUnaryFunction, Iterator > make_transform_iterator (Iterator it, AdaptableUnaryFunction fun)
 
template<typename UnaryFunction , typename OutputIterator >
transform_output_iterator< UnaryFunction, OutputIterator > __host__ __device__ make_transform_output_iterator (OutputIterator out, UnaryFunction fun)
 
template<typename... Iterators>
__host__ __device__ zip_iterator< thrust::tuple< Iterators... > > make_zip_iterator (thrust::tuple< Iterators... > t)
 
template<typename... Iterators>
__host__ __device__ zip_iterator< thrust::tuple< Iterators... > > make_zip_iterator (Iterators... its)
 
template<typename DerivedPolicy , typename InputIterator , typename Predicate >
__host__ __device__ bool all_of (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, Predicate pred)
 
template<typename InputIterator , typename Predicate >
bool all_of (InputIterator first, InputIterator last, Predicate pred)
 
template<typename DerivedPolicy , typename InputIterator , typename Predicate >
__host__ __device__ bool any_of (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, Predicate pred)
 
template<typename InputIterator , typename Predicate >
bool any_of (InputIterator first, InputIterator last, Predicate pred)
 
template<typename DerivedPolicy , typename InputIterator , typename Predicate >
__host__ __device__ bool none_of (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, Predicate pred)
 
template<typename InputIterator , typename Predicate >
bool none_of (InputIterator first, InputIterator last, Predicate pred)
 
template<typename DerivedPolicy >
__host__ __device__ pointer< void, DerivedPolicy > malloc (const thrust::detail::execution_policy_base< DerivedPolicy > &system, std::size_t n)
 
template<typename T , typename DerivedPolicy >
__host__ __device__ pointer< T, DerivedPolicy > malloc (const thrust::detail::execution_policy_base< DerivedPolicy > &system, std::size_t n)
 
template<typename T , typename DerivedPolicy >
__host__ __device__ thrust::pair< thrust::pointer< T, DerivedPolicy >, typename thrust::pointer< T, DerivedPolicy >::difference_type > get_temporary_buffer (const thrust::detail::execution_policy_base< DerivedPolicy > &system, typename thrust::pointer< T, DerivedPolicy >::difference_type n)
 
template<typename DerivedPolicy , typename Pointer >
__host__ __device__ void free (const thrust::detail::execution_policy_base< DerivedPolicy > &system, Pointer ptr)
 
template<typename DerivedPolicy , typename Pointer >
__host__ __device__ void return_temporary_buffer (const thrust::detail::execution_policy_base< DerivedPolicy > &system, Pointer p, std::ptrdiff_t n)
 
template<typename Pointer >
__host__ __device__ thrust::detail::pointer_traits< Pointer >::raw_pointer raw_pointer_cast (Pointer ptr)
 
template<typename T >
__host__ __device__ detail::raw_reference< T >::type raw_reference_cast (T &ref)
 
template<typename T >
__host__ __device__ detail::raw_reference< const T >::type raw_reference_cast (const T &ref)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
__host__ __device__ OutputIterator merge (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator merge (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename StrictWeakCompare >
__host__ __device__ OutputIterator merge (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, StrictWeakCompare comp)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename StrictWeakCompare >
OutputIterator merge (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, StrictWeakCompare comp)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename InputIterator4 , typename OutputIterator1 , typename OutputIterator2 >
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > merge_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, InputIterator4 values_first2, OutputIterator1 keys_result, OutputIterator2 values_result)
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename InputIterator4 , typename OutputIterator1 , typename OutputIterator2 >
thrust::pair< OutputIterator1, OutputIterator2 > merge_by_key (InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, InputIterator4 values_first2, OutputIterator1 keys_result, OutputIterator2 values_result)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename InputIterator4 , typename OutputIterator1 , typename OutputIterator2 , typename Compare >
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > merge_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, InputIterator4 values_first2, OutputIterator1 keys_result, OutputIterator2 values_result, Compare comp)
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename InputIterator4 , typename OutputIterator1 , typename OutputIterator2 , typename StrictWeakCompare >
thrust::pair< OutputIterator1, OutputIterator2 > merge_by_key (InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, InputIterator4 values_first2, OutputIterator1 keys_result, OutputIterator2 values_result, StrictWeakCompare comp)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 >
__host__ __device__ thrust::pair< InputIterator1, InputIterator2 > mismatch (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
 
template<typename InputIterator1 , typename InputIterator2 >
thrust::pair< InputIterator1, InputIterator2 > mismatch (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename BinaryPredicate >
__host__ __device__ thrust::pair< InputIterator1, InputIterator2 > mismatch (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename BinaryPredicate >
thrust::pair< InputIterator1, InputIterator2 > mismatch (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate pred)
 
template<class T , class U >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator== (const optional< T > &lhs, const optional< U > &rhs)
 relop More...
 
template<class T , class U >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator!= (const optional< T > &lhs, const optional< U > &rhs)
 relop
 
template<class T , class U >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator< (const optional< T > &lhs, const optional< U > &rhs)
 relop
 
template<class T , class U >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator> (const optional< T > &lhs, const optional< U > &rhs)
 relop
 
template<class T , class U >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator<= (const optional< T > &lhs, const optional< U > &rhs)
 relop
 
template<class T , class U >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator>= (const optional< T > &lhs, const optional< U > &rhs)
 relop
 
template<class T >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator== (const optional< T > &lhs, nullopt_t) noexcept
 relop_nullopt More...
 
template<class T >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator== (nullopt_t, const optional< T > &rhs) noexcept
 relop_nullopt
 
template<class T >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator!= (const optional< T > &lhs, nullopt_t) noexcept
 relop_nullopt
 
template<class T >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator!= (nullopt_t, const optional< T > &rhs) noexcept
 relop_nullopt
 
template<class T >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator< (const optional< T > &, nullopt_t) noexcept
 relop_nullopt
 
template<class T >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator< (nullopt_t, const optional< T > &rhs) noexcept
 relop_nullopt
 
template<class T >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator<= (const optional< T > &lhs, nullopt_t) noexcept
 relop_nullopt
 
template<class T >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator<= (nullopt_t, const optional< T > &) noexcept
 relop_nullopt
 
template<class T >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator> (const optional< T > &lhs, nullopt_t) noexcept
 relop_nullopt
 
template<class T >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator> (nullopt_t, const optional< T > &) noexcept
 relop_nullopt
 
template<class T >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator>= (const optional< T > &, nullopt_t) noexcept
 relop_nullopt
 
template<class T >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator>= (nullopt_t, const optional< T > &rhs) noexcept
 relop_nullopt
 
template<class T , class U >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator== (const optional< T > &lhs, const U &rhs)
 relop_t More...
 
template<class T , class U >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator== (const U &lhs, const optional< T > &rhs)
 relop_t
 
template<class T , class U >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator!= (const optional< T > &lhs, const U &rhs)
 relop_t
 
template<class T , class U >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator!= (const U &lhs, const optional< T > &rhs)
 relop_t
 
template<class T , class U >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator< (const optional< T > &lhs, const U &rhs)
 relop_t
 
template<class T , class U >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator< (const U &lhs, const optional< T > &rhs)
 relop_t
 
template<class T , class U >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator<= (const optional< T > &lhs, const U &rhs)
 relop_t
 
template<class T , class U >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator<= (const U &lhs, const optional< T > &rhs)
 relop_t
 
template<class T , class U >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator> (const optional< T > &lhs, const U &rhs)
 relop_t
 
template<class T , class U >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator> (const U &lhs, const optional< T > &rhs)
 relop_t
 
template<class T , class U >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator>= (const optional< T > &lhs, const U &rhs)
 relop_t
 
template<class T , class U >
__thrust_exec_check_disable__ __host__ __device__ constexpr bool operator>= (const U &lhs, const optional< T > &rhs)
 relop_t
 
template<class T , detail::enable_if_t< std::is_move_constructible< T >::value > * = nullptr, detail::enable_if_t< detail::is_swappable< T >::value > * = nullptr>
__thrust_exec_check_disable__ __host__ __device__ void swap (optional< T > &lhs, optional< T > &rhs) noexcept(noexcept(lhs.swap(rhs)))
 template <class t>=""> swap(optional<T> &lhs, optional<T> &rhs);
 
template<class T = detail::i_am_secret, class U , class Ret = detail::conditional_t<std::is_same<T, detail::i_am_secret>::value, detail::decay_t<U>, T>>
__thrust_exec_check_disable__ __host__ __device__ constexpr optional< Ret > make_optional (U &&v)
 
template<class T , class... Args>
__thrust_exec_check_disable__ __host__ __device__ constexpr optional< T > make_optional (Args &&... args)
 
template<class T , class U , class... Args>
__thrust_exec_check_disable__ __host__ __device__ constexpr optional< T > make_optional (std::initializer_list< U > il, Args &&... args)
 
template<class T >
 optional (T) -> optional< T >
 
template<typename T1 , typename T2 >
__host__ __device__ bool operator== (const pair< T1, T2 > &x, const pair< T1, T2 > &y)
 
template<typename T1 , typename T2 >
__host__ __device__ bool operator< (const pair< T1, T2 > &x, const pair< T1, T2 > &y)
 
template<typename T1 , typename T2 >
__host__ __device__ bool operator!= (const pair< T1, T2 > &x, const pair< T1, T2 > &y)
 
template<typename T1 , typename T2 >
__host__ __device__ bool operator> (const pair< T1, T2 > &x, const pair< T1, T2 > &y)
 
template<typename T1 , typename T2 >
__host__ __device__ bool operator<= (const pair< T1, T2 > &x, const pair< T1, T2 > &y)
 
template<typename T1 , typename T2 >
__host__ __device__ bool operator>= (const pair< T1, T2 > &x, const pair< T1, T2 > &y)
 
template<typename T1 , typename T2 >
__host__ __device__ void swap (pair< T1, T2 > &x, pair< T1, T2 > &y)
 
template<typename T1 , typename T2 >
__host__ __device__ pair< T1, T2 > make_pair (T1 x, T2 y)
 
template<typename DerivedPolicy , typename ForwardIterator , typename Predicate >
__host__ __device__ ForwardIterator partition (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, Predicate pred)
 
template<typename ForwardIterator , typename Predicate >
ForwardIterator partition (ForwardIterator first, ForwardIterator last, Predicate pred)
 
template<typename DerivedPolicy , typename ForwardIterator , typename InputIterator , typename Predicate >
__host__ __device__ ForwardIterator partition (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, InputIterator stencil, Predicate pred)
 
template<typename ForwardIterator , typename InputIterator , typename Predicate >
ForwardIterator partition (ForwardIterator first, ForwardIterator last, InputIterator stencil, Predicate pred)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator1 , typename OutputIterator2 , typename Predicate >
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > partition_copy (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator1 out_true, OutputIterator2 out_false, Predicate pred)
 
template<typename InputIterator , typename OutputIterator1 , typename OutputIterator2 , typename Predicate >
thrust::pair< OutputIterator1, OutputIterator2 > partition_copy (InputIterator first, InputIterator last, OutputIterator1 out_true, OutputIterator2 out_false, Predicate pred)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 , typename Predicate >
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > partition_copy (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator1 out_true, OutputIterator2 out_false, Predicate pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 , typename Predicate >
thrust::pair< OutputIterator1, OutputIterator2 > partition_copy (InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator1 out_true, OutputIterator2 out_false, Predicate pred)
 
template<typename DerivedPolicy , typename ForwardIterator , typename Predicate >
__host__ __device__ ForwardIterator stable_partition (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, Predicate pred)
 
template<typename ForwardIterator , typename Predicate >
ForwardIterator stable_partition (ForwardIterator first, ForwardIterator last, Predicate pred)
 
template<typename DerivedPolicy , typename ForwardIterator , typename InputIterator , typename Predicate >
__host__ __device__ ForwardIterator stable_partition (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, InputIterator stencil, Predicate pred)
 
template<typename ForwardIterator , typename InputIterator , typename Predicate >
ForwardIterator stable_partition (ForwardIterator first, ForwardIterator last, InputIterator stencil, Predicate pred)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator1 , typename OutputIterator2 , typename Predicate >
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > stable_partition_copy (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator1 out_true, OutputIterator2 out_false, Predicate pred)
 
template<typename InputIterator , typename OutputIterator1 , typename OutputIterator2 , typename Predicate >
thrust::pair< OutputIterator1, OutputIterator2 > stable_partition_copy (InputIterator first, InputIterator last, OutputIterator1 out_true, OutputIterator2 out_false, Predicate pred)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 , typename Predicate >
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > stable_partition_copy (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator1 out_true, OutputIterator2 out_false, Predicate pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 , typename Predicate >
thrust::pair< OutputIterator1, OutputIterator2 > stable_partition_copy (InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator1 out_true, OutputIterator2 out_false, Predicate pred)
 
template<typename DerivedPolicy , typename ForwardIterator , typename Predicate >
__host__ __device__ ForwardIterator partition_point (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, Predicate pred)
 
template<typename ForwardIterator , typename Predicate >
ForwardIterator partition_point (ForwardIterator first, ForwardIterator last, Predicate pred)
 
template<typename DerivedPolicy , typename InputIterator , typename Predicate >
__host__ __device__ bool is_partitioned (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, Predicate pred)
 
template<typename InputIterator , typename Predicate >
bool is_partitioned (InputIterator first, InputIterator last, Predicate pred)
 
template<typename MR , typename DerivedPolicy >
__host__ MR * get_per_device_resource (const thrust::detail::execution_policy_base< DerivedPolicy > &system)
 
template<typename DerivedPolicy , typename InputIterator >
__host__ __device__ thrust::iterator_traits< InputIterator >::value_type reduce (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last)
 
template<typename InputIterator >
thrust::iterator_traits< InputIterator >::value_type reduce (InputIterator first, InputIterator last)
 
template<typename DerivedPolicy , typename InputIterator , typename T >
__host__ __device__ T reduce (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, T init)
 
template<typename InputIterator , typename T >
reduce (InputIterator first, InputIterator last, T init)
 
template<typename DerivedPolicy , typename InputIterator , typename T , typename BinaryFunction >
__host__ __device__ T reduce (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, T init, BinaryFunction binary_op)
 
template<typename InputIterator , typename T , typename BinaryFunction >
reduce (InputIterator first, InputIterator last, T init, BinaryFunction binary_op)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 >
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > reduce_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 keys_first, InputIterator1 keys_last, InputIterator2 values_first, OutputIterator1 keys_output, OutputIterator2 values_output)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 >
thrust::pair< OutputIterator1, OutputIterator2 > reduce_by_key (InputIterator1 keys_first, InputIterator1 keys_last, InputIterator2 values_first, OutputIterator1 keys_output, OutputIterator2 values_output)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 , typename BinaryPredicate >
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > reduce_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 keys_first, InputIterator1 keys_last, InputIterator2 values_first, OutputIterator1 keys_output, OutputIterator2 values_output, BinaryPredicate binary_pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 , typename BinaryPredicate >
thrust::pair< OutputIterator1, OutputIterator2 > reduce_by_key (InputIterator1 keys_first, InputIterator1 keys_last, InputIterator2 values_first, OutputIterator1 keys_output, OutputIterator2 values_output, BinaryPredicate binary_pred)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 , typename BinaryPredicate , typename BinaryFunction >
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > reduce_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 keys_first, InputIterator1 keys_last, InputIterator2 values_first, OutputIterator1 keys_output, OutputIterator2 values_output, BinaryPredicate binary_pred, BinaryFunction binary_op)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 , typename BinaryPredicate , typename BinaryFunction >
thrust::pair< OutputIterator1, OutputIterator2 > reduce_by_key (InputIterator1 keys_first, InputIterator1 keys_last, InputIterator2 values_first, OutputIterator1 keys_output, OutputIterator2 values_output, BinaryPredicate binary_pred, BinaryFunction binary_op)
 
template<typename DerivedPolicy , typename ForwardIterator , typename T >
__host__ __device__ ForwardIterator remove (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, const T &value)
 
template<typename ForwardIterator , typename T >
ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T &value)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator , typename T >
__host__ __device__ OutputIterator remove_copy (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result, const T &value)
 
template<typename InputIterator , typename OutputIterator , typename T >
OutputIterator remove_copy (InputIterator first, InputIterator last, OutputIterator result, const T &value)
 
template<typename DerivedPolicy , typename ForwardIterator , typename Predicate >
__host__ __device__ ForwardIterator remove_if (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, Predicate pred)
 
template<typename ForwardIterator , typename Predicate >
ForwardIterator remove_if (ForwardIterator first, ForwardIterator last, Predicate pred)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator , typename Predicate >
__host__ __device__ OutputIterator remove_copy_if (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result, Predicate pred)
 
template<typename InputIterator , typename OutputIterator , typename Predicate >
OutputIterator remove_copy_if (InputIterator first, InputIterator last, OutputIterator result, Predicate pred)
 
template<typename DerivedPolicy , typename ForwardIterator , typename InputIterator , typename Predicate >
__host__ __device__ ForwardIterator remove_if (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, InputIterator stencil, Predicate pred)
 
template<typename ForwardIterator , typename InputIterator , typename Predicate >
ForwardIterator remove_if (ForwardIterator first, ForwardIterator last, InputIterator stencil, Predicate pred)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename Predicate >
__host__ __device__ OutputIterator remove_copy_if (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator result, Predicate pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename Predicate >
OutputIterator remove_copy_if (InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator result, Predicate pred)
 
template<typename DerivedPolicy , typename ForwardIterator , typename T >
__host__ __device__ void replace (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, const T &old_value, const T &new_value)
 
template<typename ForwardIterator , typename T >
void replace (ForwardIterator first, ForwardIterator last, const T &old_value, const T &new_value)
 
template<typename DerivedPolicy , typename ForwardIterator , typename Predicate , typename T >
__host__ __device__ void replace_if (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, Predicate pred, const T &new_value)
 
template<typename ForwardIterator , typename Predicate , typename T >
void replace_if (ForwardIterator first, ForwardIterator last, Predicate pred, const T &new_value)
 
template<typename DerivedPolicy , typename ForwardIterator , typename InputIterator , typename Predicate , typename T >
__host__ __device__ void replace_if (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, InputIterator stencil, Predicate pred, const T &new_value)
 
template<typename ForwardIterator , typename InputIterator , typename Predicate , typename T >
void replace_if (ForwardIterator first, ForwardIterator last, InputIterator stencil, Predicate pred, const T &new_value)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator , typename T >
__host__ __device__ OutputIterator replace_copy (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result, const T &old_value, const T &new_value)
 
template<typename InputIterator , typename OutputIterator , typename T >
OutputIterator replace_copy (InputIterator first, InputIterator last, OutputIterator result, const T &old_value, const T &new_value)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator , typename Predicate , typename T >
__host__ __device__ OutputIterator replace_copy_if (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T &new_value)
 
template<typename InputIterator , typename OutputIterator , typename Predicate , typename T >
OutputIterator replace_copy_if (InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T &new_value)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename Predicate , typename T >
__host__ __device__ OutputIterator replace_copy_if (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator result, Predicate pred, const T &new_value)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename Predicate , typename T >
OutputIterator replace_copy_if (InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator result, Predicate pred, const T &new_value)
 
template<typename DerivedPolicy , typename BidirectionalIterator >
__host__ __device__ void reverse (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, BidirectionalIterator first, BidirectionalIterator last)
 
template<typename BidirectionalIterator >
void reverse (BidirectionalIterator first, BidirectionalIterator last)
 
template<typename DerivedPolicy , typename BidirectionalIterator , typename OutputIterator >
__host__ __device__ OutputIterator reverse_copy (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, BidirectionalIterator first, BidirectionalIterator last, OutputIterator result)
 
template<typename BidirectionalIterator , typename OutputIterator >
OutputIterator reverse_copy (BidirectionalIterator first, BidirectionalIterator last, OutputIterator result)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator >
__host__ __device__ OutputIterator inclusive_scan (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result)
 
template<typename InputIterator , typename OutputIterator >
OutputIterator inclusive_scan (InputIterator first, InputIterator last, OutputIterator result)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator , typename AssociativeOperator >
__host__ __device__ OutputIterator inclusive_scan (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result, AssociativeOperator binary_op)
 
template<typename InputIterator , typename OutputIterator , typename AssociativeOperator >
OutputIterator inclusive_scan (InputIterator first, InputIterator last, OutputIterator result, AssociativeOperator binary_op)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator >
__host__ __device__ OutputIterator exclusive_scan (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result)
 
template<typename InputIterator , typename OutputIterator >
OutputIterator exclusive_scan (InputIterator first, InputIterator last, OutputIterator result)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator , typename T >
__host__ __device__ OutputIterator exclusive_scan (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result, T init)
 
template<typename InputIterator , typename OutputIterator , typename T >
OutputIterator exclusive_scan (InputIterator first, InputIterator last, OutputIterator result, T init)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator , typename T , typename AssociativeOperator >
__host__ __device__ OutputIterator exclusive_scan (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result, T init, AssociativeOperator binary_op)
 
template<typename InputIterator , typename OutputIterator , typename T , typename AssociativeOperator >
OutputIterator exclusive_scan (InputIterator first, InputIterator last, OutputIterator result, T init, AssociativeOperator binary_op)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
__host__ __device__ OutputIterator inclusive_scan_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator inclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryPredicate >
__host__ __device__ OutputIterator inclusive_scan_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryPredicate binary_pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryPredicate >
OutputIterator inclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryPredicate binary_pred)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryPredicate , typename AssociativeOperator >
__host__ __device__ OutputIterator inclusive_scan_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryPredicate binary_pred, AssociativeOperator binary_op)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryPredicate , typename AssociativeOperator >
OutputIterator inclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryPredicate binary_pred, AssociativeOperator binary_op)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
__host__ __device__ OutputIterator exclusive_scan_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator exclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T >
__host__ __device__ OutputIterator exclusive_scan_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, T init)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T >
OutputIterator exclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, T init)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T , typename BinaryPredicate >
__host__ __device__ OutputIterator exclusive_scan_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, T init, BinaryPredicate binary_pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T , typename BinaryPredicate >
OutputIterator exclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, T init, BinaryPredicate binary_pred)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T , typename BinaryPredicate , typename AssociativeOperator >
__host__ __device__ OutputIterator exclusive_scan_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, T init, BinaryPredicate binary_pred, AssociativeOperator binary_op)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename T , typename BinaryPredicate , typename AssociativeOperator >
OutputIterator exclusive_scan_by_key (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, T init, BinaryPredicate binary_pred, AssociativeOperator binary_op)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename RandomAccessIterator >
__host__ __device__ void scatter (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first, InputIterator1 last, InputIterator2 map, RandomAccessIterator result)
 
template<typename InputIterator1 , typename InputIterator2 , typename RandomAccessIterator >
void scatter (InputIterator1 first, InputIterator1 last, InputIterator2 map, RandomAccessIterator result)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename RandomAccessIterator >
__host__ __device__ void scatter_if (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first, InputIterator1 last, InputIterator2 map, InputIterator3 stencil, RandomAccessIterator output)
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename RandomAccessIterator >
void scatter_if (InputIterator1 first, InputIterator1 last, InputIterator2 map, InputIterator3 stencil, RandomAccessIterator output)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename RandomAccessIterator , typename Predicate >
__host__ __device__ void scatter_if (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first, InputIterator1 last, InputIterator2 map, InputIterator3 stencil, RandomAccessIterator output, Predicate pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename RandomAccessIterator , typename Predicate >
void scatter_if (InputIterator1 first, InputIterator1 last, InputIterator2 map, InputIterator3 stencil, RandomAccessIterator output, Predicate pred)
 
template<typename DerivedPolicy , typename ForwardIterator >
__host__ __device__ void sequence (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last)
 
template<typename ForwardIterator >
void sequence (ForwardIterator first, ForwardIterator last)
 
template<typename DerivedPolicy , typename ForwardIterator , typename T >
__host__ __device__ void sequence (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, T init)
 
template<typename ForwardIterator , typename T >
void sequence (ForwardIterator first, ForwardIterator last, T init)
 
template<typename DerivedPolicy , typename ForwardIterator , typename T >
__host__ __device__ void sequence (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, T init, T step)
 
template<typename ForwardIterator , typename T >
void sequence (ForwardIterator first, ForwardIterator last, T init, T step)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
__host__ __device__ OutputIterator set_difference (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator set_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename StrictWeakCompare >
__host__ __device__ OutputIterator set_difference (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, StrictWeakCompare comp)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename StrictWeakCompare >
OutputIterator set_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, StrictWeakCompare comp)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
__host__ __device__ OutputIterator set_intersection (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator set_intersection (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename StrictWeakCompare >
__host__ __device__ OutputIterator set_intersection (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, StrictWeakCompare comp)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename StrictWeakCompare >
OutputIterator set_intersection (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, StrictWeakCompare comp)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
__host__ __device__ OutputIterator set_symmetric_difference (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator set_symmetric_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename StrictWeakCompare >
__host__ __device__ OutputIterator set_symmetric_difference (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, StrictWeakCompare comp)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename StrictWeakCompare >
OutputIterator set_symmetric_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, StrictWeakCompare comp)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
__host__ __device__ OutputIterator set_union (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator set_union (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename StrictWeakCompare >
__host__ __device__ OutputIterator set_union (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, StrictWeakCompare comp)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename StrictWeakCompare >
OutputIterator set_union (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, StrictWeakCompare comp)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename InputIterator4 , typename OutputIterator1 , typename OutputIterator2 >
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > set_difference_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, InputIterator4 values_first2, OutputIterator1 keys_result, OutputIterator2 values_result)
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename InputIterator4 , typename OutputIterator1 , typename OutputIterator2 >
thrust::pair< OutputIterator1, OutputIterator2 > set_difference_by_key (InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, InputIterator4 values_first2, OutputIterator1 keys_result, OutputIterator2 values_result)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename InputIterator4 , typename OutputIterator1 , typename OutputIterator2 , typename StrictWeakCompare >
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > set_difference_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, InputIterator4 values_first2, OutputIterator1 keys_result, OutputIterator2 values_result, StrictWeakCompare comp)
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename InputIterator4 , typename OutputIterator1 , typename OutputIterator2 , typename StrictWeakCompare >
thrust::pair< OutputIterator1, OutputIterator2 > set_difference_by_key (InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, InputIterator4 values_first2, OutputIterator1 keys_result, OutputIterator2 values_result, StrictWeakCompare comp)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename OutputIterator1 , typename OutputIterator2 >
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > set_intersection_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, OutputIterator1 keys_result, OutputIterator2 values_result)
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename OutputIterator1 , typename OutputIterator2 >
thrust::pair< OutputIterator1, OutputIterator2 > set_intersection_by_key (InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, OutputIterator1 keys_result, OutputIterator2 values_result)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename OutputIterator1 , typename OutputIterator2 , typename StrictWeakCompare >
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > set_intersection_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, OutputIterator1 keys_result, OutputIterator2 values_result, StrictWeakCompare comp)
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename OutputIterator1 , typename OutputIterator2 , typename StrictWeakCompare >
thrust::pair< OutputIterator1, OutputIterator2 > set_intersection_by_key (InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, OutputIterator1 keys_result, OutputIterator2 values_result, StrictWeakCompare comp)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename InputIterator4 , typename OutputIterator1 , typename OutputIterator2 >
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > set_symmetric_difference_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, InputIterator4 values_first2, OutputIterator1 keys_result, OutputIterator2 values_result)
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename InputIterator4 , typename OutputIterator1 , typename OutputIterator2 >
thrust::pair< OutputIterator1, OutputIterator2 > set_symmetric_difference_by_key (InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, InputIterator4 values_first2, OutputIterator1 keys_result, OutputIterator2 values_result)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename InputIterator4 , typename OutputIterator1 , typename OutputIterator2 , typename StrictWeakCompare >
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > set_symmetric_difference_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, InputIterator4 values_first2, OutputIterator1 keys_result, OutputIterator2 values_result, StrictWeakCompare comp)
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename InputIterator4 , typename OutputIterator1 , typename OutputIterator2 , typename StrictWeakCompare >
thrust::pair< OutputIterator1, OutputIterator2 > set_symmetric_difference_by_key (InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, InputIterator4 values_first2, OutputIterator1 keys_result, OutputIterator2 values_result, StrictWeakCompare comp)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename InputIterator4 , typename OutputIterator1 , typename OutputIterator2 >
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > set_union_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, InputIterator4 values_first2, OutputIterator1 keys_result, OutputIterator2 values_result)
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename InputIterator4 , typename OutputIterator1 , typename OutputIterator2 >
thrust::pair< OutputIterator1, OutputIterator2 > set_union_by_key (InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, InputIterator4 values_first2, OutputIterator1 keys_result, OutputIterator2 values_result)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename InputIterator4 , typename OutputIterator1 , typename OutputIterator2 , typename StrictWeakCompare >
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > set_union_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, InputIterator4 values_first2, OutputIterator1 keys_result, OutputIterator2 values_result, StrictWeakCompare comp)
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename InputIterator4 , typename OutputIterator1 , typename OutputIterator2 , typename StrictWeakCompare >
thrust::pair< OutputIterator1, OutputIterator2 > set_union_by_key (InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, InputIterator4 values_first2, OutputIterator1 keys_result, OutputIterator2 values_result, StrictWeakCompare comp)
 
template<typename DerivedPolicy , typename RandomIterator , typename URBG >
__host__ __device__ void shuffle (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, RandomIterator first, RandomIterator last, URBG &&g)
 
template<typename RandomIterator , typename URBG >
__host__ __device__ void shuffle (RandomIterator first, RandomIterator last, URBG &&g)
 
template<typename DerivedPolicy , typename RandomIterator , typename OutputIterator , typename URBG >
__host__ __device__ void shuffle_copy (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, RandomIterator first, RandomIterator last, OutputIterator result, URBG &&g)
 
template<typename RandomIterator , typename OutputIterator , typename URBG >
__host__ __device__ void shuffle_copy (RandomIterator first, RandomIterator last, OutputIterator result, URBG &&g)
 
template<typename DerivedPolicy , typename RandomAccessIterator >
__host__ __device__ void sort (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, RandomAccessIterator first, RandomAccessIterator last)
 
template<typename RandomAccessIterator >
void sort (RandomAccessIterator first, RandomAccessIterator last)
 
template<typename DerivedPolicy , typename RandomAccessIterator , typename StrictWeakOrdering >
__host__ __device__ void sort (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering comp)
 
template<typename RandomAccessIterator , typename StrictWeakOrdering >
__host__ __device__ void sort (RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering comp)
 
template<typename DerivedPolicy , typename RandomAccessIterator >
__host__ __device__ void stable_sort (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, RandomAccessIterator first, RandomAccessIterator last)
 
template<typename RandomAccessIterator >
void stable_sort (RandomAccessIterator first, RandomAccessIterator last)
 
template<typename DerivedPolicy , typename RandomAccessIterator , typename StrictWeakOrdering >
__host__ __device__ void stable_sort (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering comp)
 
template<typename RandomAccessIterator , typename StrictWeakOrdering >
void stable_sort (RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering comp)
 
template<typename DerivedPolicy , typename RandomAccessIterator1 , typename RandomAccessIterator2 >
__host__ __device__ void sort_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, RandomAccessIterator1 keys_first, RandomAccessIterator1 keys_last, RandomAccessIterator2 values_first)
 
template<typename RandomAccessIterator1 , typename RandomAccessIterator2 >
void sort_by_key (RandomAccessIterator1 keys_first, RandomAccessIterator1 keys_last, RandomAccessIterator2 values_first)
 
template<typename DerivedPolicy , typename RandomAccessIterator1 , typename RandomAccessIterator2 , typename StrictWeakOrdering >
__host__ __device__ void sort_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, RandomAccessIterator1 keys_first, RandomAccessIterator1 keys_last, RandomAccessIterator2 values_first, StrictWeakOrdering comp)
 
template<typename RandomAccessIterator1 , typename RandomAccessIterator2 , typename StrictWeakOrdering >
void sort_by_key (RandomAccessIterator1 keys_first, RandomAccessIterator1 keys_last, RandomAccessIterator2 values_first, StrictWeakOrdering comp)
 
template<typename DerivedPolicy , typename RandomAccessIterator1 , typename RandomAccessIterator2 >
__host__ __device__ void stable_sort_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, RandomAccessIterator1 keys_first, RandomAccessIterator1 keys_last, RandomAccessIterator2 values_first)
 
template<typename RandomAccessIterator1 , typename RandomAccessIterator2 >
void stable_sort_by_key (RandomAccessIterator1 keys_first, RandomAccessIterator1 keys_last, RandomAccessIterator2 values_first)
 
template<typename DerivedPolicy , typename RandomAccessIterator1 , typename RandomAccessIterator2 , typename StrictWeakOrdering >
__host__ __device__ void stable_sort_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, RandomAccessIterator1 keys_first, RandomAccessIterator1 keys_last, RandomAccessIterator2 values_first, StrictWeakOrdering comp)
 
template<typename RandomAccessIterator1 , typename RandomAccessIterator2 , typename StrictWeakOrdering >
void stable_sort_by_key (RandomAccessIterator1 keys_first, RandomAccessIterator1 keys_last, RandomAccessIterator2 values_first, StrictWeakOrdering comp)
 
template<typename DerivedPolicy , typename ForwardIterator >
__host__ __device__ bool is_sorted (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last)
 
template<typename ForwardIterator >
bool is_sorted (ForwardIterator first, ForwardIterator last)
 
template<typename DerivedPolicy , typename ForwardIterator , typename Compare >
__host__ __device__ bool is_sorted (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, Compare comp)
 
template<typename ForwardIterator , typename Compare >
bool is_sorted (ForwardIterator first, ForwardIterator last, Compare comp)
 
template<typename DerivedPolicy , typename ForwardIterator >
__host__ __device__ ForwardIterator is_sorted_until (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last)
 
template<typename ForwardIterator >
ForwardIterator is_sorted_until (ForwardIterator first, ForwardIterator last)
 
template<typename DerivedPolicy , typename ForwardIterator , typename Compare >
__host__ __device__ ForwardIterator is_sorted_until (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, Compare comp)
 
template<typename ForwardIterator , typename Compare >
ForwardIterator is_sorted_until (ForwardIterator first, ForwardIterator last, Compare comp)
 
template<typename Assignable1 , typename Assignable2 >
__host__ __device__ void swap (Assignable1 &a, Assignable2 &b)
 
template<typename DerivedPolicy , typename ForwardIterator1 , typename ForwardIterator2 >
__host__ __device__ ForwardIterator2 swap_ranges (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2)
 
template<typename ForwardIterator1 , typename ForwardIterator2 >
ForwardIterator2 swap_ranges (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2)
 
template<typename DerivedPolicy >
__host__ thrust::cuda::unique_eager_event unique_eager_event_type (thrust::cuda::execution_policy< DerivedPolicy > const &) noexcept
 
template<typename T , typename DerivedPolicy >
__host__ thrust::cuda::unique_eager_future< T > unique_eager_future_type (thrust::cuda::execution_policy< DerivedPolicy > const &) noexcept
 
template<typename DerivedPolicy , typename ForwardIterator , typename UnaryOperation >
__host__ __device__ void tabulate (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, UnaryOperation unary_op)
 
template<typename ForwardIterator , typename UnaryOperation >
void tabulate (ForwardIterator first, ForwardIterator last, UnaryOperation unary_op)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator , typename UnaryFunction >
__host__ __device__ OutputIterator transform (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result, UnaryFunction op)
 
template<typename InputIterator , typename OutputIterator , typename UnaryFunction >
OutputIterator transform (InputIterator first, InputIterator last, OutputIterator result, UnaryFunction op)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryFunction >
__host__ __device__ OutputIterator transform (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryFunction op)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryFunction >
OutputIterator transform (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryFunction op)
 
template<typename DerivedPolicy , typename InputIterator , typename ForwardIterator , typename UnaryFunction , typename Predicate >
__host__ __device__ ForwardIterator transform_if (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, ForwardIterator result, UnaryFunction op, Predicate pred)
 
template<typename InputIterator , typename ForwardIterator , typename UnaryFunction , typename Predicate >
ForwardIterator transform_if (InputIterator first, InputIterator last, ForwardIterator result, UnaryFunction op, Predicate pred)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename ForwardIterator , typename UnaryFunction , typename Predicate >
__host__ __device__ ForwardIterator transform_if (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first, InputIterator1 last, InputIterator2 stencil, ForwardIterator result, UnaryFunction op, Predicate pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename ForwardIterator , typename UnaryFunction , typename Predicate >
ForwardIterator transform_if (InputIterator1 first, InputIterator1 last, InputIterator2 stencil, ForwardIterator result, UnaryFunction op, Predicate pred)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename ForwardIterator , typename BinaryFunction , typename Predicate >
__host__ __device__ ForwardIterator transform_if (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator3 stencil, ForwardIterator result, BinaryFunction binary_op, Predicate pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename ForwardIterator , typename BinaryFunction , typename Predicate >
ForwardIterator transform_if (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator3 stencil, ForwardIterator result, BinaryFunction binary_op, Predicate pred)
 
template<typename DerivedPolicy , typename InputIterator , typename UnaryFunction , typename OutputType , typename BinaryFunction >
__host__ __device__ OutputType transform_reduce (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, UnaryFunction unary_op, OutputType init, BinaryFunction binary_op)
 
template<typename InputIterator , typename UnaryFunction , typename OutputType , typename BinaryFunction >
OutputType transform_reduce (InputIterator first, InputIterator last, UnaryFunction unary_op, OutputType init, BinaryFunction binary_op)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator , typename UnaryFunction , typename AssociativeOperator >
__host__ __device__ OutputIterator transform_inclusive_scan (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result, UnaryFunction unary_op, AssociativeOperator binary_op)
 
template<typename InputIterator , typename OutputIterator , typename UnaryFunction , typename AssociativeOperator >
OutputIterator transform_inclusive_scan (InputIterator first, InputIterator last, OutputIterator result, UnaryFunction unary_op, AssociativeOperator binary_op)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator , typename UnaryFunction , typename T , typename AssociativeOperator >
__host__ __device__ OutputIterator transform_exclusive_scan (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result, UnaryFunction unary_op, T init, AssociativeOperator binary_op)
 
template<typename InputIterator , typename OutputIterator , typename UnaryFunction , typename T , typename AssociativeOperator >
OutputIterator transform_exclusive_scan (InputIterator first, InputIterator last, OutputIterator result, UnaryFunction unary_op, T init, AssociativeOperator binary_op)
 
template<int N, class HT , class TT >
__host__ __device__ access_traits< typename tuple_element< N, detail::cons< HT, TT > >::type >::non_const_type get (detail::cons< HT, TT > &t)
 
template<int N, class HT , class TT >
__host__ __device__ access_traits< typename tuple_element< N, detail::cons< HT, TT > >::type >::const_type get (const detail::cons< HT, TT > &t)
 
template<class T0 >
__host__ __device__ detail::make_tuple_mapper< T0 >::type make_tuple (const T0 &t0)
 
template<class T0 , class T1 >
__host__ __device__ detail::make_tuple_mapper< T0, T1 >::type make_tuple (const T0 &t0, const T1 &t1)
 
template<typename T0 >
__host__ __device__ tuple< T0 & > tie (T0 &t0)
 
template<typename T0 , typename T1 >
__host__ __device__ tuple< T0 &, T1 & > tie (T0 &t0, T1 &t1)
 
template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 >
__host__ __device__ void swap (tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 > &x, tuple< U0, U1, U2, U3, U4, U5, U6, U7, U8, U9 > &y)
 
template<typename DerivedPolicy , typename InputIterator , typename ForwardIterator >
__host__ __device__ ForwardIterator uninitialized_copy (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, ForwardIterator result)
 
template<typename InputIterator , typename ForwardIterator >
ForwardIterator uninitialized_copy (InputIterator first, InputIterator last, ForwardIterator result)
 
template<typename DerivedPolicy , typename InputIterator , typename Size , typename ForwardIterator >
__host__ __device__ ForwardIterator uninitialized_copy_n (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, Size n, ForwardIterator result)
 
template<typename InputIterator , typename Size , typename ForwardIterator >
ForwardIterator uninitialized_copy_n (InputIterator first, Size n, ForwardIterator result)
 
template<typename DerivedPolicy , typename ForwardIterator , typename T >
__host__ __device__ void uninitialized_fill (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, const T &x)
 
template<typename ForwardIterator , typename T >
void uninitialized_fill (ForwardIterator first, ForwardIterator last, const T &x)
 
template<typename DerivedPolicy , typename ForwardIterator , typename Size , typename T >
__host__ __device__ ForwardIterator uninitialized_fill_n (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, Size n, const T &x)
 
template<typename ForwardIterator , typename Size , typename T >
ForwardIterator uninitialized_fill_n (ForwardIterator first, Size n, const T &x)
 
template<typename DerivedPolicy , typename ForwardIterator >
__host__ __device__ ForwardIterator unique (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last)
 
template<typename ForwardIterator >
ForwardIterator unique (ForwardIterator first, ForwardIterator last)
 
template<typename DerivedPolicy , typename ForwardIterator , typename BinaryPredicate >
__host__ __device__ ForwardIterator unique (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, BinaryPredicate binary_pred)
 
template<typename ForwardIterator , typename BinaryPredicate >
ForwardIterator unique (ForwardIterator first, ForwardIterator last, BinaryPredicate binary_pred)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator >
__host__ __device__ OutputIterator unique_copy (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result)
 
template<typename InputIterator , typename OutputIterator >
OutputIterator unique_copy (InputIterator first, InputIterator last, OutputIterator result)
 
template<typename DerivedPolicy , typename InputIterator , typename OutputIterator , typename BinaryPredicate >
__host__ __device__ OutputIterator unique_copy (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate binary_pred)
 
template<typename InputIterator , typename OutputIterator , typename BinaryPredicate >
OutputIterator unique_copy (InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate binary_pred)
 
template<typename DerivedPolicy , typename ForwardIterator1 , typename ForwardIterator2 >
__host__ __device__ thrust::pair< ForwardIterator1, ForwardIterator2 > unique_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator1 keys_first, ForwardIterator1 keys_last, ForwardIterator2 values_first)
 
template<typename ForwardIterator1 , typename ForwardIterator2 >
thrust::pair< ForwardIterator1, ForwardIterator2 > unique_by_key (ForwardIterator1 keys_first, ForwardIterator1 keys_last, ForwardIterator2 values_first)
 
template<typename DerivedPolicy , typename ForwardIterator1 , typename ForwardIterator2 , typename BinaryPredicate >
__host__ __device__ thrust::pair< ForwardIterator1, ForwardIterator2 > unique_by_key (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator1 keys_first, ForwardIterator1 keys_last, ForwardIterator2 values_first, BinaryPredicate binary_pred)
 
template<typename ForwardIterator1 , typename ForwardIterator2 , typename BinaryPredicate >
thrust::pair< ForwardIterator1, ForwardIterator2 > unique_by_key (ForwardIterator1 keys_first, ForwardIterator1 keys_last, ForwardIterator2 values_first, BinaryPredicate binary_pred)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 >
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > unique_by_key_copy (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 keys_first, InputIterator1 keys_last, InputIterator2 values_first, OutputIterator1 keys_result, OutputIterator2 values_result)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 >
thrust::pair< OutputIterator1, OutputIterator2 > unique_by_key_copy (InputIterator1 keys_first, InputIterator1 keys_last, InputIterator2 values_first, OutputIterator1 keys_result, OutputIterator2 values_result)
 
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 , typename BinaryPredicate >
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > unique_by_key_copy (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, InputIterator1 keys_first, InputIterator1 keys_last, InputIterator2 values_first, OutputIterator1 keys_result, OutputIterator2 values_result, BinaryPredicate binary_pred)
 
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 , typename BinaryPredicate >
thrust::pair< OutputIterator1, OutputIterator2 > unique_by_key_copy (InputIterator1 keys_first, InputIterator1 keys_last, InputIterator2 values_first, OutputIterator1 keys_result, OutputIterator2 values_result, BinaryPredicate binary_pred)
 
template<typename DerivedPolicy , typename ForwardIterator , typename BinaryPredicate >
__host__ __device__ thrust::iterator_traits< ForwardIterator >::difference_type unique_count (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last, BinaryPredicate binary_pred)
 
template<typename DerivedPolicy , typename ForwardIterator >
__host__ __device__ thrust::iterator_traits< ForwardIterator >::difference_type unique_count (const thrust::detail::execution_policy_base< DerivedPolicy > &exec, ForwardIterator first, ForwardIterator last)
 
template<typename ForwardIterator , typename BinaryPredicate >
__host__ __device__ thrust::iterator_traits< ForwardIterator >::difference_type unique_count (ForwardIterator first, ForwardIterator last, BinaryPredicate binary_pred)
 
template<typename ForwardIterator >
__host__ __device__ thrust::iterator_traits< ForwardIterator >::difference_type unique_count (ForwardIterator first, ForwardIterator last)
 
template<typename Function >
__host__ __device__ zip_function< typename std::decay< Function >::type > make_zip_function (Function &&fun)
 

Variables

static const detail::host_t host
 
THRUST_INLINE_CONSTANT detail::device_t device
 
THRUST_INLINE_CONSTANT new_stream_t new_stream {}
 
static constexpr in_place_t in_place {}
 A tag to tell optional to construct its value in-place.
 
static constexpr nullopt_t nullopt
 Represents an empty optional static constexpr nullopt_t nullopt;. More...
 
template<typename Iterator >
constexpr bool is_contiguous_iterator_v = is_contiguous_iterator<Iterator>::value
 constexpr bool that is true if Iterator satisfies ContiguousIterator, aka it points to elements that are contiguous in memory, and false otherwise. More...
 
template<typename T >
constexpr bool is_execution_policy_v = is_execution_policy<T>::value
 constexpr bool that is true if T is an ExecutionPolicy and false otherwise.
 
template<typename T >
constexpr bool is_operator_less_function_object_v = is_operator_less_function_object<T>::value
 constexpr bool that is true if T is a BinaryPredicate equivalent to operator<, and false otherwise. More...
 
template<typename T >
constexpr bool is_operator_greater_function_object_v = is_operator_greater_function_object<T>::value
 constexpr bool that is true if T is a BinaryPredicate equivalent to operator>, and false otherwise. More...
 
template<typename T >
constexpr bool is_operator_less_or_greater_function_object_v = is_operator_less_or_greater_function_object<T>::value
 constexpr bool that is true if T is a BinaryPredicate equivalent to operator< or operator>, and false otherwise. More...
 
template<typename T >
constexpr bool is_operator_plus_function_object_v = is_operator_plus_function_object<T>::value
 constexpr bool that is true if T is a FunctionObject equivalent to operator<, and false otherwise. More...
 
template<typename... Ts>
constexpr bool conjunction_v = conjunction<Ts...>::value
 constexpr bool whose value is (... && Ts::value). More...
 
template<typename... Ts>
constexpr bool disjunction_v = disjunction<Ts...>::value
 constexpr bool whose value is (... || Ts::value). More...
 
template<typename T >
constexpr bool negation_v = negation<T>::value
 constexpr bool whose value is !Ts::value. More...
 
template<bool... Bs>
constexpr bool conjunction_value_v = conjunction_value<Bs...>::value
 constexpr bool whose value is (... && Bs). More...
 
template<bool... Bs>
constexpr bool disjunction_value_v = disjunction_value<Bs...>::value
 constexpr bool whose value is (... || Bs). More...
 
template<bool B>
constexpr bool negation_value_v = negation_value<B>::value
 constexpr bool whose value is !Ts::value. More...
 

Detailed Description

thrust is the top-level namespace which contains all Thrust functions and types.