thrust

Functions  
template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator >  
__host__ __device__ OutputIterator  thrust::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  thrust::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  thrust::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  thrust::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  thrust::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  thrust::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  thrust::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  thrust::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  thrust::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  thrust::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  thrust::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  thrust::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  thrust::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  thrust::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  thrust::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  thrust::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 >  thrust::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 >  thrust::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 >  thrust::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 >  thrust::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 >  thrust::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 >  thrust::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 >  thrust::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 >  thrust::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 >  thrust::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 >  thrust::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 >  thrust::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 >  thrust::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 >  thrust::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 >  thrust::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 >  thrust::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 >  thrust::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) 
__host__ __device__ OutputIterator thrust::set_difference  (  const thrust::detail::execution_policy_base< DerivedPolicy > &  exec, 
InputIterator1  first1,  
InputIterator1  last1,  
InputIterator2  first2,  
InputIterator2  last2,  
OutputIterator  result  
) 
set_difference
constructs a sorted range that is the set difference of the sorted ranges [first1, last1)
and [first2, last2)
. The return value is the end of the output range.
In the simplest case, set_difference
performs the "difference" operation from set theory: the output range contains a copy of every element that is contained in [first1, last1)
and not contained in [first2, last1)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [first1, last1)
contains m
elements that are equivalent to each other and if [first2, last2)
contains n
elements that are equivalent to them, the last max(mn,0)
elements from [first1, last1)
range shall be copied to the output range.
This version of set_difference
compares elements using operator<
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
first1  The beginning of the first input range. 
last1  The end of the first input range. 
first2  The beginning of the second input range. 
last2  The end of the second input range. 
result  The beginning of the output range. 
DerivedPolicy  The name of the derived execution policy. 
InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
OutputIterator  is a model of Output Iterator. 
[first1, last1)
and [first2, last2)
shall be sorted with respect to operator<
. The following code snippet demonstrates how to use set_difference
to compute the set difference of two sets of integers sorted in ascending order using the thrust::host
execution policy for parallelization:
OutputIterator thrust::set_difference  (  InputIterator1  first1, 
InputIterator1  last1,  
InputIterator2  first2,  
InputIterator2  last2,  
OutputIterator  result  
) 
set_difference
constructs a sorted range that is the set difference of the sorted ranges [first1, last1)
and [first2, last2)
. The return value is the end of the output range.
In the simplest case, set_difference
performs the "difference" operation from set theory: the output range contains a copy of every element that is contained in [first1, last1)
and not contained in [first2, last1)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [first1, last1)
contains m
elements that are equivalent to each other and if [first2, last2)
contains n
elements that are equivalent to them, the last max(mn,0)
elements from [first1, last1)
range shall be copied to the output range.
This version of set_difference
compares elements using operator<
.
first1  The beginning of the first input range. 
last1  The end of the first input range. 
first2  The beginning of the second input range. 
last2  The end of the second input range. 
result  The beginning of the output range. 
InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
OutputIterator  is a model of Output Iterator. 
[first1, last1)
and [first2, last2)
shall be sorted with respect to operator<
. The following code snippet demonstrates how to use set_difference
to compute the set difference of two sets of integers sorted in ascending order.
__host__ __device__ OutputIterator thrust::set_difference  (  const thrust::detail::execution_policy_base< DerivedPolicy > &  exec, 
InputIterator1  first1,  
InputIterator1  last1,  
InputIterator2  first2,  
InputIterator2  last2,  
OutputIterator  result,  
StrictWeakCompare  comp  
) 
set_difference
constructs a sorted range that is the set difference of the sorted ranges [first1, last1)
and [first2, last2)
. The return value is the end of the output range.
In the simplest case, set_difference
performs the "difference" operation from set theory: the output range contains a copy of every element that is contained in [first1, last1)
and not contained in [first2, last1)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [first1, last1)
contains m
elements that are equivalent to each other and if [first2, last2)
contains n
elements that are equivalent to them, the last max(mn,0)
elements from [first1, last1)
range shall be copied to the output range.
This version of set_difference
compares elements using a function object comp
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
first1  The beginning of the first input range. 
last1  The end of the first input range. 
first2  The beginning of the second input range. 
last2  The end of the second input range. 
result  The beginning of the output range. 
comp  Comparison operator. 
DerivedPolicy  The name of the derived execution policy. 
InputIterator1  is a model of Input Iterator, InputIterator1's value_type is convertable to StrictWeakCompare's first_argument_type . and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2's value_type is convertable to StrictWeakCompare's second_argument_type . and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
OutputIterator  is a model of Output Iterator. 
StrictWeakCompare  is a model of Strict Weak Ordering. 
[first1, last1)
and [first2, last2)
shall be sorted with respect to comp
. The following code snippet demonstrates how to use set_difference
to compute the set difference of two sets of integers sorted in descending order using the thrust::host
execution policy for parallelization:
OutputIterator thrust::set_difference  (  InputIterator1  first1, 
InputIterator1  last1,  
InputIterator2  first2,  
InputIterator2  last2,  
OutputIterator  result,  
StrictWeakCompare  comp  
) 
set_difference
constructs a sorted range that is the set difference of the sorted ranges [first1, last1)
and [first2, last2)
. The return value is the end of the output range.
In the simplest case, set_difference
performs the "difference" operation from set theory: the output range contains a copy of every element that is contained in [first1, last1)
and not contained in [first2, last1)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [first1, last1)
contains m
elements that are equivalent to each other and if [first2, last2)
contains n
elements that are equivalent to them, the last max(mn,0)
elements from [first1, last1)
range shall be copied to the output range.
This version of set_difference
compares elements using a function object comp
.
first1  The beginning of the first input range. 
last1  The end of the first input range. 
first2  The beginning of the second input range. 
last2  The end of the second input range. 
result  The beginning of the output range. 
comp  Comparison operator. 
InputIterator1  is a model of Input Iterator, InputIterator1's value_type is convertable to StrictWeakCompare's first_argument_type . and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2's value_type is convertable to StrictWeakCompare's second_argument_type . and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
OutputIterator  is a model of Output Iterator. 
StrictWeakCompare  is a model of Strict Weak Ordering. 
[first1, last1)
and [first2, last2)
shall be sorted with respect to comp
. The following code snippet demonstrates how to use set_difference
to compute the set difference of two sets of integers sorted in descending order.
__host__ __device__ thrust::pair<OutputIterator1,OutputIterator2> thrust::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  
) 
set_difference_by_key
performs a keyvalue difference operation from set theory. set_difference_by_key
constructs a sorted range that is the difference of the sorted ranges [keys_first1, keys_last1)
and [keys_first2, keys_last2)
. Associated with each element from the input and output key ranges is a value element. The associated input value ranges need not be sorted.
In the simplest case, set_difference_by_key
performs the "difference" operation from set theory: the keys output range contains a copy of every element that is contained in [keys_first1, keys_last1)
and not contained in [keys_first2, keys_last2)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [keys_first1, keys_last1)
contains m
elements that are equivalent to each other and if [keys_first2, keys_last2)
contains n
elements that are equivalent to them, the last max(mn,0)
elements from [keys_first1, keys_last1)
range shall be copied to the output range.
Each time a key element is copied from [keys_first1, keys_last1)
or [keys_first2, keys_last2)
is copied to the keys output range, the corresponding value element is copied from the corresponding values input range (beginning at values_first1
or values_first2
) to the values output range.
This version of set_difference_by_key
compares key elements using operator<
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
keys_first1  The beginning of the first input range of keys. 
keys_last1  The end of the first input range of keys. 
keys_first2  The beginning of the second input range of keys. 
keys_last2  The end of the second input range of keys. 
values_first1  The beginning of the first input range of values. 
values_first2  The beginning of the first input range of values. 
keys_result  The beginning of the output range of keys. 
values_result  The beginning of the output range of values. 
pair
p
such that p.first
is the end of the output range of keys, and such that p.second
is the end of the output range of values.DerivedPolicy  The name of the derived execution policy. 
InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator3  is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types . 
InputIterator4  is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
[keys_first1, keys_last1)
and [keys_first2, keys_last2)
shall be sorted with respect to operator<
. The following code snippet demonstrates how to use set_difference_by_key
to compute the set difference of two sets of integers sorted in ascending order with their values using the thrust::host
execution policy for parallelization:
thrust::pair<OutputIterator1,OutputIterator2> thrust::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  
) 
set_difference_by_key
performs a keyvalue difference operation from set theory. set_difference_by_key
constructs a sorted range that is the difference of the sorted ranges [keys_first1, keys_last1)
and [keys_first2, keys_last2)
. Associated with each element from the input and output key ranges is a value element. The associated input value ranges need not be sorted.
In the simplest case, set_difference_by_key
performs the "difference" operation from set theory: the keys output range contains a copy of every element that is contained in [keys_first1, keys_last1)
and not contained in [keys_first2, keys_last2)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [keys_first1, keys_last1)
contains m
elements that are equivalent to each other and if [keys_first2, keys_last2)
contains n
elements that are equivalent to them, the last max(mn,0)
elements from [keys_first1, keys_last1)
range shall be copied to the output range.
Each time a key element is copied from [keys_first1, keys_last1)
or [keys_first2, keys_last2)
is copied to the keys output range, the corresponding value element is copied from the corresponding values input range (beginning at values_first1
or values_first2
) to the values output range.
This version of set_difference_by_key
compares key elements using operator<
.
keys_first1  The beginning of the first input range of keys. 
keys_last1  The end of the first input range of keys. 
keys_first2  The beginning of the second input range of keys. 
keys_last2  The end of the second input range of keys. 
values_first1  The beginning of the first input range of values. 
values_first2  The beginning of the first input range of values. 
keys_result  The beginning of the output range of keys. 
values_result  The beginning of the output range of values. 
pair
p
such that p.first
is the end of the output range of keys, and such that p.second
is the end of the output range of values.InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator3  is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types . 
InputIterator4  is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
[keys_first1, keys_last1)
and [keys_first2, keys_last2)
shall be sorted with respect to operator<
. The following code snippet demonstrates how to use set_difference_by_key
to compute the set difference of two sets of integers sorted in ascending order with their values.
__host__ __device__ thrust::pair<OutputIterator1,OutputIterator2> thrust::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  
) 
set_difference_by_key
performs a keyvalue difference operation from set theory. set_difference_by_key
constructs a sorted range that is the difference of the sorted ranges [keys_first1, keys_last1)
and [keys_first2, keys_last2)
. Associated with each element from the input and output key ranges is a value element. The associated input value ranges need not be sorted.
In the simplest case, set_difference_by_key
performs the "difference" operation from set theory: the keys output range contains a copy of every element that is contained in [keys_first1, keys_last1)
and not contained in [keys_first2, keys_last2)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [keys_first1, keys_last1)
contains m
elements that are equivalent to each other and if [keys_first2, keys_last2)
contains n
elements that are equivalent to them, the last max(mn,0)
elements from [keys_first1, keys_last1)
range shall be copied to the output range.
Each time a key element is copied from [keys_first1, keys_last1)
or [keys_first2, keys_last2)
is copied to the keys output range, the corresponding value element is copied from the corresponding values input range (beginning at values_first1
or values_first2
) to the values output range.
This version of set_difference_by_key
compares key elements using a function object comp
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
keys_first1  The beginning of the first input range of keys. 
keys_last1  The end of the first input range of keys. 
keys_first2  The beginning of the second input range of keys. 
keys_last2  The end of the second input range of keys. 
values_first1  The beginning of the first input range of values. 
values_first2  The beginning of the first input range of values. 
keys_result  The beginning of the output range of keys. 
values_result  The beginning of the output range of values. 
comp  Comparison operator. 
pair
p
such that p.first
is the end of the output range of keys, and such that p.second
is the end of the output range of values.DerivedPolicy  The name of the derived execution policy. 
InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator3  is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types . 
InputIterator4  is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
StrictWeakCompare  is a model of Strict Weak Ordering. 
[keys_first1, keys_last1)
and [keys_first2, keys_last2)
shall be sorted with respect to comp
. The following code snippet demonstrates how to use set_difference_by_key
to compute the set difference of two sets of integers sorted in descending order with their values using the thrust::host
execution policy for parallelization:
thrust::pair<OutputIterator1,OutputIterator2> thrust::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  
) 
set_difference_by_key
performs a keyvalue difference operation from set theory. set_difference_by_key
constructs a sorted range that is the difference of the sorted ranges [keys_first1, keys_last1)
and [keys_first2, keys_last2)
. Associated with each element from the input and output key ranges is a value element. The associated input value ranges need not be sorted.
In the simplest case, set_difference_by_key
performs the "difference" operation from set theory: the keys output range contains a copy of every element that is contained in [keys_first1, keys_last1)
and not contained in [keys_first2, keys_last2)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [keys_first1, keys_last1)
contains m
elements that are equivalent to each other and if [keys_first2, keys_last2)
contains n
elements that are equivalent to them, the last max(mn,0)
elements from [keys_first1, keys_last1)
range shall be copied to the output range.
Each time a key element is copied from [keys_first1, keys_last1)
or [keys_first2, keys_last2)
is copied to the keys output range, the corresponding value element is copied from the corresponding values input range (beginning at values_first1
or values_first2
) to the values output range.
This version of set_difference_by_key
compares key elements using a function object comp
.
keys_first1  The beginning of the first input range of keys. 
keys_last1  The end of the first input range of keys. 
keys_first2  The beginning of the second input range of keys. 
keys_last2  The end of the second input range of keys. 
values_first1  The beginning of the first input range of values. 
values_first2  The beginning of the first input range of values. 
keys_result  The beginning of the output range of keys. 
values_result  The beginning of the output range of values. 
comp  Comparison operator. 
pair
p
such that p.first
is the end of the output range of keys, and such that p.second
is the end of the output range of values.InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator3  is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types . 
InputIterator4  is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
StrictWeakCompare  is a model of Strict Weak Ordering. 
[keys_first1, keys_last1)
and [keys_first2, keys_last2)
shall be sorted with respect to comp
. The following code snippet demonstrates how to use set_difference_by_key
to compute the set difference of two sets of integers sorted in descending order with their values.
__host__ __device__ OutputIterator thrust::set_intersection  (  const thrust::detail::execution_policy_base< DerivedPolicy > &  exec, 
InputIterator1  first1,  
InputIterator1  last1,  
InputIterator2  first2,  
InputIterator2  last2,  
OutputIterator  result  
) 
set_intersection
constructs a sorted range that is the intersection of sorted ranges [first1, last1)
and [first2, last2)
. The return value is the end of the output range.
In the simplest case, set_intersection
performs the "intersection" operation from set theory: the output range contains a copy of every element that is contained in both [first1, last1)
and [first2, last2)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if a value appears m
times in [first1, last1)
and n
times in [first2, last2)
(where m
may be zero), then it appears min(m,n)
times in the output range. set_intersection
is stable, meaning that both elements are copied from the first range rather than the second, and that the relative order of elements in the output range is the same as in the first input range.
This version of set_intersection
compares objects using operator<
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
first1  The beginning of the first input range. 
last1  The end of the first input range. 
first2  The beginning of the second input range. 
last2  The end of the second input range. 
result  The beginning of the output range. 
DerivedPolicy  The name of the derived execution policy. 
InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
OutputIterator  is a model of Output Iterator. 
[first1, last1)
and [first2, last2)
shall be sorted with respect to operator<
. The following code snippet demonstrates how to use set_intersection
to compute the set intersection of two sets of integers sorted in ascending order using the thrust::host
execution policy for parallelization:
OutputIterator thrust::set_intersection  (  InputIterator1  first1, 
InputIterator1  last1,  
InputIterator2  first2,  
InputIterator2  last2,  
OutputIterator  result  
) 
set_intersection
constructs a sorted range that is the intersection of sorted ranges [first1, last1)
and [first2, last2)
. The return value is the end of the output range.
In the simplest case, set_intersection
performs the "intersection" operation from set theory: the output range contains a copy of every element that is contained in both [first1, last1)
and [first2, last2)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if a value appears m
times in [first1, last1)
and n
times in [first2, last2)
(where m
may be zero), then it appears min(m,n)
times in the output range. set_intersection
is stable, meaning that both elements are copied from the first range rather than the second, and that the relative order of elements in the output range is the same as in the first input range.
This version of set_intersection
compares objects using operator<
.
first1  The beginning of the first input range. 
last1  The end of the first input range. 
first2  The beginning of the second input range. 
last2  The end of the second input range. 
result  The beginning of the output range. 
InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
OutputIterator  is a model of Output Iterator. 
[first1, last1)
and [first2, last2)
shall be sorted with respect to operator<
. The following code snippet demonstrates how to use set_intersection
to compute the set intersection of two sets of integers sorted in ascending order.
__host__ __device__ OutputIterator thrust::set_intersection  (  const thrust::detail::execution_policy_base< DerivedPolicy > &  exec, 
InputIterator1  first1,  
InputIterator1  last1,  
InputIterator2  first2,  
InputIterator2  last2,  
OutputIterator  result,  
StrictWeakCompare  comp  
) 
set_intersection
constructs a sorted range that is the intersection of sorted ranges [first1, last1)
and [first2, last2)
. The return value is the end of the output range.
In the simplest case, set_intersection
performs the "intersection" operation from set theory: the output range contains a copy of every element that is contained in both [first1, last1)
and [first2, last2)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if a value appears m
times in [first1, last1)
and n
times in [first2, last2)
(where m
may be zero), then it appears min(m,n)
times in the output range. set_intersection
is stable, meaning that both elements are copied from the first range rather than the second, and that the relative order of elements in the output range is the same as in the first input range.
This version of set_intersection
compares elements using a function object comp
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
first1  The beginning of the first input range. 
last1  The end of the first input range. 
first2  The beginning of the second input range. 
last2  The end of the second input range. 
result  The beginning of the output range. 
comp  Comparison operator. 
[first1, last1)
and [first2, last2)
shall be sorted with respect to comp
. DerivedPolicy  The name of the derived execution policy. 
InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
OutputIterator  is a model of Output Iterator. 
The following code snippet demonstrates how to use set_intersection
to compute the set intersection of sets of integers sorted in descending order using the thrust::host
execution policy for parallelization:
OutputIterator thrust::set_intersection  (  InputIterator1  first1, 
InputIterator1  last1,  
InputIterator2  first2,  
InputIterator2  last2,  
OutputIterator  result,  
StrictWeakCompare  comp  
) 
set_intersection
constructs a sorted range that is the intersection of sorted ranges [first1, last1)
and [first2, last2)
. The return value is the end of the output range.
In the simplest case, set_intersection
performs the "intersection" operation from set theory: the output range contains a copy of every element that is contained in both [first1, last1)
and [first2, last2)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if a value appears m
times in [first1, last1)
and n
times in [first2, last2)
(where m
may be zero), then it appears min(m,n)
times in the output range. set_intersection
is stable, meaning that both elements are copied from the first range rather than the second, and that the relative order of elements in the output range is the same as in the first input range.
This version of set_intersection
compares elements using a function object comp
.
first1  The beginning of the first input range. 
last1  The end of the first input range. 
first2  The beginning of the second input range. 
last2  The end of the second input range. 
result  The beginning of the output range. 
comp  Comparison operator. 
[first1, last1)
and [first2, last2)
shall be sorted with respect to comp
. InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
OutputIterator  is a model of Output Iterator. 
The following code snippet demonstrates how to use set_intersection
to compute the set intersection of sets of integers sorted in descending order.
__host__ __device__ thrust::pair<OutputIterator1,OutputIterator2> thrust::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  
) 
set_intersection_by_key
performs a keyvalue intersection operation from set theory. set_intersection_by_key
constructs a sorted range that is the intersection of the sorted ranges [keys_first1, keys_last1)
and [keys_first2, keys_last2)
. Associated with each element from the input and output key ranges is a value element. The associated input value ranges need not be sorted.
In the simplest case, set_intersection_by_key
performs the "intersection" operation from set theory: the keys output range contains a copy of every element that is contained in both [keys_first1, keys_last1)
[keys_first2, keys_last2)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if an element appears m
times in [keys_first1, keys_last1)
and n
times in [keys_first2, keys_last2)
(where m
may be zero), then it appears min(m,n)
times in the keys output range. set_intersection_by_key
is stable, meaning both that elements are copied from the first input range rather than the second, and that the relative order of elements in the output range is the same as the first input range.
Each time a key element is copied from [keys_first1, keys_last1)
to the keys output range, the corresponding value element is copied from [values_first1, values_last1)
to the values output range.
This version of set_intersection_by_key
compares objects using operator<
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
keys_first1  The beginning of the first input range of keys. 
keys_last1  The end of the first input range of keys. 
keys_first2  The beginning of the second input range of keys. 
keys_last2  The end of the second input range of keys. 
values_first1  The beginning of the first input range of values. 
keys_result  The beginning of the output range of keys. 
values_result  The beginning of the output range of values. 
pair
p
such that p.first
is the end of the output range of keys, and such that p.second
is the end of the output range of values.set_intersection_by_key
is unique in that it has no values_first2
parameter because elements from the second input range are never copied to the output range.DerivedPolicy  The name of the derived execution policy. 
InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator3  is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
[keys_first1, keys_last1)
and [keys_first2, keys_last2)
shall be sorted with respect to operator<
. The following code snippet demonstrates how to use set_intersection_by_key
to compute the set intersection of two sets of integers sorted in ascending order with their values using the thrust::host
execution policy for parallelization:
thrust::pair<OutputIterator1,OutputIterator2> thrust::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  
) 
set_intersection_by_key
performs a keyvalue intersection operation from set theory. set_intersection_by_key
constructs a sorted range that is the intersection of the sorted ranges [keys_first1, keys_last1)
and [keys_first2, keys_last2)
. Associated with each element from the input and output key ranges is a value element. The associated input value ranges need not be sorted.
In the simplest case, set_intersection_by_key
performs the "intersection" operation from set theory: the keys output range contains a copy of every element that is contained in both [keys_first1, keys_last1)
[keys_first2, keys_last2)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if an element appears m
times in [keys_first1, keys_last1)
and n
times in [keys_first2, keys_last2)
(where m
may be zero), then it appears min(m,n)
times in the keys output range. set_intersection_by_key
is stable, meaning both that elements are copied from the first input range rather than the second, and that the relative order of elements in the output range is the same as the first input range.
Each time a key element is copied from [keys_first1, keys_last1)
to the keys output range, the corresponding value element is copied from [values_first1, values_last1)
to the values output range.
This version of set_intersection_by_key
compares objects using operator<
.
keys_first1  The beginning of the first input range of keys. 
keys_last1  The end of the first input range of keys. 
keys_first2  The beginning of the second input range of keys. 
keys_last2  The end of the second input range of keys. 
values_first1  The beginning of the first input range of values. 
keys_result  The beginning of the output range of keys. 
values_result  The beginning of the output range of values. 
pair
p
such that p.first
is the end of the output range of keys, and such that p.second
is the end of the output range of values.set_intersection_by_key
is unique in that it has no values_first2
parameter because elements from the second input range are never copied to the output range.InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator3  is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
[keys_first1, keys_last1)
and [keys_first2, keys_last2)
shall be sorted with respect to operator<
. The following code snippet demonstrates how to use set_intersection_by_key
to compute the set intersection of two sets of integers sorted in ascending order with their values.
__host__ __device__ thrust::pair<OutputIterator1,OutputIterator2> thrust::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  
) 
set_intersection_by_key
performs a keyvalue intersection operation from set theory. set_intersection_by_key
constructs a sorted range that is the intersection of the sorted ranges [keys_first1, keys_last1)
and [keys_first2, keys_last2)
. Associated with each element from the input and output key ranges is a value element. The associated input value ranges need not be sorted.
In the simplest case, set_intersection_by_key
performs the "intersection" operation from set theory: the keys output range contains a copy of every element that is contained in both [keys_first1, keys_last1)
[keys_first2, keys_last2)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if an element appears m
times in [keys_first1, keys_last1)
and n
times in [keys_first2, keys_last2)
(where m
may be zero), then it appears min(m,n)
times in the keys output range. set_intersection_by_key
is stable, meaning both that elements are copied from the first input range rather than the second, and that the relative order of elements in the output range is the same as the first input range.
Each time a key element is copied from [keys_first1, keys_last1)
to the keys output range, the corresponding value element is copied from [values_first1, values_last1)
to the values output range.
This version of set_intersection_by_key
compares objects using a function object comp
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
keys_first1  The beginning of the first input range of keys. 
keys_last1  The end of the first input range of keys. 
keys_first2  The beginning of the second input range of keys. 
keys_last2  The end of the second input range of keys. 
values_first1  The beginning of the first input range of values. 
keys_result  The beginning of the output range of keys. 
values_result  The beginning of the output range of values. 
comp  Comparison operator. 
pair
p
such that p.first
is the end of the output range of keys, and such that p.second
is the end of the output range of values.set_intersection_by_key
is unique in that it has no values_first2
parameter because elements from the second input range are never copied to the output range.DerivedPolicy  The name of the derived execution policy. 
InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator3  is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
StrictWeakCompare  is a model of Strict Weak Ordering. 
[keys_first1, keys_last1)
and [keys_first2, keys_last2)
shall be sorted with respect to comp
. The following code snippet demonstrates how to use set_intersection_by_key
to compute the set intersection of two sets of integers sorted in descending order with their values using the thrust::host
execution policy for parallelization:
thrust::pair<OutputIterator1,OutputIterator2> thrust::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  
) 
set_intersection_by_key
performs a keyvalue intersection operation from set theory. set_intersection_by_key
constructs a sorted range that is the intersection of the sorted ranges [keys_first1, keys_last1)
and [keys_first2, keys_last2)
. Associated with each element from the input and output key ranges is a value element. The associated input value ranges need not be sorted.
In the simplest case, set_intersection_by_key
performs the "intersection" operation from set theory: the keys output range contains a copy of every element that is contained in both [keys_first1, keys_last1)
[keys_first2, keys_last2)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if an element appears m
times in [keys_first1, keys_last1)
and n
times in [keys_first2, keys_last2)
(where m
may be zero), then it appears min(m,n)
times in the keys output range. set_intersection_by_key
is stable, meaning both that elements are copied from the first input range rather than the second, and that the relative order of elements in the output range is the same as the first input range.
Each time a key element is copied from [keys_first1, keys_last1)
to the keys output range, the corresponding value element is copied from [values_first1, values_last1)
to the values output range.
This version of set_intersection_by_key
compares objects using a function object comp
.
keys_first1  The beginning of the first input range of keys. 
keys_last1  The end of the first input range of keys. 
keys_first2  The beginning of the second input range of keys. 
keys_last2  The end of the second input range of keys. 
values_first1  The beginning of the first input range of values. 
keys_result  The beginning of the output range of keys. 
values_result  The beginning of the output range of values. 
comp  Comparison operator. 
pair
p
such that p.first
is the end of the output range of keys, and such that p.second
is the end of the output range of values.set_intersection_by_key
is unique in that it has no values_first2
parameter because elements from the second input range are never copied to the output range.InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator3  is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
StrictWeakCompare  is a model of Strict Weak Ordering. 
[keys_first1, keys_last1)
and [keys_first2, keys_last2)
shall be sorted with respect to comp
. The following code snippet demonstrates how to use set_intersection_by_key
to compute the set intersection of two sets of integers sorted in descending order with their values.
__host__ __device__ OutputIterator thrust::set_symmetric_difference  (  const thrust::detail::execution_policy_base< DerivedPolicy > &  exec, 
InputIterator1  first1,  
InputIterator1  last1,  
InputIterator2  first2,  
InputIterator2  last2,  
OutputIterator  result  
) 
set_symmetric_difference
constructs a sorted range that is the set symmetric difference of the sorted ranges [first1, last1)
and [first2, last2)
. The return value is the end of the output range.
In the simplest case, set_symmetric_difference
performs a set theoretic calculation: it constructs the union of the two sets A  B and B  A, where A and B are the two input ranges. That is, the output range contains a copy of every element that is contained in [first1, last1)
but not [first2, last1)
, and a copy of every element that is contained in [first2, last2)
but not [first1, last1)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [first1, last1)
contains m
elements that are equivalent to each other and [first2, last1)
contains n
elements that are equivalent to them, then m  n
of those elements shall be copied to the output range: the last m  n
elements from [first1, last1)
if m > n
, and the last n  m
of these elements from [first2, last2)
if m < n
.
This version of set_union
compares elements using operator<
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
first1  The beginning of the first input range. 
last1  The end of the first input range. 
first2  The beginning of the second input range. 
last2  The end of the second input range. 
result  The beginning of the output range. 
DerivedPolicy  The name of the derived execution policy. 
InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
OutputIterator  is a model of Output Iterator. 
[first1, last1)
and [first2, last2)
shall be sorted with respect to operator<
. The following code snippet demonstrates how to use set_symmetric_difference
to compute the symmetric difference of two sets of integers sorted in ascending order using the thrust::host
execution policy for parallelization:
OutputIterator thrust::set_symmetric_difference  (  InputIterator1  first1, 
InputIterator1  last1,  
InputIterator2  first2,  
InputIterator2  last2,  
OutputIterator  result  
) 
set_symmetric_difference
constructs a sorted range that is the set symmetric difference of the sorted ranges [first1, last1)
and [first2, last2)
. The return value is the end of the output range.
In the simplest case, set_symmetric_difference
performs a set theoretic calculation: it constructs the union of the two sets A  B and B  A, where A and B are the two input ranges. That is, the output range contains a copy of every element that is contained in [first1, last1)
but not [first2, last1)
, and a copy of every element that is contained in [first2, last2)
but not [first1, last1)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [first1, last1)
contains m
elements that are equivalent to each other and [first2, last1)
contains n
elements that are equivalent to them, then m  n
of those elements shall be copied to the output range: the last m  n
elements from [first1, last1)
if m > n
, and the last n  m
of these elements from [first2, last2)
if m < n
.
This version of set_union
compares elements using operator<
.
first1  The beginning of the first input range. 
last1  The end of the first input range. 
first2  The beginning of the second input range. 
last2  The end of the second input range. 
result  The beginning of the output range. 
InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
OutputIterator  is a model of Output Iterator. 
[first1, last1)
and [first2, last2)
shall be sorted with respect to operator<
. The following code snippet demonstrates how to use set_symmetric_difference
to compute the symmetric difference of two sets of integers sorted in ascending order.
__host__ __device__ OutputIterator thrust::set_symmetric_difference  (  const thrust::detail::execution_policy_base< DerivedPolicy > &  exec, 
InputIterator1  first1,  
InputIterator1  last1,  
InputIterator2  first2,  
InputIterator2  last2,  
OutputIterator  result,  
StrictWeakCompare  comp  
) 
set_symmetric_difference
constructs a sorted range that is the set symmetric difference of the sorted ranges [first1, last1)
and [first2, last2)
. The return value is the end of the output range.
In the simplest case, set_symmetric_difference
performs a set theoretic calculation: it constructs the union of the two sets A  B and B  A, where A and B are the two input ranges. That is, the output range contains a copy of every element that is contained in [first1, last1)
but not [first2, last1)
, and a copy of every element that is contained in [first2, last2)
but not [first1, last1)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [first1, last1)
contains m
elements that are equivalent to each other and [first2, last1)
contains n
elements that are equivalent to them, then m  n
of those elements shall be copied to the output range: the last m  n
elements from [first1, last1)
if m > n
, and the last n  m
of these elements from [first2, last2)
if m < n
.
This version of set_union
compares elements using a function object comp
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
first1  The beginning of the first input range. 
last1  The end of the first input range. 
first2  The beginning of the second input range. 
last2  The end of the second input range. 
result  The beginning of the output range. 
comp  Comparison operator. 
DerivedPolicy  The name of the derived execution policy. 
InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
OutputIterator  is a model of Output Iterator. 
[first1, last1)
and [first2, last2)
shall be sorted with respect to comp
. The following code snippet demonstrates how to use set_symmetric_difference
to compute the symmetric difference of two sets of integers sorted in descending order using the thrust::host
execution policy for parallelization:
OutputIterator thrust::set_symmetric_difference  (  InputIterator1  first1, 
InputIterator1  last1,  
InputIterator2  first2,  
InputIterator2  last2,  
OutputIterator  result,  
StrictWeakCompare  comp  
) 
set_symmetric_difference
constructs a sorted range that is the set symmetric difference of the sorted ranges [first1, last1)
and [first2, last2)
. The return value is the end of the output range.
In the simplest case, set_symmetric_difference
performs a set theoretic calculation: it constructs the union of the two sets A  B and B  A, where A and B are the two input ranges. That is, the output range contains a copy of every element that is contained in [first1, last1)
but not [first2, last1)
, and a copy of every element that is contained in [first2, last2)
but not [first1, last1)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [first1, last1)
contains m
elements that are equivalent to each other and [first2, last1)
contains n
elements that are equivalent to them, then m  n
of those elements shall be copied to the output range: the last m  n
elements from [first1, last1)
if m > n
, and the last n  m
of these elements from [first2, last2)
if m < n
.
This version of set_union
compares elements using a function object comp
.
first1  The beginning of the first input range. 
last1  The end of the first input range. 
first2  The beginning of the second input range. 
last2  The end of the second input range. 
result  The beginning of the output range. 
comp  Comparison operator. 
InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
OutputIterator  is a model of Output Iterator. 
[first1, last1)
and [first2, last2)
shall be sorted with respect to comp
. The following code snippet demonstrates how to use set_symmetric_difference
to compute the symmetric difference of two sets of integers sorted in descending order.
__host__ __device__ thrust::pair<OutputIterator1,OutputIterator2> thrust::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  
) 
set_symmetric_difference_by_key
performs a keyvalue symmetric difference operation from set theory. set_difference_by_key
constructs a sorted range that is the symmetric difference of the sorted ranges [keys_first1, keys_last1)
and [keys_first2, keys_last2)
. Associated with each element from the input and output key ranges is a value element. The associated input value ranges need not be sorted.
In the simplest case, set_symmetric_difference_by_key
performs a set theoretic calculation: it constructs the union of the two sets A  B and B  A, where A and B are the two input ranges. That is, the output range contains a copy of every element that is contained in [keys_first1, keys_last1)
but not [keys_first2, keys_last1)
, and a copy of every element that is contained in [keys_first2, keys_last2)
but not [keys_first1, keys_last1)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [keys_first1, keys_last1)
contains m
elements that are equivalent to each other and [keys_first2, keys_last1)
contains n
elements that are equivalent to them, then m  n
of those elements shall be copied to the output range: the last m  n
elements from [keys_first1, keys_last1)
if m > n
, and the last n  m
of these elements from [keys_first2, keys_last2)
if m < n
.
Each time a key element is copied from [keys_first1, keys_last1)
or [keys_first2, keys_last2)
is copied to the keys output range, the corresponding value element is copied from the corresponding values input range (beginning at values_first1
or values_first2
) to the values output range.
This version of set_symmetric_difference_by_key
compares key elements using operator<
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
keys_first1  The beginning of the first input range of keys. 
keys_last1  The end of the first input range of keys. 
keys_first2  The beginning of the second input range of keys. 
keys_last2  The end of the second input range of keys. 
values_first1  The beginning of the first input range of values. 
values_first2  The beginning of the first input range of values. 
keys_result  The beginning of the output range of keys. 
values_result  The beginning of the output range of values. 
pair
p
such that p.first
is the end of the output range of keys, and such that p.second
is the end of the output range of values.DerivedPolicy  The name of the derived execution policy. 
InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator3  is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types . 
InputIterator4  is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
[keys_first1, keys_last1)
and [keys_first2, keys_last2)
shall be sorted with respect to operator<
. The following code snippet demonstrates how to use set_symmetric_difference_by_key
to compute the symmetric difference of two sets of integers sorted in ascending order with their values using the thrust::host
execution policy for parallelization:
thrust::pair<OutputIterator1,OutputIterator2> thrust::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  
) 
set_symmetric_difference_by_key
performs a keyvalue symmetric difference operation from set theory. set_difference_by_key
constructs a sorted range that is the symmetric difference of the sorted ranges [keys_first1, keys_last1)
and [keys_first2, keys_last2)
. Associated with each element from the input and output key ranges is a value element. The associated input value ranges need not be sorted.
In the simplest case, set_symmetric_difference_by_key
performs a set theoretic calculation: it constructs the union of the two sets A  B and B  A, where A and B are the two input ranges. That is, the output range contains a copy of every element that is contained in [keys_first1, keys_last1)
but not [keys_first2, keys_last1)
, and a copy of every element that is contained in [keys_first2, keys_last2)
but not [keys_first1, keys_last1)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [keys_first1, keys_last1)
contains m
elements that are equivalent to each other and [keys_first2, keys_last1)
contains n
elements that are equivalent to them, then m  n
of those elements shall be copied to the output range: the last m  n
elements from [keys_first1, keys_last1)
if m > n
, and the last n  m
of these elements from [keys_first2, keys_last2)
if m < n
.
Each time a key element is copied from [keys_first1, keys_last1)
or [keys_first2, keys_last2)
is copied to the keys output range, the corresponding value element is copied from the corresponding values input range (beginning at values_first1
or values_first2
) to the values output range.
This version of set_symmetric_difference_by_key
compares key elements using operator<
.
keys_first1  The beginning of the first input range of keys. 
keys_last1  The end of the first input range of keys. 
keys_first2  The beginning of the second input range of keys. 
keys_last2  The end of the second input range of keys. 
values_first1  The beginning of the first input range of values. 
values_first2  The beginning of the first input range of values. 
keys_result  The beginning of the output range of keys. 
values_result  The beginning of the output range of values. 
pair
p
such that p.first
is the end of the output range of keys, and such that p.second
is the end of the output range of values.InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator3  is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types . 
InputIterator4  is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
[keys_first1, keys_last1)
and [keys_first2, keys_last2)
shall be sorted with respect to operator<
. The following code snippet demonstrates how to use set_symmetric_difference_by_key
to compute the symmetric difference of two sets of integers sorted in ascending order with their values.
__host__ __device__ thrust::pair<OutputIterator1,OutputIterator2> thrust::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  
) 
set_symmetric_difference_by_key
performs a keyvalue symmetric difference operation from set theory. set_difference_by_key
constructs a sorted range that is the symmetric difference of the sorted ranges [keys_first1, keys_last1)
and [keys_first2, keys_last2)
. Associated with each element from the input and output key ranges is a value element. The associated input value ranges need not be sorted.
In the simplest case, set_symmetric_difference_by_key
performs a set theoretic calculation: it constructs the union of the two sets A  B and B  A, where A and B are the two input ranges. That is, the output range contains a copy of every element that is contained in [keys_first1, keys_last1)
but not [keys_first2, keys_last1)
, and a copy of every element that is contained in [keys_first2, keys_last2)
but not [keys_first1, keys_last1)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [keys_first1, keys_last1)
contains m
elements that are equivalent to each other and [keys_first2, keys_last1)
contains n
elements that are equivalent to them, then m  n
of those elements shall be copied to the output range: the last m  n
elements from [keys_first1, keys_last1)
if m > n
, and the last n  m
of these elements from [keys_first2, keys_last2)
if m < n
.
Each time a key element is copied from [keys_first1, keys_last1)
or [keys_first2, keys_last2)
is copied to the keys output range, the corresponding value element is copied from the corresponding values input range (beginning at values_first1
or values_first2
) to the values output range.
This version of set_symmetric_difference_by_key
compares key elements using a function object comp
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
keys_first1  The beginning of the first input range of keys. 
keys_last1  The end of the first input range of keys. 
keys_first2  The beginning of the second input range of keys. 
keys_last2  The end of the second input range of keys. 
values_first1  The beginning of the first input range of values. 
values_first2  The beginning of the first input range of values. 
keys_result  The beginning of the output range of keys. 
values_result  The beginning of the output range of values. 
comp  Comparison operator. 
pair
p
such that p.first
is the end of the output range of keys, and such that p.second
is the end of the output range of values.DerivedPolicy  The name of the derived execution policy. 
InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator3  is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types . 
InputIterator4  is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
StrictWeakCompare  is a model of Strict Weak Ordering. 
[keys_first1, keys_last1)
and [keys_first2, keys_last2)
shall be sorted with respect to comp
. The following code snippet demonstrates how to use set_symmetric_difference_by_key
to compute the symmetric difference of two sets of integers sorted in descending order with their values using the thrust::host
execution policy for parallelization:
thrust::pair<OutputIterator1,OutputIterator2> thrust::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  
) 
set_symmetric_difference_by_key
performs a keyvalue symmetric difference operation from set theory. set_difference_by_key
constructs a sorted range that is the symmetric difference of the sorted ranges [keys_first1, keys_last1)
and [keys_first2, keys_last2)
. Associated with each element from the input and output key ranges is a value element. The associated input value ranges need not be sorted.
In the simplest case, set_symmetric_difference_by_key
performs a set theoretic calculation: it constructs the union of the two sets A  B and B  A, where A and B are the two input ranges. That is, the output range contains a copy of every element that is contained in [keys_first1, keys_last1)
but not [keys_first2, keys_last1)
, and a copy of every element that is contained in [keys_first2, keys_last2)
but not [keys_first1, keys_last1)
. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [keys_first1, keys_last1)
contains m
elements that are equivalent to each other and [keys_first2, keys_last1)
contains n
elements that are equivalent to them, then m  n
of those elements shall be copied to the output range: the last m  n
elements from [keys_first1, keys_last1)
if m > n
, and the last n  m
of these elements from [keys_first2, keys_last2)
if m < n
.
Each time a key element is copied from [keys_first1, keys_last1)
or [keys_first2, keys_last2)
is copied to the keys output range, the corresponding value element is copied from the corresponding values input range (beginning at values_first1
or values_first2
) to the values output range.
This version of set_symmetric_difference_by_key
compares key elements using a function object comp
.
keys_first1  The beginning of the first input range of keys. 
keys_last1  The end of the first input range of keys. 
keys_first2  The beginning of the second input range of keys. 
keys_last2  The end of the second input range of keys. 
values_first1  The beginning of the first input range of values. 
values_first2  The beginning of the first input range of values. 
keys_result  The beginning of the output range of keys. 
values_result  The beginning of the output range of values. 
comp  Comparison operator. 
pair
p
such that p.first
is the end of the output range of keys, and such that p.second
is the end of the output range of values.InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator3  is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types . 
InputIterator4  is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
StrictWeakCompare  is a model of Strict Weak Ordering. 
[keys_first1, keys_last1)
and [keys_first2, keys_last2)
shall be sorted with respect to comp
. The following code snippet demonstrates how to use set_symmetric_difference_by_key
to compute the symmetric difference of two sets of integers sorted in descending order with their values.
__host__ __device__ OutputIterator thrust::set_union  (  const thrust::detail::execution_policy_base< DerivedPolicy > &  exec, 
InputIterator1  first1,  
InputIterator1  last1,  
InputIterator2  first2,  
InputIterator2  last2,  
OutputIterator  result  
) 
set_union
constructs a sorted range that is the union of the sorted ranges [first1, last1)
and [first2, last2)
. The return value is the end of the output range.
In the simplest case, set_union
performs the "union" operation from set theory: the output range contains a copy of every element that is contained in [first1, last1)
, [first2, last1)
, or both. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [first1, last1)
contains m
elements that are equivalent to each other and if [first2, last2)
contains n
elements that are equivalent to them, then all m
elements from the first range shall be copied to the output range, in order, and then max(n  m, 0)
elements from the second range shall be copied to the output, in order.
This version of set_union
compares elements using operator<
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
first1  The beginning of the first input range. 
last1  The end of the first input range. 
first2  The beginning of the second input range. 
last2  The end of the second input range. 
result  The beginning of the output range. 
DerivedPolicy  The name of the derived execution policy. 
InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
OutputIterator  is a model of Output Iterator. 
[first1, last1)
and [first2, last2)
shall be sorted with respect to operator<
. The following code snippet demonstrates how to use set_union
to compute the union of two sets of integers sorted in ascending order using the thrust::host
execution policy for parallelization:
OutputIterator thrust::set_union  (  InputIterator1  first1, 
InputIterator1  last1,  
InputIterator2  first2,  
InputIterator2  last2,  
OutputIterator  result  
) 
set_union
constructs a sorted range that is the union of the sorted ranges [first1, last1)
and [first2, last2)
. The return value is the end of the output range.
In the simplest case, set_union
performs the "union" operation from set theory: the output range contains a copy of every element that is contained in [first1, last1)
, [first2, last1)
, or both. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [first1, last1)
contains m
elements that are equivalent to each other and if [first2, last2)
contains n
elements that are equivalent to them, then all m
elements from the first range shall be copied to the output range, in order, and then max(n  m, 0)
elements from the second range shall be copied to the output, in order.
This version of set_union
compares elements using operator<
.
first1  The beginning of the first input range. 
last1  The end of the first input range. 
first2  The beginning of the second input range. 
last2  The end of the second input range. 
result  The beginning of the output range. 
InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
OutputIterator  is a model of Output Iterator. 
[first1, last1)
and [first2, last2)
shall be sorted with respect to operator<
. The following code snippet demonstrates how to use set_union
to compute the union of two sets of integers sorted in ascending order.
__host__ __device__ OutputIterator thrust::set_union  (  const thrust::detail::execution_policy_base< DerivedPolicy > &  exec, 
InputIterator1  first1,  
InputIterator1  last1,  
InputIterator2  first2,  
InputIterator2  last2,  
OutputIterator  result,  
StrictWeakCompare  comp  
) 
set_union
constructs a sorted range that is the union of the sorted ranges [first1, last1)
and [first2, last2)
. The return value is the end of the output range.
In the simplest case, set_union
performs the "union" operation from set theory: the output range contains a copy of every element that is contained in [first1, last1)
, [first2, last1)
, or both. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [first1, last1)
contains m
elements that are equivalent to each other and if [first2, last2)
contains n
elements that are equivalent to them, then all m
elements from the first range shall be copied to the output range, in order, and then max(n  m, 0)
elements from the second range shall be copied to the output, in order.
This version of set_union
compares elements using a function object comp
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
first1  The beginning of the first input range. 
last1  The end of the first input range. 
first2  The beginning of the second input range. 
last2  The end of the second input range. 
result  The beginning of the output range. 
comp  Comparison operator. 
DerivedPolicy  The name of the derived execution policy. 
InputIterator1  is a model of Input Iterator, InputIterator1's value_type is convertable to StrictWeakCompare's first_argument_type . and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2's value_type is convertable to StrictWeakCompare's second_argument_type . and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
OutputIterator  is a model of Output Iterator. 
StrictWeakCompare  is a model of Strict Weak Ordering. 
[first1, last1)
and [first2, last2)
shall be sorted with respect to comp
. The following code snippet demonstrates how to use set_union
to compute the union of two sets of integers sorted in ascending order using the thrust::host
execution policy for parallelization:
OutputIterator thrust::set_union  (  InputIterator1  first1, 
InputIterator1  last1,  
InputIterator2  first2,  
InputIterator2  last2,  
OutputIterator  result,  
StrictWeakCompare  comp  
) 
set_union
constructs a sorted range that is the union of the sorted ranges [first1, last1)
and [first2, last2)
. The return value is the end of the output range.
In the simplest case, set_union
performs the "union" operation from set theory: the output range contains a copy of every element that is contained in [first1, last1)
, [first2, last1)
, or both. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [first1, last1)
contains m
elements that are equivalent to each other and if [first2, last2)
contains n
elements that are equivalent to them, then all m
elements from the first range shall be copied to the output range, in order, and then max(n  m, 0)
elements from the second range shall be copied to the output, in order.
This version of set_union
compares elements using a function object comp
.
first1  The beginning of the first input range. 
last1  The end of the first input range. 
first2  The beginning of the second input range. 
last2  The end of the second input range. 
result  The beginning of the output range. 
comp  Comparison operator. 
InputIterator1  is a model of Input Iterator, InputIterator1's value_type is convertable to StrictWeakCompare's first_argument_type . and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2's value_type is convertable to StrictWeakCompare's second_argument_type . and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
OutputIterator  is a model of Output Iterator. 
StrictWeakCompare  is a model of Strict Weak Ordering. 
[first1, last1)
and [first2, last2)
shall be sorted with respect to comp
. The following code snippet demonstrates how to use set_union
to compute the union of two sets of integers sorted in ascending order.
__host__ __device__ thrust::pair<OutputIterator1,OutputIterator2> thrust::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  
) 
set_union_by_key
performs a keyvalue union operation from set theory. set_union_by_key
constructs a sorted range that is the union of the sorted ranges [keys_first1, keys_last1)
and [keys_first2, keys_last2)
. Associated with each element from the input and output key ranges is a value element. The associated input value ranges need not be sorted.
In the simplest case, set_union_by_key
performs the "union" operation from set theory: the output range contains a copy of every element that is contained in [keys_first1, keys_last1)
, [keys_first2, keys_last1)
, or both. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [keys_first1, keys_last1)
contains m
elements that are equivalent to each other and if [keys_first2, keys_last2)
contains n
elements that are equivalent to them, then all m
elements from the first range shall be copied to the output range, in order, and then max(n  m, 0)
elements from the second range shall be copied to the output, in order.
Each time a key element is copied from [keys_first1, keys_last1)
or [keys_first2, keys_last2)
is copied to the keys output range, the corresponding value element is copied from the corresponding values input range (beginning at values_first1
or values_first2
) to the values output range.
This version of set_union_by_key
compares key elements using operator<
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
keys_first1  The beginning of the first input range of keys. 
keys_last1  The end of the first input range of keys. 
keys_first2  The beginning of the second input range of keys. 
keys_last2  The end of the second input range of keys. 
values_first1  The beginning of the first input range of values. 
values_first2  The beginning of the first input range of values. 
keys_result  The beginning of the output range of keys. 
values_result  The beginning of the output range of values. 
pair
p
such that p.first
is the end of the output range of keys, and such that p.second
is the end of the output range of values.DerivedPolicy  The name of the derived execution policy. 
InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator3  is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types . 
InputIterator4  is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
[keys_first1, keys_last1)
and [keys_first2, keys_last2)
shall be sorted with respect to operator<
. The following code snippet demonstrates how to use set_symmetric_difference_by_key
to compute the symmetric difference of two sets of integers sorted in ascending order with their values using the thrust::host
execution policy for parallelization:
thrust::pair<OutputIterator1,OutputIterator2> thrust::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  
) 
set_union_by_key
performs a keyvalue union operation from set theory. set_union_by_key
constructs a sorted range that is the union of the sorted ranges [keys_first1, keys_last1)
and [keys_first2, keys_last2)
. Associated with each element from the input and output key ranges is a value element. The associated input value ranges need not be sorted.
In the simplest case, set_union_by_key
performs the "union" operation from set theory: the output range contains a copy of every element that is contained in [keys_first1, keys_last1)
, [keys_first2, keys_last1)
, or both. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [keys_first1, keys_last1)
contains m
elements that are equivalent to each other and if [keys_first2, keys_last2)
contains n
elements that are equivalent to them, then all m
elements from the first range shall be copied to the output range, in order, and then max(n  m, 0)
elements from the second range shall be copied to the output, in order.
Each time a key element is copied from [keys_first1, keys_last1)
or [keys_first2, keys_last2)
is copied to the keys output range, the corresponding value element is copied from the corresponding values input range (beginning at values_first1
or values_first2
) to the values output range.
This version of set_union_by_key
compares key elements using operator<
.
keys_first1  The beginning of the first input range of keys. 
keys_last1  The end of the first input range of keys. 
keys_first2  The beginning of the second input range of keys. 
keys_last2  The end of the second input range of keys. 
values_first1  The beginning of the first input range of values. 
values_first2  The beginning of the first input range of values. 
keys_result  The beginning of the output range of keys. 
values_result  The beginning of the output range of values. 
pair
p
such that p.first
is the end of the output range of keys, and such that p.second
is the end of the output range of values.InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator3  is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types . 
InputIterator4  is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
[keys_first1, keys_last1)
and [keys_first2, keys_last2)
shall be sorted with respect to operator<
. The following code snippet demonstrates how to use set_symmetric_difference_by_key
to compute the symmetric difference of two sets of integers sorted in ascending order with their values.
__host__ __device__ thrust::pair<OutputIterator1,OutputIterator2> thrust::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  
) 
set_union_by_key
performs a keyvalue union operation from set theory. set_union_by_key
constructs a sorted range that is the union of the sorted ranges [keys_first1, keys_last1)
and [keys_first2, keys_last2)
. Associated with each element from the input and output key ranges is a value element. The associated input value ranges need not be sorted.
In the simplest case, set_union_by_key
performs the "union" operation from set theory: the output range contains a copy of every element that is contained in [keys_first1, keys_last1)
, [keys_first2, keys_last1)
, or both. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [keys_first1, keys_last1)
contains m
elements that are equivalent to each other and if [keys_first2, keys_last2)
contains n
elements that are equivalent to them, then all m
elements from the first range shall be copied to the output range, in order, and then max(n  m, 0)
elements from the second range shall be copied to the output, in order.
Each time a key element is copied from [keys_first1, keys_last1)
or [keys_first2, keys_last2)
is copied to the keys output range, the corresponding value element is copied from the corresponding values input range (beginning at values_first1
or values_first2
) to the values output range.
This version of set_union_by_key
compares key elements using a function object comp
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
keys_first1  The beginning of the first input range of keys. 
keys_last1  The end of the first input range of keys. 
keys_first2  The beginning of the second input range of keys. 
keys_last2  The end of the second input range of keys. 
values_first1  The beginning of the first input range of values. 
values_first2  The beginning of the first input range of values. 
keys_result  The beginning of the output range of keys. 
values_result  The beginning of the output range of values. 
comp  Comparison operator. 
pair
p
such that p.first
is the end of the output range of keys, and such that p.second
is the end of the output range of values.DerivedPolicy  The name of the derived execution policy. 
InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator3  is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types . 
InputIterator4  is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
StrictWeakCompare  is a model of Strict Weak Ordering. 
[keys_first1, keys_last1)
and [keys_first2, keys_last2)
shall be sorted with respect to comp
. The following code snippet demonstrates how to use set_symmetric_difference_by_key
to compute the symmetric difference of two sets of integers sorted in descending order with their values using the thrust::host
execution policy for parallelization:
thrust::pair<OutputIterator1,OutputIterator2> thrust::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  
) 
set_union_by_key
performs a keyvalue union operation from set theory. set_union_by_key
constructs a sorted range that is the union of the sorted ranges [keys_first1, keys_last1)
and [keys_first2, keys_last2)
. Associated with each element from the input and output key ranges is a value element. The associated input value ranges need not be sorted.
In the simplest case, set_union_by_key
performs the "union" operation from set theory: the output range contains a copy of every element that is contained in [keys_first1, keys_last1)
, [keys_first2, keys_last1)
, or both. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if [keys_first1, keys_last1)
contains m
elements that are equivalent to each other and if [keys_first2, keys_last2)
contains n
elements that are equivalent to them, then all m
elements from the first range shall be copied to the output range, in order, and then max(n  m, 0)
elements from the second range shall be copied to the output, in order.
Each time a key element is copied from [keys_first1, keys_last1)
or [keys_first2, keys_last2)
is copied to the keys output range, the corresponding value element is copied from the corresponding values input range (beginning at values_first1
or values_first2
) to the values output range.
This version of set_union_by_key
compares key elements using a function object comp
.
keys_first1  The beginning of the first input range of keys. 
keys_last1  The end of the first input range of keys. 
keys_first2  The beginning of the second input range of keys. 
keys_last2  The end of the second input range of keys. 
values_first1  The beginning of the first input range of values. 
values_first2  The beginning of the first input range of values. 
keys_result  The beginning of the output range of keys. 
values_result  The beginning of the output range of values. 
comp  Comparison operator. 
pair
p
such that p.first
is the end of the output range of keys, and such that p.second
is the end of the output range of values.InputIterator1  is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type , InputIterator1's value_type is a model of LessThan Comparable, the ordering on InputIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator2  is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type , InputIterator2's value_type is a model of LessThan Comparable, the ordering on InputIterator2's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2's value_type is convertable to a type in OutputIterator's set of value_types . 
InputIterator3  is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types . 
InputIterator4  is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
StrictWeakCompare  is a model of Strict Weak Ordering. 
[keys_first1, keys_last1)
and [keys_first2, keys_last2)
shall be sorted with respect to comp
. The following code snippet demonstrates how to use set_symmetric_difference_by_key
to compute the symmetric difference of two sets of integers sorted in descending order with their values.