GOSTSec
/
ccminer
mirror of https://github.com/GOSTSec/ccminer
1
0
Fork 0
Code Issues Releases Wiki Activity
GOSTcoin support for ccminer CUDA miner project, compatible with most nvidia cards
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
202 Commits
2 Branches
52 Tags
66 MiB
 
 
 
 
 
Tree: e40a7a720c
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'e40a7a720c'
${ noResults }
ccminer/compat/thrust/unique.h

960 lines
45 KiB
Raw Blame History

/*
* Copyright 2008-2012 NVIDIA Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*! \file unique.h
* \brief Move unique elements to the front of a range
*/
#pragma once
#include <thrust/detail/config.h>
#include <thrust/detail/execution_policy.h>
#include <thrust/pair.h>
namespace thrust
{
/*! \addtogroup stream_compaction
* \{
*/
/*! For each group of consecutive elements in the range <tt>[first, last)</tt>
* with the same value, \p unique removes all but the first element of
* the group. The return value is an iterator \c new_last such that
* no two consecutive elements in the range <tt>[first, new_last)</tt> are
* equal. The iterators in the range <tt>[new_last, last)</tt> are all still
* dereferenceable, but the elements that they point to are unspecified.
* \p unique is stable, meaning that the relative order of elements that are
* not removed is unchanged.
*
* This version of \p unique uses \c operator== to test for equality.
*
* The algorithm's execution is parallelized as determined by \p exec.
*
* \param exec The execution policy to use for parallelization.
* \param first The beginning of the input range.
* \param last The end of the input range.
* \return The end of the unique range <tt>[first, new_last)</tt>.
*
* \tparam DerivedPolicy The name of the derived execution policy.
* \tparam ForwardIterator is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>,
* and \p ForwardIterator is mutable,
* and \p ForwardIterator's \c value_type is a model of <a href="http://www.sgi.com/tech/stl/EqualityComparable.html">Equality Comparable</a>.
*
* The following code snippet demonstrates how to use \p unique to
* compact a sequence of numbers to remove consecutive duplicates using the \p thrust::host execution policy
* for parallelization:
*
* \code
* #include <thrust/unique.h>
* #include <thrust/execution_policy.h>
* ...
* const int N = 7;
* int A[N] = {1, 3, 3, 3, 2, 2, 1};
* int *new_end = thrust::unique(thrust::host, A, A + N);
* // The first four values of A are now {1, 3, 2, 1}
* // Values beyond new_end are unspecified.
* \endcode
*
* \see http://www.sgi.com/tech/stl/unique.html
* \see unique_copy
*/
template<typename DerivedPolicy,
typename ForwardIterator>
ForwardIterator unique(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
ForwardIterator first,
ForwardIterator last);
/*! For each group of consecutive elements in the range <tt>[first, last)</tt>
* with the same value, \p unique removes all but the first element of
* the group. The return value is an iterator \c new_last such that
* no two consecutive elements in the range <tt>[first, new_last)</tt> are
* equal. The iterators in the range <tt>[new_last, last)</tt> are all still
* dereferenceable, but the elements that they point to are unspecified.
* \p unique is stable, meaning that the relative order of elements that are
* not removed is unchanged.
*
* This version of \p unique uses \c operator== to test for equality.
*
* \param first The beginning of the input range.
* \param last The end of the input range.
* \return The end of the unique range <tt>[first, new_last)</tt>.
*
* \tparam ForwardIterator is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>,
* and \p ForwardIterator is mutable,
* and \p ForwardIterator's \c value_type is a model of <a href="http://www.sgi.com/tech/stl/EqualityComparable.html">Equality Comparable</a>.
*
* The following code snippet demonstrates how to use \p unique to
* compact a sequence of numbers to remove consecutive duplicates.
*
* \code
* #include <thrust/unique.h>
* ...
* const int N = 7;
* int A[N] = {1, 3, 3, 3, 2, 2, 1};
* int *new_end = thrust::unique(A, A + N);
* // The first four values of A are now {1, 3, 2, 1}
* // Values beyond new_end are unspecified.
* \endcode
*
* \see http://www.sgi.com/tech/stl/unique.html
* \see unique_copy
*/
template <typename ForwardIterator>
ForwardIterator unique(ForwardIterator first,
ForwardIterator last);
/*! For each group of consecutive elements in the range <tt>[first, last)</tt>
* with the same value, \p unique removes all but the first element of
* the group. The return value is an iterator \c new_last such that
* no two consecutive elements in the range <tt>[first, new_last)</tt> are
* equal. The iterators in the range <tt>[new_last, last)</tt> are all still
* dereferenceable, but the elements that they point to are unspecified.
* \p unique is stable, meaning that the relative order of elements that are
* not removed is unchanged.
*
* This version of \p unique uses the function object \p binary_pred to test
* for equality.
*
* The algorithm's execution is parallelized as determined by \p exec.
*
* \param exec The execution policy to use for parallelization.
* \param first The beginning of the input range.
* \param last The end of the input range.
* \param binary_pred The binary predicate used to determine equality.
* \return The end of the unique range <tt>[first, new_last)</tt>
*
* \tparam DerivedPolicy The name of the derived execution policy.
* \tparam ForwardIterator is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>,
* and \p ForwardIterator is mutable,
* and \p ForwardIterator's \c value_type is convertible to \p BinaryPredicate's \c first_argument_type and to \p BinaryPredicate's \c second_argument_type.
* \tparam BinaryPredicate is a model of <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary Predicate</a>.
*
* The following code snippet demonstrates how to use \p unique to
* compact a sequence of numbers to remove consecutive duplicates using the \p thrust::host execution policy
* for parallelization:
*
* \code
* #include <thrust/unique.h>
* #include <thrust/execution_policy.h>
* ...
* const int N = 7;
* int A[N] = {1, 3, 3, 3, 2, 2, 1};
* int *new_end = thrust::unique(thrust::host, A, A + N, thrust::equal_to<int>());
* // The first four values of A are now {1, 3, 2, 1}
* // Values beyond new_end are unspecified.
* \endcode
*
* \see http://www.sgi.com/tech/stl/unique.html
* \see unique_copy
*/
template<typename DerivedPolicy,
typename ForwardIterator,
typename BinaryPredicate>
ForwardIterator unique(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
ForwardIterator first,
ForwardIterator last,
BinaryPredicate binary_pred);
/*! For each group of consecutive elements in the range <tt>[first, last)</tt>
* with the same value, \p unique removes all but the first element of
* the group. The return value is an iterator \c new_last such that
* no two consecutive elements in the range <tt>[first, new_last)</tt> are
* equal. The iterators in the range <tt>[new_last, last)</tt> are all still
* dereferenceable, but the elements that they point to are unspecified.
* \p unique is stable, meaning that the relative order of elements that are
* not removed is unchanged.
*
* This version of \p unique uses the function object \p binary_pred to test
* for equality.
*
* \param first The beginning of the input range.
* \param last The end of the input range.
* \param binary_pred The binary predicate used to determine equality.
* \return The end of the unique range <tt>[first, new_last)</tt>
*
* \tparam ForwardIterator is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>,
* and \p ForwardIterator is mutable,
* and \p ForwardIterator's \c value_type is convertible to \p BinaryPredicate's \c first_argument_type and to \p BinaryPredicate's \c second_argument_type.
* \tparam BinaryPredicate is a model of <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary Predicate</a>.
*
* The following code snippet demonstrates how to use \p unique to
* compact a sequence of numbers to remove consecutive duplicates.
*
* \code
* #include <thrust/unique.h>
* ...
* const int N = 7;
* int A[N] = {1, 3, 3, 3, 2, 2, 1};
* int *new_end = thrust::unique(A, A + N, thrust::equal_to<int>());
* // The first four values of A are now {1, 3, 2, 1}
* // Values beyond new_end are unspecified.
* \endcode
*
* \see http://www.sgi.com/tech/stl/unique.html
* \see unique_copy
*/
template <typename ForwardIterator,
typename BinaryPredicate>
ForwardIterator unique(ForwardIterator first,
ForwardIterator last,
BinaryPredicate binary_pred);
/*! \p unique_copy copies elements from the range <tt>[first, last)</tt>
* to a range beginning with \p result, except that in a consecutive group
* of duplicate elements only the first one is copied. The return value
* is the end of the range to which the elements are copied.
*
* The reason there are two different versions of unique_copy is that there
* are two different definitions of what it means for a consecutive group of
* elements to be duplicates. In the first version, the test is simple
* equality: the elements in a range <tt>[f, l)</tt> are duplicates if,
* for every iterator \p i in the range, either <tt>i == f</tt> or else
* <tt>*i == *(i-1)</tt>. In the second, the test is an arbitrary
* \p BinaryPredicate \p binary_pred: the elements in <tt>[f, l)</tt> are
* duplicates if, for every iterator \p i in the range, either <tt>i == f</tt>
* or else <tt>binary_pred(*i, *(i-1))</tt> is \p true.
*
* This version of \p unique_copy uses \c operator== to test for equality.
*
* The algorithm's execution is parallelized as determined by \p exec.
*
* \param exec The execution policy to use for parallelization.
* \param first The beginning of the input range.
* \param last The end of the input range.
* \param result The beginning of the output range.
* \return The end of the unique range <tt>[result, result_end)</tt>.
*
* \tparam DerivedPolicy The name of the derived execution policy.
* \tparam InputIterator is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>,
* and \p InputIterator's \c value_type is a model of <a href="http://www.sgi.com/tech/stl/EqualityComparable.html">Equality Comparable</a>.
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a> and
* and \p InputIterator's \c value_type is convertible to \c OutputIterator's \c value_type.
*
* \pre The range <tt>[first,last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap.
*
* The following code snippet demonstrates how to use \p unique_copy to
* compact a sequence of numbers to remove consecutive duplicates using the \p thrust::host execution
* policy for parallelization:
*
* \code
* #include <thrust/unique.h>
* #include <thrust/execution_policy.h>
* ...
* const int N = 7;
* int A[N] = {1, 3, 3, 3, 2, 2, 1};
* int B[N];
* int *result_end = thrust::unique_copy(thrust::host, A, A + N, B);
* // The first four values of B are now {1, 3, 2, 1} and (result_end - B) is 4
* // Values beyond result_end are unspecified
* \endcode
*
* \see unique
* \see http://www.sgi.com/tech/stl/unique_copy.html
*/
template<typename DerivedPolicy,
typename InputIterator,
typename OutputIterator>
OutputIterator unique_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
InputIterator first,
InputIterator last,
OutputIterator result);
/*! \p unique_copy copies elements from the range <tt>[first, last)</tt>
* to a range beginning with \p result, except that in a consecutive group
* of duplicate elements only the first one is copied. The return value
* is the end of the range to which the elements are copied.
*
* The reason there are two different versions of unique_copy is that there
* are two different definitions of what it means for a consecutive group of
* elements to be duplicates. In the first version, the test is simple
* equality: the elements in a range <tt>[f, l)</tt> are duplicates if,
* for every iterator \p i in the range, either <tt>i == f</tt> or else
* <tt>*i == *(i-1)</tt>. In the second, the test is an arbitrary
* \p BinaryPredicate \p binary_pred: the elements in <tt>[f, l)</tt> are
* duplicates if, for every iterator \p i in the range, either <tt>i == f</tt>
* or else <tt>binary_pred(*i, *(i-1))</tt> is \p true.
*
* This version of \p unique_copy uses \c operator== to test for equality.
*
* \param first The beginning of the input range.
* \param last The end of the input range.
* \param result The beginning of the output range.
* \return The end of the unique range <tt>[result, result_end)</tt>.
*
* \tparam InputIterator is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>,
* and \p InputIterator's \c value_type is a model of <a href="http://www.sgi.com/tech/stl/EqualityComparable.html">Equality Comparable</a>.
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a> and
* and \p InputIterator's \c value_type is convertible to \c OutputIterator's \c value_type.
*
* \pre The range <tt>[first,last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap.
*
* The following code snippet demonstrates how to use \p unique_copy to
* compact a sequence of numbers to remove consecutive duplicates.
*
* \code
* #include <thrust/unique.h>
* ...
* const int N = 7;
* int A[N] = {1, 3, 3, 3, 2, 2, 1};
* int B[N];
* int *result_end = thrust::unique_copy(A, A + N, B);
* // The first four values of B are now {1, 3, 2, 1} and (result_end - B) is 4
* // Values beyond result_end are unspecified
* \endcode
*
* \see unique
* \see http://www.sgi.com/tech/stl/unique_copy.html
*/
template <typename InputIterator,
typename OutputIterator>
OutputIterator unique_copy(InputIterator first,
InputIterator last,
OutputIterator result);
/*! \p unique_copy copies elements from the range <tt>[first, last)</tt>
* to a range beginning with \p result, except that in a consecutive group
* of duplicate elements only the first one is copied. The return value
* is the end of the range to which the elements are copied.
*
* This version of \p unique_copy uses the function object \c binary_pred
* to test for equality.
*
* The algorithm's execution is parallelized as determined by \p exec.
*
* \param exec The execution policy to use for parallelization.
* \param first The beginning of the input range.
* \param last The end of the input range.
* \param result The beginning of the output range.
* \param binary_pred The binary predicate used to determine equality.
* \return The end of the unique range <tt>[result, result_end)</tt>.
*
* \tparam DerivedPolicy The name of the derived execution policy.
* \tparam InputIterator is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>,
* and \p InputIterator's \c value_type is a model of <a href="http://www.sgi.com/tech/stl/EqualityComparable.html">Equality Comparable</a>.
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a> and
* and \p InputIterator's \c value_type is convertible to \c OutputIterator's \c value_type.
* \tparam BinaryPredicate is a model of <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary Predicate</a>.
*
* \pre The range <tt>[first,last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap.
*
* The following code snippet demonstrates how to use \p unique_copy to
* compact a sequence of numbers to remove consecutive duplicates using the \p thrust::host execution
* policy for parallelization:
*
* \code
* #include <thrust/unique.h>
* #include <thrust/execution_policy.h>
* ...
* const int N = 7;
* int A[N] = {1, 3, 3, 3, 2, 2, 1};
* int B[N];
* int *result_end = thrust::unique_copy(thrust::host, A, A + N, B, thrust::equal_to<int>());
* // The first four values of B are now {1, 3, 2, 1} and (result_end - B) is 4
* // Values beyond result_end are unspecified.
* \endcode
*
* \see unique
* \see http://www.sgi.com/tech/stl/unique_copy.html
*/
template<typename DerivedPolicy,
typename InputIterator,
typename OutputIterator,
typename BinaryPredicate>
OutputIterator unique_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
InputIterator first,
InputIterator last,
OutputIterator result,
BinaryPredicate binary_pred);
/*! \p unique_copy copies elements from the range <tt>[first, last)</tt>
* to a range beginning with \p result, except that in a consecutive group
* of duplicate elements only the first one is copied. The return value
* is the end of the range to which the elements are copied.
*
* This version of \p unique_copy uses the function object \c binary_pred
* to test for equality.
*
* \param first The beginning of the input range.
* \param last The end of the input range.
* \param result The beginning of the output range.
* \param binary_pred The binary predicate used to determine equality.
* \return The end of the unique range <tt>[result, result_end)</tt>.
*
* \tparam InputIterator is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>,
* and \p InputIterator's \c value_type is a model of <a href="http://www.sgi.com/tech/stl/EqualityComparable.html">Equality Comparable</a>.
* \tparam OutputIterator is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a> and
* and \p InputIterator's \c value_type is convertible to \c OutputIterator's \c value_type.
* \tparam BinaryPredicate is a model of <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary Predicate</a>.
*
* \pre The range <tt>[first,last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap.
*
* The following code snippet demonstrates how to use \p unique_copy to
* compact a sequence of numbers to remove consecutive duplicates.
*
* \code
* #include <thrust/unique.h>
* ...
* const int N = 7;
* int A[N] = {1, 3, 3, 3, 2, 2, 1};
* int B[N];
* int *result_end = thrust::unique_copy(A, A + N, B, thrust::equal_to<int>());
* // The first four values of B are now {1, 3, 2, 1} and (result_end - B) is 4
* // Values beyond result_end are unspecified.
* \endcode
*
* \see unique
* \see http://www.sgi.com/tech/stl/unique_copy.html
*/
template <typename InputIterator,
typename OutputIterator,
typename BinaryPredicate>
OutputIterator unique_copy(InputIterator first,
InputIterator last,
OutputIterator result,
BinaryPredicate binary_pred);
/*! \p unique_by_key is a generalization of \p unique to key-value pairs.
* For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
* that are equal, \p unique_by_key removes all but the first element of
* the group. Similarly, the corresponding values in the range
* <tt>[values_first, values_first + (keys_last - keys_first))</tt>
* are also removed.
*
* The return value is a \p pair of iterators <tt>(new_keys_last,new_values_last)</tt>
* such that no two consecutive elements in the range <tt>[keys_first, new_keys_last)</tt>
* are equal.
*
* This version of \p unique_by_key uses \c operator== to test for equality and
* \c project1st to reduce values with equal keys.
*
* The algorithm's execution is parallelized as determined by \p exec.
*
* \param exec The execution policy to use for parallelization.
* \param keys_first The beginning of the key range.
* \param keys_last The end of the key range.
* \param values_first The beginning of the value range.
* \return A pair of iterators at end of the ranges <tt>[key_first, keys_new_last)</tt> and <tt>[values_first, values_new_last)</tt>.
*
* \tparam DerivedPolicy The name of the derived execution policy.
* \tparam ForwardIterator1 is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>,
* and \p ForwardIterator1 is mutable,
* and \p ForwardIterator's \c value_type is a model of <a href="http://www.sgi.com/tech/stl/EqualityComparable.html">Equality Comparable</a>.
* \tparam ForwardIterator2 is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>,
* and \p ForwardIterator2 is mutable.
*
* \pre The range <tt>[keys_first, keys_last)</tt> and the range <tt>[values_first, values_first + (keys_last - keys_first))</tt> shall not overlap.
*
* The following code snippet demonstrates how to use \p unique_by_key to
* compact a sequence of key/value pairs to remove consecutive duplicates using the \p thrust::host
* execution policy for parallelization:
*
* \code
* #include <thrust/unique.h>
* #include <thrust/execution_policy.h>
* ...
* const int N = 7;
* int A[N] = {1, 3, 3, 3, 2, 2, 1}; // keys
* int B[N] = {9, 8, 7, 6, 5, 4, 3}; // values
*
* thrust::pair<int*,int*> new_end;
* new_end = thrust::unique_by_key(thrust::host, A, A + N, B);
*
* // The first four keys in A are now {1, 3, 2, 1} and new_end.first - A is 4.
* // The first four values in B are now {9, 8, 5, 3} and new_end.second - B is 4.
* \endcode
*
* \see unique
* \see unique_by_key_copy
* \see reduce_by_key
*/
template<typename DerivedPolicy,
typename ForwardIterator1,
typename ForwardIterator2>
thrust::pair<ForwardIterator1,ForwardIterator2>
unique_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
ForwardIterator1 keys_first,
ForwardIterator1 keys_last,
ForwardIterator2 values_first);
/*! \p unique_by_key is a generalization of \p unique to key-value pairs.
* For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
* that are equal, \p unique_by_key removes all but the first element of
* the group. Similarly, the corresponding values in the range
* <tt>[values_first, values_first + (keys_last - keys_first))</tt>
* are also removed.
*
* The return value is a \p pair of iterators <tt>(new_keys_last,new_values_last)</tt>
* such that no two consecutive elements in the range <tt>[keys_first, new_keys_last)</tt>
* are equal.
*
* This version of \p unique_by_key uses \c operator== to test for equality and
* \c project1st to reduce values with equal keys.
*
* \param keys_first The beginning of the key range.
* \param keys_last The end of the key range.
* \param values_first The beginning of the value range.
* \return A pair of iterators at end of the ranges <tt>[key_first, keys_new_last)</tt> and <tt>[values_first, values_new_last)</tt>.
*
* \tparam ForwardIterator1 is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>,
* and \p ForwardIterator1 is mutable,
* and \p ForwardIterator's \c value_type is a model of <a href="http://www.sgi.com/tech/stl/EqualityComparable.html">Equality Comparable</a>.
* \tparam ForwardIterator2 is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>,
* and \p ForwardIterator2 is mutable.
*
* \pre The range <tt>[keys_first, keys_last)</tt> and the range <tt>[values_first, values_first + (keys_last - keys_first))</tt> shall not overlap.
*
* The following code snippet demonstrates how to use \p unique_by_key to
* compact a sequence of key/value pairs to remove consecutive duplicates.
*
* \code
* #include <thrust/unique.h>
* ...
* const int N = 7;
* int A[N] = {1, 3, 3, 3, 2, 2, 1}; // keys
* int B[N] = {9, 8, 7, 6, 5, 4, 3}; // values
*
* thrust::pair<int*,int*> new_end;
* new_end = thrust::unique_by_key(A, A + N, B);
*
* // The first four keys in A are now {1, 3, 2, 1} and new_end.first - A is 4.
* // The first four values in B are now {9, 8, 5, 3} and new_end.second - B is 4.
* \endcode
*
* \see unique
* \see unique_by_key_copy
* \see reduce_by_key
*/
template <typename ForwardIterator1,
typename ForwardIterator2>
thrust::pair<ForwardIterator1,ForwardIterator2>
unique_by_key(ForwardIterator1 keys_first,
ForwardIterator1 keys_last,
ForwardIterator2 values_first);
/*! \p unique_by_key is a generalization of \p unique to key-value pairs.
* For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
* that are equal, \p unique_by_key removes all but the first element of
* the group. Similarly, the corresponding values in the range
* <tt>[values_first, values_first + (keys_last - keys_first))</tt>
* are also removed.
*
* This version of \p unique_by_key uses the function object \c binary_pred
* to test for equality and \c project1st to reduce values with equal keys.
*
* The algorithm's execution is parallelized as determined by \p exec.
*
* \param exec The execution policy to use for parallelization.
* \param keys_first The beginning of the key range.
* \param keys_last The end of the key range.
* \param values_first The beginning of the value range.
* \param binary_pred The binary predicate used to determine equality.
* \return The end of the unique range <tt>[first, new_last)</tt>.
*
* \tparam DerivedPolicy The name of the derived execution policy.
* \tparam ForwardIterator1 is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>,
* and \p ForwardIterator1 is mutable,
* and \p ForwardIterator's \c value_type is a model of <a href="http://www.sgi.com/tech/stl/EqualityComparable.html">Equality Comparable</a>.
* \tparam ForwardIterator2 is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>,
* and \p ForwardIterator2 is mutable.
* \tparam BinaryPredicate is a model of <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary Predicate</a>.
*
* \pre The range <tt>[keys_first, keys_last)</tt> and the range <tt>[values_first, values_first + (keys_last - keys_first))</tt> shall not overlap.
*
* The following code snippet demonstrates how to use \p unique_by_key to
* compact a sequence of key/value pairs to remove consecutive duplicates using the \p thrust::host
* execution policy for parallelization:
*
* \code
* #include <thrust/unique.h>
* #include <thrust/execution_policy.h>
* ...
* const int N = 7;
* int A[N] = {1, 3, 3, 3, 2, 2, 1}; // keys
* int B[N] = {9, 8, 7, 6, 5, 4, 3}; // values
*
* thrust::pair<int*,int*> new_end;
* thrust::equal_to<int> binary_pred;
* new_end = thrust::unique_by_key(thrust::host, keys, keys + N, values, binary_pred);
*
* // The first four keys in A are now {1, 3, 2, 1} and new_end.first - A is 4.
* // The first four values in B are now {9, 8, 5, 3} and new_end.second - B is 4.
* \endcode
*
* \see unique
* \see unique_by_key_copy
* \see reduce_by_key
*/
template<typename DerivedPolicy,
typename ForwardIterator1,
typename ForwardIterator2,
typename BinaryPredicate>
thrust::pair<ForwardIterator1,ForwardIterator2>
unique_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
ForwardIterator1 keys_first,
ForwardIterator1 keys_last,
ForwardIterator2 values_first,
BinaryPredicate binary_pred);
/*! \p unique_by_key is a generalization of \p unique to key-value pairs.
* For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
* that are equal, \p unique_by_key removes all but the first element of
* the group. Similarly, the corresponding values in the range
* <tt>[values_first, values_first + (keys_last - keys_first))</tt>
* are also removed.
*
* This version of \p unique_by_key uses the function object \c binary_pred
* to test for equality and \c project1st to reduce values with equal keys.
*
* \param keys_first The beginning of the key range.
* \param keys_last The end of the key range.
* \param values_first The beginning of the value range.
* \param binary_pred The binary predicate used to determine equality.
* \return The end of the unique range <tt>[first, new_last)</tt>.
*
* \tparam ForwardIterator1 is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>,
* and \p ForwardIterator1 is mutable,
* and \p ForwardIterator's \c value_type is a model of <a href="http://www.sgi.com/tech/stl/EqualityComparable.html">Equality Comparable</a>.
* \tparam ForwardIterator2 is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>,
* and \p ForwardIterator2 is mutable.
* \tparam BinaryPredicate is a model of <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary Predicate</a>.
*
* \pre The range <tt>[keys_first, keys_last)</tt> and the range <tt>[values_first, values_first + (keys_last - keys_first))</tt> shall not overlap.
*
* The following code snippet demonstrates how to use \p unique_by_key to
* compact a sequence of key/value pairs to remove consecutive duplicates.
*
* \code
* #include <thrust/unique.h>
* ...
* const int N = 7;
* int A[N] = {1, 3, 3, 3, 2, 2, 1}; // keys
* int B[N] = {9, 8, 7, 6, 5, 4, 3}; // values
*
* thrust::pair<int*,int*> new_end;
* thrust::equal_to<int> binary_pred;
* new_end = thrust::unique_by_key(keys, keys + N, values, binary_pred);
*
* // The first four keys in A are now {1, 3, 2, 1} and new_end.first - A is 4.
* // The first four values in B are now {9, 8, 5, 3} and new_end.second - B is 4.
* \endcode
*
* \see unique
* \see unique_by_key_copy
* \see reduce_by_key
*/
template <typename ForwardIterator1,
typename ForwardIterator2,
typename BinaryPredicate>
thrust::pair<ForwardIterator1,ForwardIterator2>
unique_by_key(ForwardIterator1 keys_first,
ForwardIterator1 keys_last,
ForwardIterator2 values_first,
BinaryPredicate binary_pred);
/*! \p unique_by_key_copy is a generalization of \p unique_copy to key-value pairs.
* For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
* that are equal, \p unique_by_key_copy copies the first element of the group to
* a range beginning with \c keys_result and the corresponding values from the range
* <tt>[values_first, values_first + (keys_last - keys_first))</tt> are copied to a range
* beginning with \c values_result.
*
* This version of \p unique_by_key_copy uses \c operator== to test for equality and
* \c project1st to reduce values with equal keys.
*
* The algorithm's execution is parallelized as determined by \p exec.
*
* \param exec The execution policy to use for parallelization.
* \param keys_first The beginning of the input key range.
* \param keys_last The end of the input key range.
* \param values_first The beginning of the input value range.
* \param keys_result The beginning of the output key range.
* \param values_result The beginning of the output value range.
* \return A pair of iterators at end of the ranges <tt>[keys_result, keys_result_last)</tt> and <tt>[values_result, values_result_last)</tt>.
*
* \tparam DerivedPolicy The name of the derived execution policy.
* \tparam InputIterator1 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>,
* \tparam InputIterator2 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>,
* \tparam OutputIterator1 is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a> and
* and \p InputIterator1's \c value_type is convertible to \c OutputIterator1's \c value_type.
* \tparam OutputIterator2 is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a> and
* and \p InputIterator2's \c value_type is convertible to \c OutputIterator2's \c value_type.
*
* \pre The input ranges shall not overlap either output range.
*
* The following code snippet demonstrates how to use \p unique_by_key_copy to
* compact a sequence of key/value pairs and with equal keys using the \p thrust::host execution policy
* for parallelization:
*
* \code
* #include <thrust/unique.h>
* #include <thrust/execution_policy.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(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, 8, 5, 3} and new_end.second - D is 4.
* \endcode
*
* \see unique_copy
* \see unique_by_key
* \see reduce_by_key
*/
template<typename DerivedPolicy,
typename InputIterator1,
typename InputIterator2,
typename OutputIterator1,
typename OutputIterator2>
thrust::pair<OutputIterator1,OutputIterator2>
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);
/*! \p unique_by_key_copy is a generalization of \p unique_copy to key-value pairs.
* For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
* that are equal, \p unique_by_key_copy copies the first element of the group to
* a range beginning with \c keys_result and the corresponding values from the range
* <tt>[values_first, values_first + (keys_last - keys_first))</tt> are copied to a range
* beginning with \c values_result.
*
* This version of \p unique_by_key_copy uses \c operator== to test for equality and
* \c project1st to reduce values with equal keys.
*
* \param keys_first The beginning of the input key range.
* \param keys_last The end of the input key range.
* \param values_first The beginning of the input value range.
* \param keys_result The beginning of the output key range.
* \param values_result The beginning of the output value range.
* \return A pair of iterators at end of the ranges <tt>[keys_result, keys_result_last)</tt> and <tt>[values_result, values_result_last)</tt>.
*
* \tparam InputIterator1 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>,
* \tparam InputIterator2 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>,
* \tparam OutputIterator1 is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a> and
* and \p InputIterator1's \c value_type is convertible to \c OutputIterator1's \c value_type.
* \tparam OutputIterator2 is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a> and
* and \p InputIterator2's \c value_type is convertible to \c OutputIterator2's \c value_type.
*
* \pre The input ranges shall not overlap either output range.
*
* The following code snippet demonstrates how to use \p unique_by_key_copy to
* compact a sequence of key/value pairs and with equal keys.
*
* \code
* #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.
* \endcode
*
* \see unique_copy
* \see unique_by_key
* \see reduce_by_key
*/
template <typename InputIterator1,
typename InputIterator2,
typename OutputIterator1,
typename OutputIterator2>
thrust::pair<OutputIterator1,OutputIterator2>
unique_by_key_copy(InputIterator1 keys_first,
InputIterator1 keys_last,
InputIterator2 values_first,
OutputIterator1 keys_result,
OutputIterator2 values_result);
/*! \p unique_by_key_copy is a generalization of \p unique_copy to key-value pairs.
* For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
* that are equal, \p unique_by_key_copy copies the first element of the group to
* a range beginning with \c keys_result and the corresponding values from the range
* <tt>[values_first, values_first + (keys_last - keys_first))</tt> are copied to a range
* beginning with \c values_result.
*
* This version of \p unique_by_key_copy uses the function object \c binary_pred
* to test for equality and \c project1st to reduce values with equal keys.
*
* The algorithm's execution is parallelized as determined by \p exec.
*
* \param exec The execution policy to use for parallelization.
* \param keys_first The beginning of the input key range.
* \param keys_last The end of the input key range.
* \param values_first The beginning of the input value range.
* \param keys_result The beginning of the output key range.
* \param values_result The beginning of the output value range.
* \param binary_pred The binary predicate used to determine equality.
* \return A pair of iterators at end of the ranges <tt>[keys_result, keys_result_last)</tt> and <tt>[values_result, values_result_last)</tt>.
*
* \tparam DerivedPolicy The name of the derived execution policy.
* \tparam InputIterator1 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>,
* \tparam InputIterator2 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>,
* \tparam OutputIterator1 is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a> and
* and \p InputIterator1's \c value_type is convertible to \c OutputIterator1's \c value_type.
* \tparam OutputIterator2 is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a> and
* and \p InputIterator2's \c value_type is convertible to \c OutputIterator2's \c value_type.
* \tparam BinaryPredicate is a model of <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary Predicate</a>.
*
* \pre The input ranges shall not overlap either output range.
*
* The following code snippet demonstrates how to use \p unique_by_key_copy to
* compact a sequence of key/value pairs and with equal keys using the \p thrust::host execution policy for
* parallelization:
*
* \code
* #include <thrust/unique.h>
* #include <thrust/execution_policy.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;
* thrust::equal_to<int> binary_pred;
* 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.
* \endcode
*
* \see unique_copy
* \see unique_by_key
* \see reduce_by_key
*/
template<typename DerivedPolicy,
typename InputIterator1,
typename InputIterator2,
typename OutputIterator1,
typename OutputIterator2,
typename BinaryPredicate>
thrust::pair<OutputIterator1,OutputIterator2>
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);
/*! \p unique_by_key_copy is a generalization of \p unique_copy to key-value pairs.
* For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
* that are equal, \p unique_by_key_copy copies the first element of the group to
* a range beginning with \c keys_result and the corresponding values from the range
* <tt>[values_first, values_first + (keys_last - keys_first))</tt> are copied to a range
* beginning with \c values_result.
*
* This version of \p unique_by_key_copy uses the function object \c binary_pred
* to test for equality and \c project1st to reduce values with equal keys.
*
* \param keys_first The beginning of the input key range.
* \param keys_last The end of the input key range.
* \param values_first The beginning of the input value range.
* \param keys_result The beginning of the output key range.
* \param values_result The beginning of the output value range.
* \param binary_pred The binary predicate used to determine equality.
* \return A pair of iterators at end of the ranges <tt>[keys_result, keys_result_last)</tt> and <tt>[values_result, values_result_last)</tt>.
*
* \tparam InputIterator1 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>,
* \tparam InputIterator2 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>,
* \tparam OutputIterator1 is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a> and
* and \p InputIterator1's \c value_type is convertible to \c OutputIterator1's \c value_type.
* \tparam OutputIterator2 is a model of <a href="http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a> and
* and \p InputIterator2's \c value_type is convertible to \c OutputIterator2's \c value_type.
* \tparam BinaryPredicate is a model of <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary Predicate</a>.
*
* \pre The input ranges shall not overlap either output range.
*
* The following code snippet demonstrates how to use \p unique_by_key_copy to
* compact a sequence of key/value pairs and with equal keys.
*
* \code
* #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;
* thrust::equal_to<int> binary_pred;
* new_end = thrust::unique_by_key_copy(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.
* \endcode
*
* \see unique_copy
* \see unique_by_key
* \see reduce_by_key
*/
template <typename InputIterator1,
typename InputIterator2,
typename OutputIterator1,
typename OutputIterator2,
typename BinaryPredicate>
thrust::pair<OutputIterator1,OutputIterator2>
unique_by_key_copy(InputIterator1 keys_first,
InputIterator1 keys_last,
InputIterator2 values_first,
OutputIterator1 keys_result,
OutputIterator2 values_result,
BinaryPredicate binary_pred);
/*! \} // end stream_compaction
*/
} // end namespace thrust
#include <thrust/detail/unique.inl>