Set Operations

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);

Functions

Function thrust::set_difference

template <typename DerivedPolicy,   typename InputIterator1,   typename InputIterator2,   typename OutputIterator> __host__ __device__ OutputIterator set_difference(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,   InputIterator1 first1,   InputIterator1 last1,   InputIterator2 first2,   InputIterator2 last2,   OutputIterator result); 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.

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:

#include <thrust/set_operations.h>
#include <thrust/execution_policy.h>
...
int A1[7] = {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 + 7, A2, A2 + 5, result);
// result is now {0, 4, 6}

Template Parameters:

• DerivedPolicy The name of the derived execution policy.
• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• OutputIterator is a model of Output Iterator.

Function Parameters:

• exec The execution policy to use for parallelization.
• first1 The beginning of the first input range.
• last1 The end of the first input range.
• first2 The beginning of the second input range.
• last2 The end of the second input range.
• result The beginning of the output range.

Preconditions:

• The ranges [first1, last1) and [first2, last2) shall be sorted with respect to operator<.
• The resulting range shall not overlap with either input range.

Returns: The end of the output range.

See:

• https://en.cppreference.com/w/cpp/algorithm/set_difference
• includes
• set_union
• set_intersection
• set_symmetric_difference
• sort
• is_sorted

Function thrust::set_difference

template <typename InputIterator1,   typename InputIterator2,   typename OutputIterator> OutputIterator 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<.

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

#include <thrust/set_operations.h>
...
int A1[7] = {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 + 7, A2, A2 + 5, result);
// result is now {0, 4, 6}

Template Parameters:

• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• OutputIterator is a model of Output Iterator.

Function Parameters:

• first1 The beginning of the first input range.
• last1 The end of the first input range.
• first2 The beginning of the second input range.
• last2 The end of the second input range.
• result The beginning of the output range.

Preconditions:

• The ranges [first1, last1) and [first2, last2) shall be sorted with respect to operator<.
• The resulting range shall not overlap with either input range.

Returns: The end of the output range.

See:

• https://en.cppreference.com/w/cpp/algorithm/set_difference
• includes
• set_union
• set_intersection
• set_symmetric_difference
• sort
• is_sorted

Function thrust::set_difference

template <typename DerivedPolicy,   typename InputIterator1,   typename InputIterator2,   typename OutputIterator,   typename StrictWeakCompare> __host__ __device__ OutputIterator set_difference(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,   InputIterator1 first1,   InputIterator1 last1,   InputIterator2 first2,   InputIterator2 last2,   OutputIterator result,   StrictWeakCompare comp); 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.

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:

#include <thrust/set_operations.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
int A1[7] = {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 + 7, A2, A2 + 5, result, thrust::greater<int>());
// result is now {6, 4, 0}

Template Parameters:

• DerivedPolicy The name of the derived execution policy.
• InputIterator1 is a model of Input Iterator, InputIterator1'svalue_type is convertable to StrictWeakCompare'sfirst_argument_type. and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2'svalue_type is convertable to StrictWeakCompare'ssecond_argument_type. and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• OutputIterator is a model of Output Iterator.
• StrictWeakCompare is a model of Strict Weak Ordering.

Function Parameters:

• exec The execution policy to use for parallelization.
• first1 The beginning of the first input range.
• last1 The end of the first input range.
• first2 The beginning of the second input range.
• last2 The end of the second input range.
• result The beginning of the output range.
• comp Comparison operator.

Preconditions:

• The ranges [first1, last1) and [first2, last2) shall be sorted with respect to comp.
• The resulting range shall not overlap with either input range.

Returns: The end of the output range.

See:

• https://en.cppreference.com/w/cpp/algorithm/set_difference
• includes
• set_union
• set_intersection
• set_symmetric_difference
• sort
• is_sorted

Function thrust::set_difference

template <typename InputIterator1,   typename InputIterator2,   typename OutputIterator,   typename StrictWeakCompare> OutputIterator 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.

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

#include <thrust/set_operations.h>
#include <thrust/functional.h>
...
int A1[7] = {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 + 7, A2, A2 + 5, result, thrust::greater<int>());
// result is now {6, 4, 0}

Template Parameters:

• InputIterator1 is a model of Input Iterator, InputIterator1'svalue_type is convertable to StrictWeakCompare'sfirst_argument_type. and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2'svalue_type is convertable to StrictWeakCompare'ssecond_argument_type. and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• OutputIterator is a model of Output Iterator.
• StrictWeakCompare is a model of Strict Weak Ordering.

Function Parameters:

• first1 The beginning of the first input range.
• last1 The end of the first input range.
• first2 The beginning of the second input range.
• last2 The end of the second input range.
• result The beginning of the output range.
• comp Comparison operator.

Preconditions:

• The ranges [first1, last1) and [first2, last2) shall be sorted with respect to comp.
• The resulting range shall not overlap with either input range.

Returns: The end of the output range.

See:

• https://en.cppreference.com/w/cpp/algorithm/set_difference
• includes
• set_union
• set_intersection
• set_symmetric_difference
• sort
• is_sorted

Function thrust::set_intersection

template <typename DerivedPolicy,   typename InputIterator1,   typename InputIterator2,   typename OutputIterator> __host__ __device__ OutputIterator set_intersection(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,   InputIterator1 first1,   InputIterator1 last1,   InputIterator2 first2,   InputIterator2 last2,   OutputIterator result); 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.

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:

#include <thrust/set_operations.h>
#include <thrust/execution_policy.h>
...
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}

Template Parameters:

• DerivedPolicy The name of the derived execution policy.
• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• OutputIterator is a model of Output Iterator.

Function Parameters:

• exec The execution policy to use for parallelization.
• first1 The beginning of the first input range.
• last1 The end of the first input range.
• first2 The beginning of the second input range.
• last2 The end of the second input range.
• result The beginning of the output range.

Preconditions:

• The ranges [first1, last1) and [first2, last2) shall be sorted with respect to operator<.
• The resulting range shall not overlap with either input range.

Returns: The end of the output range.

See:

• https://en.cppreference.com/w/cpp/algorithm/set_intersection
• includes
• set_union
• set_intersection
• set_symmetric_difference
• sort
• is_sorted

Function thrust::set_intersection

template <typename InputIterator1,   typename InputIterator2,   typename OutputIterator> OutputIterator 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<.

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

#include <thrust/set_operations.h>
...
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}

Template Parameters:

• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• OutputIterator is a model of Output Iterator.

Function Parameters:

• first1 The beginning of the first input range.
• last1 The end of the first input range.
• first2 The beginning of the second input range.
• last2 The end of the second input range.
• result The beginning of the output range.

Preconditions:

• The ranges [first1, last1) and [first2, last2) shall be sorted with respect to operator<.
• The resulting range shall not overlap with either input range.

Returns: The end of the output range.

See:

• https://en.cppreference.com/w/cpp/algorithm/set_intersection
• includes
• set_union
• set_intersection
• set_symmetric_difference
• sort
• is_sorted

Function thrust::set_intersection

template <typename DerivedPolicy,   typename InputIterator1,   typename InputIterator2,   typename OutputIterator,   typename StrictWeakCompare> __host__ __device__ OutputIterator set_intersection(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,   InputIterator1 first1,   InputIterator1 last1,   InputIterator2 first2,   InputIterator2 last2,   OutputIterator result,   StrictWeakCompare comp); 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.

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:

#include <thrust/set_operations.h>
#include <thrust/execution_policy.h>
...
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}

Template Parameters:

• DerivedPolicy The name of the derived execution policy.
• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• OutputIterator is a model of Output Iterator.

Function Parameters:

• exec The execution policy to use for parallelization.
• first1 The beginning of the first input range.
• last1 The end of the first input range.
• first2 The beginning of the second input range.
• last2 The end of the second input range.
• result The beginning of the output range.
• comp Comparison operator.

Preconditions:

• The ranges [first1, last1) and [first2, last2) shall be sorted with respect to comp.
• The resulting range shall not overlap with either input range.

Returns: The end of the output range.

See:

• https://en.cppreference.com/w/cpp/algorithm/set_intersection
• includes
• set_union
• set_intersection
• set_symmetric_difference
• sort
• is_sorted

Function thrust::set_intersection

template <typename InputIterator1,   typename InputIterator2,   typename OutputIterator,   typename StrictWeakCompare> OutputIterator 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.

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

#include <thrust/set_operations.h>
...
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}

Template Parameters:

• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• OutputIterator is a model of Output Iterator.

Function Parameters:

• first1 The beginning of the first input range.
• last1 The end of the first input range.
• first2 The beginning of the second input range.
• last2 The end of the second input range.
• result The beginning of the output range.
• comp Comparison operator.

Preconditions:

• The ranges [first1, last1) and [first2, last2) shall be sorted with respect to comp.
• The resulting range shall not overlap with either input range.

Returns: The end of the output range.

See:

• https://en.cppreference.com/w/cpp/algorithm/set_intersection
• includes
• set_union
• set_intersection
• set_symmetric_difference
• sort
• is_sorted

Function thrust::set_symmetric_difference

template <typename DerivedPolicy,   typename InputIterator1,   typename InputIterator2,   typename OutputIterator> __host__ __device__ OutputIterator set_symmetric_difference(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,   InputIterator1 first1,   InputIterator1 last1,   InputIterator2 first2,   InputIterator2 last2,   OutputIterator result); 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.

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:

#include <thrust/set_operations.h>
#include <thrust/execution_policy.h>
...
int A1[7] = {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 + 7, A2, A2 + 5, result);
// result = {0, 4, 5, 6, 7, 8}

Template Parameters:

• DerivedPolicy The name of the derived execution policy.
• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• OutputIterator is a model of Output Iterator.

Function Parameters:

• exec The execution policy to use for parallelization.
• first1 The beginning of the first input range.
• last1 The end of the first input range.
• first2 The beginning of the second input range.
• last2 The end of the second input range.
• result The beginning of the output range.

Preconditions:

• The ranges [first1, last1) and [first2, last2) shall be sorted with respect to operator<.
• The resulting range shall not overlap with either input range.

Returns: The end of the output range.

See:

• https://en.cppreference.com/w/cpp/algorithm/set_symmetric_difference
• merge
• includes
• set_difference
• set_union
• set_intersection
• sort
• is_sorted

Function thrust::set_symmetric_difference

template <typename InputIterator1,   typename InputIterator2,   typename OutputIterator> OutputIterator 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<.

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.

#include <thrust/set_operations.h>
...
int A1[7] = {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 + 7, A2, A2 + 5, result);
// result = {0, 4, 5, 6, 7, 8}

Template Parameters:

• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• OutputIterator is a model of Output Iterator.

Function Parameters:

• first1 The beginning of the first input range.
• last1 The end of the first input range.
• first2 The beginning of the second input range.
• last2 The end of the second input range.
• result The beginning of the output range.

Preconditions:

• The ranges [first1, last1) and [first2, last2) shall be sorted with respect to operator<.
• The resulting range shall not overlap with either input range.

Returns: The end of the output range.

See:

• https://en.cppreference.com/w/cpp/algorithm/set_symmetric_difference
• merge
• includes
• set_difference
• set_union
• set_intersection
• sort
• is_sorted

Function thrust::set_symmetric_difference

template <typename DerivedPolicy,   typename InputIterator1,   typename InputIterator2,   typename OutputIterator,   typename StrictWeakCompare> __host__ __device__ OutputIterator set_symmetric_difference(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,   InputIterator1 first1,   InputIterator1 last1,   InputIterator2 first2,   InputIterator2 last2,   OutputIterator result,   StrictWeakCompare comp); 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.

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:

#include <thrust/set_operations.h>
#include <thrust/execution_policy.h>
...
int A1[7] = {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 + 7, A2, A2 + 5, result);
// result = {8, 7, 6, 5, 4, 0}

Template Parameters:

• DerivedPolicy The name of the derived execution policy.
• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• OutputIterator is a model of Output Iterator.

Function Parameters:

• exec The execution policy to use for parallelization.
• first1 The beginning of the first input range.
• last1 The end of the first input range.
• first2 The beginning of the second input range.
• last2 The end of the second input range.
• result The beginning of the output range.
• comp Comparison operator.

Preconditions:

• The ranges [first1, last1) and [first2, last2) shall be sorted with respect to comp.
• The resulting range shall not overlap with either input range.

Returns: The end of the output range.

See:

• https://en.cppreference.com/w/cpp/algorithm/set_symmetric_difference
• merge
• includes
• set_difference
• set_union
• set_intersection
• sort
• is_sorted

Function thrust::set_symmetric_difference

template <typename InputIterator1,   typename InputIterator2,   typename OutputIterator,   typename StrictWeakCompare> OutputIterator set_symmetric_difference(InputIterator1 first1,   InputIterator1 last1,   InputIterator2 first2,   InputIterator2 last2,   OutputIterator result,   StrictWeakCompare comp); 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 following code snippet demonstrates how to use set_symmetric_difference to compute the symmetric difference of two sets of integers sorted in descending order.

#include <thrust/set_operations.h>
...
int A1[7] = {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 + 7, A2, A2 + 5, result);
// result = {8, 7, 6, 5, 4, 0}

Template Parameters:

• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• OutputIterator is a model of Output Iterator.

Function Parameters:

• first1 The beginning of the first input range.
• last1 The end of the first input range.
• first2 The beginning of the second input range.
• last2 The end of the second input range.
• result The beginning of the output range.
• comp Comparison operator.

Preconditions:

• The ranges [first1, last1) and [first2, last2) shall be sorted with respect to comp.
• The resulting range shall not overlap with either input range.

Returns: The end of the output range.

See:

• https://en.cppreference.com/w/cpp/algorithm/set_symmetric_difference
• merge
• includes
• set_difference
• set_union
• set_intersection
• sort
• is_sorted

Function thrust::set_union

template <typename DerivedPolicy,   typename InputIterator1,   typename InputIterator2,   typename OutputIterator> __host__ __device__ OutputIterator set_union(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,   InputIterator1 first1,   InputIterator1 last1,   InputIterator2 first2,   InputIterator2 last2,   OutputIterator result); 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.

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:

#include <thrust/set_operations.h>
#include <thrust/execution_policy.h>
...
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}

Template Parameters:

• DerivedPolicy The name of the derived execution policy.
• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• OutputIterator is a model of Output Iterator.

Function Parameters:

• exec The execution policy to use for parallelization.
• first1 The beginning of the first input range.
• last1 The end of the first input range.
• first2 The beginning of the second input range.
• last2 The end of the second input range.
• result The beginning of the output range.

Preconditions:

• The ranges [first1, last1) and [first2, last2) shall be sorted with respect to operator<.
• The resulting range shall not overlap with either input range.

Returns: The end of the output range.

See:

• https://en.cppreference.com/w/cpp/algorithm/set_union
• merge
• includes
• set_union
• set_intersection
• set_symmetric_difference
• sort
• is_sorted

Function thrust::set_union

template <typename InputIterator1,   typename InputIterator2,   typename OutputIterator> OutputIterator 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<.

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

#include <thrust/set_operations.h>
...
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}

Template Parameters:

• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• OutputIterator is a model of Output Iterator.

Function Parameters:

• first1 The beginning of the first input range.
• last1 The end of the first input range.
• first2 The beginning of the second input range.
• last2 The end of the second input range.
• result The beginning of the output range.

Preconditions:

• The ranges [first1, last1) and [first2, last2) shall be sorted with respect to operator<.
• The resulting range shall not overlap with either input range.

Returns: The end of the output range.

See:

• https://en.cppreference.com/w/cpp/algorithm/set_union
• merge
• includes
• set_union
• set_intersection
• set_symmetric_difference
• sort
• is_sorted

Function thrust::set_union

template <typename DerivedPolicy,   typename InputIterator1,   typename InputIterator2,   typename OutputIterator,   typename StrictWeakCompare> __host__ __device__ OutputIterator set_union(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,   InputIterator1 first1,   InputIterator1 last1,   InputIterator2 first2,   InputIterator2 last2,   OutputIterator result,   StrictWeakCompare comp); 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.

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:

#include <thrust/set_operations.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
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}

Template Parameters:

• DerivedPolicy The name of the derived execution policy.
• InputIterator1 is a model of Input Iterator, InputIterator1'svalue_type is convertable to StrictWeakCompare'sfirst_argument_type. and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2'svalue_type is convertable to StrictWeakCompare'ssecond_argument_type. and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• OutputIterator is a model of Output Iterator.
• StrictWeakCompare is a model of Strict Weak Ordering.

Function Parameters:

• exec The execution policy to use for parallelization.
• first1 The beginning of the first input range.
• last1 The end of the first input range.
• first2 The beginning of the second input range.
• last2 The end of the second input range.
• result The beginning of the output range.
• comp Comparison operator.

Preconditions:

• The ranges [first1, last1) and [first2, last2) shall be sorted with respect to comp.
• The resulting range shall not overlap with either input range.

Returns: The end of the output range.

See:

• https://en.cppreference.com/w/cpp/algorithm/set_union
• merge
• includes
• set_union
• set_intersection
• set_symmetric_difference
• sort
• is_sorted

Function thrust::set_union

template <typename InputIterator1,   typename InputIterator2,   typename OutputIterator,   typename StrictWeakCompare> OutputIterator 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.

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

#include <thrust/set_operations.h>
#include <thrust/functional.h>
...
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}

Template Parameters:

• InputIterator1 is a model of Input Iterator, InputIterator1'svalue_type is convertable to StrictWeakCompare'sfirst_argument_type. and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2'svalue_type is convertable to StrictWeakCompare'ssecond_argument_type. and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• OutputIterator is a model of Output Iterator.
• StrictWeakCompare is a model of Strict Weak Ordering.

Function Parameters:

• first1 The beginning of the first input range.
• last1 The end of the first input range.
• first2 The beginning of the second input range.
• last2 The end of the second input range.
• result The beginning of the output range.
• comp Comparison operator.

Preconditions:

• The ranges [first1, last1) and [first2, last2) shall be sorted with respect to comp.
• The resulting range shall not overlap with either input range.

Returns: The end of the output range.

See:

• https://en.cppreference.com/w/cpp/algorithm/set_union
• merge
• includes
• set_union
• set_intersection
• set_symmetric_difference
• sort
• is_sorted

Function thrust::set_difference_by_key

template <typename DerivedPolicy,   typename InputIterator1,   typename InputIterator2,   typename InputIterator3,   typename InputIterator4,   typename OutputIterator1,   typename OutputIterator2> __host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > set_difference_by_key(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,   InputIterator1 keys_first1,   InputIterator1 keys_last1,   InputIterator2 keys_first2,   InputIterator2 keys_last2,   InputIterator3 values_first1,   InputIterator4 values_first2,   OutputIterator1 keys_result,   OutputIterator2 values_result); 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.

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:

#include <thrust/set_operations.h>
#include <thrust/execution_policy.h>
...
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}

Template Parameters:

• DerivedPolicy The name of the derived execution policy.
• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator3 is a model of Input Iterator, and InputIterator3'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• InputIterator4 is a model of Input Iterator, and InputIterator4'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• OutputIterator1 is a model of Output Iterator.
• OutputIterator2 is a model of Output Iterator.

Function Parameters:

• exec The execution policy to use for parallelization.
• keys_first1 The beginning of the first input range of keys.
• keys_last1 The end of the first input range of keys.
• keys_first2 The beginning of the second input range of keys.
• keys_last2 The end of the second input range of keys.
• values_first1 The beginning of the first input range of values.
• values_first2 The beginning of the first input range of values.
• keys_result The beginning of the output range of keys.
• values_result The beginning of the output range of values.

Preconditions:

• 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.

Returns: A pairp 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.

See:

• set_union_by_key
• set_intersection_by_key
• set_symmetric_difference_by_key
• sort_by_key
• is_sorted

Function thrust::set_difference_by_key

template <typename InputIterator1,   typename InputIterator2,   typename InputIterator3,   typename InputIterator4,   typename OutputIterator1,   typename OutputIterator2> thrust::pair< OutputIterator1, OutputIterator2 > set_difference_by_key(InputIterator1 keys_first1,   InputIterator1 keys_last1,   InputIterator2 keys_first2,   InputIterator2 keys_last2,   InputIterator3 values_first1,   InputIterator4 values_first2,   OutputIterator1 keys_result,   OutputIterator2 values_result); 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 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.

#include <thrust/set_operations.h>
...
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}

Template Parameters:

• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator3 is a model of Input Iterator, and InputIterator3'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• InputIterator4 is a model of Input Iterator, and InputIterator4'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• OutputIterator1 is a model of Output Iterator.
• OutputIterator2 is a model of Output Iterator.

Function Parameters:

• keys_first1 The beginning of the first input range of keys.
• keys_last1 The end of the first input range of keys.
• keys_first2 The beginning of the second input range of keys.
• keys_last2 The end of the second input range of keys.
• values_first1 The beginning of the first input range of values.
• values_first2 The beginning of the first input range of values.
• keys_result The beginning of the output range of keys.
• values_result The beginning of the output range of values.

Preconditions:

• 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.

Returns: A pairp 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.

See:

• set_union_by_key
• set_intersection_by_key
• set_symmetric_difference_by_key
• sort_by_key
• is_sorted

Function thrust::set_difference_by_key

template <typename DerivedPolicy,   typename InputIterator1,   typename InputIterator2,   typename InputIterator3,   typename InputIterator4,   typename OutputIterator1,   typename OutputIterator2,   typename StrictWeakCompare> __host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > set_difference_by_key(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,   InputIterator1 keys_first1,   InputIterator1 keys_last1,   InputIterator2 keys_first2,   InputIterator2 keys_last2,   InputIterator3 values_first1,   InputIterator4 values_first2,   OutputIterator1 keys_result,   OutputIterator2 values_result,   StrictWeakCompare comp); 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.

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:

#include <thrust/set_operations.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
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}

Template Parameters:

• DerivedPolicy The name of the derived execution policy.
• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator3 is a model of Input Iterator, and InputIterator3'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• InputIterator4 is a model of Input Iterator, and InputIterator4'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• OutputIterator1 is a model of Output Iterator.
• OutputIterator2 is a model of Output Iterator.
• StrictWeakCompare is a model of Strict Weak Ordering.

Function Parameters:

• exec The execution policy to use for parallelization.
• keys_first1 The beginning of the first input range of keys.
• keys_last1 The end of the first input range of keys.
• keys_first2 The beginning of the second input range of keys.
• keys_last2 The end of the second input range of keys.
• values_first1 The beginning of the first input range of values.
• values_first2 The beginning of the first input range of values.
• keys_result The beginning of the output range of keys.
• values_result The beginning of the output range of values.
• comp Comparison operator.

Preconditions:

• 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.

Returns: A pairp 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.

See:

• set_union_by_key
• set_intersection_by_key
• set_symmetric_difference_by_key
• sort_by_key
• is_sorted

Function thrust::set_difference_by_key

template <typename InputIterator1,   typename InputIterator2,   typename InputIterator3,   typename InputIterator4,   typename OutputIterator1,   typename OutputIterator2,   typename StrictWeakCompare> thrust::pair< OutputIterator1, OutputIterator2 > set_difference_by_key(InputIterator1 keys_first1,   InputIterator1 keys_last1,   InputIterator2 keys_first2,   InputIterator2 keys_last2,   InputIterator3 values_first1,   InputIterator4 values_first2,   OutputIterator1 keys_result,   OutputIterator2 values_result,   StrictWeakCompare comp); 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 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.

#include <thrust/set_operations.h>
#include <thrust/functional.h>
...
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}

Template Parameters:

• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator3 is a model of Input Iterator, and InputIterator3'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• InputIterator4 is a model of Input Iterator, and InputIterator4'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• OutputIterator1 is a model of Output Iterator.
• OutputIterator2 is a model of Output Iterator.
• StrictWeakCompare is a model of Strict Weak Ordering.

Function Parameters:

• keys_first1 The beginning of the first input range of keys.
• keys_last1 The end of the first input range of keys.
• keys_first2 The beginning of the second input range of keys.
• keys_last2 The end of the second input range of keys.
• values_first1 The beginning of the first input range of values.
• values_first2 The beginning of the first input range of values.
• keys_result The beginning of the output range of keys.
• values_result The beginning of the output range of values.
• comp Comparison operator.

Preconditions:

• 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.

Returns: A pairp 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.

See:

• set_union_by_key
• set_intersection_by_key
• set_symmetric_difference_by_key
• sort_by_key
• is_sorted

Function thrust::set_intersection_by_key

template <typename DerivedPolicy,   typename InputIterator1,   typename InputIterator2,   typename InputIterator3,   typename OutputIterator1,   typename OutputIterator2> __host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > set_intersection_by_key(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,   InputIterator1 keys_first1,   InputIterator1 keys_last1,   InputIterator2 keys_first2,   InputIterator2 keys_last2,   InputIterator3 values_first1,   OutputIterator1 keys_result,   OutputIterator2 values_result); 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.

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:

#include <thrust/set_operations.h>
#include <thrust/execution_policy.h>
...
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}

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:

• DerivedPolicy The name of the derived execution policy.
• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator3 is a model of Input Iterator, and InputIterator3'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• OutputIterator1 is a model of Output Iterator.
• OutputIterator2 is a model of Output Iterator.

Function Parameters:

• exec The execution policy to use for parallelization.
• keys_first1 The beginning of the first input range of keys.
• keys_last1 The end of the first input range of keys.
• keys_first2 The beginning of the second input range of keys.
• keys_last2 The end of the second input range of keys.
• values_first1 The beginning of the first input range of values.
• keys_result The beginning of the output range of keys.
• values_result The beginning of the output range of values.

Preconditions:

• 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.

Returns: A pairp 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.

See:

• set_union_by_key
• set_difference_by_key
• set_symmetric_difference_by_key
• sort_by_key
• is_sorted

Function thrust::set_intersection_by_key

template <typename InputIterator1,   typename InputIterator2,   typename InputIterator3,   typename OutputIterator1,   typename OutputIterator2> thrust::pair< OutputIterator1, OutputIterator2 > set_intersection_by_key(InputIterator1 keys_first1,   InputIterator1 keys_last1,   InputIterator2 keys_first2,   InputIterator2 keys_last2,   InputIterator3 values_first1,   OutputIterator1 keys_result,   OutputIterator2 values_result); 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 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.

#include <thrust/set_operations.h>
...
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}

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:

• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator3 is a model of Input Iterator, and InputIterator3'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• OutputIterator1 is a model of Output Iterator.
• OutputIterator2 is a model of Output Iterator.

Function Parameters:

• keys_first1 The beginning of the first input range of keys.
• keys_last1 The end of the first input range of keys.
• keys_first2 The beginning of the second input range of keys.
• keys_last2 The end of the second input range of keys.
• values_first1 The beginning of the first input range of values.
• keys_result The beginning of the output range of keys.
• values_result The beginning of the output range of values.

Preconditions:

• 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.

Returns: A pairp 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.

See:

• set_union_by_key
• set_difference_by_key
• set_symmetric_difference_by_key
• sort_by_key
• is_sorted

Function thrust::set_intersection_by_key

template <typename DerivedPolicy,   typename InputIterator1,   typename InputIterator2,   typename InputIterator3,   typename OutputIterator1,   typename OutputIterator2,   typename StrictWeakCompare> __host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > set_intersection_by_key(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,   InputIterator1 keys_first1,   InputIterator1 keys_last1,   InputIterator2 keys_first2,   InputIterator2 keys_last2,   InputIterator3 values_first1,   OutputIterator1 keys_result,   OutputIterator2 values_result,   StrictWeakCompare comp); 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.

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:

#include <thrust/set_operations.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
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}

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:

• DerivedPolicy The name of the derived execution policy.
• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator3 is a model of Input Iterator, and InputIterator3'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• OutputIterator1 is a model of Output Iterator.
• OutputIterator2 is a model of Output Iterator.
• StrictWeakCompare is a model of Strict Weak Ordering.

Function Parameters:

• exec The execution policy to use for parallelization.
• keys_first1 The beginning of the first input range of keys.
• keys_last1 The end of the first input range of keys.
• keys_first2 The beginning of the second input range of keys.
• keys_last2 The end of the second input range of keys.
• values_first1 The beginning of the first input range of values.
• keys_result The beginning of the output range of keys.
• values_result The beginning of the output range of values.
• comp Comparison operator.

Preconditions:

• 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.

Returns: A pairp 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.

See:

• set_union_by_key
• set_difference_by_key
• set_symmetric_difference_by_key
• sort_by_key
• is_sorted

Function thrust::set_intersection_by_key

template <typename InputIterator1,   typename InputIterator2,   typename InputIterator3,   typename OutputIterator1,   typename OutputIterator2,   typename StrictWeakCompare> thrust::pair< OutputIterator1, OutputIterator2 > set_intersection_by_key(InputIterator1 keys_first1,   InputIterator1 keys_last1,   InputIterator2 keys_first2,   InputIterator2 keys_last2,   InputIterator3 values_first1,   OutputIterator1 keys_result,   OutputIterator2 values_result,   StrictWeakCompare comp); 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 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.

#include <thrust/set_operations.h>
#include <thrust/functional.h>
...
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}

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:

• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator3 is a model of Input Iterator, and InputIterator3'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• OutputIterator1 is a model of Output Iterator.
• OutputIterator2 is a model of Output Iterator.
• StrictWeakCompare is a model of Strict Weak Ordering.

Function Parameters:

• keys_first1 The beginning of the first input range of keys.
• keys_last1 The end of the first input range of keys.
• keys_first2 The beginning of the second input range of keys.
• keys_last2 The end of the second input range of keys.
• values_first1 The beginning of the first input range of values.
• keys_result The beginning of the output range of keys.
• values_result The beginning of the output range of values.
• comp Comparison operator.

Preconditions:

• 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.

Returns: A pairp 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.

See:

• set_union_by_key
• set_difference_by_key
• set_symmetric_difference_by_key
• sort_by_key
• is_sorted

Function thrust::set_symmetric_difference_by_key

template <typename DerivedPolicy,   typename InputIterator1,   typename InputIterator2,   typename InputIterator3,   typename InputIterator4,   typename OutputIterator1,   typename OutputIterator2> __host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > set_symmetric_difference_by_key(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,   InputIterator1 keys_first1,   InputIterator1 keys_last1,   InputIterator2 keys_first2,   InputIterator2 keys_last2,   InputIterator3 values_first1,   InputIterator4 values_first2,   OutputIterator1 keys_result,   OutputIterator2 values_result); 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.

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:

#include <thrust/set_operations.h>
#include <thrust/execution_policy.h>
...
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}

Template Parameters:

• DerivedPolicy The name of the derived execution policy.
• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator3 is a model of Input Iterator, and InputIterator3'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• InputIterator4 is a model of Input Iterator, and InputIterator4'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• OutputIterator1 is a model of Output Iterator.
• OutputIterator2 is a model of Output Iterator.

Function Parameters:

• exec The execution policy to use for parallelization.
• keys_first1 The beginning of the first input range of keys.
• keys_last1 The end of the first input range of keys.
• keys_first2 The beginning of the second input range of keys.
• keys_last2 The end of the second input range of keys.
• values_first1 The beginning of the first input range of values.
• values_first2 The beginning of the first input range of values.
• keys_result The beginning of the output range of keys.
• values_result The beginning of the output range of values.

Preconditions:

• 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.

Returns: A pairp 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.

See:

• set_union_by_key
• set_intersection_by_key
• set_difference_by_key
• sort_by_key
• is_sorted

Function thrust::set_symmetric_difference_by_key

template <typename InputIterator1,   typename InputIterator2,   typename InputIterator3,   typename InputIterator4,   typename OutputIterator1,   typename OutputIterator2> thrust::pair< OutputIterator1, OutputIterator2 > set_symmetric_difference_by_key(InputIterator1 keys_first1,   InputIterator1 keys_last1,   InputIterator2 keys_first2,   InputIterator2 keys_last2,   InputIterator3 values_first1,   InputIterator4 values_first2,   OutputIterator1 keys_result,   OutputIterator2 values_result); 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 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.

#include <thrust/set_operations.h>
...
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}

Template Parameters:

• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator3 is a model of Input Iterator, and InputIterator3'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• InputIterator4 is a model of Input Iterator, and InputIterator4'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• OutputIterator1 is a model of Output Iterator.
• OutputIterator2 is a model of Output Iterator.

Function Parameters:

• keys_first1 The beginning of the first input range of keys.
• keys_last1 The end of the first input range of keys.
• keys_first2 The beginning of the second input range of keys.
• keys_last2 The end of the second input range of keys.
• values_first1 The beginning of the first input range of values.
• values_first2 The beginning of the first input range of values.
• keys_result The beginning of the output range of keys.
• values_result The beginning of the output range of values.

Preconditions:

• 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.

Returns: A pairp 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.

See:

• set_union_by_key
• set_intersection_by_key
• set_difference_by_key
• sort_by_key
• is_sorted

Function thrust::set_symmetric_difference_by_key

template <typename DerivedPolicy,   typename InputIterator1,   typename InputIterator2,   typename InputIterator3,   typename InputIterator4,   typename OutputIterator1,   typename OutputIterator2,   typename StrictWeakCompare> __host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > set_symmetric_difference_by_key(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,   InputIterator1 keys_first1,   InputIterator1 keys_last1,   InputIterator2 keys_first2,   InputIterator2 keys_last2,   InputIterator3 values_first1,   InputIterator4 values_first2,   OutputIterator1 keys_result,   OutputIterator2 values_result,   StrictWeakCompare comp); 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.

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:

#include <thrust/set_operations.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
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}

Template Parameters:

• DerivedPolicy The name of the derived execution policy.
• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator3 is a model of Input Iterator, and InputIterator3'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• InputIterator4 is a model of Input Iterator, and InputIterator4'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• OutputIterator1 is a model of Output Iterator.
• OutputIterator2 is a model of Output Iterator.
• StrictWeakCompare is a model of Strict Weak Ordering.

Function Parameters:

• exec The execution policy to use for parallelization.
• keys_first1 The beginning of the first input range of keys.
• keys_last1 The end of the first input range of keys.
• keys_first2 The beginning of the second input range of keys.
• keys_last2 The end of the second input range of keys.
• values_first1 The beginning of the first input range of values.
• values_first2 The beginning of the first input range of values.
• keys_result The beginning of the output range of keys.
• values_result The beginning of the output range of values.
• comp Comparison operator.

Preconditions:

• 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.

Returns: A pairp 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.

See:

• set_union_by_key
• set_intersection_by_key
• set_difference_by_key
• sort_by_key
• is_sorted

Function thrust::set_symmetric_difference_by_key

template <typename InputIterator1,   typename InputIterator2,   typename InputIterator3,   typename InputIterator4,   typename OutputIterator1,   typename OutputIterator2,   typename StrictWeakCompare> thrust::pair< OutputIterator1, OutputIterator2 > set_symmetric_difference_by_key(InputIterator1 keys_first1,   InputIterator1 keys_last1,   InputIterator2 keys_first2,   InputIterator2 keys_last2,   InputIterator3 values_first1,   InputIterator4 values_first2,   OutputIterator1 keys_result,   OutputIterator2 values_result,   StrictWeakCompare comp); 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 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.

#include <thrust/set_operations.h>
#include <thrust/functional.h>
...
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}

Template Parameters:

• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator3 is a model of Input Iterator, and InputIterator3'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• InputIterator4 is a model of Input Iterator, and InputIterator4'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• OutputIterator1 is a model of Output Iterator.
• OutputIterator2 is a model of Output Iterator.
• StrictWeakCompare is a model of Strict Weak Ordering.

Function Parameters:

• keys_first1 The beginning of the first input range of keys.
• keys_last1 The end of the first input range of keys.
• keys_first2 The beginning of the second input range of keys.
• keys_last2 The end of the second input range of keys.
• values_first1 The beginning of the first input range of values.
• values_first2 The beginning of the first input range of values.
• keys_result The beginning of the output range of keys.
• values_result The beginning of the output range of values.
• comp Comparison operator.

Preconditions:

• 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.

Returns: A pairp 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.

See:

• set_union_by_key
• set_intersection_by_key
• set_difference_by_key
• sort_by_key
• is_sorted

Function thrust::set_union_by_key

template <typename DerivedPolicy,   typename InputIterator1,   typename InputIterator2,   typename InputIterator3,   typename InputIterator4,   typename OutputIterator1,   typename OutputIterator2> __host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > set_union_by_key(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,   InputIterator1 keys_first1,   InputIterator1 keys_last1,   InputIterator2 keys_first2,   InputIterator2 keys_last2,   InputIterator3 values_first1,   InputIterator4 values_first2,   OutputIterator1 keys_result,   OutputIterator2 values_result); 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.

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:

#include <thrust/set_operations.h>
#include <thrust/execution_policy.h>
...
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}

Template Parameters:

• DerivedPolicy The name of the derived execution policy.
• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator3 is a model of Input Iterator, and InputIterator3'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• InputIterator4 is a model of Input Iterator, and InputIterator4'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• OutputIterator1 is a model of Output Iterator.
• OutputIterator2 is a model of Output Iterator.

Function Parameters:

• exec The execution policy to use for parallelization.
• keys_first1 The beginning of the first input range of keys.
• keys_last1 The end of the first input range of keys.
• keys_first2 The beginning of the second input range of keys.
• keys_last2 The end of the second input range of keys.
• values_first1 The beginning of the first input range of values.
• values_first2 The beginning of the first input range of values.
• keys_result The beginning of the output range of keys.
• values_result The beginning of the output range of values.

Preconditions:

• 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.

Returns: A pairp 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.

See:

• set_symmetric_difference_by_key
• set_intersection_by_key
• set_difference_by_key
• sort_by_key
• is_sorted

Function thrust::set_union_by_key

template <typename InputIterator1,   typename InputIterator2,   typename InputIterator3,   typename InputIterator4,   typename OutputIterator1,   typename OutputIterator2> thrust::pair< OutputIterator1, OutputIterator2 > set_union_by_key(InputIterator1 keys_first1,   InputIterator1 keys_last1,   InputIterator2 keys_first2,   InputIterator2 keys_last2,   InputIterator3 values_first1,   InputIterator4 values_first2,   OutputIterator1 keys_result,   OutputIterator2 values_result); 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 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.

#include <thrust/set_operations.h>
...
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}

Template Parameters:

• InputIterator1 is a model of Input Iterator, InputIterator1 and InputIterator2 have the same value_type, InputIterator1'svalue_type is a model of LessThan Comparable, the ordering on InputIterator1'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator1'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator2 is a model of Input Iterator, InputIterator2 and InputIterator1 have the same value_type, InputIterator2'svalue_type is a model of LessThan Comparable, the ordering on InputIterator2'svalue_type is a strict weak ordering, as defined in the LessThan Comparable requirements, and InputIterator2'svalue_type is convertable to a type in OutputIterator's set of value_types.
• InputIterator3 is a model of Input Iterator, and InputIterator3'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• InputIterator4 is a model of Input Iterator, and InputIterator4'svalue_type is convertible to a type in OutputIterator2's set of value_types.
• OutputIterator1 is a model of Output Iterator.
• OutputIterator2 is a model of Output Iterator.