thrust::merge_by_key #

See also

See also

Parameters:

exec – The execution policy to use for parallelization.
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 merged output range of keys.
values_result – The beginning of the merged output range of values.

Template Parameters:

DerivedPolicy – The name of the derived execution policy.
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 convertible 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 convertible 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.

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.

Pre:

The ranges [keys_first1, keys_last1) and [keys_first2, keys_last2) shall be sorted with respect to operator<.

Pre:

The resulting ranges shall not overlap with any input range.

`merge_by_key(keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result)`#

template<typename InputIterator1, typename InputIterator2, typename InputIterator3, typename InputIterator4, typename OutputIterator1, typename OutputIterator2> thrust::pair<OutputIterator1, OutputIterator2> thrust::merge_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, )#

merge_by_key performs a key-value merge. That is, merge_by_key copies elements from [keys_first1, keys_last1) and [keys_first2, keys_last2) into a single range, [keys_result, keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2)) such that the resulting range is in ascending key order.

At the same time, merge_by_key copies elements from the two associated ranges [values_first1 + (keys_last1 - keys_first1)) and [values_first2 + (keys_last2 - keys_first2)) into a single range, [values_result, values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2)) such that the resulting range is in ascending order implied by each input element’s associated key.

merge_by_key is stable, meaning both that the relative order of elements within each input range is preserved, and that for equivalent elements in all input key ranges the element from the first range precedes the element from the second.

The return value is is (keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2)) and (values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2)).

The following code snippet demonstrates how to use merge_by_key to compute the merger of two sets of integers sorted in ascending order.

 #include <thrust/merge.h>
 #include <thrust/functional.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 B_vals[7] = {1, 1, 1, 1, 1, 1, 1};

 int keys_result[13];
 int vals_result[13];

 thrust::pair<int*,int*> end = thrust::merge_by_key(A_keys, A_keys + 6, B_keys, B_keys + 7, A_vals, B_vals,
keys_result, vals_result);

 // keys_result = {1, 1, 1, 2, 3, 3, 5, 5, 7, 8, 9, 11, 13}
 // vals_result = {0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,  0,  1}

See also

See also

See also

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 merged output range of keys.
values_result – The beginning of the merged 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 convertible 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 convertible 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.

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.

Pre:

The ranges [keys_first1, keys_last1) and [keys_first2, keys_last2) shall be sorted with respect to operator<.

Pre:

The resulting ranges shall not overlap with any input range.

`merge_by_key(exec, keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result, comp)`#

template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename InputIterator3, typename InputIterator4, typename OutputIterator1, typename OutputIterator2, typename Compare> thrust::pair<OutputIterator1, OutputIterator2> thrust::merge_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, Compare comp, )#

merge_by_key performs a key-value merge. That is, merge_by_key copies elements from [keys_first1, keys_last1) and [keys_first2, keys_last2) into a single range, [keys_result, keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2)) such that the resulting range is in ascending key order.

At the same time, merge_by_key copies elements from the two associated ranges [values_first1 + (keys_last1 - keys_first1)) and [values_first2 + (keys_last2 - keys_first2)) into a single range, [values_result, values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2)) such that the resulting range is in ascending order implied by each input element’s associated key.

merge_by_key is stable, meaning both that the relative order of elements within each input range is preserved, and that for equivalent elements in all input key ranges the element from the first range precedes the element from the second.

The return value is is (keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2)) and (values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2)).

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

The algorithm’s execution is parallelized using exec.

The following code snippet demonstrates how to use merge_by_key to compute the merger of two sets of integers sorted in descending order using the thrust::host execution policy for parallelization:

#include <thrust/merge.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 B_vals[7] = { 1, 1, 1, 1, 1, 1, 1};

int keys_result[13];
int vals_result[13];

thrust::pair<int*,int*> end =
  thrust::merge_by_key(thrust::host,
                       A_keys, A_keys + 6,
                       B_keys, B_keys + 7,
                       A_vals, B_vals,
                       keys_result, vals_result,
                       ::cuda::std::greater<int>());

// keys_result = {13, 11, 9, 8, 7, 5, 5, 3, 3, 2, 1, 1, 1}
// vals_result = { 1,  0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1}

See also

See also

See also

Parameters:

exec – The execution policy to use for parallelization.
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 merged output range of keys.
values_result – The beginning of the merged output range of values.
comp – Comparison operator.

Template Parameters:

DerivedPolicy – The name of the derived execution policy.
InputIterator1 – is a model of Input Iterator, InputIterator1's value_type is convertible to StrictWeakCompare's first argument type. and InputIterator1's value_type is convertible to a type in OutputIterator1's set of value_types.
InputIterator2 – is a model of Input Iterator, InputIterator2's value_type is convertible to StrictWeakCompare's second argument type. and InputIterator2's value_type is convertible to a type in OutputIterator1'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.

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.

Pre:

The ranges [keys_first1, keys_last1) and [keys_first2, keys_last2) shall be sorted with respect to comp.

Pre:

The resulting ranges shall not overlap with any input range.

`merge_by_key(keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result, comp)`#

template<typename InputIterator1, typename InputIterator2, typename InputIterator3, typename InputIterator4, typename OutputIterator1, typename OutputIterator2, typename StrictWeakCompare> thrust::pair<OutputIterator1, OutputIterator2> thrust::merge_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, )#

merge_by_key performs a key-value merge. That is, merge_by_key copies elements from [keys_first1, keys_last1) and [keys_first2, keys_last2) into a single range, [keys_result, keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2)) such that the resulting range is in ascending key order.

At the same time, merge_by_key copies elements from the two associated ranges [values_first1 + (keys_last1 - keys_first1)) and [values_first2 + (keys_last2 - keys_first2)) into a single range, [values_result, values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2)) such that the resulting range is in ascending order implied by each input element’s associated key.

merge_by_key is stable, meaning both that the relative order of elements within each input range is preserved, and that for equivalent elements in all input key ranges the element from the first range precedes the element from the second.

The return value is is (keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2)) and (values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2)).

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

The following code snippet demonstrates how to use merge_by_key to compute the merger of two sets of integers sorted in descending order.

 #include <thrust/merge.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 B_vals[7] = { 1, 1, 1, 1, 1, 1, 1};

 int keys_result[13];
 int vals_result[13];

 thrust::pair<int*,int*> end = thrust::merge_by_key(A_keys, A_keys + 6, B_keys, B_keys + 7, A_vals, B_vals,
keys_result, vals_result, ::cuda::std::greater<int>());

 // keys_result = {13, 11, 9, 8, 7, 5, 5, 3, 3, 2, 1, 1, 1}
 // vals_result = { 1,  0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1}

See also

See also

See also