Thrust

◆ reduce_by_key() [1/6]

template<typename DerivedPolicy , typename InputIterator1 , typename InputIterator2 , typename OutputIterator1 , typename OutputIterator2 >
__host__ __device__ thrust::pair<OutputIterator1,OutputIterator2> thrust::reduce_by_key ( const thrust::detail::execution_policy_base< DerivedPolicy > &  exec,
InputIterator1  keys_first,
InputIterator1  keys_last,
InputIterator2  values_first,
OutputIterator1  keys_output,
OutputIterator2  values_output 
)

reduce_by_key is a generalization of reduce to key-value pairs. For each group of consecutive keys in the range [keys_first, keys_last) that are equal, reduce_by_key copies the first element of the group to the keys_output. The corresponding values in the range are reduced using the plus and the result copied to values_output.

This version of reduce_by_key uses the function object equal_to to test for equality and plus 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_outputThe beginning of the output key range.
values_outputThe beginning of the output value range.
Returns
A pair of iterators at end of the ranges [keys_output, keys_output_last) and [values_output, values_output_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.
Precondition
The input ranges shall not overlap either output range.

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

#include <thrust/reduce.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::reduce_by_key(thrust::host, 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, 21, 9, 3} and new_end.second - D is 4.
See also
reduce
unique_copy
unique_by_key
unique_by_key_copy