thrust
Functions
Set Operations

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)
 

Detailed Description

Function Documentation

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 
)

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(m-n,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.

Parameters
execThe execution policy to use for parallelization.
first1The beginning of the first input range.
last1The end of the first input range.
first2The beginning of the second input range.
last2The end of the second input range.
resultThe beginning of the output range.
Returns
The end of the output range.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is 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.
InputIterator2is 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.
OutputIteratoris a model of Output Iterator.
Precondition
The ranges [first1, last1) and [first2, last2) shall be sorted with respect to operator<.
The resulting range shall not overlap with either input range.

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:

...
int A1[6] = {0, 1, 3, 4, 5, 6, 9};
int A2[5] = {1, 3, 5, 7, 9};
int result[3];
int *result_end = thrust::set_difference(thrust::host, A1, A1 + 6, A2, A2 + 5, result);
// result is now {0, 4, 6}
See Also
http://www.sgi.com/tech/stl/set_difference.html
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
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(m-n,0) elements from [first1, last1) range shall be copied to the output range.

This version of set_difference compares elements using operator<.

Parameters
first1The beginning of the first input range.
last1The end of the first input range.
first2The beginning of the second input range.
last2The end of the second input range.
resultThe beginning of the output range.
Returns
The end of the output range.
Template Parameters
InputIterator1is 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.
InputIterator2is 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.
OutputIteratoris a model of Output Iterator.
Precondition
The ranges [first1, last1) and [first2, last2) shall be sorted with respect to operator<.
The resulting range shall not overlap with either input range.

The following code snippet demonstrates how to use set_difference to compute the set difference of two sets of integers sorted in ascending order.

...
int A1[6] = {0, 1, 3, 4, 5, 6, 9};
int A2[5] = {1, 3, 5, 7, 9};
int result[3];
int *result_end = thrust::set_difference(A1, A1 + 6, A2, A2 + 5, result);
// result is now {0, 4, 6}
See Also
http://www.sgi.com/tech/stl/set_difference.html
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted
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 
)

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(m-n,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.

Parameters
execThe execution policy to use for parallelization.
first1The beginning of the first input range.
last1The end of the first input range.
first2The beginning of the second input range.
last2The end of the second input range.
resultThe beginning of the output range.
compComparison operator.
Returns
The end of the output range.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is 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.
InputIterator2is 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.
OutputIteratoris a model of Output Iterator.
StrictWeakCompareis a model of Strict Weak Ordering.
Precondition
The ranges [first1, last1) and [first2, last2) shall be sorted with respect to comp.
The resulting range shall not overlap with either input range.

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:

...
int A1[6] = {9, 6, 5, 4, 3, 1, 0};
int A2[5] = {9, 7, 5, 3, 1};
int result[3];
int *result_end = thrust::set_difference(thrust::host, A1, A1 + 6, A2, A2 + 5, result, thrust::greater<int>());
// result is now {6, 4, 0}
See Also
http://www.sgi.com/tech/stl/set_difference.html
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted
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 
)

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(m-n,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.

Parameters
first1The beginning of the first input range.
last1The end of the first input range.
first2The beginning of the second input range.
last2The end of the second input range.
resultThe beginning of the output range.
compComparison operator.
Returns
The end of the output range.
Template Parameters
InputIterator1is 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.
InputIterator2is 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.
OutputIteratoris a model of Output Iterator.
StrictWeakCompareis a model of Strict Weak Ordering.
Precondition
The ranges [first1, last1) and [first2, last2) shall be sorted with respect to comp.
The resulting range shall not overlap with either input range.

The following code snippet demonstrates how to use set_difference to compute the set difference of two sets of integers sorted in descending order.

...
int A1[6] = {9, 6, 5, 4, 3, 1, 0};
int A2[5] = {9, 7, 5, 3, 1};
int result[3];
int *result_end = thrust::set_difference(A1, A1 + 6, A2, A2 + 5, result, thrust::greater<int>());
// result is now {6, 4, 0}
See Also
http://www.sgi.com/tech/stl/set_difference.html
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted
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 
)

set_difference_by_key performs a key-value 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(m-n,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.

Parameters
execThe execution policy to use for parallelization.
keys_first1The beginning of the first input range of keys.
keys_last1The end of the first input range of keys.
keys_first2The beginning of the second input range of keys.
keys_last2The end of the second input range of keys.
values_first1The beginning of the first input range of values.
values_first2The beginning of the first input range of values.
keys_resultThe beginning of the output range of keys.
values_resultThe beginning of the output range of values.
Returns
A 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.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is 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.
InputIterator2is 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.
InputIterator3is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types.
InputIterator4is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types.
OutputIterator1is a model of Output Iterator.
OutputIterator2is a model of Output Iterator.
Precondition
The ranges [keys_first1, keys_last1) and [keys_first2, keys_last2) shall be sorted with respect to operator<.
The resulting ranges shall not overlap with any input range.

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:

...
int A_keys[6] = {0, 1, 3, 4, 5, 6, 9};
int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};
int B_keys[5] = {1, 3, 5, 7, 9};
int B_vals[5] = {1, 1, 1, 1, 1};
int keys_result[3];
int vals_result[3];
thrust::pair<int*,int*> end = thrust::set_difference_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
// keys_result is now {0, 4, 6}
// vals_result is now {0, 0, 0}
See Also
set_union_by_key
set_intersection_by_key
set_symmetric_difference_by_key
sort_by_key
is_sorted
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 
)

set_difference_by_key performs a key-value 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(m-n,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<.

Parameters
keys_first1The beginning of the first input range of keys.
keys_last1The end of the first input range of keys.
keys_first2The beginning of the second input range of keys.
keys_last2The end of the second input range of keys.
values_first1The beginning of the first input range of values.
values_first2The beginning of the first input range of values.
keys_resultThe beginning of the output range of keys.
values_resultThe beginning of the output range of values.
Returns
A 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.
Template Parameters
InputIterator1is 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.
InputIterator2is 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.
InputIterator3is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types.
InputIterator4is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types.
OutputIterator1is a model of Output Iterator.
OutputIterator2is a model of Output Iterator.
Precondition
The ranges [keys_first1, keys_last1) and [keys_first2, keys_last2) shall be sorted with respect to operator<.
The resulting ranges shall not overlap with any input range.

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.

...
int A_keys[6] = {0, 1, 3, 4, 5, 6, 9};
int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};
int B_keys[5] = {1, 3, 5, 7, 9};
int B_vals[5] = {1, 1, 1, 1, 1};
int keys_result[3];
int vals_result[3];
thrust::pair<int*,int*> end = thrust::set_difference_by_key(A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
// keys_result is now {0, 4, 6}
// vals_result is now {0, 0, 0}
See Also
set_union_by_key
set_intersection_by_key
set_symmetric_difference_by_key
sort_by_key
is_sorted
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 
)

set_difference_by_key performs a key-value 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(m-n,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.

Parameters
execThe execution policy to use for parallelization.
keys_first1The beginning of the first input range of keys.
keys_last1The end of the first input range of keys.
keys_first2The beginning of the second input range of keys.
keys_last2The end of the second input range of keys.
values_first1The beginning of the first input range of values.
values_first2The beginning of the first input range of values.
keys_resultThe beginning of the output range of keys.
values_resultThe beginning of the output range of values.
compComparison operator.
Returns
A 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.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is 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.
InputIterator2is 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.
InputIterator3is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types.
InputIterator4is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types.
OutputIterator1is a model of Output Iterator.
OutputIterator2is a model of Output Iterator.
StrictWeakCompareis a model of Strict Weak Ordering.
Precondition
The ranges [keys_first1, keys_last1) and [keys_first2, keys_last2) shall be sorted with respect to comp.
The resulting ranges shall not overlap with any input range.

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:

...
int A_keys[6] = {9, 6, 5, 4, 3, 1, 0};
int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};
int B_keys[5] = {9, 7, 5, 3, 1};
int B_vals[5] = {1, 1, 1, 1, 1};
int keys_result[3];
int vals_result[3];
thrust::pair<int*,int*> end = thrust::set_difference_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result, thrust::greater<int>());
// keys_result is now {0, 4, 6}
// vals_result is now {0, 0, 0}
See Also
set_union_by_key
set_intersection_by_key
set_symmetric_difference_by_key
sort_by_key
is_sorted
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 
)

set_difference_by_key performs a key-value 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(m-n,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.

Parameters
keys_first1The beginning of the first input range of keys.
keys_last1The end of the first input range of keys.
keys_first2The beginning of the second input range of keys.
keys_last2The end of the second input range of keys.
values_first1The beginning of the first input range of values.
values_first2The beginning of the first input range of values.
keys_resultThe beginning of the output range of keys.
values_resultThe beginning of the output range of values.
compComparison operator.
Returns
A 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.
Template Parameters
InputIterator1is 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.
InputIterator2is 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.
InputIterator3is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types.
InputIterator4is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types.
OutputIterator1is a model of Output Iterator.
OutputIterator2is a model of Output Iterator.
StrictWeakCompareis a model of Strict Weak Ordering.
Precondition
The ranges [keys_first1, keys_last1) and [keys_first2, keys_last2) shall be sorted with respect to comp.
The resulting ranges shall not overlap with any input range.

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.

...
int A_keys[6] = {9, 6, 5, 4, 3, 1, 0};
int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};
int B_keys[5] = {9, 7, 5, 3, 1};
int B_vals[5] = {1, 1, 1, 1, 1};
int keys_result[3];
int vals_result[3];
thrust::pair<int*,int*> end = thrust::set_difference_by_key(A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result, thrust::greater<int>());
// keys_result is now {0, 4, 6}
// vals_result is now {0, 0, 0}
See Also
set_union_by_key
set_intersection_by_key
set_symmetric_difference_by_key
sort_by_key
is_sorted
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 
)

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.

Parameters
execThe execution policy to use for parallelization.
first1The beginning of the first input range.
last1The end of the first input range.
first2The beginning of the second input range.
last2The end of the second input range.
resultThe beginning of the output range.
Returns
The end of the output range.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is 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.
InputIterator2is 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.
OutputIteratoris a model of Output Iterator.
Precondition
The ranges [first1, last1) and [first2, last2) shall be sorted with respect to operator<.
The resulting range shall not overlap with either input range.

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:

...
int A1[6] = {1, 3, 5, 7, 9, 11};
int A2[7] = {1, 1, 2, 3, 5, 8, 13};
int result[7];
int *result_end = thrust::set_intersection(thrust::host, A1, A1 + 6, A2, A2 + 7, result);
// result is now {1, 3, 5}
See Also
http://www.sgi.com/tech/stl/set_intersection.html
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
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<.

Parameters
first1The beginning of the first input range.
last1The end of the first input range.
first2The beginning of the second input range.
last2The end of the second input range.
resultThe beginning of the output range.
Returns
The end of the output range.
Template Parameters
InputIterator1is 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.
InputIterator2is 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.
OutputIteratoris a model of Output Iterator.
Precondition
The ranges [first1, last1) and [first2, last2) shall be sorted with respect to operator<.
The resulting range shall not overlap with either input range.

The following code snippet demonstrates how to use set_intersection to compute the set intersection of two sets of integers sorted in ascending order.

...
int A1[6] = {1, 3, 5, 7, 9, 11};
int A2[7] = {1, 1, 2, 3, 5, 8, 13};
int result[7];
int *result_end = thrust::set_intersection(A1, A1 + 6, A2, A2 + 7, result);
// result is now {1, 3, 5}
See Also
http://www.sgi.com/tech/stl/set_intersection.html
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted
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 
)

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.

Parameters
execThe execution policy to use for parallelization.
first1The beginning of the first input range.
last1The end of the first input range.
first2The beginning of the second input range.
last2The end of the second input range.
resultThe beginning of the output range.
compComparison operator.
Returns
The end of the output range.
Precondition
The ranges [first1, last1) and [first2, last2) shall be sorted with respect to comp.
The resulting range shall not overlap with either input range.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is 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.
InputIterator2is 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.
OutputIteratoris 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:

...
int A1[6] = {11, 9, 7, 5, 3, 1};
int A2[7] = {13, 8, 5, 3, 2, 1, 1};
int result[3];
int *result_end = thrust::set_intersection(thrust::host, A1, A1 + 6, A2, A2 + 7, result, thrust::greater<int>());
// result is now {5, 3, 1}
See Also
http://www.sgi.com/tech/stl/set_intersection.html
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted
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 
)

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.

Parameters
first1The beginning of the first input range.
last1The end of the first input range.
first2The beginning of the second input range.
last2The end of the second input range.
resultThe beginning of the output range.
compComparison operator.
Returns
The end of the output range.
Precondition
The ranges [first1, last1) and [first2, last2) shall be sorted with respect to comp.
The resulting range shall not overlap with either input range.
Template Parameters
InputIterator1is 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.
InputIterator2is 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.
OutputIteratoris 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.

...
int A1[6] = {11, 9, 7, 5, 3, 1};
int A2[7] = {13, 8, 5, 3, 2, 1, 1};
int result[3];
int *result_end = thrust::set_intersection(A1, A1 + 6, A2, A2 + 7, result, thrust::greater<int>());
// result is now {5, 3, 1}
See Also
http://www.sgi.com/tech/stl/set_intersection.html
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted
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 
)

set_intersection_by_key performs a key-value 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.

Parameters
execThe execution policy to use for parallelization.
keys_first1The beginning of the first input range of keys.
keys_last1The end of the first input range of keys.
keys_first2The beginning of the second input range of keys.
keys_last2The end of the second input range of keys.
values_first1The beginning of the first input range of values.
keys_resultThe beginning of the output range of keys.
values_resultThe beginning of the output range of values.
Returns
A 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.
Note
Unlike the other key-value set operations, 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.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is 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.
InputIterator2is 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.
InputIterator3is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types.
OutputIterator1is a model of Output Iterator.
OutputIterator2is a model of Output Iterator.
Precondition
The ranges [keys_first1, keys_last1) and [keys_first2, keys_last2) shall be sorted with respect to operator<.
The resulting ranges shall not overlap with any input range.

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:

...
int A_keys[6] = {1, 3, 5, 7, 9, 11};
int A_vals[6] = {0, 0, 0, 0, 0, 0};
int B_keys[7] = {1, 1, 2, 3, 5, 8, 13};
int keys_result[7];
int vals_result[7];
thrust::pair<int*,int*> end = thrust::set_intersection_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 7, A_vals, keys_result, vals_result);
// keys_result is now {1, 3, 5}
// vals_result is now {0, 0, 0}
See Also
set_union_by_key
set_difference_by_key
set_symmetric_difference_by_key
sort_by_key
is_sorted
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 
)

set_intersection_by_key performs a key-value 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<.

Parameters
keys_first1The beginning of the first input range of keys.
keys_last1The end of the first input range of keys.
keys_first2The beginning of the second input range of keys.
keys_last2The end of the second input range of keys.
values_first1The beginning of the first input range of values.
keys_resultThe beginning of the output range of keys.
values_resultThe beginning of the output range of values.
Returns
A 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.
Note
Unlike the other key-value set operations, 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.
Template Parameters
InputIterator1is 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.
InputIterator2is 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.
InputIterator3is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types.
OutputIterator1is a model of Output Iterator.
OutputIterator2is a model of Output Iterator.
Precondition
The ranges [keys_first1, keys_last1) and [keys_first2, keys_last2) shall be sorted with respect to operator<.
The resulting ranges shall not overlap with any input range.

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.

...
int A_keys[6] = {1, 3, 5, 7, 9, 11};
int A_vals[6] = {0, 0, 0, 0, 0, 0};
int B_keys[7] = {1, 1, 2, 3, 5, 8, 13};
int keys_result[7];
int vals_result[7];
thrust::pair<int*,int*> end = thrust::set_intersection_by_key(A_keys, A_keys + 6, B_keys, B_keys + 7, A_vals, keys_result, vals_result);
// keys_result is now {1, 3, 5}
// vals_result is now {0, 0, 0}
See Also
set_union_by_key
set_difference_by_key
set_symmetric_difference_by_key
sort_by_key
is_sorted
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 
)

set_intersection_by_key performs a key-value 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.

Parameters
execThe execution policy to use for parallelization.
keys_first1The beginning of the first input range of keys.
keys_last1The end of the first input range of keys.
keys_first2The beginning of the second input range of keys.
keys_last2The end of the second input range of keys.
values_first1The beginning of the first input range of values.
keys_resultThe beginning of the output range of keys.
values_resultThe beginning of the output range of values.
compComparison operator.
Returns
A 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.
Note
Unlike the other key-value set operations, 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.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is 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.
InputIterator2is 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.
InputIterator3is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types.
OutputIterator1is a model of Output Iterator.
OutputIterator2is a model of Output Iterator.
StrictWeakCompareis a model of Strict Weak Ordering.
Precondition
The ranges [keys_first1, keys_last1) and [keys_first2, keys_last2) shall be sorted with respect to comp.
The resulting ranges shall not overlap with any input range.

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:

...
int A_keys[6] = {11, 9, 7, 5, 3, 1};
int A_vals[6] = { 0, 0, 0, 0, 0, 0};
int B_keys[7] = {13, 8, 5, 3, 2, 1, 1};
int keys_result[7];
int vals_result[7];
thrust::pair<int*,int*> end = thrust::set_intersection_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 7, A_vals, keys_result, vals_result, thrust::greater<int>());
// keys_result is now {5, 3, 1}
// vals_result is now {0, 0, 0}
See Also
set_union_by_key
set_difference_by_key
set_symmetric_difference_by_key
sort_by_key
is_sorted
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 
)

set_intersection_by_key performs a key-value 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.

Parameters
keys_first1The beginning of the first input range of keys.
keys_last1The end of the first input range of keys.
keys_first2The beginning of the second input range of keys.
keys_last2The end of the second input range of keys.
values_first1The beginning of the first input range of values.
keys_resultThe beginning of the output range of keys.
values_resultThe beginning of the output range of values.
compComparison operator.
Returns
A 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.
Note
Unlike the other key-value set operations, 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.
Template Parameters
InputIterator1is 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.
InputIterator2is 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.
InputIterator3is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types.
OutputIterator1is a model of Output Iterator.
OutputIterator2is a model of Output Iterator.
StrictWeakCompareis a model of Strict Weak Ordering.
Precondition
The ranges [keys_first1, keys_last1) and [keys_first2, keys_last2) shall be sorted with respect to comp.
The resulting ranges shall not overlap with any input range.

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.

...
int A_keys[6] = {11, 9, 7, 5, 3, 1};
int A_vals[6] = { 0, 0, 0, 0, 0, 0};
int B_keys[7] = {13, 8, 5, 3, 2, 1, 1};
int keys_result[7];
int vals_result[7];
thrust::pair<int*,int*> end = thrust::set_intersection_by_key(A_keys, A_keys + 6, B_keys, B_keys + 7, A_vals, keys_result, vals_result, thrust::greater<int>());
// keys_result is now {5, 3, 1}
// vals_result is now {0, 0, 0}
See Also
set_union_by_key
set_difference_by_key
set_symmetric_difference_by_key
sort_by_key
is_sorted
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 
)

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.

Parameters
execThe execution policy to use for parallelization.
first1The beginning of the first input range.
last1The end of the first input range.
first2The beginning of the second input range.
last2The end of the second input range.
resultThe beginning of the output range.
Returns
The end of the output range.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is 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.
InputIterator2is 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.
OutputIteratoris a model of Output Iterator.
Precondition
The ranges [first1, last1) and [first2, last2) shall be sorted with respect to operator<.
The resulting range shall not overlap with either input range.

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:

...
int A1[6] = {0, 1, 2, 2, 4, 6, 7};
int A2[5] = {1, 1, 2, 5, 8};
int result[6];
int *result_end = thrust::set_symmetric_difference(thrust::host, A1, A1 + 6, A2, A2 + 5, result);
// result = {0, 4, 5, 6, 7, 8}
See Also
http://www.sgi.com/tech/stl/set_symmetric_difference.html
merge
includes
set_difference
set_union
set_intersection
sort
is_sorted
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
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<.

Parameters
first1The beginning of the first input range.
last1The end of the first input range.
first2The beginning of the second input range.
last2The end of the second input range.
resultThe beginning of the output range.
Returns
The end of the output range.
Template Parameters
InputIterator1is 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.
InputIterator2is 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.
OutputIteratoris a model of Output Iterator.
Precondition
The ranges [first1, last1) and [first2, last2) shall be sorted with respect to operator<.
The resulting range shall not overlap with either input range.

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.

...
int A1[6] = {0, 1, 2, 2, 4, 6, 7};
int A2[5] = {1, 1, 2, 5, 8};
int result[6];
int *result_end = thrust::set_symmetric_difference(A1, A1 + 6, A2, A2 + 5, result);
// result = {0, 4, 5, 6, 7, 8}
See Also
http://www.sgi.com/tech/stl/set_symmetric_difference.html
merge
includes
set_difference
set_union
set_intersection
sort
is_sorted
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 
)

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.

Parameters
execThe execution policy to use for parallelization.
first1The beginning of the first input range.
last1The end of the first input range.
first2The beginning of the second input range.
last2The end of the second input range.
resultThe beginning of the output range.
compComparison operator.
Returns
The end of the output range.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is 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.
InputIterator2is 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.
OutputIteratoris a model of Output Iterator.
Precondition
The ranges [first1, last1) and [first2, last2) shall be sorted with respect to comp.
The resulting range shall not overlap with either input range.

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:

...
int A1[6] = {7, 6, 4, 2, 2, 1, 0};
int A2[5] = {8, 5, 2, 1, 1};
int result[6];
int *result_end = thrust::set_symmetric_difference(thrust::host, A1, A1 + 6, A2, A2 + 5, result);
// result = {8, 7, 6, 5, 4, 0}
See Also
http://www.sgi.com/tech/stl/set_symmetric_difference.html
merge
includes
set_difference
set_union
set_intersection
sort
is_sorted
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 
)

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.

Parameters
first1The beginning of the first input range.
last1The end of the first input range.
first2The beginning of the second input range.
last2The end of the second input range.
resultThe beginning of the output range.
compComparison operator.
Returns
The end of the output range.
Template Parameters
InputIterator1is 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.
InputIterator2is 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.
OutputIteratoris a model of Output Iterator.
Precondition
The ranges [first1, last1) and [first2, last2) shall be sorted with respect to comp.
The resulting range shall not overlap with either input range.

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.

...
int A1[6] = {7, 6, 4, 2, 2, 1, 0};
int A2[5] = {8, 5, 2, 1, 1};
int result[6];
int *result_end = thrust::set_symmetric_difference(A1, A1 + 6, A2, A2 + 5, result);
// result = {8, 7, 6, 5, 4, 0}
See Also
http://www.sgi.com/tech/stl/set_symmetric_difference.html
merge
includes
set_difference
set_union
set_intersection
sort
is_sorted
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 
)

set_symmetric_difference_by_key performs a key-value 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.

Parameters
execThe execution policy to use for parallelization.
keys_first1The beginning of the first input range of keys.
keys_last1The end of the first input range of keys.
keys_first2The beginning of the second input range of keys.
keys_last2The end of the second input range of keys.
values_first1The beginning of the first input range of values.
values_first2The beginning of the first input range of values.
keys_resultThe beginning of the output range of keys.
values_resultThe beginning of the output range of values.
Returns
A 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.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is 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.
InputIterator2is 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.
InputIterator3is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types.
InputIterator4is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types.
OutputIterator1is a model of Output Iterator.
OutputIterator2is a model of Output Iterator.
Precondition
The ranges [keys_first1, keys_last1) and [keys_first2, keys_last2) shall be sorted with respect to operator<.
The resulting ranges shall not overlap with any input range.

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:

...
int A_keys[6] = {0, 1, 2, 2, 4, 6, 7};
int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};
int B_keys[5] = {1, 1, 2, 5, 8};
int B_vals[5] = {1, 1, 1, 1, 1};
int keys_result[6];
int vals_result[6];
thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
// keys_result is now {0, 4, 5, 6, 7, 8}
// vals_result is now {0, 0, 1, 0, 0, 1}
See Also
set_union_by_key
set_intersection_by_key
set_difference_by_key
sort_by_key
is_sorted
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 
)

set_symmetric_difference_by_key performs a key-value 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<.

Parameters
keys_first1The beginning of the first input range of keys.
keys_last1The end of the first input range of keys.
keys_first2The beginning of the second input range of keys.
keys_last2The end of the second input range of keys.
values_first1The beginning of the first input range of values.
values_first2The beginning of the first input range of values.
keys_resultThe beginning of the output range of keys.
values_resultThe beginning of the output range of values.
Returns
A 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.
Template Parameters
InputIterator1is 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.
InputIterator2is 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.
InputIterator3is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types.
InputIterator4is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types.
OutputIterator1is a model of Output Iterator.
OutputIterator2is a model of Output Iterator.
Precondition
The ranges [keys_first1, keys_last1) and [keys_first2, keys_last2) shall be sorted with respect to operator<.
The resulting ranges shall not overlap with any input range.

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.

...
int A_keys[6] = {0, 1, 2, 2, 4, 6, 7};
int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};
int B_keys[5] = {1, 1, 2, 5, 8};
int B_vals[5] = {1, 1, 1, 1, 1};
int keys_result[6];
int vals_result[6];
thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
// keys_result is now {0, 4, 5, 6, 7, 8}
// vals_result is now {0, 0, 1, 0, 0, 1}
See Also
set_union_by_key
set_intersection_by_key
set_difference_by_key
sort_by_key
is_sorted
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 
)

set_symmetric_difference_by_key performs a key-value 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.

Parameters
execThe execution policy to use for parallelization.
keys_first1The beginning of the first input range of keys.
keys_last1The end of the first input range of keys.
keys_first2The beginning of the second input range of keys.
keys_last2The end of the second input range of keys.
values_first1The beginning of the first input range of values.
values_first2The beginning of the first input range of values.
keys_resultThe beginning of the output range of keys.
values_resultThe beginning of the output range of values.
compComparison operator.
Returns
A 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.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is 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.
InputIterator2is 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.
InputIterator3is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types.
InputIterator4is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types.
OutputIterator1is a model of Output Iterator.
OutputIterator2is a model of Output Iterator.
StrictWeakCompareis a model of Strict Weak Ordering.
Precondition
The ranges [keys_first1, keys_last1) and [keys_first2, keys_last2) shall be sorted with respect to comp.
The resulting ranges shall not overlap with any input range.

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:

...
int A_keys[6] = {7, 6, 4, 2, 2, 1, 0};
int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};
int B_keys[5] = {8, 5, 2, 1, 1};
int B_vals[5] = {1, 1, 1, 1, 1};
int keys_result[6];
int vals_result[6];
thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
// keys_result is now {8, 7, 6, 5, 4, 0}
// vals_result is now {1, 0, 0, 1, 0, 0}
See Also
set_union_by_key
set_intersection_by_key
set_difference_by_key
sort_by_key
is_sorted
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 
)

set_symmetric_difference_by_key performs a key-value 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.

Parameters
keys_first1The beginning of the first input range of keys.
keys_last1The end of the first input range of keys.
keys_first2The beginning of the second input range of keys.
keys_last2The end of the second input range of keys.
values_first1The beginning of the first input range of values.
values_first2The beginning of the first input range of values.
keys_resultThe beginning of the output range of keys.
values_resultThe beginning of the output range of values.
compComparison operator.
Returns
A 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.
Template Parameters
InputIterator1is 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.
InputIterator2is 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.
InputIterator3is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types.
InputIterator4is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types.
OutputIterator1is a model of Output Iterator.
OutputIterator2is a model of Output Iterator.
StrictWeakCompareis a model of Strict Weak Ordering.
Precondition
The ranges [keys_first1, keys_last1) and [keys_first2, keys_last2) shall be sorted with respect to comp.
The resulting ranges shall not overlap with any input range.

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.

...
int A_keys[6] = {7, 6, 4, 2, 2, 1, 0};
int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};
int B_keys[5] = {8, 5, 2, 1, 1};
int B_vals[5] = {1, 1, 1, 1, 1};
int keys_result[6];
int vals_result[6];
thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
// keys_result is now {8, 7, 6, 5, 4, 0}
// vals_result is now {1, 0, 0, 1, 0, 0}
See Also
set_union_by_key
set_intersection_by_key
set_difference_by_key
sort_by_key
is_sorted
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 
)

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.

Parameters
execThe execution policy to use for parallelization.
first1The beginning of the first input range.
last1The end of the first input range.
first2The beginning of the second input range.
last2The end of the second input range.
resultThe beginning of the output range.
Returns
The end of the output range.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is 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.
InputIterator2is 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.
OutputIteratoris a model of Output Iterator.
Precondition
The ranges [first1, last1) and [first2, last2) shall be sorted with respect to operator<.
The resulting range shall not overlap with either input range.

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:

...
int A1[7] = {0, 2, 4, 6, 8, 10, 12};
int A2[5] = {1, 3, 5, 7, 9};
int result[11];
int *result_end = thrust::set_union(thrust::host, A1, A1 + 7, A2, A2 + 5, result);
// result = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12}
See Also
http://www.sgi.com/tech/stl/set_union.html
merge
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
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<.

Parameters
first1The beginning of the first input range.
last1The end of the first input range.
first2The beginning of the second input range.
last2The end of the second input range.
resultThe beginning of the output range.
Returns
The end of the output range.
Template Parameters
InputIterator1is 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.
InputIterator2is 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.
OutputIteratoris a model of Output Iterator.
Precondition
The ranges [first1, last1) and [first2, last2) shall be sorted with respect to operator<.
The resulting range shall not overlap with either input range.

The following code snippet demonstrates how to use set_union to compute the union of two sets of integers sorted in ascending order.

...
int A1[7] = {0, 2, 4, 6, 8, 10, 12};
int A2[5] = {1, 3, 5, 7, 9};
int result[11];
int *result_end = thrust::set_union(A1, A1 + 7, A2, A2 + 5, result);
// result = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12}
See Also
http://www.sgi.com/tech/stl/set_union.html
merge
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted
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 
)

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.

Parameters
execThe execution policy to use for parallelization.
first1The beginning of the first input range.
last1The end of the first input range.
first2The beginning of the second input range.
last2The end of the second input range.
resultThe beginning of the output range.
compComparison operator.
Returns
The end of the output range.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is 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.
InputIterator2is 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.
OutputIteratoris a model of Output Iterator.
StrictWeakCompareis a model of Strict Weak Ordering.
Precondition
The ranges [first1, last1) and [first2, last2) shall be sorted with respect to comp.
The resulting range shall not overlap with either input range.

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:

...
int A1[7] = {12, 10, 8, 6, 4, 2, 0};
int A2[5] = {9, 7, 5, 3, 1};
int result[11];
int *result_end = thrust::set_union(thrust::host, A1, A1 + 7, A2, A2 + 5, result, thrust::greater<int>());
// result = {12, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
See Also
http://www.sgi.com/tech/stl/set_union.html
merge
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted
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 
)

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.

Parameters
first1The beginning of the first input range.
last1The end of the first input range.
first2The beginning of the second input range.
last2The end of the second input range.
resultThe beginning of the output range.
compComparison operator.
Returns
The end of the output range.
Template Parameters
InputIterator1is 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.
InputIterator2is 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.
OutputIteratoris a model of Output Iterator.
StrictWeakCompareis a model of Strict Weak Ordering.
Precondition
The ranges [first1, last1) and [first2, last2) shall be sorted with respect to comp.
The resulting range shall not overlap with either input range.

The following code snippet demonstrates how to use set_union to compute the union of two sets of integers sorted in ascending order.

...
int A1[7] = {12, 10, 8, 6, 4, 2, 0};
int A2[5] = {9, 7, 5, 3, 1};
int result[11];
int *result_end = thrust::set_union(A1, A1 + 7, A2, A2 + 5, result, thrust::greater<int>());
// result = {12, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
See Also
http://www.sgi.com/tech/stl/set_union.html
merge
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted
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 
)

set_union_by_key performs a key-value 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.

Parameters
execThe execution policy to use for parallelization.
keys_first1The beginning of the first input range of keys.
keys_last1The end of the first input range of keys.
keys_first2The beginning of the second input range of keys.
keys_last2The end of the second input range of keys.
values_first1The beginning of the first input range of values.
values_first2The beginning of the first input range of values.
keys_resultThe beginning of the output range of keys.
values_resultThe beginning of the output range of values.
Returns
A 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.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is 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.
InputIterator2is 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.
InputIterator3is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types.
InputIterator4is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types.
OutputIterator1is a model of Output Iterator.
OutputIterator2is a model of Output Iterator.
Precondition
The ranges [keys_first1, keys_last1) and [keys_first2, keys_last2) shall be sorted with respect to operator<.
The resulting ranges shall not overlap with any input range.

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:

...
int A_keys[6] = {0, 2, 4, 6, 8, 10, 12};
int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};
int B_keys[5] = {1, 3, 5, 7, 9};
int B_vals[5] = {1, 1, 1, 1, 1};
int keys_result[11];
int vals_result[11];
thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
// keys_result is now {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12}
// vals_result is now {0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0}
See Also
set_symmetric_difference_by_key
set_intersection_by_key
set_difference_by_key
sort_by_key
is_sorted
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 
)

set_union_by_key performs a key-value 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<.

Parameters
keys_first1The beginning of the first input range of keys.
keys_last1The end of the first input range of keys.
keys_first2The beginning of the second input range of keys.
keys_last2The end of the second input range of keys.
values_first1The beginning of the first input range of values.
values_first2The beginning of the first input range of values.
keys_resultThe beginning of the output range of keys.
values_resultThe beginning of the output range of values.
Returns
A 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.
Template Parameters
InputIterator1is 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.
InputIterator2is 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.
InputIterator3is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types.
InputIterator4is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types.
OutputIterator1is a model of Output Iterator.
OutputIterator2is a model of Output Iterator.
Precondition
The ranges [keys_first1, keys_last1) and [keys_first2, keys_last2) shall be sorted with respect to operator<.
The resulting ranges shall not overlap with any input range.

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.

...
int A_keys[6] = {0, 2, 4, 6, 8, 10, 12};
int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};
int B_keys[5] = {1, 3, 5, 7, 9};
int B_vals[5] = {1, 1, 1, 1, 1};
int keys_result[11];
int vals_result[11];
thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
// keys_result is now {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12}
// vals_result is now {0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0}
See Also
set_symmetric_difference_by_key
set_intersection_by_key
set_difference_by_key
sort_by_key
is_sorted
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 
)

set_union_by_key performs a key-value 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.

Parameters
execThe execution policy to use for parallelization.
keys_first1The beginning of the first input range of keys.
keys_last1The end of the first input range of keys.
keys_first2The beginning of the second input range of keys.
keys_last2The end of the second input range of keys.
values_first1The beginning of the first input range of values.
values_first2The beginning of the first input range of values.
keys_resultThe beginning of the output range of keys.
values_resultThe beginning of the output range of values.
compComparison operator.
Returns
A 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.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is 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.
InputIterator2is 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.
InputIterator3is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types.
InputIterator4is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types.
OutputIterator1is a model of Output Iterator.
OutputIterator2is a model of Output Iterator.
StrictWeakCompareis a model of Strict Weak Ordering.
Precondition
The ranges [keys_first1, keys_last1) and [keys_first2, keys_last2) shall be sorted with respect to comp.
The resulting ranges shall not overlap with any input range.

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:

...
int A_keys[6] = {12, 10, 8, 6, 4, 2, 0};
int A_vals[6] = { 0, 0, 0, 0, 0, 0, 0};
int B_keys[5] = {9, 7, 5, 3, 1};
int B_vals[5] = {1, 1, 1, 1, 1};
int keys_result[11];
int vals_result[11];
thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result, thrust::greater<int>());
// keys_result is now {12, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
// vals_result is now { 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0}
See Also
set_symmetric_difference_by_key
set_intersection_by_key
set_difference_by_key
sort_by_key
is_sorted
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 
)

set_union_by_key performs a key-value 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.

Parameters
keys_first1The beginning of the first input range of keys.
keys_last1The end of the first input range of keys.
keys_first2The beginning of the second input range of keys.
keys_last2The end of the second input range of keys.
values_first1The beginning of the first input range of values.
values_first2The beginning of the first input range of values.
keys_resultThe beginning of the output range of keys.
values_resultThe beginning of the output range of values.
compComparison operator.
Returns
A 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.
Template Parameters
InputIterator1is 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.
InputIterator2is 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.
InputIterator3is a model of Input Iterator, and InputIterator3's value_type is convertible to a type in OutputIterator2's set of value_types.
InputIterator4is a model of Input Iterator, and InputIterator4's value_type is convertible to a type in OutputIterator2's set of value_types.
OutputIterator1is a model of Output Iterator.
OutputIterator2is a model of Output Iterator.
StrictWeakCompareis a model of Strict Weak Ordering.
Precondition
The ranges [keys_first1, keys_last1) and [keys_first2, keys_last2) shall be sorted with respect to comp.
The resulting ranges shall not overlap with any input range.

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.

...
int A_keys[6] = {12, 10, 8, 6, 4, 2, 0};
int A_vals[6] = { 0, 0, 0, 0, 0, 0, 0};
int B_keys[5] = {9, 7, 5, 3, 1};
int B_vals[5] = {1, 1, 1, 1, 1};
int keys_result[11];
int vals_result[11];
thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result, thrust::greater<int>());
// keys_result is now {12, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
// vals_result is now { 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0}
See Also
set_symmetric_difference_by_key
set_intersection_by_key
set_difference_by_key
sort_by_key
is_sorted