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.
 
 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 functionality for manipulating memory specific to one of Thrust's 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
 
class  constant_iterator
 
class  counting_iterator
 
struct  device_execution_policy
 
class  device_malloc_allocator
 
class  device_new_allocator
 
class  device_ptr
 
class  device_ptr_memory_resource
 
class  device_reference
 
class  device_vector
 
class  discard_iterator
 
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  input_device_iterator_tag
 
struct  is_contiguous_iterator
 
struct  is_execution_policy
 
struct  is_indirectly_trivially_relocatable_to
 
struct  is_operator_greater_function_object
 
struct  is_operator_less_function_object
 
struct  is_operator_less_or_greater_function_object
 
struct  is_operator_plus_function_object
 
struct  is_trivially_relocatable
 
struct  is_trivially_relocatable_to
 
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
 
struct  multiplies
 
struct  negate
 
struct  not_equal_to
 
struct  output_device_iterator_tag
 
struct  pair
 
class  permutation_iterator
 
struct  plus
 
struct  proclaim_contiguous_iterator
 
struct  proclaim_trivially_relocatable
 
struct  project1st
 
struct  project2nd
 
struct  random_access_device_iterator_tag
 
class  reverse_iterator
 
struct  square
 
class  transform_iterator
 
class  transform_output_iterator
 
class  tuple
 
struct  tuple_element
 
struct  tuple_size
 
struct  unary_function
 
struct  unary_negate
 
class  zip_iterator
 

Typedefs

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
 

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 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__ bool operator== (const complex< T0 > &x, const std::complex< T1 > &y)
 
template<typename T0 , typename T1 >
__host__ 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__ bool operator!= (const complex< T0 > &x, const std::complex< T1 > &y)
 
template<typename T0 , typename T1 >
__host__ 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)
 
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 >
__host__ __device__ device_ptr< T > device_pointer_cast (T *ptr)
 
template<typename T >
__host__ __device__ device_ptr< T > device_pointer_cast (const device_ptr< T > &ptr)
 
template<typename T >
__host__ __device__ void swap (device_reference< T > x, 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 V , typename I >
__host__ __device__ constant_iterator< V, I > make_constant_iterator (V x, I 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<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 IteratorTuple >
__host__ __device__ zip_iterator< IteratorTuple > make_zip_iterator (IteratorTuple t)
 
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)
 
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<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 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 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 , 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)
 

Variables

static const detail::host_t host
 
static const detail::device_t device
 

Detailed Description

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