Template Function thrust::unique_by_key_copy(InputIterator1, InputIterator1, InputIterator2, OutputIterator1, OutputIterator2)

Function Documentation

template<typename InputIterator1, typename InputIterator2, typename OutputIterator1, typename OutputIterator2>
thrust::pair<OutputIterator1, OutputIterator2> thrust::unique_by_key_copy(InputIterator1 keys_first, InputIterator1 keys_last, InputIterator2 values_first, OutputIterator1 keys_result, OutputIterator2 values_result)

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 operator== to test for equality and project1st to reduce values with equal keys.

The following code snippet demonstrates how to use

unique_by_key_copy to compact a sequence of key/value pairs and with equal keys.
Return

A pair of iterators at end of the ranges [keys_result, keys_result_last) and [values_result, values_result_last).

Pre

The input ranges shall not overlap either output range.

Parameters

  • keys_first: The beginning of the input key range.

  • keys_last: The end of the input key range.

  • values_first: The beginning of the input value range.

  • keys_result: The beginning of the output key range.

  • values_result: The beginning of the output value range.

Template Parameters

  • InputIterator1: is a model of Input Iterator,

  • InputIterator2: is a model of Input Iterator,

  • OutputIterator1: is a model of Output Iterator and and InputIterator1's value_type is convertible to OutputIterator1's value_type.

  • OutputIterator2: is a model of Output Iterator and and InputIterator2's value_type is convertible to OutputIterator2's value_type.

#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

thrust::pair<int*,int*> new_end;
new_end = thrust::unique_by_key_copy(A, A + N, B, C, D);

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

unique_copy

See

unique_by_key

See

reduce_by_key