# 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**:

The name of the derived execution policy.`DerivedPolicy`

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator`

**Function Parameters**:

The execution policy to use for parallelization.`exec`

The beginning of the first input range.`first1`

The end of the first input range.`last1`

The beginning of the second input range.`first2`

The end of the second input range.`last2`

The beginning of the output range.`result`

**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**:

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator`

**Function Parameters**:

The beginning of the first input range.`first1`

The end of the first input range.`last1`

The beginning of the second input range.`first2`

The end of the second input range.`last2`

The beginning of the output range.`result`

**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**:

The name of the derived execution policy.`DerivedPolicy`

is a model of Input Iterator,`InputIterator1`

`InputIterator1's`

`value_type`

is convertable to`StrictWeakCompare's`

`first_argument_type`

. and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2's`

`value_type`

is convertable to`StrictWeakCompare's`

`second_argument_type`

. and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator`

is a model of Strict Weak Ordering.`StrictWeakCompare`

**Function Parameters**:

The execution policy to use for parallelization.`exec`

The beginning of the first input range.`first1`

The end of the first input range.`last1`

The beginning of the second input range.`first2`

The end of the second input range.`last2`

The beginning of the output range.`result`

Comparison operator.`comp`

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

`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**:

is a model of Input Iterator,`InputIterator1`

`InputIterator1's`

`value_type`

is convertable to`StrictWeakCompare's`

`first_argument_type`

. and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2's`

`value_type`

is convertable to`StrictWeakCompare's`

`second_argument_type`

. and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator`

is a model of Strict Weak Ordering.`StrictWeakCompare`

**Function Parameters**:

The beginning of the first input range.`first1`

The end of the first input range.`last1`

The beginning of the second input range.`first2`

The end of the second input range.`last2`

The beginning of the output range.`result`

Comparison operator.`comp`

**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**:

The name of the derived execution policy.`DerivedPolicy`

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator`

**Function Parameters**:

The execution policy to use for parallelization.`exec`

The beginning of the first input range.`first1`

The end of the first input range.`last1`

The beginning of the second input range.`first2`

The end of the second input range.`last2`

The beginning of the output range.`result`

**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**:

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator`

**Function Parameters**:

The beginning of the first input range.`first1`

The end of the first input range.`last1`

The beginning of the second input range.`first2`

The end of the second input range.`last2`

The beginning of the output range.`result`

**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**:

The name of the derived execution policy.`DerivedPolicy`

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator`

**Function Parameters**:

The execution policy to use for parallelization.`exec`

The beginning of the first input range.`first1`

The end of the first input range.`last1`

The beginning of the second input range.`first2`

The end of the second input range.`last2`

The beginning of the output range.`result`

Comparison operator.`comp`

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

`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**:

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator`

**Function Parameters**:

The beginning of the first input range.`first1`

The end of the first input range.`last1`

The beginning of the second input range.`first2`

The end of the second input range.`last2`

The beginning of the output range.`result`

Comparison operator.`comp`

**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**:

The name of the derived execution policy.`DerivedPolicy`

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator`

**Function Parameters**:

The execution policy to use for parallelization.`exec`

The beginning of the first input range.`first1`

The end of the first input range.`last1`

The beginning of the second input range.`first2`

The end of the second input range.`last2`

The beginning of the output range.`result`

**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**:

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator`

**Function Parameters**:

The beginning of the first input range.`first1`

The end of the first input range.`last1`

The beginning of the second input range.`first2`

The end of the second input range.`last2`

The beginning of the output range.`result`

**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**:

The name of the derived execution policy.`DerivedPolicy`

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator`

**Function Parameters**:

The execution policy to use for parallelization.`exec`

The beginning of the first input range.`first1`

The end of the first input range.`last1`

The beginning of the second input range.`first2`

The end of the second input range.`last2`

The beginning of the output range.`result`

Comparison operator.`comp`

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

`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**:

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator`

**Function Parameters**:

The beginning of the first input range.`first1`

The end of the first input range.`last1`

The beginning of the second input range.`first2`

The end of the second input range.`last2`

The beginning of the output range.`result`

Comparison operator.`comp`

**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**:

The name of the derived execution policy.`DerivedPolicy`

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator`

**Function Parameters**:

The execution policy to use for parallelization.`exec`

The beginning of the first input range.`first1`

The end of the first input range.`last1`

The beginning of the second input range.`first2`

The end of the second input range.`last2`

The beginning of the output range.`result`

**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**:

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator`

**Function Parameters**:

The beginning of the first input range.`first1`

The end of the first input range.`last1`

The beginning of the second input range.`first2`

The end of the second input range.`last2`

The beginning of the output range.`result`

**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**:

The name of the derived execution policy.`DerivedPolicy`

is a model of Input Iterator,`InputIterator1`

`InputIterator1's`

`value_type`

is convertable to`StrictWeakCompare's`

`first_argument_type`

. and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2's`

`value_type`

is convertable to`StrictWeakCompare's`

`second_argument_type`

. and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator`

is a model of Strict Weak Ordering.`StrictWeakCompare`

**Function Parameters**:

The execution policy to use for parallelization.`exec`

The beginning of the first input range.`first1`

The end of the first input range.`last1`

The beginning of the second input range.`first2`

The end of the second input range.`last2`

The beginning of the output range.`result`

Comparison operator.`comp`

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

`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**:

is a model of Input Iterator,`InputIterator1`

`InputIterator1's`

`value_type`

is convertable to`StrictWeakCompare's`

`first_argument_type`

. and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2's`

`value_type`

is convertable to`StrictWeakCompare's`

`second_argument_type`

. and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator`

is a model of Strict Weak Ordering.`StrictWeakCompare`

**Function Parameters**:

The beginning of the first input range.`first1`

The end of the first input range.`last1`

The beginning of the second input range.`first2`

The end of the second input range.`last2`

The beginning of the output range.`result`

Comparison operator.`comp`

**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**:

The name of the derived execution policy.`DerivedPolicy`

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator3`

`InputIterator3's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator4`

`InputIterator4's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator1`

is a model of Output Iterator.`OutputIterator2`

**Function Parameters**:

The execution policy to use for parallelization.`exec`

The beginning of the first input range of keys.`keys_first1`

The end of the first input range of keys.`keys_last1`

The beginning of the second input range of keys.`keys_first2`

The end of the second input range of keys.`keys_last2`

The beginning of the first input range of values.`values_first1`

The beginning of the first input range of values.`values_first2`

The beginning of the output range of keys.`keys_result`

The beginning of the output range of values.`values_result`

**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 `pair`

`p`

such that `p.first`

is the end of the output range of keys, and such that `p.second`

is the end of the output range of values.

**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**:

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator3`

`InputIterator3's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator4`

`InputIterator4's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator1`

is a model of Output Iterator.`OutputIterator2`

**Function Parameters**:

The beginning of the first input range of keys.`keys_first1`

The end of the first input range of keys.`keys_last1`

The beginning of the second input range of keys.`keys_first2`

The end of the second input range of keys.`keys_last2`

The beginning of the first input range of values.`values_first1`

The beginning of the first input range of values.`values_first2`

The beginning of the output range of keys.`keys_result`

The beginning of the output range of values.`values_result`

**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 `pair`

`p`

such that `p.first`

is the end of the output range of keys, and such that `p.second`

is the end of the output range of values.

**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**:

The name of the derived execution policy.`DerivedPolicy`

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator3`

`InputIterator3's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator4`

`InputIterator4's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator1`

is a model of Output Iterator.`OutputIterator2`

is a model of Strict Weak Ordering.`StrictWeakCompare`

**Function Parameters**:

The execution policy to use for parallelization.`exec`

The beginning of the first input range of keys.`keys_first1`

The end of the first input range of keys.`keys_last1`

The beginning of the second input range of keys.`keys_first2`

The end of the second input range of keys.`keys_last2`

The beginning of the first input range of values.`values_first1`

The beginning of the first input range of values.`values_first2`

The beginning of the output range of keys.`keys_result`

The beginning of the output range of values.`values_result`

Comparison operator.`comp`

**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 `pair`

`p`

such that `p.first`

is the end of the output range of keys, and such that `p.second`

is the end of the output range of values.

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

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

`[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**:

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator3`

`InputIterator3's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator4`

`InputIterator4's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator1`

is a model of Output Iterator.`OutputIterator2`

is a model of Strict Weak Ordering.`StrictWeakCompare`

**Function Parameters**:

The beginning of the first input range of keys.`keys_first1`

The end of the first input range of keys.`keys_last1`

The beginning of the second input range of keys.`keys_first2`

The end of the second input range of keys.`keys_last2`

The beginning of the first input range of values.`values_first1`

The beginning of the first input range of values.`values_first2`

The beginning of the output range of keys.`keys_result`

The beginning of the output range of values.`values_result`

Comparison operator.`comp`

**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 `pair`

`p`

such that `p.first`

is the end of the output range of keys, and such that `p.second`

is the end of the output range of values.

**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**:

The name of the derived execution policy.`DerivedPolicy`

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator3`

`InputIterator3's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator1`

is a model of Output Iterator.`OutputIterator2`

**Function Parameters**:

The execution policy to use for parallelization.`exec`

The beginning of the first input range of keys.`keys_first1`

The end of the first input range of keys.`keys_last1`

The beginning of the second input range of keys.`keys_first2`

The end of the second input range of keys.`keys_last2`

The beginning of the first input range of values.`values_first1`

The beginning of the output range of keys.`keys_result`

The beginning of the output range of values.`values_result`

**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 `pair`

`p`

such that `p.first`

is the end of the output range of keys, and such that `p.second`

is the end of the output range of values.

**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**:

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator3`

`InputIterator3's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator1`

is a model of Output Iterator.`OutputIterator2`

**Function Parameters**:

The beginning of the first input range of keys.`keys_first1`

The end of the first input range of keys.`keys_last1`

The beginning of the second input range of keys.`keys_first2`

The end of the second input range of keys.`keys_last2`

The beginning of the first input range of values.`values_first1`

The beginning of the output range of keys.`keys_result`

The beginning of the output range of values.`values_result`

**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 `pair`

`p`

such that `p.first`

is the end of the output range of keys, and such that `p.second`

is the end of the output range of values.

**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**:

The name of the derived execution policy.`DerivedPolicy`

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator3`

`InputIterator3's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator1`

is a model of Output Iterator.`OutputIterator2`

is a model of Strict Weak Ordering.`StrictWeakCompare`

**Function Parameters**:

The execution policy to use for parallelization.`exec`

The beginning of the first input range of keys.`keys_first1`

The end of the first input range of keys.`keys_last1`

The beginning of the second input range of keys.`keys_first2`

The end of the second input range of keys.`keys_last2`

The beginning of the first input range of values.`values_first1`

The beginning of the output range of keys.`keys_result`

The beginning of the output range of values.`values_result`

Comparison operator.`comp`

**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 `pair`

`p`

such that `p.first`

is the end of the output range of keys, and such that `p.second`

is the end of the output range of values.

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

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

`[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**:

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator3`

`InputIterator3's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator1`

is a model of Output Iterator.`OutputIterator2`

is a model of Strict Weak Ordering.`StrictWeakCompare`

**Function Parameters**:

The beginning of the first input range of keys.`keys_first1`

The end of the first input range of keys.`keys_last1`

The beginning of the second input range of keys.`keys_first2`

The end of the second input range of keys.`keys_last2`

The beginning of the first input range of values.`values_first1`

The beginning of the output range of keys.`keys_result`

The beginning of the output range of values.`values_result`

Comparison operator.`comp`

**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 `pair`

`p`

such that `p.first`

is the end of the output range of keys, and such that `p.second`

is the end of the output range of values.

**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`

.

`[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**:

The name of the derived execution policy.`DerivedPolicy`

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator3`

`InputIterator3's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator4`

`InputIterator4's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator1`

is a model of Output Iterator.`OutputIterator2`

**Function Parameters**:

The execution policy to use for parallelization.`exec`

The beginning of the first input range of keys.`keys_first1`

The end of the first input range of keys.`keys_last1`

The beginning of the second input range of keys.`keys_first2`

The end of the second input range of keys.`keys_last2`

The beginning of the first input range of values.`values_first1`

The beginning of the first input range of values.`values_first2`

The beginning of the output range of keys.`keys_result`

The beginning of the output range of values.`values_result`

**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 `pair`

`p`

such that `p.first`

is the end of the output range of keys, and such that `p.second`

is the end of the output range of values.

**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`

.

`[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**:

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator3`

`InputIterator3's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator4`

`InputIterator4's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator1`

is a model of Output Iterator.`OutputIterator2`

**Function Parameters**:

The beginning of the first input range of keys.`keys_first1`

The end of the first input range of keys.`keys_last1`

The beginning of the second input range of keys.`keys_first2`

The end of the second input range of keys.`keys_last2`

The beginning of the first input range of values.`values_first1`

The beginning of the first input range of values.`values_first2`

The beginning of the output range of keys.`keys_result`

The beginning of the output range of values.`values_result`

**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 `pair`

`p`

such that `p.first`

is the end of the output range of keys, and such that `p.second`

is the end of the output range of values.

**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`

.

`[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**:

The name of the derived execution policy.`DerivedPolicy`

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator3`

`InputIterator3's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator4`

`InputIterator4's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator1`

is a model of Output Iterator.`OutputIterator2`

is a model of Strict Weak Ordering.`StrictWeakCompare`

**Function Parameters**:

The execution policy to use for parallelization.`exec`

The beginning of the first input range of keys.`keys_first1`

The end of the first input range of keys.`keys_last1`

The beginning of the second input range of keys.`keys_first2`

The end of the second input range of keys.`keys_last2`

The beginning of the first input range of values.`values_first1`

The beginning of the first input range of values.`values_first2`

The beginning of the output range of keys.`keys_result`

The beginning of the output range of values.`values_result`

Comparison operator.`comp`

**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 `pair`

`p`

such that `p.first`

is the end of the output range of keys, and such that `p.second`

is the end of the output range of values.

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

`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`

.

`[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**:

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator3`

`InputIterator3's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator4`

`InputIterator4's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator1`

is a model of Output Iterator.`OutputIterator2`

is a model of Strict Weak Ordering.`StrictWeakCompare`

**Function Parameters**:

The beginning of the first input range of keys.`keys_first1`

The end of the first input range of keys.`keys_last1`

The beginning of the second input range of keys.`keys_first2`

The end of the second input range of keys.`keys_last2`

The beginning of the first input range of values.`values_first1`

The beginning of the first input range of values.`values_first2`

The beginning of the output range of keys.`keys_result`

The beginning of the output range of values.`values_result`

Comparison operator.`comp`

**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 `pair`

`p`

such that `p.first`

is the end of the output range of keys, and such that `p.second`

is the end of the output range of values.

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

`[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**:

The name of the derived execution policy.`DerivedPolicy`

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator3`

`InputIterator3's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator4`

`InputIterator4's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator1`

is a model of Output Iterator.`OutputIterator2`

**Function Parameters**:

The execution policy to use for parallelization.`exec`

The beginning of the first input range of keys.`keys_first1`

The end of the first input range of keys.`keys_last1`

The beginning of the second input range of keys.`keys_first2`

The end of the second input range of keys.`keys_last2`

The beginning of the first input range of values.`values_first1`

The beginning of the first input range of values.`values_first2`

The beginning of the output range of keys.`keys_result`

The beginning of the output range of values.`values_result`

**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 `pair`

`p`

such that `p.first`

is the end of the output range of keys, and such that `p.second`

is the end of the output range of values.

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

`[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**:

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator3`

`InputIterator3's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator4`

`InputIterator4's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator1`

is a model of Output Iterator.`OutputIterator2`

**Function Parameters**:

The beginning of the first input range of keys.`keys_first1`

The end of the first input range of keys.`keys_last1`

The beginning of the second input range of keys.`keys_first2`

The end of the second input range of keys.`keys_last2`

The beginning of the first input range of values.`values_first1`

The beginning of the first input range of values.`values_first2`

The beginning of the output range of keys.`keys_result`

The beginning of the output range of values.`values_result`

**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 `pair`

`p`

such that `p.first`

is the end of the output range of keys, and such that `p.second`

is the end of the output range of values.

**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 DerivedPolicy, typename InputIterator1, typename InputIterator2, typename InputIterator3, typename InputIterator4, typename OutputIterator1, typename OutputIterator2, typename StrictWeakCompare> __host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 > `

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

`[keys_first1, keys_last1)`

or `[keys_first2, keys_last2)`

is copied to the keys output range, the corresponding value element is copied from the corresponding values input range (beginning at `values_first1`

or `values_first2`

) to the values output range.

This version of `set_union_by_key`

compares key elements using a function object `comp`

.

The algorithm’s execution is parallelized as determined by `exec`

.

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

**Template Parameters**:

The name of the derived execution policy.`DerivedPolicy`

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator3`

`InputIterator3's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator4`

`InputIterator4's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator1`

is a model of Output Iterator.`OutputIterator2`

is a model of Strict Weak Ordering.`StrictWeakCompare`

**Function Parameters**:

The execution policy to use for parallelization.`exec`

The beginning of the first input range of keys.`keys_first1`

The end of the first input range of keys.`keys_last1`

The beginning of the second input range of keys.`keys_first2`

The end of the second input range of keys.`keys_last2`

The beginning of the first input range of values.`values_first1`

The beginning of the first input range of values.`values_first2`

The beginning of the output range of keys.`keys_result`

The beginning of the output range of values.`values_result`

Comparison operator.`comp`

**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 `pair`

`p`

such that `p.first`

is the end of the output range of keys, and such that `p.second`

is the end of the output range of values.

**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, typename StrictWeakCompare> thrust::pair< OutputIterator1, OutputIterator2 > `

**set_union_by_key**(InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, InputIterator4 values_first2, OutputIterator1 keys_result, OutputIterator2 values_result, StrictWeakCompare comp);`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.

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

`[keys_first1, keys_last1)`

or `[keys_first2, keys_last2)`

is copied to the keys output range, the corresponding value element is copied from the corresponding values input range (beginning at `values_first1`

or `values_first2`

) to the values output range.

This version of `set_union_by_key`

compares key elements using a function object `comp`

.

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

**Template Parameters**:

is a model of Input Iterator,`InputIterator1`

`InputIterator1`

and`InputIterator2`

have the same`value_type`

,`InputIterator1's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator1's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator1's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator,`InputIterator2`

`InputIterator2`

and`InputIterator1`

have the same`value_type`

,`InputIterator2's`

`value_type`

is a model of LessThan Comparable, the ordering on`InputIterator2's`

`value_type`

is a strict weak ordering, as defined in the LessThan Comparable requirements, and`InputIterator2's`

`value_type`

is convertable to a type in`OutputIterator's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator3`

`InputIterator3's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Input Iterator, and`InputIterator4`

`InputIterator4's`

`value_type`

is convertible to a type in`OutputIterator2's`

set of`value_types`

.is a model of Output Iterator.`OutputIterator1`

is a model of Output Iterator.`OutputIterator2`

is a model of Strict Weak Ordering.`StrictWeakCompare`

**Function Parameters**:

The beginning of the first input range of keys.`keys_first1`

The end of the first input range of keys.`keys_last1`

The beginning of the second input range of keys.`keys_first2`

The end of the second input range of keys.`keys_last2`

The beginning of the first input range of values.`values_first1`

The beginning of the first input range of values.`values_first2`

The beginning of the output range of keys.`keys_result`

The beginning of the output range of values.`values_result`

Comparison operator.`comp`

**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 `pair`

`p`

such that `p.first`

is the end of the output range of keys, and such that `p.second`

is the end of the output range of values.

**See**:

`set_symmetric_difference_by_key`

`set_intersection_by_key`

`set_difference_by_key`

`sort_by_key`

`is_sorted`