thrust

◆ unique_by_key_copy() [3/4]

template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 , typename BinaryPredicate >
__host__ __device__ thrust::pair<OutputIterator1,OutputIterator2> thrust::unique_by_key_copy ( const thrust::detail::execution_policy_base< DerivedPolicy > &  exec,
InputIterator1  keys_first,
InputIterator1  keys_last,
InputIterator2  values_first,
OutputIterator1  keys_result,
OutputIterator2  values_result,
BinaryPredicate  binary_pred 
)

unique_by_key_copy is a generalization of unique_copy to key-value pairs. For each group of consecutive keys in the range [keys_first, keys_last) that are equal, unique_by_key_copy copies the first element of the group to a range beginning with keys_result and the corresponding values from the range [values_first, values_first + (keys_last - keys_first)) are copied to a range beginning with values_result.

This version of unique_by_key_copy uses the function object binary_pred to test for equality and project1st to reduce values with equal keys.

The algorithm's execution is parallelized as determined by exec.

Parameters
execThe execution policy to use for parallelization.
keys_firstThe beginning of the input key range.
keys_lastThe end of the input key range.
values_firstThe beginning of the input value range.
keys_resultThe beginning of the output key range.
values_resultThe beginning of the output value range.
binary_predThe binary predicate used to determine equality.
Returns
A pair of iterators at end of the ranges [keys_result, keys_result_last) and [values_result, values_result_last).
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIterator1is a model of Input Iterator,
InputIterator2is a model of Input Iterator,
OutputIterator1is a model of Output Iterator and and InputIterator1's value_type is convertible to OutputIterator1's value_type.
OutputIterator2is a model of Output Iterator and and InputIterator2's value_type is convertible to OutputIterator2's value_type.
BinaryPredicateis a model of Binary Predicate.
Precondition
The input ranges shall not overlap either output range.

The following code snippet demonstrates how to use unique_by_key_copy to compact a sequence of key/value pairs and with equal keys using the thrust::host execution policy for parallelization:

#include <thrust/unique.h>
...
const int N = 7;
int A[N] = {1, 3, 3, 3, 2, 2, 1}; // input keys
int B[N] = {9, 8, 7, 6, 5, 4, 3}; // input values
int C[N]; // output keys
int D[N]; // output values
new_end = thrust::unique_by_key_copy(thrust::host, A, A + N, B, C, D, binary_pred);
// The first four keys in C are now {1, 3, 2, 1} and new_end.first - C is 4.
// The first four values in D are now {9, 8, 5, 3} and new_end.second - D is 4.
See also
unique_copy
unique_by_key
reduce_by_key