Thrust

## ◆ set_symmetric_difference_by_key() [4/4]

template<typename InputIterator1 , typename InputIterator2 , typename InputIterator3 , typename InputIterator4 , typename OutputIterator1 , typename OutputIterator2 , typename StrictWeakCompare >
 thrust::pair thrust::set_symmetric_difference_by_key ( InputIterator1 keys_first1, InputIterator1 keys_last1, InputIterator2 keys_first2, InputIterator2 keys_last2, InputIterator3 values_first1, InputIterator4 values_first2, OutputIterator1 keys_result, OutputIterator2 values_result, StrictWeakCompare comp )

`set_symmetric_difference_by_key` performs a key-value symmetric difference operation from set theory. `set_difference_by_key` constructs a sorted range that is the symmetric difference of the sorted ranges `[keys_first1, keys_last1)` and `[keys_first2, keys_last2)`. Associated with each element from the input and output key ranges is a value element. The associated input value ranges need not be sorted.

In the simplest case, `set_symmetric_difference_by_key` performs a set theoretic calculation: it constructs the union of the two sets A - B and B - A, where A and B are the two input ranges. That is, the output range contains a copy of every element that is contained in `[keys_first1, keys_last1)` but not `[keys_first2, keys_last1)`, and a copy of every element that is contained in `[keys_first2, keys_last2)` but not `[keys_first1, keys_last1)`. The general case is more complicated, because the input ranges may contain duplicate elements. The generalization is that if `[keys_first1, keys_last1)` contains `m` elements that are equivalent to each other and `[keys_first2, keys_last1)` contains `n` elements that are equivalent to them, then `|m - n|` of those elements shall be copied to the output range: the last `m - n` elements from `[keys_first1, keys_last1)` if `m > n`, and the last `n - m` of these elements from `[keys_first2, keys_last2)` if `m < n`.

Each time a key element is copied from `[keys_first1, keys_last1)` or `[keys_first2, keys_last2)` is copied to the keys output range, the corresponding value element is copied from the corresponding values input range (beginning at `values_first1` or `values_first2`) to the values output range.

This version of `set_symmetric_difference_by_key` compares key elements using a function object `comp`.

Parameters
 keys_first1 The beginning of the first input range of keys. keys_last1 The end of the first input range of keys. keys_first2 The beginning of the second input range of keys. keys_last2 The end of the second input range of keys. values_first1 The beginning of the first input range of values. values_first2 The beginning of the first input range of values. keys_result The beginning of the output range of keys. values_result The beginning of the output range of values. comp Comparison operator.
Returns
A `pair` `p` such that `p.first` is the end of the output range of keys, and such that `p.second` is the end of the output range of values.
Template Parameters
 InputIterator1 is a model of Input Iterator, `InputIterator1` and `InputIterator2` have the same `value_type`, `InputIterator1's` `value_type` is a model of LessThan Comparable, the ordering on `InputIterator1's` `value_type` is a strict weak ordering, as defined in the LessThan Comparable requirements, and `InputIterator1's` `value_type` is convertable to a type in `OutputIterator's` set of `value_types`. InputIterator2 is a model of Input Iterator, `InputIterator2` and `InputIterator1` have the same `value_type`, `InputIterator2's` `value_type` is a model of LessThan Comparable, the ordering on `InputIterator2's` `value_type` is a strict weak ordering, as defined in the LessThan Comparable requirements, and `InputIterator2's` `value_type` is convertable to a type in `OutputIterator's` set of `value_types`. InputIterator3 is a model of Input Iterator, and `InputIterator3's` `value_type` is convertible to a type in `OutputIterator2's` set of `value_types`. InputIterator4 is a model of Input Iterator, and `InputIterator4's` `value_type` is convertible to a type in `OutputIterator2's` set of `value_types`. OutputIterator1 is a model of Output Iterator. OutputIterator2 is a model of Output Iterator. StrictWeakCompare is a model of Strict Weak Ordering.
Precondition
The ranges `[keys_first1, keys_last1)` and `[keys_first2, keys_last2)` shall be sorted with respect to `comp`.
The resulting ranges shall not overlap with any input range.

The following code snippet demonstrates how to use `set_symmetric_difference_by_key` to compute the symmetric difference of two sets of integers sorted in descending order with their values.

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