2. 使用Thrust API 

thrust::equal

template <typename InputIterator1,
  typename InputIterator2>
bool
equal(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2);

如果逐个比较元素时，两个范围 [first1, last1) 和 [first2, first2 + (last1 - first1)) 相等， equal 返回 true ；否则返回 false。

当且仅当对于 [first1, last1) 中的每个迭代器 i ， *i == *(first2 + (i - first1)) ，此版本的 equal 返回 true。

以下代码片段演示了如何使用 equal 测试两个范围的相等性：

#include <thrust/equal.h>
...
int A1[7] = {3, 1, 4, 1, 5, 9, 3};
int A2[7] = {3, 1, 4, 2, 8, 5, 7};
...
bool result = thrust::equal(A1, A1 + 7, A2);

// result == false

模板参数

InputIterator1：是 Input Iterator 的模型， InputIterator1 的 value_type 是 Equality Comparable 的模型，并且 InputIterator1 的 value_type 和 InputIterator2 的 value_type 可以进行相等性比较
InputIterator2：是 Input Iterator 的模型， InputIterator2 的 value_type 是 Equality Comparable 的模型，并且 InputIterator2 的 value_type 和 InputIterator1 的 value_type 可以进行相等性比较

函数参数

first1：第一个序列的起始
last1：第一个序列的末尾
first2：第二个序列的起始

返回值

如果序列相等，返回 true ，否则返回 false

另请参阅

thrust::equal

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename BinaryPredicate>
__host__ __device__ bool
equal(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  BinaryPredicate binary_pred);

如果逐个比较元素时，两个范围 [first1, last1) 和 [first2, first2 + (last1 - first1)) 相等， equal 返回 true ；否则返回 false。

当且仅当对于 [first1, last1) 中的每个迭代器 i ， binary_pred(*i, *(first2 + (i - first1))) 为 true ，此版本的 equal 返回 true。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 执行策略，使用 equal 比较两个范围内的元素模2取余的结果是否相等：

#include <thrust/equal.h>
#include <thrust/execution_policy.h>
...

struct compare_modulo_two
{
__host__ __device__
bool operator()(int x, int y) const
{
   return (x % 2) == (y % 2);
}
};
...
int x[6] = {0, 2, 4, 6, 8, 10};
int y[6] = {1, 3, 5, 7, 9, 11};

bool result = thrust::equal(x, x + 6, y, compare_modulo_two());

// result is false

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型， InputIterator1 的 value_type 可转换为 BinaryPredicate 的 first_argument_type
InputIterator2：是 Input Iterator 的模型， InputIterator2 的 value_type 可转换为 BinaryPredicate 的 second_argument_type
BinaryPredicate：是 Binary Predicate 的模型

函数参数

exec：用于并行化的执行策略
first1：第一个序列的起始
last1：第一个序列的末尾
first2：第二个序列的起始
binary_pred：用于测试元素相等性的二元谓词

返回值

如果序列相等，返回 true ，否则返回 false

另请参阅

thrust::equal

template <typename InputIterator1,
  typename InputIterator2,
  typename BinaryPredicate>
bool
equal(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  BinaryPredicate binary_pred);

如果逐个比较元素时，两个范围 [first1, last1) 和 [first2, first2 + (last1 - first1)) 相等， equal 返回 true ；否则返回 false。

当且仅当对于 [first1, last1) 中的每个迭代器 i ， binary_pred(*i, *(first2 + (i - first1))) 为 true ，此版本的 equal 返回 true。

以下代码片段演示了如何使用 equal 比较modulo 2两个范围内的元素：

#include <thrust/equal.h>

struct compare_modulo_two
{
__host__ __device__
bool operator()(int x, int y) const
{
   return (x % 2) == (y % 2);
}
};
...
int x[6] = {0, 2, 4, 6, 8, 10};
int y[6] = {1, 3, 5, 7, 9, 11};

bool result = thrust::equal(x, x + 5, y, compare_modulo_two());

// result is true

模板参数

InputIterator1：是 Input Iterator 的模型， InputIterator1 的 value_type 可转换为 BinaryPredicate 的 first_argument_type
InputIterator2：是 Input Iterator 的模型， InputIterator2 的 value_type 可转换为 BinaryPredicate 的 second_argument_type
BinaryPredicate：是 Binary Predicate 的模型

函数参数

first1：第一个序列的起始
last1：第一个序列的末尾
first2：第二个序列的起始
binary_pred：用于测试元素相等性的二元谓词

返回值

如果序列相等，返回 true ，否则返回 false

另请参阅

2.1.4.3. 计数（Counting）

函数

template <typename DerivedPolicy,
  typename InputIterator,
  typename EqualityComparable>
__host__ __device__ thrust::iterator_traits< InputIterator >::difference_type
thrust::count(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  const EqualityComparable & value);

template <typename InputIterator,
  typename EqualityComparable>
thrust::iterator_traits< InputIterator >::difference_type
thrust::count(InputIterator first,
  InputIterator last,
  const EqualityComparable & value);

template <typename DerivedPolicy,
  typename InputIterator,
  typename Predicate>
__host__ __device__ thrust::iterator_traits< InputIterator >::difference_type
thrust::count_if(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  Predicate pred);

template <typename InputIterator,
  typename Predicate>
thrust::iterator_traits< InputIterator >::difference_type
thrust::count_if(InputIterator first,
  InputIterator last,
  Predicate pred);

thrust::count

template <typename DerivedPolicy,
  typename InputIterator,
  typename EqualityComparable>
__host__ __device__ thrust::iterator_traits< InputIterator >::difference_type
count(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  const EqualityComparable & value);

count 查找 [first,last) 内等于 value 的元素数量。具体而言， count 返回 [first, last) ‍内满足 *i == value ‍的迭代器 i 的数量。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::device 执行策略，使用 count 计算感兴趣值范围内的实例数量：

#include <thrust/count.h>
#include <thrust/device_vector.h>
#include <thrust/execution_policy.h>
...
// put 3 1s in a device_vector
thrust::device_vector<int> vec(5,0);
vec[1] = 1;
vec[3] = 1;
vec[4] = 1;

// count the 1s
int result = thrust::count(thrust::device, vec.begin(), vec.end(), 1);
// result == 3

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator：必须是 Input Iterator 的模型， InputIterator 的 value_type 必须是 Equality Comparable 的模型
EqualityComparable：必须是 Equality Comparable 的模型，并且可以和 InputIterator 的 value_type 进行相等性比较

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾
value：待计数的值

返回值

等于 value 的元素数量

另请参阅

thrust::count

template <typename InputIterator,
  typename EqualityComparable> thrust::iterator_traits< InputIterator >::difference_type
count(InputIterator first,
  InputIterator last,
  const EqualityComparable & value);

count 查找 [first,last) 内等于 value 的元素数量。具体而言， count 返回 [first, last) ‍内满足 *i == value ‍的迭代器 i 的数量。

以下代码片段演示了如何使用 count 计算感兴趣值范围内的实例数量：

#include <thrust/count.h>
#include <thrust/device_vector.h>
...
// put 3 1s in a device_vector
thrust::device_vector<int> vec(5,0);
vec[1] = 1;
vec[3] = 1;
vec[4] = 1;

// count the 1s
int result = thrust::count(vec.begin(), vec.end(), 1);
// result == 3

模板参数

InputIterator：必须是 Input Iterator 的模型， InputIterator 的 value_type 必须是 Equality Comparable 的模型
EqualityComparable：必须是 Equality Comparable 的模型，并且可以和 InputIterator 的 value_type 进行相等性比较

函数参数

first：序列起始
last：序列末尾
value：待计数的值

返回值

等于 value 的元素数量

另请参阅

thrust::count_if

template <typename DerivedPolicy,
  typename InputIterator,
  typename Predicate>
__host__ __device__ thrust::iterator_traits< InputIterator >::difference_type
count_if(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  Predicate pred);

count_if 查找 [first,last) 内其谓词为 true 的元素数量。具体而言， count_if 返回 [first, last) ‍内满足 pred(*i) == true ‍的迭代器 i 的数量。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::device 执行策略，使用 count 计算一个范围内的奇数数量：

#include <thrust/count.h>
#include <thrust/device_vector.h>
#include <thrust/execution_policy.h>
...
struct is_odd
{
__host__ __device__
bool operator()(int &x)
{
   return x & 1;
}
};
...
// fill a device_vector with even & odd numbers
thrust::device_vector<int> vec(5);
vec[0] = 0;
vec[1] = 1;
vec[2] = 2;
vec[3] = 3;
vec[4] = 4;

// count the odd elements in vec
int result = thrust::count_if(thrust::device, vec.begin(), vec.end(), is_odd());
// result == 2

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator：必须是 Input Iterator 的模型， InputIterator 的 value_type 必须可转换为 Predicate 的 argument_type
Predicate：必须是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾
pred：谓词

返回值

pred 为 true 的元素数量

另请参阅

thrust::count_if

template <typename InputIterator,
  typename Predicate>
thrust::iterator_traits< InputIterator >::difference_type
count_if(InputIterator first,
  InputIterator last,
  Predicate pred);

count_if 查找 [first,last) 内其谓词为 true 的元素数量。具体而言， count_if 返回 [first, last) ‍内满足 pred(*i) == true ‍的迭代器 i 的数量。

以下代码片段演示了如何使用 count 计算一个范围内的奇数数量：

#include <thrust/count.h>
#include <thrust/device_vector.h>
...
struct is_odd
{
__host__ __device__
bool operator()(int &x)
{
   return x & 1;
}
};
...
// fill a device_vector with even & odd numbers
thrust::device_vector<int> vec(5);
vec[0] = 0;
vec[1] = 1;
vec[2] = 2;
vec[3] = 3;
vec[4] = 4;

// count the odd elements in vec
int result = thrust::count_if(vec.begin(), vec.end(), is_odd());
// result == 2

模板参数

InputIterator：必须是 Input Iterator 的模型， InputIterator 的 value_type 必须可转换为 Predicate 的 argument_type
Predicate：必须是 Predicate 的模型

函数参数

first：序列起始
last：序列末尾
pred：谓词

返回值

pred 为 true 的元素数量

另请参阅

https://en.cppreference.com/w/cpp/algorithm/min_element

2.1.4.4. 最值（Extrema）

函数

template <typename DerivedPolicy,
  typename ForwardIterator>
__host__ __device__ ForwardIterator
thrust::min_element(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last);

template <typename ForwardIterator>
ForwardIterator
thrust::min_element(ForwardIterator first,
  ForwardIterator last);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename BinaryPredicate>
__host__ __device__ ForwardIterator
thrust::min_element(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  BinaryPredicate comp);

template <typename ForwardIterator,
  typename BinaryPredicate>
ForwardIterator
thrust::min_element(ForwardIterator first,
  ForwardIterator last,
  BinaryPredicate comp);

template <typename DerivedPolicy,
  typename ForwardIterator>
__host__ __device__ ForwardIterator
thrust::max_element(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last);

template <typename ForwardIterator>
ForwardIterator
thrust::max_element(ForwardIterator first,
  ForwardIterator last);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename BinaryPredicate>
__host__ __device__
ForwardIterator
thrust::max_element(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  BinaryPredicate comp);

template <typename ForwardIterator,
  typename BinaryPredicate>
ForwardIterator
thrust::max_element(ForwardIterator first,
  ForwardIterator last,
  BinaryPredicate comp);

template <typename DerivedPolicy,
  typename ForwardIterator>
__host__ __device__ thrust::pair< ForwardIterator, ForwardIterator >
thrust::minmax_element(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last);

template <typename ForwardIterator>
thrust::pair< ForwardIterator, ForwardIterator >
thrust::minmax_element(ForwardIterator first,
  ForwardIterator last);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename BinaryPredicate>
__host__ __device__ thrust::pair< ForwardIterator, ForwardIterator >
thrust::minmax_element(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  BinaryPredicate comp);

template <typename ForwardIterator,
  typename BinaryPredicate>
thrust::pair< ForwardIterator, ForwardIterator >
thrust::minmax_element(ForwardIterator first,
  ForwardIterator last,
  BinaryPredicate comp);

thrust::min_element

template <typename DerivedPolicy,
  typename ForwardIterator>
__host__ __device__ ForwardIterator
min_element(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last);

min_element 查找范围 [first, last) 内最小的元素。 ‌返回 [first, last) 内第一个迭代器 i ，使得 [first, last) 内没有迭代器指向小于 *i 的值。当且仅当 [first, last) 为空范围，返回值为 last。

min_element 的两个版本在定义一个元素是否小于另一个元素方面有所不同。此版本使用 operator< 比较对象。具体而言，此版本的 min_element 返回 [first, last) 内的第一个迭代器 i ，因此，对于 [first, last) 内第一个迭代器 j ， *j < *i 为 false。

算法的执行由 exec 确定并行化。

#include <thrust/extrema.h>
#include <thrust/execution_policy.h>
...
int data[6] = {1, 0, 2, 2, 1, 3};
int *result = thrust::min_element(thrust::host, data, data + 6);

// result is data + 1
// *result is 0

模板参数

ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 是 LessThan Comparable 的模型

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾

返回值

如果 [first, last) 不是空范围，返回指向范围内最小元素的迭代器；否则，返回 last

另请参阅

thrust::min_element

template <typename ForwardIterator>
ForwardIterator
min_element(ForwardIterator first,
  ForwardIterator last);

min_element 查找范围 [first, last) 内最小的元素。‌返回 [first, last) 内第一个迭代器 i ，使得 [first, last) 内没有迭代器指向小于 *i 的值。当且仅当 [first, last) 为空范围，返回值为 last。

min_element 的两个版本在定义一个元素是否小于另一个元素方面有所不同。此版本使用 operator< 比较对象。具体而言，此版本的 min_element 返回 [first, last) 内的第一个迭代器 i ，因此，对于 [first, last) 内第一个迭代器 j ， *j < *i 为 false。

#include <thrust/extrema.h>
...
int data[6] = {1, 0, 2, 2, 1, 3};
int *result = thrust::min_element(data, data + 6);

// result is data + 1
// *result is 0

模板参数

ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 是 LessThan Comparable 的模型

函数参数

first：序列起始
last：序列末尾

返回值

如果 [first, last) 不是空范围，返回指向范围内最小元素的迭代器；否则，返回 last

另请参阅

https://en.cppreference.com/w/cpp/algorithm/min_element

thrust::min_element

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename BinaryPredicate>
__host__ __device__ ForwardIterator
min_element(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  BinaryPredicate comp);

min_element 查找范围 [first, last) 内最小的元素。‌返回 [first, last) 内第一个迭代器 i ，使得 [first, last) 内没有迭代器指向小于 *i 的值。当且仅当 [first, last) 为空范围，返回值为 last。

min_element 的两个版本在定义一个元素是否小于另一个元素方面有所不同。此版本使用函数对象 comp 比较对象。具体而言，此版本的 min_element 返回 [first, last) 内的第一个迭代器 i ，因此，对于 [first, last) 内第一个迭代器 j ， comp(*j, *i) 为 false。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 min_element 查找键值对集合中的最小元素：

#include <thrust/extrema.h>
#include <thrust/execution_policy.h>
...

struct key_value
{
int key;
int value;
};

struct compare_key_value
{
__host__ __device__
bool operator()(key_value lhs, key_value rhs)
{
   return lhs.key < rhs.key;
}
};

...
key_value data[4] = { {4,5}, {0,7}, {2,3}, {6,1} };

key_value *smallest = thrust::min_element(thrust::host, data, data + 4, compare_key_value());

// smallest == data + 1
// *smallest == {0,7}

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 可转换为 comp 的 first_argument_type 和 second_argument_type
BinaryPredicate：是 Binary Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾
comp：用于比较的二元谓词

返回值

如果 [first, last) 不是空范围，返回指向范围内最小元素的迭代器；否则，返回 last

另请参阅

https://en.cppreference.com/w/cpp/algorithm/min_element

thrust::min_element

template <typename ForwardIterator,
  typename BinaryPredicate>
ForwardIterator
min_element(ForwardIterator first,
  ForwardIterator last,
  BinaryPredicate comp);

min_element 查找范围 [first, last) 内最小的元素。 ‌返回 [first, last) 内第一个迭代器 i ，使得 [first, last) 内没有迭代器指向小于 *i 的值。当且仅当 [first, last) 为空范围，返回值为 last。

min_element 的两个版本在定义一个元素是否小于另一个元素方面有所不同。此版本使用函数对象 comp 比较对象。具体而言，此版本的 min_element 返回 [first, last) 内的第一个迭代器 i ，因此，对于 [first, last) 内第一个迭代器 j ， comp(*j, *i) 为 false。

以下代码片段演示了如何使用 min_element 查找键值对集合中的最小元素：

#include <thrust/extrema.h>

struct key_value
{
int key;
int value;
};

struct compare_key_value
{
__host__ __device__
bool operator()(key_value lhs, key_value rhs)
{
   return lhs.key < rhs.key;
}
};

...
key_value data[4] = { {4,5}, {0,7}, {2,3}, {6,1} };

key_value *smallest = thrust::min_element(data, data + 4, compare_key_value());

// smallest == data + 1
// *smallest == {0,7}

模板参数

ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 可转换为 comp 的 first_argument_type 和 second_argument_type
BinaryPredicate：是 Binary Predicate 的模型

函数参数

first：序列起始
last：序列末尾
comp：用于比较的二元谓词

返回值

如果 [first, last) 不是空范围，返回指向范围内最小元素的迭代器；否则，返回 last

另请参阅

https://en.cppreference.com/w/cpp/algorithm/min_element

thrust::max_element

template <typename DerivedPolicy,
  typename ForwardIterator>
__host__ __device__ ForwardIterator
max_element(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last);

max_element 查找范围 [first, last) 内最大的元素。‌返回 [first, last) 内第一个迭代器 i ，使得 [first, last) 内没有迭代器指向大于 *i 的值。当且仅当 [first, last) 为空范围，返回值为 last。

max_element 的两个版本不同之处在于它们如何定义一个元素是否大于另一个元素。此版本使用 operator< 比较对象。具体而言，此版本的 max_element 返回 [first, last) 内的第一个迭代器 i ，因此，对于 [first, last) 内第一个迭代器 j ， *i < *j 为 false。

算法的执行由 exec 确定并行化。

#include <thrust/extrema.h>
#include <thrust/execution_policy.h>
...
int data[6] = {1, 0, 2, 2, 1, 3};
int *result = thrust::max_element(thrust::host, data, data + 6);

// *result == 3

模板参数

DerivedPolicy：Thrust后端系统
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 是 LessThan Comparable 的模型

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾

返回值

如果 [first, last) 不是空范围，返回指向范围内最大元素的迭代器；否则，返回 last

另请参阅

https://en.cppreference.com/w/cpp/algorithm/max_element

thrust::max_element

template <typename ForwardIterator>
ForwardIterator
max_element(ForwardIterator first,
  ForwardIterator last);

max_element 查找范围 [first, last) 内最大的元素。‌返回 [first, last) 内第一个迭代器 i ，使得 [first, last) 内没有迭代器指向大于 *i 的值。当且仅当 [first, last) 为空范围，返回值为 last。

max_element 的两个版本不同之处在于它们如何定义一个元素是否大于另一个元素。此版本使用 operator< 比较对象。具体而言，此版本的 max_element 返回 [first, last) 内的第一个迭代器 i ，因此，对于 [first, last) 内第一个迭代器 j ， *i < *j 为 false。

#include <thrust/extrema.h>
...
int data[6] = {1, 0, 2, 2, 1, 3};
int *result = thrust::max_element(data, data + 6);

// *result == 3

模板参数

ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 是 LessThan Comparable 的模型

函数参数

first：序列起始
last：序列末尾

返回值

如果 [first, last) 不是空范围，返回指向范围内最大元素的迭代器；否则，返回 last

另请参阅

https://en.cppreference.com/w/cpp/algorithm/max_element

thrust::max_element

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename BinaryPredicate>
__host__ __device__ ForwardIterator
max_element(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  BinaryPredicate comp);

max_element 查找范围 [first, last) 内最大的元素。‌返回 [first, last) 内第一个迭代器 i ，使得 [first, last) 内没有迭代器指向大于 *i 的值。当且仅当 [first, last) 为空范围，返回值为 last。

max_element 的两个版本在定义一个元素是否小于另一个元素方面有所不同。此版本使用函数对象 comp 比较对象。具体而言，此版本的 max_element 返回 [first, last) 内的第一个迭代器 i ，因此，对于 [first, last) 内第一个迭代器 j ， comp(*i, *j) 为 false。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 max_element 查找键值对集合中的最大元素：

#include <thrust/extrema.h>
#include <thrust/execution_policy.h>
...

struct key_value
{
int key;
int value;
};

struct compare_key_value
{
__host__ __device__
bool operator()(key_value lhs, key_value rhs)
{
   return lhs.key < rhs.key;
}
};

...
key_value data[4] = { {4,5}, {0,7}, {2,3}, {6,1} };

key_value *largest = thrust::max_element(thrust::host, data, data + 4, compare_key_value());

// largest == data + 3
// *largest == {6,1}

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 可转换为 comp 的 first_argument_type 和 second_argument_type
BinaryPredicate：是 Binary Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾
comp：用于比较的二元谓词

返回值

如果 [first, last) 不是空范围，返回指向范围内最大元素的迭代器；否则，返回 last

另请参阅

https://en.cppreference.com/w/cpp/algorithm/max_element

thrust::max_element

template <typename ForwardIterator,
  typename BinaryPredicate>
ForwardIterator
max_element(ForwardIterator first,
  ForwardIterator last,
  BinaryPredicate comp);

max_element 查找范围 [first, last) 内最大的元素。 ‌返回 [first, last) 内第一个迭代器 i ，使得 [first, last) 内没有迭代器指向大于 *i 的值。当且仅当 [first, last) 为空范围，返回值为 last。

max_element 的两个版本在定义一个元素是否小于另一个元素方面有所不同。此版本使用函数对象 comp 比较对象。具体而言，此版本的 max_element 返回 [first, last) 内的第一个迭代器 i ，因此，对于 [first, last) 内第一个迭代器 j ， comp(*i, *j) 为 false。

以下代码片段演示了如何使用 max_element 查找键值对集合中的最大元素：

#include <thrust/extrema.h>

struct key_value
{
int key;
int value;
};

struct compare_key_value
{
__host__ __device__
bool operator()(key_value lhs, key_value rhs)
{
   return lhs.key < rhs.key;
}
};

...
key_value data[4] = { {4,5}, {0,7}, {2,3}, {6,1} };

key_value *largest = thrust::max_element(data, data + 4, compare_key_value());

// largest == data + 3
// *largest == {6,1}

模板参数

ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 可转换为 comp 的 first_argument_type 和 second_argument_type
BinaryPredicate：是 Binary Predicate 的模型

函数参数

first：序列起始
last：序列末尾
comp：用于比较的二元谓词

返回值

如果 [first, last) 不是空范围，返回指向范围内最大元素的迭代器；否则，返回 last

另请参阅

https://en.cppreference.com/w/cpp/algorithm/max_element

thrust::minmax_element

template <typename DerivedPolicy,
  typename ForwardIterator>
__host__ __device__ thrust::pair< ForwardIterator, ForwardIterator >
minmax_element(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last);

minmax_element 查找范围 [first, last) 内最小和最大的元素。返回一对迭代器 (imin, imax) ，其中 imin ‍与 min_element 返回的迭代器相同；imax ‍与 max_element 返回的迭代器相同。此函数可能比单独调用 min_element 和 max_element 更高效。

算法的执行由 exec 确定并行化。

#include <thrust/extrema.h>
#include <thrust/execution_policy.h>
...
int data[6] = {1, 0, 2, 2, 1, 3};
thrust::pair<int *, int *> result = thrust::minmax_element(thrust::host, data, data + 6);

// result.first is data + 1
// result.second is data + 5
// *result.first is 0
// *result.second is 3

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 是 LessThan Comparable 的模型

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾

返回值

如果 [first, last) 不是空范围，返回指向范围内最小和最大元素的一对迭代器；否则，返回 last

另请参阅

min_element
max_element
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1840.pdf

thrust::minmax_element

template <typename ForwardIterator>
thrust::pair< ForwardIterator, ForwardIterator >
minmax_element(ForwardIterator first,
  ForwardIterator last);

minmax_element 查找范围 [first, last) 内最小和最大的元素。返回一对迭代器 (imin, imax) ，其中 imin ‍与 min_element 返回的迭代器相同；imax ‍与 max_element 返回的迭代器相同。此函数可能比单独调用 min_element 和 max_element 更高效。

#include <thrust/extrema.h>
...
int data[6] = {1, 0, 2, 2, 1, 3};
thrust::pair<int *, int *> result = thrust::minmax_element(data, data + 6);

// result.first is data + 1
// result.second is data + 5
// *result.first is 0
// *result.second is 3

模板参数

ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 是 LessThan Comparable 的模型

函数参数

first：序列起始
last：序列末尾

返回值

如果 [first, last) 不是空范围，返回指向范围内最小和最大元素的一对迭代器；否则，返回 last

另请参阅

min_element
max_element
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1840.pdf

thrust::minmax_element

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename BinaryPredicate>
__host__ __device__ thrust::pair< ForwardIterator, ForwardIterator >
minmax_element(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  BinaryPredicate comp);

minmax_element 查找范围 [first, last) 内最小和最大的元素。返回一对迭代器 (imin, imax) ，其中 imin ‍与 min_element 返回的迭代器相同；imax ‍与 max_element 返回的迭代器相同。此函数可能比单独调用 min_element 和 max_element 更高效。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 minmax_element 查找键值对集合中的最小和最大元素：

#include <thrust/extrema.h>
#include <thrust/pair.h>
#include <thrust/execution_policy.h>
...

struct key_value
{
int key;
int value;
};

struct compare_key_value
{
__host__ __device__
bool operator()(key_value lhs, key_value rhs)
{
   return lhs.key < rhs.key;
}
};

...
key_value data[4] = { {4,5}, {0,7}, {2,3}, {6,1} };

thrust::pair<key_value*,key_value*> extrema = thrust::minmax_element(thrust::host, data, data + 4, compare_key_value());

// extrema.first   == data + 1
// *extrema.first  == {0,7}
// extrema.second  == data + 3
// *extrema.second == {6,1}

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 可转换为 comp 的 first_argument_type 和 second_argument_type
BinaryPredicate：是 Binary Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾
comp：用于比较的二元谓词

返回值

如果 [first, last) 不是空范围，返回指向范围内最小和最大元素的一对迭代器；否则，返回 last

另请参阅

min_element
max_element
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1840.pdf

thrust::minmax_element

template <typename ForwardIterator,
  typename BinaryPredicate>
thrust::pair< ForwardIterator, ForwardIterator >
minmax_element(ForwardIterator first,
  ForwardIterator last,
  BinaryPredicate comp);

minmax_element 查找范围 [first, last) 内最小和最大的元素。返回一对迭代器 (imin, imax) ，其中 imin ‍与 min_element 返回的迭代器相同；imax ‍与 max_element 返回的迭代器相同。此函数可能比单独调用 min_element 和 max_element 更高效。

以下代码片段演示了如何使用 minmax_element 查找键值对集合中的最小和最大元素：

#include <thrust/extrema.h>
#include <thrust/pair.h>

struct key_value
{
int key;
int value;
};

struct compare_key_value
{
__host__ __device__
bool operator()(key_value lhs, key_value rhs)
{
   return lhs.key < rhs.key;
}
};

...
key_value data[4] = { {4,5}, {0,7}, {2,3}, {6,1} };

thrust::pair<key_value*,key_value*> extrema = thrust::minmax_element(data, data + 4, compare_key_value());

// extrema.first   == data + 1
// *extrema.first  == {0,7}
// extrema.second  == data + 3
// *extrema.second == {6,1}

模板参数

ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 可转换为 comp 的 first_argument_type 和 second_argument_type
BinaryPredicate：是 Binary Predicate 的模型

函数参数

first：序列起始
last：序列末尾
comp：用于比较的二元谓词

返回值

如果 [first, last) 不是空范围，返回指向范围内最小和最大元素的一对迭代器；否则，返回 last

另请参阅

min_element
max_element
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1840.pdf

2.1.4.5. ‌逻辑（Logical）

逻辑

template <typename DerivedPolicy,
  typename InputIterator,
  typename Predicate>
__host__ __device__ bool
thrust::all_of(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
 Predicate pred);

template <typename InputIterator,
  typename Predicate>
bool
thrust::all_of(InputIterator first,
  InputIterator last,
  Predicate pred);

template <typename DerivedPolicy,
  typename InputIterator,
  typename Predicate>
__host__ __device__ bool
thrust::any_of(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  Predicate pred);

template <typename InputIterator,
  typename Predicate>
bool
thrust::any_of(InputIterator first,
  InputIterator last,
  Predicate pred);

template <typename DerivedPolicy,
  typename InputIterator,
  typename Predicate>
__host__ __device__ bool
thrust::none_of(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  Predicate pred);

template <typename InputIterator,
  typename Predicate>
bool
thrust::none_of(InputIterator first,
  InputIterator last,
  Predicate pred);

thrust::all_of

template <typename DerivedPolicy,
  typename InputIterator,
  typename Predicate>
__host__ __device__ bool
all_of(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  Predicate pred);

all_of 确定范围内所有元素是否满足一个谓词。具体而言，如果对于范围 [first, last) 内每个迭代器 i ， pred(*i) 为 true ，则 all_of 返回 true；否则返回 false。

算法的执行由 exec 确定并行化。

#include <thrust/logical.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
bool A[3] = {true, true, false};

thrust::all_of(thrust::host, A, A + 2, thrust::identity<bool>()); // returns true
thrust::all_of(thrust::host, A, A + 3, thrust::identity<bool>()); // returns false

// empty range
thrust::all_of(thrust::host, A, A, thrust::identity<bool>()); // returns false

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator：是 Input Iterator 的模型
Predicate：必须是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾
pred：用于测试范围内元素的谓词

返回值

如果所有元素满足谓词，则返回 true；否则返回 false

另请参阅

any_of
none_of
transform_reduce

thrust::all_of

template <typename InputIterator,
  typename Predicate>
bool
all_of(InputIterator first,
  InputIterator last,
  Predicate pred);

all_of 确定范围内所有元素是否满足一个谓词。具体而言，如果对于范围 [first, last) 内每个迭代器 i ， pred(*i) 为 true ，则 all_of 返回 true；否则返回 false。

#include <thrust/logical.h>
#include <thrust/functional.h>
...
bool A[3] = {true, true, false};

thrust::all_of(A, A + 2, thrust::identity<bool>()); // returns true
thrust::all_of(A, A + 3, thrust::identity<bool>()); // returns false

// empty range
thrust::all_of(A, A, thrust::identity<bool>()); // returns false

模板参数

InputIterator：是 Input Iterator 的模型
Predicate：必须是 Predicate 的模型

函数参数

first：序列起始
last：序列末尾
pred：用于测试范围内元素的谓词

返回值

如果所有元素满足谓词，则返回 true；否则返回 false

另请参阅

any_of
none_of
transform_reduce

thrust::any_of

template <typename DerivedPolicy,
  typename InputIterator,
  typename Predicate>
__host__ __device__ bool
any_of(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  Predicate pred);

any_of 确定范围内是否有元素满足一个谓词。具体而言，如果对于范围 [first, last) 内任意一个迭代器 i ， pred(*i) 为 true ，则 any_of 返回 true；否则返回 false。

算法的执行由 exec 确定并行化。

#include <thrust/logical.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
bool A[3] = {true, true, false};

thrust::any_of(thrust::host, A, A + 2, thrust::identity<bool>()); // returns true
thrust::any_of(thrust::host, A, A + 3, thrust::identity<bool>()); // returns true

thrust::any_of(thrust::host, A + 2, A + 3, thrust::identity<bool>()); // returns false

// empty range
thrust::any_of(thrust::host, A, A, thrust::identity<bool>()); // returns false

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator：是 Input Iterator 的模型
Predicate：必须是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾
pred：用于测试范围内元素的谓词

返回值

如果有元素满足谓词，则返回 true；否则返回 false

另请参阅

all_of
none_of
transform_reduce

thrust::any_of

template <typename InputIterator,
  typename Predicate>
bool
any_of(InputIterator first,
  InputIterator last,
  Predicate pred);

any_of 确定范围内是否有元素满足一个谓词。具体而言，如果对于范围 [first, last) 内任意一个迭代器 i ， pred(*i) 为 true ，则 any_of 返回 true；否则返回 false。

#include <thrust/logical.h>
#include <thrust/functional.h>
...
bool A[3] = {true, true, false};

thrust::any_of(A, A + 2, thrust::identity<bool>()); // returns true
thrust::any_of(A, A + 3, thrust::identity<bool>()); // returns true

thrust::any_of(A + 2, A + 3, thrust::identity<bool>()); // returns false

// empty range
thrust::any_of(A, A, thrust::identity<bool>()); // returns false

模板参数

InputIterator：是 Input Iterator 的模型
Predicate：必须是 Predicate 的模型

函数参数

first：序列起始
last：序列末尾
pred：用于测试范围内元素的谓词

返回值

如果有元素满足谓词，则返回 true；否则返回 false

另请参阅

all_of
none_of
transform_reduce

thrust::none_of

template <typename DerivedPolicy,
  typename InputIterator,
  typename Predicate>
__host__ __device__ bool
none_of(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  Predicate pred);

none_of 确定范围内元素是否都不满足一个谓词。具体而言，如果对于范围 [first, last) 内的迭代器 i ， pred(*i) 不为 true ，则 none_of 返回 true；否则返回 false。

算法的执行由 exec 确定并行化。

#include <thrust/logical.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
bool A[3] = {true, true, false};

thrust::none_of(thrust::host, A, A + 2, thrust::identity<bool>()); // returns false
thrust::none_of(thrust::host, A, A + 3, thrust::identity<bool>()); // returns false

thrust::none_of(thrust::host, A + 2, A + 3, thrust::identity<bool>()); // returns true

// empty range
thrust::none_of(thrust::host, A, A, thrust::identity<bool>()); // returns true

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator：是 Input Iterator 的模型
Predicate：必须是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾
pred：用于测试范围内元素的谓词

返回值

如果没有元素满足谓词，则返回 true；否则返回 false

另请参阅

all_of
any_of
transform_reduce

thrust::none_of

template <typename InputIterator,
  typename Predicate>
bool
none_of(InputIterator first,
  InputIterator last,
  Predicate pred);

none_of 确定范围内元素是否都不满足一个谓词。具体而言，如果对于范围 [first, last) 内的迭代器 i ， pred(*i) 不为 true ，则 none_of 返回 true；否则返回 false。

#include <thrust/logical.h>
#include <thrust/functional.h>
...
bool A[3] = {true, true, false};

thrust::none_of(A, A + 2, thrust::identity<bool>()); // returns false
thrust::none_of(A, A + 3, thrust::identity<bool>()); // returns false

thrust::none_of(A + 2, A + 3, thrust::identity<bool>()); // returns true

// empty range
thrust::none_of(A, A, thrust::identity<bool>()); // returns true

模板参数

InputIterator：是 Input Iterator 的模型
Predicate：必须是 Predicate 的模型

函数参数

first：序列起始
last：序列末尾
pred：用于测试范围内元素的谓词

返回值

如果没有元素满足谓词，则返回 true；否则返回 false

另请参阅

all_of
any_of
transform_reduce

2.1.4.6. ‌谓词（Predicate）

函数

template <typename DerivedPolicy,
  typename InputIterator,
  typename Predicate>
__host__ __device__ bool
thrust::is_partitioned(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  Predicate pred);

template <typename InputIterator,
  typename Predicate>
bool
thrust::is_partitioned(InputIterator first,
  InputIterator last,
  Predicate pred);

template <typename DerivedPolicy,
  typename ForwardIterator>
__host__ __device__ bool
thrust::is_sorted(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last);

template <typename ForwardIterator>
bool
thrust::is_sorted(ForwardIterator first,
  ForwardIterator last);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename Compare>
__host__ __device__ bool
thrust::is_sorted(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  Compare comp);

template <typename ForwardIterator,
  typename Compare>
bool
thrust::is_sorted(ForwardIterator first,
  ForwardIterator last,
  Compare comp);

template <typename DerivedPolicy,
  typename ForwardIterator>
__host__ __device__ ForwardIterator
thrust::is_sorted_until(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last);

template <typename ForwardIterator>
ForwardIterator
thrust::is_sorted_until(ForwardIterator first,
  ForwardIterator last);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename Compare>
__host__ __device__ ForwardIterator
thrust::is_sorted_until(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  Compare comp);

template <typename ForwardIterator,
  typename Compare>
ForwardIterator
thrust::is_sorted_until(ForwardIterator first,
  ForwardIterator last,
  Compare comp);

thrust::is_partitioned

template <typename DerivedPolicy,
  typename InputIterator,
  typename Predicate>
__host__ __device__ bool
is_partitioned(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  Predicate pred);

如果给定范围是根据谓词划分的， is_partitioned 返回 true；否则返回 false。

具体而言，如果 [first, last) 为空或 [first, last) 根据 pred 分区，则 is_partitioned 为 true ，即满足 pred 的所有元素都先于不满足 pred 的元素。

算法的执行由 exec 确定并行化。

#include <thrust/partition.h>
#include <thrust/execution_policy.h>

struct is_even
{
__host__ __device__
bool operator()(const int &x)
{
   return (x % 2) == 0;
}
};

...

int A[] = {2, 4, 6, 8, 10, 1, 3, 5, 7, 9};
int B[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

thrust::is_partitioned(thrust::host, A, A + 10, is_even()); // returns true
thrust::is_partitioned(thrust::host, B, B + 10, is_even()); // returns false

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 Predicate 的 argument_type
Predicate：是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：待检查的范围的起始
last：待检查的范围的末尾
pred：决定范围 [first, last) 内每个元素属于哪个分区的函数对象

返回值

如果 [first, last) 被 pred 分区或 [first, last) 为空，则返回 true；否则，返回 false

另请参阅

partition

thrust::is_partitioned

template <typename InputIterator,
  typename Predicate>
bool
is_partitioned(InputIterator first,
  InputIterator last,
  Predicate pred);

如果给定范围是根据谓词划分的， is_partitioned 返回 true；否则返回 false。具体而言，如果 [first, last) 为空或 [first, last) 根据 pred 分区，则 is_partitioned 为 true ，即满足 pred 的所有元素都先于不满足 pred 的元素。

#include <thrust/partition.h>

struct is_even
{
__host__ __device__
bool operator()(const int &x)
{
   return (x % 2) == 0;
}
};

...

int A[] = {2, 4, 6, 8, 10, 1, 3, 5, 7, 9};
int B[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

thrust::is_partitioned(A, A + 10, is_even()); // returns true
thrust::is_partitioned(B, B + 10, is_even()); // returns false

模板参数

InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 Predicate 的 argument_type
Predicate：是 Predicate 的模型

函数参数

first：待检查的范围的起始
last：待检查的范围的末尾
pred：决定范围 [first, last) 内每个元素属于哪个分区的函数对象

返回值

如果 [first, last) 被 pred 分区或 [first, last) 为空，则返回 true；否则，返回 false

另请参阅

partition

thrust::is_sorted

template <typename DerivedPolicy,
  typename ForwardIterator>
__host__ __device__ bool
is_sorted(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last);

如果范围 [first, last) 为升序， is_sorted 返回 true；否则，返回 false。

具体而言，如果对于范围 [first, last - 1) ‍内的某个迭代器 i ，表达式 *(i + 1) < *i 为 true ，则此版本的 is_sorted 返回 false。

算法的执行由 exec 确定并行化。

下面的代码片段演示了如何通过 thrust::device 并行化执行策略，使用 is_sorted 测试 device_vector 的内容是否按升序存储：

#include <thrust/sort.h>
#include <thrust/device_vector.h>
#include <thrust/sort.h>
#include <thrust/execution_policy.h>
...
thrust::device_vector<int> v(6);
v[0] = 1;
v[1] = 4;
v[2] = 2;
v[3] = 8;
v[4] = 5;
v[5] = 7;

bool result = thrust::is_sorted(thrust::device, v.begin(), v.end());

// result == false

thrust::sort(v.begin(), v.end());
result = thrust::is_sorted(thrust::device, v.begin(), v.end());

// result == true

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 是 LessThan Comparable 的模型，且如在 LessThan Comparable 要求中定义的， ForwardIterator 的 value_type 对象上的排序是 严格弱序

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾

返回值

如果序列是有序的，返回 true；否则，返回 false

另请参阅

https://en.cppreference.com/w/cpp/algorithm/is_sorted
is_sorted_until
sort
stable_sort
less<T>

thrust::is_sorted

template <typename ForwardIterator> bool is_sorted(ForwardIterator first,   ForwardIterator last);

如果范围 [first, last) 为升序， is_sorted 返回 true；否则，返回 false。

具体而言，如果对于范围 [first, last - 1) ‍内的某个迭代器 i ，表达式 *(i + 1) < *i 为 true ，则此版本的 is_sorted 返回 false。

下面的代码片段演示了如何使用 is_sorted 测试 device_vector 的内容是否按升序排序：

#include <thrust/sort.h>
#include <thrust/device_vector.h>
#include <thrust/sort.h>
...
thrust::device_vector<int> v(6);
v[0] = 1;
v[1] = 4;
v[2] = 2;
v[3] = 8;
v[4] = 5;
v[5] = 7;

bool result = thrust::is_sorted(v.begin(), v.end());

// result == false

thrust::sort(v.begin(), v.end());
result = thrust::is_sorted(v.begin(), v.end());

// result == true

模板参数

ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 是 LessThan Comparable 的模型，且如在 LessThan Comparable 要求中定义的， ForwardIterator 的 value_type 对象上的排序是 严格弱序

函数参数

first：序列起始
last：序列末尾

返回值

如果序列是有序的，返回 true；否则，返回 false

另请参阅

https://en.cppreference.com/w/cpp/algorithm/is_sorted
is_sorted_until
sort
stable_sort
less<T>

thrust::is_sorted

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename Compare>
__host__ __device__ bool
is_sorted(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  Compare comp);

如果根据用户定义的比较运算按升序对范围 [first, last) 进行排序， is_sorted 返回 true；否则，返回 false。

具体而言，如果对于范围 [first, last - 1) ‍内的某个迭代器 i ，表达式 comp(*(i + 1), *i) 为 true ，则此版本的 is_sorted 返回 false。

算法的执行由 exec 确定并行化。

下面的代码片段演示了如何通过 thrust::device 并行化执行策略，使用 is_sorted 测试 device_vector 的内容是否按降序排序：

#include <thrust/sort.h>
#include <thrust/functional.h>
#include <thrust/device_vector.h>
#include <thrust/execution_policy.h>
...
thrust::device_vector<int> v(6);
v[0] = 1;
v[1] = 4;
v[2] = 2;
v[3] = 8;
v[4] = 5;
v[5] = 7;

thrust::greater<int> comp;
bool result = thrust::is_sorted(thrust::device, v.begin(), v.end(), comp);

// result == false

thrust::sort(v.begin(), v.end(), comp);
result = thrust::is_sorted(thrust::device, v.begin(), v.end(), comp);

// result == true

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 可转换为 StrictWeakOrdering 的 first_argument_type 和 second_argument_type
Compare：是 Strict Weak Ordering 的模型

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾
comp：比较运算符

返回值

如果序列是按照 comp 排序的，返回 true；否则，返回 false

另请参阅

https://en.cppreference.com/w/cpp/algorithm/is_sorted
sort
stable_sort
less<T>

thrust::is_sorted

template <typename ForwardIterator,
  typename Compare>
bool
is_sorted(ForwardIterator first,
  ForwardIterator last,
  Compare comp);

如果根据用户定义的比较运算按升序对范围 [first, last) 进行排序， is_sorted 返回 true；否则，返回 false。

具体而言，如果对于范围 [first, last - 1) ‍内的某个迭代器 i ，表达式 comp(*(i + 1), *i) 为 true ，则此版本的 is_sorted 返回 false。

下面的代码片段演示了如何使用 is_sorted 测试 device_vector 的内容是否按降序排序：

#include <thrust/sort.h>
#include <thrust/functional.h>
#include <thrust/device_vector.h>
...
thrust::device_vector<int> v(6);
v[0] = 1;
v[1] = 4;
v[2] = 2;
v[3] = 8;
v[4] = 5;
v[5] = 7;

thrust::greater<int> comp;
bool result = thrust::is_sorted(v.begin(), v.end(), comp);

// result == false

thrust::sort(v.begin(), v.end(), comp);
result = thrust::is_sorted(v.begin(), v.end(), comp);

// result == true

模板参数

ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 可转换为 StrictWeakOrdering 的 first_argument_type 和 second_argument_type
Compare：是 Strict Weak Ordering 的模型

函数参数

first：序列起始
last：序列末尾
comp：比较运算符

返回值

如果序列是按照 comp 排序的，返回 true；否则，返回 false

另请参阅

https://en.cppreference.com/w/cpp/algorithm/is_sorted
sort
stable_sort
less<T>

thrust::is_sorted_until

template <typename DerivedPolicy,
  typename ForwardIterator>
__host__ __device__ ForwardIterator
is_sorted_until(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last);

此版本的 is_sorted_until 返回 [first,last] 内使得 [first,last) 根据 operator< 排序的最后一个迭代器 i。如果 distance(first,last) < 2 ， is_sorted_until 则返回 last。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 is_sorted_until 查找数组中数据未排序的第一个位置：

#include <thrust/sort.h>
#include <thrust/execution_policy.h>

...

int A[8] = {0, 1, 2, 3, 0, 1, 2, 3};

int * B = thrust::is_sorted_until(thrust::host, A, A + 8);

// B - A is 4
// [A, B) is sorted

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 是 LessThan Comparable 的模型

函数参数

exec：用于并行化的执行策略
first：感兴趣范围的起始
last：感兴趣范围的末尾

返回值

输入范围内使其排序的最后一个迭代器

另请参阅

is_sorted
sort
sort_by_key
stable_sort
stable_sort_by_key

thrust::is_sorted_until

template <typename ForwardIterator>
ForwardIterator
is_sorted_until(ForwardIterator first,
  ForwardIterator last);

此版本的 is_sorted_until 返回 [first,last] 内使得 [first,last) 根据 operator< 排序的最后一个迭代器 i。如果 distance(first,last) < 2 ， is_sorted_until 则返回 last。

以下代码片段演示了如何使用 is_sorted_until 查找数组中数据未排序的第一个位置：

#include <thrust/sort.h>

...

int A[8] = {0, 1, 2, 3, 0, 1, 2, 3};

int * B = thrust::is_sorted_until(A, A + 8);

// B - A is 4
// [A, B) is sorted

模板参数

ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 是 LessThan Comparable 的模型

函数参数

first：感兴趣范围的起始
last：感兴趣范围的末尾

返回值

输入范围内使其排序的最后一个迭代器

另请参阅

is_sorted
sort
sort_by_key
stable_sort
stable_sort_by_key

thrust::is_sorted_until

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename Compare>
__host__ __device__ ForwardIterator
is_sorted_until(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  Compare comp);

此版本的 is_sorted_until 返回 [first,last] 内使得 [first,last) 根据函数对象 comp 排序的最后一个迭代器 i。如果 distance(first,last) < 2 ， is_sorted_until 则返回 last。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 is_sorted_until 查找数组中数据未按降序排序的第一个位置：

#include <thrust/sort.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>

...

int A[8] = {3, 2, 1, 0, 3, 2, 1, 0};

thrust::greater<int> comp;
int * B = thrust::is_sorted_until(thrust::host, A, A + 8, comp);

// B - A is 4
// [A, B) is sorted in descending order

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型，且 ForwardIterator 的 value_type 可转换为 Compare 的 argument_type
Compare：是 Strict Weak Ordering 的模型

函数参数

exec：用于并行化的执行策略
first：感兴趣范围的起始
last：感兴趣范围的末尾
comp：用于比较的函数对象

返回值

输入范围内使其排序的最后一个迭代器

另请参阅

is_sorted
sort
sort_by_key
stable_sort
stable_sort_by_key

thrust::is_sorted_until

template <typename ForwardIterator,
  typename Compare>
ForwardIterator
is_sorted_until(ForwardIterator first,
  ForwardIterator last,
  Compare comp);

此版本的 is_sorted_until 返回 [first,last] 内使得 [first,last) 根据函数对象 comp 排序的最后一个迭代器 i。如果 distance(first,last) < 2 ， is_sorted_until 则返回 last。

以下代码片段演示了如何使用 is_sorted_until 查找数组中数据未按降序排列的第一个位置：

#include <thrust/sort.h>
#include <thrust/functional.h>

...

int A[8] = {3, 2, 1, 0, 3, 2, 1, 0};

thrust::greater<int> comp;
int * B = thrust::is_sorted_until(A, A + 8, comp);

// B - A is 4
// [A, B) is sorted in descending order

模板参数

ForwardIterator：是 Forward Iterator 的模型，且 ForwardIterator 的 value_type 可转换为 Compare 的 argument_type
Compare：是 Strict Weak Ordering 的模型

函数参数

first：感兴趣范围的起始
last：感兴趣范围的末尾
comp：用于比较的函数对象

返回值

输入范围内使其排序的最后一个迭代器

另请参阅

is_sorted
sort
sort_by_key
stable_sort
stable_sort_by_key

2.1.4.7. 变换归约（Transformed Reduction）

函数

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputType>
__host__ __device__ OutputType
thrust::inner_product(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  OutputType init);

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputType>
OutputType
thrust::inner_product(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  OutputType init);

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputType,
  typename BinaryFunction1,
  typename BinaryFunction2>
__host__ __device__ OutputType
thrust::inner_product(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  OutputType init,
  BinaryFunction1 binary_op1,
  BinaryFunction2 binary_op2);

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputType,
  typename BinaryFunction1,
  typename BinaryFunction2>
OutputType
thrust::inner_product(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  OutputType init,
  BinaryFunction1 binary_op1,
  BinaryFunction2 binary_op2);

template <typename DerivedPolicy,
  typename InputIterator,
  typename UnaryFunction,
  typename OutputType,
  typename BinaryFunction>
__host__ __device__ OutputType
thrust::transform_reduce(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  UnaryFunction unary_op,
  OutputType init,
  BinaryFunction binary_op);

template <typename InputIterator,
  typename UnaryFunction,
  typename OutputType,
  typename BinaryFunction>
OutputType
thrust::transform_reduce(InputIterator first,
  InputIterator last,
  UnaryFunction unary_op,
  OutputType init,
  BinaryFunction binary_op);

thrust::inner_product

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputType>
__host__ __device__ OutputType
inner_product(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  OutputType init);

inner_product 计算范围 [first1, last1) 和 [first2, first2 + (last1 - first1)) 的内积。

具体而言，此版本的 inner_product 计算 init + (*first1 * *first2) + (*(first1+1) * *(first2+1)) + … 的和。

算法的执行由 exec 确定并行化。

下面的代码片段演示了如何通过 thrust::host 并行化执行策略，用 inner_product 计算两个向量的点积：

#include <thrust/inner_product.h>
#include <thrust/execution_policy.h>
...
float vec1[3] = {1.0f, 2.0f, 5.0f};
float vec2[3] = {4.0f, 1.0f, 5.0f};

float result = thrust::inner_product(thrust::host, vec1, vec1 + 3, vec2, 0.0f);

// result == 31.0f

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型
InputIterator2：是 Input Iterator 的模型
OutputType：是 Assignable 的模型，如果 x 是 OutputType 的类型对象， y 是 InputIterator1 的 value_type 的对象， z 是 InputIterator2 的 value_type 的对象，则定义 x + y * z ，且可转换为 OutputType

函数参数

exec：用于并行化的执行策略
first1：第一个序列的起始
last1：第一个序列的末尾
first2：第二个序列的起始
init：结果的初始值

返回值

序列 [first1, last1) 和 [first2, last2) 加上 init 的内积

另请参阅

https://en.cppreference.com/w/cpp/algorithm/inner_product

thrust::inner_product

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputType>
OutputType
inner_product(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  OutputType init);

inner_product 计算范围 [first1, last1) 和 [first2, first2 + (last1 - first1)) 的内积。

具体而言，此版本的 inner_product 计算 init + (*first1 * *first2) + (*(first1+1) * *(first2+1)) + … 的和。

与C++标准模板库函数 std::inner_product 不同，此函数不保证执行顺序。

下面的代码片段演示了如何使用 inner_product 计算两个向量的点积：

#include <thrust/inner_product.h>
...
float vec1[3] = {1.0f, 2.0f, 5.0f};
float vec2[3] = {4.0f, 1.0f, 5.0f};

float result = thrust::inner_product(vec1, vec1 + 3, vec2, 0.0f);

// result == 31.0f

模板参数

InputIterator1：是 Input Iterator 的模型
InputIterator2：是 Input Iterator 的模型
OutputType：是 Assignable 的模型，如果 x 是 OutputType 的类型对象， y 是 InputIterator1 的 value_type 的对象， z 是 InputIterator2 的 value_type 的对象，则定义 x + y * z ，且可转换为 OutputType

函数参数

first1：第一个序列的起始
last1：第一个序列的末尾
first2：第二个序列的起始
init：结果的初始值

返回值

序列 [first1, last1) 和 [first2, last2) 加上 init 的内积

另请参阅

https://en.cppreference.com/w/cpp/algorithm/inner_product

thrust::inner_product

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputType,
  typename BinaryFunction1,
  typename BinaryFunction2>
__host__ __device__ OutputType
inner_product(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  OutputType init,
  BinaryFunction1 binary_op1,
  BinaryFunction2 binary_op2);

inner_product 计算范围 [first1, last1) 和 [first2, first2 + (last1 - first1)) 的内积。

此版本的 inner_product 与第一个版本相同，只不过使用的是两个用户提供的函数对象，而不是 operator+ ‍和 operator*。

具体而言，此版本的 inner_product 计算 binary_op1( init, binary_op2(*first1, *first2) ), … 的和。

算法的执行由 exec 确定并行化。

#include <thrust/inner_product.h>
#include <thrust/execution_policy.h>
...
float vec1[3] = {1.0f, 2.0f, 5.0f};
float vec2[3] = {4.0f, 1.0f, 5.0f};

float init = 0.0f;
thrust::plus<float>       binary_op1;
thrust::multiplies<float> binary_op2;

float result = thrust::inner_product(thrust::host, vec1, vec1 + 3, vec2, init, binary_op1, binary_op2);

// result == 31.0f

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型， InputIterator1 的 value_type 可转换为 BinaryFunction2 的 first_argument_type
InputIterator2：是 Input Iterator 的模型， InputIterator2 的 value_type 可转换为 BinaryFunction2 的 second_argument_type
OutputType：是 Assignable 的模型， OutputType 可转换为 BinaryFunction1 的 first_argument_type
BinaryFunction1：是 Binary Function 的模型， BinaryFunction1 的 return_type 可转换为 OutputType
BinaryFunction2：是 Binary Function 的模型， BinaryFunction2 的 return_type 可转换为 BinaryFunction1 的 second_argument_type

函数参数

exec：用于并行化的执行策略
first1：第一个序列的起始
last1：第一个序列的末尾
first2：第二个序列的起始
init：结果的初始值
binary_op1：广义相加运算
binary_op2：广义相乘运算

返回值

序列 [first1, last1) 和 [first2, last2) 的内积

另请参阅

https://en.cppreference.com/w/cpp/algorithm/inner_product

thrust::inner_product

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputType,
  typename BinaryFunction1,
  typename BinaryFunction2>
OutputType
inner_product(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  OutputType init,
  BinaryFunction1 binary_op1,
  BinaryFunction2 binary_op2);

inner_product 计算范围 [first1, last1) 和 [first2, first2 + (last1 - first1)) 的内积。

此版本的 inner_product 与第一个版本相同，只不过使用的是两个用户提供的函数对象，而不是 operator+ ‍和 operator*。

具体而言，此版本的 inner_product 计算 binary_op1( init, binary_op2(*first1, *first2) ), … 的和。

与C++标准模板库函数 std::inner_product 不同，此函数不保证执行顺序。

#include <thrust/inner_product.h>
...
float vec1[3] = {1.0f, 2.0f, 5.0f};
float vec2[3] = {4.0f, 1.0f, 5.0f};

float init = 0.0f;
thrust::plus<float>       binary_op1;
thrust::multiplies<float> binary_op2;

float result = thrust::inner_product(vec1, vec1 + 3, vec2, init, binary_op1, binary_op2);

// result == 31.0f

模板参数

InputIterator1：是 Input Iterator 的模型， InputIterator1 的 value_type 可转换为 BinaryFunction2 的 first_argument_type
InputIterator2：是 Input Iterator 的模型， InputIterator2 的 value_type 可转换为 BinaryFunction2 的 second_argument_type
OutputType：是 Assignable 的模型， OutputType 可转换为 BinaryFunction1 的 first_argument_type
BinaryFunction1：是 Binary Function 的模型， BinaryFunction1 的 return_type 可转换为 OutputType
BinaryFunction2：是 Binary Function 的模型， BinaryFunction2 的 return_type 可转换为 BinaryFunction1 的 second_argument_type

函数参数

first1：第一个序列的起始
last1：第一个序列的末尾
first2：第二个序列的起始
init：结果的初始值
binary_op1：广义相加运算
binary_op2：广义相乘运算

返回值

序列 [first1, last1) 和 [first2, last2) 的内积

另请参阅

https://en.cppreference.com/w/cpp/algorithm/inner_product

thrust::transform_reduce

template <typename DerivedPolicy,
  typename InputIterator,
  typename UnaryFunction,
  typename OutputType,
  typename BinaryFunction>
__host__ __device__ OutputType
transform_reduce(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  UnaryFunction unary_op,
  OutputType init,
  BinaryFunction binary_op);

transform_reduce 融合了 transform 和 reduce 运算。 transform_reduce 相当于执行由 unary_op 定义的变换，使序列成为临时序列，然后对变换后的序列执行 reduce 运算。多数情况下，将这两个运算融合在一起更高效，因为需要的内存读取和写入更少了。

transform_reduce 根据 unary_op 对序列 [first, last) 的变换执行归约。具体而言，将 unary_op 应用于序列的每个元素，然后使用初始值 init 将结果归约为具有 binary_op 的单个值。请注意，不对初始值 init 应用变换 unary_op。不指定归约的顺序，所以 binary_op 必须具有交换律和结合律。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 transform_reduce 计算一个范围内元素绝对值的最大值：

#include <thrust/transform_reduce.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>

template<typename T>
struct absolute_value : public unary_function<T,T>
{
__host__ __device__ T operator()(const T &x) const
{
   return x < T(0) ? -x : x;
}
};

...

int data[6] = {-1, 0, -2, -2, 1, -3};
int result = thrust::transform_reduce(thrust::host,
data, data + 6,
absolute_value<int>(),
0,
thrust::maximum<int>());
// result == 3

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 UnaryFunction 的 argument_type
UnaryFunction：是 Unary Function 的模型， UnaryFunction 的 result_type 可转换为 OutputType
OutputType：是 Assignable 的模型，且可转换为 BinaryFunction 的 first_argument_type 和 second_argument_type
BinaryFunction：是 Binary Function 的模型， BinaryFunction 的 result_type 可转换为 OutputType

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾
unary_op：应用于输入序列每个元素的函数
init：结果被初始化为此值
binary_op：归约运算

返回值

变换归约的结果

另请参阅

transform
reduce

thrust::transform_reduce

template <typename InputIterator,
  typename UnaryFunction,
  typename OutputType,
  typename BinaryFunction>
OutputType
transform_reduce(InputIterator first,
  InputIterator last,
  UnaryFunction unary_op,
  OutputType init,
  BinaryFunction binary_op);

transform_reduce 融合了 transform 和 reduce 运算。 transform_reduce 相当于执行由 unary_op 定义的变换，使序列成为临时序列，然后对变换后的序列执行 reduce 运算。多数情况下，将这两个运算融合在一起更高效，因为需要的内存读取和写入更少了。

transform_reduce 根据 unary_op 对序列 [first, last) 的变换执行归约。具体而言，将 unary_op 应用于序列的每个元素，然后使用初始值 init 将结果归约为具有 binary_op 的单个值。请注意，不对初始值 init ‍应用变换 unary_op。不指定归约的顺序，所以 binary_op 必须具有交换律和结合律。

以下代码片段演示了如何使用 transform_reduce 计算一个范围内元素绝对值的最大值：

#include <thrust/transform_reduce.h>
#include <thrust/functional.h>

template<typename T>
struct absolute_value : public unary_function<T,T>
{
__host__ __device__ T operator()(const T &x) const
{
   return x < T(0) ? -x : x;
}
};

...

int data[6] = {-1, 0, -2, -2, 1, -3};
int result = thrust::transform_reduce(data, data + 6,
absolute_value<int>(),
0,
thrust::maximum<int>());
// result == 3

模板参数

InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 UnaryFunction 的 argument_type
UnaryFunction：是 Unary Function 的模型， UnaryFunction 的 result_type 可转换为 OutputType
OutputType：是 Assignable 的模型，且可转换为 BinaryFunction 的 first_argument_type 和 second_argument_type
BinaryFunction：是 Binary Function 的模型， BinaryFunction 的 result_type 可转换为 OutputType

函数参数

first：序列起始
last：序列末尾
unary_op：应用于输入序列每个元素的函数
init：结果被初始化为此值
binary_op：归约运算

返回值

变换归约的结果

另请参阅

transform
reduce

2.1.5. ‍重新排序（Reordering）

2.1.5.1. ‍分区（Partitioning）

函数

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename Predicate>
__host__ __device__ ForwardIterator
thrust::partition(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
 ForwardIterator first,
  ForwardIterator last,
  Predicate pred);

template <typename ForwardIterator,
  typename Predicate>
ForwardIterator
thrust::partition(ForwardIterator first,
  ForwardIterator last,
  Predicate pred);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename InputIterator,
  typename Predicate>
__host__ __device__ ForwardIterator
thrust::partition(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  InputIterator stencil,
  Predicate pred);

template <typename ForwardIterator,
  typename InputIterator,
  typename Predicate>
ForwardIterator
thrust::partition(ForwardIterator first,
  ForwardIterator last,
  InputIterator stencil,
  Predicate pred);

template <typename DerivedPolicy,
  typename InputIterator,
  typename OutputIterator1,
  typename OutputIterator2,
  typename Predicate>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
thrust::partition_copy(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  OutputIterator1 out_true,
  OutputIterator2 out_false,
  Predicate pred);

template <typename InputIterator,
  typename OutputIterator1,
  typename OutputIterator2,
  typename Predicate>
thrust::pair< OutputIterator1, OutputIterator2 >
thrust::partition_copy(InputIterator first,
  InputIterator last,
  OutputIterator1 out_true,
  OutputIterator2 out_false,
  Predicate pred);

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator1,
  typename OutputIterator2,
  typename Predicate>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
thrust::partition_copy(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first,
  InputIterator1 last,
  InputIterator2 stencil,
  OutputIterator1 out_true,
  OutputIterator2 out_false,
  Predicate pred);

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator1,
  typename OutputIterator2,
  typename Predicate>
thrust::pair< OutputIterator1, OutputIterator2 >
thrust::partition_copy(InputIterator1 first,
  InputIterator1 last,
  InputIterator2 stencil,
  OutputIterator1 out_true,
  OutputIterator2 out_false,
  Predicate pred);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename Predicate>
__host__ __device__ ForwardIterator
thrust::stable_partition(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  Predicate pred);

template <typename ForwardIterator,
  typename Predicate>
ForwardIterator
thrust::stable_partition(ForwardIterator first,
  ForwardIterator last,
  Predicate pred);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename InputIterator,
  typename Predicate>
__host__ __device__ ForwardIterator
thrust::stable_partition(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  InputIterator stencil,
  Predicate pred);

template <typename ForwardIterator,
  typename InputIterator,
  typename Predicate>
ForwardIterator
thrust::stable_partition(ForwardIterator first,
  ForwardIterator last,
  InputIterator stencil,
  Predicate pred);

template <typename DerivedPolicy,
  typename InputIterator,
  typename OutputIterator1,
  typename OutputIterator2,
  typename Predicate>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
thrust::stable_partition_copy(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  OutputIterator1 out_true,
  OutputIterator2 out_false,
  Predicate pred);

template <typename InputIterator,
  typename OutputIterator1,
  typename OutputIterator2,
  typename Predicate>
thrust::pair< OutputIterator1, OutputIterator2 >
thrust::stable_partition_copy(InputIterator first,
  InputIterator last,
  OutputIterator1 out_true,
  OutputIterator2 out_false,
  Predicate pred);

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator1,
  typename OutputIterator2,
  typename Predicate>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
thrust::stable_partition_copy(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first,
  InputIterator1 last,
  InputIterator2 stencil,
  OutputIterator1 out_true,
  OutputIterator2 out_false,
  Predicate pred);

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator1,
  typename OutputIterator2,
  typename Predicate>
thrust::pair< OutputIterator1, OutputIterator2 >
thrust::stable_partition_copy(InputIterator1 first,
  InputIterator1 last,
  InputIterator2 stencil,
  OutputIterator1 out_true,
  OutputIterator2 out_false,
  Predicate pred);

thrust::partition

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename Predicate>
__host__ __device__ ForwardIterator
partition(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  Predicate pred);

partition 基于函数对象 pred 对元素 [first, last) 重新排序，使得满足 pred 的所有元素先于不满足 pred 的元素。后置条件是，对于范围 [first, last) 内的某些迭代器 middle，范围 [first,middle) 内的每个迭代器 i 使 pred(*i) 为 true；范围 [middle, last) 内的每一个迭代器 i ‍使其为 false。 partition 的返回值是 middle。

请注意，两个重新排序的序列中元素的相对顺序不一定与原始序列中的顺序相同。另一种算法 stable_partition 确实保证了保持相对顺序。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 partition 对序列重新排序，使偶数先于奇数：

#include <thrust/partition.h>
#include <thrust/execution_policy.h>
...
struct is_even
{
__host__ __device__
bool operator()(const int &x)
{
   return (x % 2) == 0;
}
};
...
int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
const int N = sizeof(A)/sizeof(int);
thrust::partition(thrust::host,
A, A + N,
is_even());
// A is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 可转换为 Predicate 的 argument_type。 ForwardIterator 是可变的
Predicate：是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：待重新排序的序列的起始
last：待重新排序的序列的末尾
pred：决定序列 [first, last) 内每个元素属于哪个分区的函数对象

返回值

指向第二分区第一个元素的迭代器，即不满足 pred 的元素的序列

另请参阅

https://en.cppreference.com/w/cpp/algorithm/partition
stable_partition
partition_copy

thrust::partition

template <typename ForwardIterator,
  typename Predicate>
ForwardIterator
partition(ForwardIterator first,
  ForwardIterator last,
  Predicate pred);

partition 基于函数对象 pred 对元素 [first, last) 重新排序，使得满足 pred 的所有元素先于不满足 pred 的元素。后置条件是，对于范围 [first, last) 内的某些迭代器 middle，范围 [first,middle) 内的每个迭代器 i 使 pred(*i) 为 true；范围 [middle, last) 内的每一个迭代器 i ‍使其为 false。 partition 的返回值是 middle。

请注意，两个重新排序的序列中元素的相对顺序不一定与原始序列中的顺序相同。另一种算法 stable_partition 确实保证了保持相对顺序。

以下代码片段演示了如何使用 partition 对序列重新排序，使偶数先于奇数：

#include <thrust/partition.h>
...
struct is_even
{
__host__ __device__
bool operator()(const int &x)
{
   return (x % 2) == 0;
}
};
...
int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
const int N = sizeof(A)/sizeof(int);
thrust::partition(A, A + N,
is_even());
// A is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}

模板参数

ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 可转换为 Predicate 的 argument_type。 ForwardIterator 是可变的
Predicate：是 Predicate 的模型

函数参数

first：待重新排序的序列的起始
last：待重新排序的序列的末尾
pred：决定序列 [first, last) 内每个元素属于哪个分区的函数对象

返回值

指向第二分区第一个元素的迭代器，即不满足 pred 的元素的序列

另请参阅

https://en.cppreference.com/w/cpp/algorithm/partition
stable_partition
partition_copy

thrust::partition

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename InputIterator,
  typename Predicate>
__host__ __device__ ForwardIterator
partition(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  InputIterator stencil,
  Predicate pred);

partition 基于应用于模板范围 [stencil, stencil + (last - first)) 的函数对象 pred 对元素 [first, last) 重新排序，使得对应模板元素满足 pred 的所有元素先于其对应模板元素不满足 pred 的所有元素。后置条件是，对于范围 [first, last) 内的某些迭代器 middle，范围 [stencil,stencil + (middle - first)) 内的每个迭代器 stencil_i 使 pred(*stencil_i) 为 true；范围 [stencil + (middle - first), stencil + (last - first)) 内的每一个迭代器 stencil_i ‍使其为 false。 stable_partition 的返回值是 middle。

请注意，两个重新排序的序列中元素的相对顺序不一定与原始序列中的顺序相同。另一种算法 stable_partition 确实保证了保持相对顺序。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 partition 对序列重新排序，使偶数先于奇数：

#include <thrust/partition.h>
#include <thrust/execution_policy.h>
...
struct is_even
{
__host__ __device__
bool operator()(const int &x)
{
   return (x % 2) == 0;
}
};
...
int A[] = {0, 1, 0, 1, 0, 1, 0, 1, 0,  1};
int S[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
const int N = sizeof(A)/sizeof(int);
thrust::partition(thrust::host, A, A + N, S, is_even());
// A is now {1, 1, 1, 1, 1, 0, 0, 0, 0, 0}
// S is unmodified

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型，且 ForwardIterator 是可变的
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 Predicate 的 argument_type
Predicate：是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：待重新排序的序列的起始
last：待重新排序的序列的末尾
stencil：模版序列的起始
pred：决定序列 [first, last) 内每个元素属于哪个分区的函数对象

前提条件

范围 [first,last) ‍不应与范围 [stencil, stencil + (last - first)) 重叠

返回值

指向第二分区第一个元素的迭代器，即其模版元素不满足 pred 的元素的序列

另请参阅

https://en.cppreference.com/w/cpp/algorithm/partition
stable_partition
partition_copy

thrust::partition

template <typename ForwardIterator,
  typename InputIterator,
  typename Predicate>
ForwardIterator
partition(ForwardIterator first,
  ForwardIterator last,
  InputIterator stencil,
  Predicate pred);

partition 基于应用于模板范围 [stencil, stencil + (last - first)) 的函数对象 pred 对元素 [first, last) 重新排序，使得对应模板元素满足 pred 的所有元素先于其对应模板元素不满足 pred 的所有元素。后置条件是，对于范围 [first, last) 内的某些迭代器 middle，范围 [stencil,stencil + (middle - first)) 内的每个迭代器 stencil_i 使 pred(*stencil_i) 为 true；范围 [stencil + (middle - first), stencil + (last - first)) 内的每一个迭代器 stencil_i ‍使其为 false。 stable_partition 的返回值是 middle。

请注意，两个重新排序的序列中元素的相对顺序不一定与原始序列中的顺序相同。另一种算法 stable_partition 确实保证了保持相对顺序。

以下代码片段演示了如何使用 partition 对序列重新排序，使偶数先于奇数：

#include <thrust/partition.h>
...
struct is_even
{
__host__ __device__
bool operator()(const int &x)
{
   return (x % 2) == 0;
}
};
...
int A[] = {0, 1, 0, 1, 0, 1, 0, 1, 0,  1};
int S[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
const int N = sizeof(A)/sizeof(int);
thrust::partition(A, A + N, S, is_even());
// A is now {1, 1, 1, 1, 1, 0, 0, 0, 0, 0}
// S is unmodified

模板参数

ForwardIterator：是 Forward Iterator 的模型，且 ForwardIterator 是可变的
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 Predicate 的 argument_type
Predicate：是 Predicate 的模型

函数参数

first：待重新排序的序列的起始
last：待重新排序的序列的末尾
stencil：模版序列的起始
pred：决定序列 [first, last) 内每个元素属于哪个分区的函数对象

前提条件

范围 [first,last) ‍不应与范围 [stencil, stencil + (last - first)) 重叠

返回值

指向第二分区第一个元素的迭代器，即其模版元素不满足 pred 的元素的序列

另请参阅

https://en.cppreference.com/w/cpp/algorithm/partition
stable_partition
partition_copy

thrust::partition_copy

template <typename DerivedPolicy,
  typename InputIterator,
  typename OutputIterator1,
  typename OutputIterator2,
  typename Predicate>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
partition_copy(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  OutputIterator1 out_true,
  OutputIterator2 out_false,
  Predicate pred);

partition_copy 与 partition 的不同之处仅在于重新排序的序列被写入不同的输出序列，而不是就地写入。

partition_copy 基于函数对象 pred 复制 [first, last) ‍内的元素。‍将所有满足 pred 的元素复制到从 out_true 开始的范围，将所有不满足的元素复制到从 out_false 开始的范围。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 partition_copy 将一个序列分成偶数和奇数的两个输出序列：

#include <thrust/partition.h>
#include <thrust/execution_policy.h>
...
struct is_even
{
__host__ __device__
bool operator()(const int &x)
{
   return (x % 2) == 0;
}
};
...
int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int result[10];
const int N = sizeof(A)/sizeof(int);
int *evens = result;
int *odds  = result + 5;
thrust::partition_copy(thrust::host, A, A + N, evens, odds, is_even());
// A remains {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
// result is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}
// evens points to {2, 4, 6, 8, 10}
// odds points to {1, 3, 5, 7, 9}

备注

两个重新排序的序列中元素的相对顺序不一定与原始序列中的顺序相同。另一种算法 stable_partition_copy 确实保证了保持相对顺序。

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 Predicate 的 argument_type ，以及 OutputIterator1 和 OutputIterator2 的 value_types
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型
Predicate：是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：待重新排序的序列的起始
last：待重新排序的序列的末尾
out_true：满足 pred ‍的元素的目标结果序列
out_false：不满足 pred ‍的元素的目标结果序列
pred：决定序列 [first, last) 内每个元素属于哪个分区的函数对象

前提条件

输入范围不应与任何一个输出范围重叠

返回值

p pair ，其中 p.first 是从 out_true 开始的输出范围的末尾， p.second 是从 out_false 开始的输出范围的末尾

另请参阅

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2569.pdf
stable_partition_copy
partition

thrust::partition_copy

template <typename InputIterator,
  typename OutputIterator1,
  typename OutputIterator2,
  typename Predicate>
thrust::pair< OutputIterator1, OutputIterator2 >
partition_copy(InputIterator first,
  InputIterator last,
  OutputIterator1 out_true,
  OutputIterator2 out_false,
  Predicate pred);

partition_copy 与 partition 的不同之处仅在于重新排序的序列被写入不同的输出序列，而不是就地写入。

partition_copy 基于函数对象 pred 复制 [first, last) ‍内的元素。‍将所有满足 pred 的元素复制到从 out_true 开始的范围，将所有不满足的元素复制到从 out_false 开始的范围。

以下代码片段演示了如何使用 partition_copy 将一个序列分成偶数和奇数的两个输出序列：

#include <thrust/partition.h>
...
struct is_even
{
__host__ __device__
bool operator()(const int &x)
{
   return (x % 2) == 0;
}
};
...
int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int result[10];
const int N = sizeof(A)/sizeof(int);
int *evens = result;
int *odds  = result + 5;
thrust::partition_copy(A, A + N, evens, odds, is_even());
// A remains {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
// result is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}
// evens points to {2, 4, 6, 8, 10}
// odds points to {1, 3, 5, 7, 9}

备注

两个重新排序的序列中元素的相对顺序不一定与原始序列中的顺序相同。另一种算法 stable_partition_copy 确实保证了保持相对顺序。

模板参数

InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 Predicate 的 argument_type ，以及 OutputIterator1 和 OutputIterator2 的 value_types
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型
Predicate：是 Predicate 的模型

函数参数

first：待重新排序的序列的起始
last：待重新排序的序列的末尾
out_true：满足 pred ‍的元素的目标结果序列
out_false：不满足 pred ‍的元素的目标结果序列
pred：决定序列 [first, last) 内每个元素属于哪个分区的函数对象

前提条件

输入范围不应与任何一个输出范围重叠

返回值

p pair ，其中 p.first 是从 out_true 开始的输出范围的末尾， p.second 是从 out_false 开始的输出范围的末尾

另请参阅

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2569.pdf
stable_partition_copy
partition

thrust::partition_copy

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator1,
  typename OutputIterator2,
  typename Predicate>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
partition_copy(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first,
  InputIterator1 last,
  InputIterator2 stencil,
  OutputIterator1 out_true,
  OutputIterator2 out_false,
  Predicate pred);

partition_copy 与 partition 的不同之处仅在于重新排序的序列被写入不同的输出序列，而不是就地写入。

partition_copy 基于应用于模板元素范围的函数对象 pred 复制 [first, last) ‍内的元素。‍将其相应模板元素满足 pred 的所有元素复制到从 out_true 开始的范围，将其模板元素不满足 pred 的所有元素复制到从 out_false 开始的范围。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 partition_copy 将一个序列分成偶数和奇数的两个输出序列：

#include <thrust/partition.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int S[] = {0, 1, 0, 1, 0, 1, 0, 1, 0,  1};
int result[10];
const int N = sizeof(A)/sizeof(int);
int *evens = result;
int *odds  = result + 5;
thrust::stable_partition_copy(thrust::host, A, A + N, S, evens, odds, thrust::identity<int>());
// A remains {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
// S remains {0, 1, 0, 1, 0, 1, 0, 1, 0,  1}
// result is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}
// evens points to {2, 4, 6, 8, 10}
// odds points to {1, 3, 5, 7, 9}

备注

两个重新排序的序列中元素的相对顺序不一定与原始序列中的顺序相同。另一种算法 stable_partition_copy 确实保证了保持相对顺序。

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 OutputIterator1 和 OutputIterator2 的 value_types
InputIterator2：是 Input Iterator 的模型， InputIterator2 的 value_type 可转换为 Predicate 的 argument_type
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型
Predicate：是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：待重新排序的序列的起始
last：待重新排序的序列的末尾
stencil：模版序列的起始
out_true：满足 pred ‍的元素的目标结果序列
out_false：不满足 pred ‍的元素的目标结果序列
pred：决定序列 [first, last) 内每个元素属于哪个分区的函数对象

前提条件

输入范围不应与任何一个输出范围重叠

返回值

p pair ，其中 p.first 是从 out_true 开始的输出范围的末尾， p.second 是从 out_false 开始的输出范围的末尾

另请参阅

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2569.pdf
stable_partition_copy
partition

thrust::partition_copy

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator1,
  typename OutputIterator2,
  typename Predicate>
thrust::pair< OutputIterator1, OutputIterator2 >
partition_copy(InputIterator1 first,
  InputIterator1 last,
  InputIterator2 stencil,
  OutputIterator1 out_true,
  OutputIterator2 out_false,
  Predicate pred);

partition_copy 与 partition 的不同之处仅在于重新排序的序列被写入不同的输出序列，而不是就地写入。

partition_copy 基于应用于模板元素范围的函数对象 pred 复制 [first, last) ‍内的元素。‍将其相应模板元素满足 pred 的所有元素复制到从 out_true 开始的范围，将其模板元素不满足 pred 的所有元素复制到从 out_false 开始的范围。

以下代码片段演示了如何使用 partition_copy 将一个序列分成偶数和奇数的两个输出序列：

#include <thrust/partition.h>
#include <thrust/functional.h>
...
int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int S[] = {0, 1, 0, 1, 0, 1, 0, 1, 0,  1};
int result[10];
const int N = sizeof(A)/sizeof(int);
int *evens = result;
int *odds  = result + 5;
thrust::stable_partition_copy(A, A + N, S, evens, odds, thrust::identity<int>());
// A remains {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
// S remains {0, 1, 0, 1, 0, 1, 0, 1, 0,  1}
// result is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}
// evens points to {2, 4, 6, 8, 10}
// odds points to {1, 3, 5, 7, 9}

备注

两个重新排序的序列中元素的相对顺序不一定与原始序列中的顺序相同。另一种算法 stable_partition_copy 确实保证了保持相对顺序。

模板参数

InputIterator1：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 OutputIterator1 和 OutputIterator2 的 value_types
InputIterator2：是 Input Iterator 的模型， InputIterator2 的 value_type 可转换为 Predicate 的 argument_type
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型
Predicate：是 Predicate 的模型

函数参数

first：待重新排序的序列的起始
last：待重新排序的序列的末尾
stencil：模版序列的起始
out_true：满足 pred ‍的元素的目标结果序列
out_false：不满足 pred ‍的元素的目标结果序列
pred：决定序列 [first, last) 内每个元素属于哪个分区的函数对象

前提条件

输入范围不应与任何一个输出范围重叠

返回值

p pair ，其中 p.first 是从 out_true 开始的输出范围的末尾， p.second 是从 out_false 开始的输出范围的末尾

另请参阅

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2569.pdf
stable_partition_copy
partition

thrust::stable_partition

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename Predicate>
__host__ __device__ ForwardIterator
stable_partition(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  Predicate pred);

stable_partition 很像 partition ，它基于函数对象 pred 对元素 [first, last) 重新排序，使得满足 pred 的所有元素先于不满足 pred 的元素。后置条件是，对于范围 [first, last) 内的某些迭代器 middle ，范围 [first,middle) 内的每个迭代器 i 使 pred(*i) 为 true；范围 [middle, last) 内的每一个迭代器 i ‍使其为 false。 stable_partition 的返回值是 middle。

stable_partition 与 partition 的不同之处在于 stable_partition 会保持相对顺序。即，如果 x 和 y 是 [first, last) 内的元素， stencil_x 和 stencil_y 是 [stencil, stencil + (last - first)) 内相应位置的模版元素，满足 pred(stencil_x) == pred(stencil_y) ，并且如果 x ‍先于 y ，那么在 stable_partition 之后， x 先与 y 仍然为 true 。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 stable_partition 对序列重新排序，使偶数先于奇数：

#include <thrust/partition.h>
#include <thrust/execution_policy.h>
...
struct is_even
{
__host__ __device__
bool operator()(const int &x)
{
   return (x % 2) == 0;
}
};
...
int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
const int N = sizeof(A)/sizeof(int);
thrust::stable_partition(thrust::host,
   A, A + N,
   is_even());
// A is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 可转换为 Predicate 的 argument_type。 ForwardIterator 是可变的
Predicate：是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：待重新排序的序列的第一个元素
last1：待重新排序的序列中最末元素之后的一个位置
pred：决定序列 [first, last) 内每个元素属于哪个分区的函数对象

返回值

指向第二分区第一个元素的迭代器，即不满足 pred 的元素序列

另请参阅

https://en.cppreference.com/w/cpp/algorithm/stable_partition
partition
stable_partition_copy

thrust::stable_partition

template <typename ForwardIterator,
  typename Predicate>
ForwardIterator
stable_partition(ForwardIterator first,
  ForwardIterator last,
  Predicate pred);

stable_partition 很像 partition ，它基于函数对象 pred 对元素 [first, last) 重新排序，使得满足 pred 的所有元素先于不满足 pred 的元素。后置条件是，对于范围 [first, last) 内的某些迭代器 middle，范围 [first,middle) 内的每个迭代器 i 使 pred(*i) 为 true；范围 [middle, last) 内的每一个迭代器 i ‍使其为 false。 stable_partition 的返回值是 middle。

stable_partition 与 partition 的不同之处在于 stable_partition 会保持相对顺序。即，如果 x 和 y 是 [first, last) 内的元素， stencil_x 和 stencil_y 是 [stencil, stencil + (last - first)) 内相应位置的模版元素，满足 pred(stencil_x) == pred(stencil_y) ，并且如果 x ‍先于 y ，那么在 stable_partition 之后， x 先与 y 仍然为 true 。

以下代码片段演示了如何使用 stable_partition 对序列重新排序，使偶数先于奇数：

#include <thrust/partition.h>
...
struct is_even
{
__host__ __device__
bool operator()(const int &x)
{
   return (x % 2) == 0;
}
};
...
int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
const int N = sizeof(A)/sizeof(int);
thrust::stable_partition(A, A + N,
   is_even());
// A is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}

模板参数

ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 可转换为 Predicate 的 argument_type。 ForwardIterator 是可变的
Predicate：是 Predicate 的模型

函数参数

first：待重新排序的序列第一个元素
last1：待重新排序的序列中最末元素之后的一个位置
pred：决定序列 [first, last) 内每个元素属于哪个分区的函数对象

返回值

指向第二分区第一个元素的迭代器，即不满足 pred 的元素序列

另请参阅

https://en.cppreference.com/w/cpp/algorithm/stable_partition
partition
stable_partition_copy

thrust::stable_partition

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename InputIterator,
  typename Predicate>
__host__ __device__ ForwardIterator
stable_partition(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  InputIterator stencil,
  Predicate pred);

stable_partition 很像 partition ，它基于应用于模板范围 [stencil, stencil + (last - first)) 的函数对象 pred 对元素 [first, last) 重新排序，使得对应模板元素满足 pred 的所有元素先于其对应模板元素不满足 pred 的所有元素。后置条件是，对于范围 [first, last) 内的某些迭代器 middle，范围 [stencil,stencil + (middle - first)) 内的每个迭代器 stencil_i 使 pred(*stencil_i) 为 true；范围 [stencil + (middle - first), stencil + (last - first)) 内的每一个迭代器 stencil_i ‍使其为 false。 stable_partition 的返回值是 middle。

stable_partition 与 partition 的不同之处在于 stable_partition 会保持相对顺序。即，如果 x 和 y 是 [first, last) 内的元素，满足 pred(x) == pred(y)，并且如果 x ‍先于 y，那么在 stable_partition 之后， x 先于 y ‍仍然为 true 。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 stable_partition 对序列重新排序，使偶数先于奇数：

#include <thrust/partition.h>
#include <thrust/execution_policy.h>
...
struct is_even
{
__host__ __device__
bool operator()(const int &x)
{
   return (x % 2) == 0;
}
};
...
int A[] = {0, 1, 0, 1, 0, 1, 0, 1, 0,  1};
int S[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
const int N = sizeof(A)/sizeof(int);
thrust::stable_partition(thrust::host, A, A + N, S, is_even());
// A is now {1, 1, 1, 1, 1, 0, 0, 0, 0, 0}
// S is unmodified

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型，且 ForwardIterator 是可变的
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 Predicate 的 argument_type
Predicate：是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：待重新排序的序列第一个元素
last1：待重新排序的序列中最末元素之后的一个位置
stencil：模版序列的起始
pred：决定序列 [first, last) 内每个元素属于哪个分区的函数对象

前提条件

范围 [first, last) 不应与范围 [stencil, stencil + (last - first)) 重叠

返回值

指向第二分区第一个元素的迭代器，即其模版元素不满足 pred 的元素的序列

另请参阅

https://en.cppreference.com/w/cpp/algorithm/stable_partition
partition
stable_partition_copy

thrust::stable_partition

template <typename ForwardIterator,
  typename InputIterator,
  typename Predicate>
ForwardIterator
stable_partition(ForwardIterator first,
  ForwardIterator last,
  InputIterator stencil,
  Predicate pred);

stable_partition 很像 partition ，它基于应用于模板范围 [stencil, stencil + (last - first)) 的函数对象 pred 对元素 [first, last) 重新排序，使得对应模板元素满足 pred 的所有元素先于其对应模板元素不满足 pred 的所有元素。后置条件是，对于范围 [first, last) 内的某些迭代器 middle，范围 [stencil,stencil + (middle - first)) 内的每个迭代器 stencil_i 使 pred(*stencil_i) 为 true；范围 [stencil + (middle - first), stencil + (last - first)) 内的每一个迭代器 stencil_i ‍使其为 false。 stable_partition 的返回值是 middle。

stable_partition 与 partition 的不同之处在于 stable_partition 会保持相对顺序。即，如果 x 和 y 是 [first, last) 内的元素，满足 pred(x) == pred(y)，并且如果 x ‍先于 y，那么在 stable_partition 之后， x 先于 y ‍仍然为 true 。

以下代码片段演示了如何使用 stable_partition 对序列重新排序，使偶数先于奇数：

#include <thrust/partition.h>
...
struct is_even
{
__host__ __device__
bool operator()(const int &x)
{
   return (x % 2) == 0;
}
};
...
int A[] = {0, 1, 0, 1, 0, 1, 0, 1, 0,  1};
int S[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
const int N = sizeof(A)/sizeof(int);
thrust::stable_partition(A, A + N, S, is_even());
// A is now {1, 1, 1, 1, 1, 0, 0, 0, 0, 0}
// S is unmodified

模板参数

ForwardIterator：是 Forward Iterator 的模型，且 ForwardIterator 是可变的
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 Predicate 的 argument_type
Predicate：是 Predicate 的模型

函数参数

first：待重新排序的序列第一个元素
last1：待重新排序的序列中最末元素之后的一个位置
stencil：模版序列的起始
pred：决定序列 [first, last) 内每个元素属于哪个分区的函数对象

前提条件

范围 [first, last) 不应与范围 [stencil, stencil + (last - first)) 重叠

返回值

指向第二分区第一个元素的迭代器，即其模版元素不满足 pred 的元素的序列

另请参阅

https://en.cppreference.com/w/cpp/algorithm/stable_partition
partition
stable_partition_copy

thrust::stable_partition_copy

template <typename DerivedPolicy,
  typename InputIterator,
  typename OutputIterator1,
  typename OutputIterator2,
  typename Predicate>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
stable_partition_copy(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  OutputIterator1 out_true,
  OutputIterator2 out_false,
  Predicate pred);

stable_partition_copy 与 stable_partition 的不同之处仅在于重新排序的序列被写入不同的输出序列，而不是就地写入。

stable_partition_copy 基于函数对象 pred 复制 [first, last) ‍内的元素。 ‍将所有满足 pred 的元素复制到从 out_true 开始的范围，将所有不满足的元素复制到从 out_false 开始的范围。

stable_partition_copy 与 partition_copy 的不同之处在于 stable_partition_copy 会保持相对顺序。即，如果 x 和 y 是 [first, last) 内的元素，满足 pred(x) == pred(y) ，并且如果 x ‍先于 y ，那么在 stable_partition_copy 之后，在输出中 x 先于 y 仍然为 true 。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 stable_partition_copy 对序列重新排序，使偶数先于奇数：

#include <thrust/partition.h>
#include <thrust/execution_policy.h>
...
struct is_even
{
__host__ __device__
bool operator()(const int &x)
{
   return (x % 2) == 0;
}
};
...
int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int result[10];
const int N = sizeof(A)/sizeof(int);
int *evens = result;
int *odds  = result + 5;
thrust::stable_partition_copy(thrust::host, A, A + N, evens, odds, is_even());
// A remains {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
// result is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}
// evens points to {2, 4, 6, 8, 10}
// odds points to {1, 3, 5, 7, 9}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 Predicate 的 argument_type ，以及 OutputIterator1 和 OutputIterator2 的 value_types
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型
Predicate：是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：待重新排序的序列第一个元素
last1：待重新排序的序列中最末元素之后的一个位置
out_true：满足 pred ‍的元素的目标结果序列
out_false：不满足 pred ‍的元素的目标结果序列
pred：决定序列 [first, last) 内每个元素属于哪个分区的函数对象

前提条件

输入范围不应与任何一个输出范围重叠

返回值

p pair ，其中 p.first 是从 out_true 开始的输出范围的末尾， p.second 是从 out_false 开始的输出范围的末尾

另请参阅

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2569.pdf
partition_copy
stable_partition

thrust::stable_partition_copy

template <typename InputIterator,
  typename OutputIterator1,
  typename OutputIterator2,
  typename Predicate>
thrust::pair< OutputIterator1, OutputIterator2 >
stable_partition_copy(InputIterator first,
  InputIterator last,
  OutputIterator1 out_true,
  OutputIterator2 out_false,
  Predicate pred);

stable_partition_copy 与 stable_partition 的不同之处仅在于重新排序的序列被写入不同的输出序列，而不是就地写入。

stable_partition_copy 基于函数对象 pred 复制 [first, last) ‍内的元素。 ‍将所有满足 pred 的元素复制到从 out_true 开始的范围，将所有不满足的元素复制到从 out_false 开始的范围。

stable_partition_copy 与 partition_copy 的不同之处在于 stable_partition_copy 会保持相对顺序。即，如果 x 和 y 是 [first, last) 内的元素，满足 pred(x) == pred(y)，并且如果 x ‍先于 y ，那么在 stable_partition_copy 之后，在输出中 x 先于 y 仍然为 true 。

以下代码片段演示了如何使用 stable_partition_copy 对序列重新排序，使偶数先于奇数：

#include <thrust/partition.h>
...
struct is_even
{
__host__ __device__
bool operator()(const int &x)
{
   return (x % 2) == 0;
}
};
...
int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int result[10];
const int N = sizeof(A)/sizeof(int);
int *evens = result;
int *odds  = result + 5;
thrust::stable_partition_copy(A, A + N, evens, odds, is_even());
// A remains {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
// result is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}
// evens points to {2, 4, 6, 8, 10}
// odds points to {1, 3, 5, 7, 9}

模板参数

InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 Predicate 的 argument_type ，以及 OutputIterator1 和 OutputIterator2 的 value_types
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型
Predicate：是 Predicate 的模型

函数参数

first：待重新排序的序列第一个元素
last1：待重新排序的序列中最末元素之后的一个位置
out_true：满足 pred ‍的元素的目标结果序列
out_false：不满足 pred ‍的元素的目标结果序列
pred：决定序列 [first, last) 内每个元素属于哪个分区的函数对象

前提条件

输入范围不应与任何一个输出范围重叠

返回值

p pair ，其中 p.first 是从 out_true 开始的输出范围的末尾， p.second 是从 out_false 开始的输出范围的末尾

另请参阅

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2569.pdf
partition_copy
stable_partition

thrust::stable_partition_copy

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator1,
  typename OutputIterator2,
  typename Predicate>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
stable_partition_copy(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first,
  InputIterator1 last,
  InputIterator2 stencil,
  OutputIterator1 out_true,
  OutputIterator2 out_false,
  Predicate pred);

stable_partition_copy 与 stable_partition 的不同之处仅在于重新排序的序列被写入不同的输出序列，而不是就地写入。

stable_partition_copy 基于应用于模板元素范围的函数对象 pred 复制 [first, last) ‍内的元素。 ‍将其相应模板元素满足 pred 的所有元素复制到从 out_true 开始的范围，将其模板元素不满足 pred 的所有元素复制到从 out_false 开始的范围。

stable_partition_copy 与 partition_copy 的不同之处在于 stable_partition_copy 会保持相对顺序。即，如果 x 和 y 是 [first, last) 内的元素，满足 pred(x) == pred(y)，并且如果 x ‍先于 y ，那么在 stable_partition_copy 之后，在输出中 x 先于 y 仍然为 true 。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 stable_partition_copy 对序列重新排序，使偶数先于奇数：

#include <thrust/partition.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int S[] = {0, 1, 0, 1, 0, 1, 0, 1, 0,  1};
int result[10];
const int N = sizeof(A)/sizeof(int);
int *evens = result;
int *odds  = result + 5;
thrust::stable_partition_copy(thrust::host, A, A + N, S, evens, odds, thrust::identity<int>());
// A remains {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
// S remains {0, 1, 0, 1, 0, 1, 0, 1, 0,  1}
// result is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}
// evens points to {2, 4, 6, 8, 10}
// odds points to {1, 3, 5, 7, 9}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 OutputIterator1 和 OutputIterator2 的 value_types
InputIterator2：是 Input Iterator 的模型， InputIterator2 的 value_type 可转换为 Predicate 的 argument_type
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型
Predicate：是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：待重新排序的序列第一个元素
last1：待重新排序的序列中最末元素之后的一个位置
stencil：模版序列的起始
out_true：满足 pred ‍的元素的目标结果序列
out_false：不满足 pred ‍的元素的目标结果序列
pred：决定序列 [first, last) 内每个元素属于哪个分区的函数对象

前提条件

输入范围不应与任何一个输出范围重叠

返回值

p pair ，其中 p.first 是从 out_true 开始的输出范围的末尾， p.second 是从 out_false 开始的输出范围的末尾

另请参阅

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2569.pdf
partition_copy
stable_partition

thrust::stable_partition_copy

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator1,
  typename OutputIterator2,
  typename Predicate>
thrust::pair< OutputIterator1, OutputIterator2 >
stable_partition_copy(InputIterator1 first,
  InputIterator1 last,
  InputIterator2 stencil,
  OutputIterator1 out_true,
  OutputIterator2 out_false,
  Predicate pred);

stable_partition_copy 与 stable_partition 的不同之处仅在于重新排序的序列被写入不同的输出序列，而不是就地写入。

stable_partition_copy 基于应用于模板元素范围的函数对象 pred 复制 [first, last) ‍内的元素。 ‍将其相应模板元素满足 pred 的所有元素复制到从 out_true 开始的范围，将其模板元素不满足 pred 的所有元素复制到从 out_false 开始的范围。

stable_partition_copy 与 partition_copy 的不同之处在于 stable_partition_copy 会保持相对顺序。即，如果 x 和 y 是 [first, last) 内的元素，满足 pred(x) == pred(y)，并且如果 x ‍先于 y ，那么在 stable_partition_copy 之后，在输出中 x 先于 y 仍然为 true 。

以下代码片段演示了如何使用 stable_partition_copy 对序列重新排序，使偶数先于奇数：

#include <thrust/partition.h>
#include <thrust/functional.h>
...
int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int S[] = {0, 1, 0, 1, 0, 1, 0, 1, 0,  1};
int result[10];
const int N = sizeof(A)/sizeof(int);
int *evens = result;
int *odds  = result + 5;
thrust::stable_partition_copy(A, A + N, S, evens, odds, thrust::identity<int>());
// A remains {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
// S remains {0, 1, 0, 1, 0, 1, 0, 1, 0,  1}
// result is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}
// evens points to {2, 4, 6, 8, 10}
// odds points to {1, 3, 5, 7, 9}

模板参数

InputIterator1：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 OutputIterator1 和 OutputIterator2 的 value_types
InputIterator2：是 Input Iterator 的模型， InputIterator2 的 value_type 可转换为 Predicate 的 argument_type
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型
Predicate：是 Predicate 的模型

函数参数

first：待重新排序的序列第一个元素
last1：待重新排序的序列中最末元素之后的一个位置
stencil：模版序列的起始
out_true：满足 pred ‍的元素的目标结果序列
out_false：不满足 pred ‍的元素的目标结果序列
pred：决定序列 [first, last) 内每个元素属于哪个分区的函数对象

前提条件

输入范围不应与任何一个输出范围重叠

返回值

p pair ，其中 p.first 是从 out_true 开始的输出范围的末尾， p.second 是从 out_false 开始的输出范围的末尾

另请参阅

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2569.pdf
partition_copy
stable_partition

2.1.5.2. ‍洗牌（Shuffling）

洗牌

template <typename DerivedPolicy,
  typename RandomIterator,
  typename URBG>
__host__ __device__ void
thrust::shuffle(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  RandomIterator first,
  RandomIterator last,
  URBG && g);

template <typename RandomIterator,
  typename URBG>
__host__ __device__ void
thrust::shuffle(RandomIterator first,
  RandomIterator last,
  URBG && g);

template <typename DerivedPolicy,
  typename RandomIterator,
  typename OutputIterator,
  typename URBG>
__host__ __device__ void
thrust::shuffle_copy(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  RandomIterator first,
  RandomIterator last,
  OutputIterator result,
  URBG && g);

template <typename RandomIterator,
  typename OutputIterator,
  typename URBG>
__host__ __device__ void
thrust::shuffle_copy(RandomIterator first,
  RandomIterator last,
  OutputIterator result,
  URBG && g);

thrust::shuffle

template <typename DerivedPolicy,
  typename RandomIterator,
  typename URBG>
__host__ __device__ void
shuffle(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  RandomIterator first,
  RandomIterator last,
  URBG && g);

shuffle 通过由随机引擎 g 定义的均匀伪随机排列（uniform pseudorandom permutation）来重新排序元素 [first, last)。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 shuffle 创建随机排列：

#include <thrust/shuffle.h>
#include <thrust/random.h>
#include <thrust/execution_policy.h>
int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
const int N = sizeof(A)/sizeof(int);
thrust::default_random_engine g;
thrust::shuffle(thrust::host, A, A + N, g);
// A is now {6, 5, 8, 7, 2, 1, 4, 3, 10, 9}

模板参数

DerivedPolicy：派生执行策略的名称
RandomIterator：随机访问迭代器
URBG：均匀随机位生成器

函数参数

exec：用于并行化的执行策略
first：待洗牌的序列起始
last：待洗牌的序列末尾
g：一个均匀随机位生成器

另请参阅

shuffle_copy

thrust::shuffle

template <typename RandomIterator,
  typename URBG>
__host__ __device__ void
shuffle(RandomIterator first,
  RandomIterator last,
  URBG && g);

shuffle 通过由随机引擎 g 定义的均匀伪随机排列来重新排序元素 [first, last)。

以下代码片段演示了如何使用 shuffle 创建随机排列：

#include <thrust/shuffle.h>
#include <thrust/random.h>
int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
const int N = sizeof(A)/sizeof(int);
thrust::default_random_engine g;
thrust::shuffle(A, A + N, g);
// A is now {6, 5, 8, 7, 2, 1, 4, 3, 10, 9}

模板参数

RandomIterator：随机访问迭代器
URBG：均匀随机位生成器

函数参数

first：待洗牌的序列起始
last：待洗牌的序列末尾
g：一个均匀随机位生成器

另请参阅

shuffle_copy

thrust::shuffle_copy

template <typename DerivedPolicy,
  typename RandomIterator,
  typename OutputIterator,
  typename URBG>
__host__ __device__ void
shuffle_copy(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  RandomIterator first,
  RandomIterator last,
  OutputIterator result,
  URBG && g);

shuffle_copy 与 shuffle 的不同之处仅在于重新排序的序列被写入不同的输出序列，而不是就地写入。 shuffle_copy 通过由随机引擎 g 定义的均匀伪随机排列来重新排序元素 [first, last)。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何使用 shuffle_copy 创建随机排列：

#include <thrust/shuffle.h>
#include <thrust/random.h>
#include <thrust/execution_policy.h>
int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int result[10];
const int N = sizeof(A)/sizeof(int);
thrust::default_random_engine g;
thrust::shuffle_copy(thrust::host, A, A + N, result, g);
// result is now {6, 5, 8, 7, 2, 1, 4, 3, 10, 9}

模板参数

DerivedPolicy：派生执行策略的名称
RandomIterator：随机访问迭代器
OutputIterator：是 Output Iterator 的模型
URBG：均匀随机位生成器

函数参数

exec：用于并行化的执行策略
first：待洗牌的序列起始
last：待洗牌的序列末尾
result：已洗牌的目标序列
g：一个均匀随机位生成器

另请参阅

shuffle

thrust::shuffle_copy

template <typename RandomIterator,
  typename OutputIterator,
  typename URBG>
__host__ __device__ void
shuffle_copy(RandomIterator first,
  RandomIterator last,
  OutputIterator result,
  URBG && g);

shuffle_copy 与 shuffle 的不同之处仅在于重新排序的序列被写入不同的输出序列，而不是就地写入。 shuffle_copy 通过由随机引擎 g 定义的均匀伪随机排列来重新排序元素 [first, last)。

以下代码片段演示了如何使用 shuffle_copy 创建随机排列：

#include <thrust/shuffle.h>
#include <thrust/random.h>
int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int result[10];
const int N = sizeof(A)/sizeof(int);
thrust::default_random_engine g;
thrust::shuffle_copy(A, A + N, result, g);
// result is now {6, 5, 8, 7, 2, 1, 4, 3, 10, 9}

模板参数

RandomIterator：随机访问迭代器
OutputIterator：是 Output Iterator 的模型
URBG：均匀随机位生成器

函数参数

first：待洗牌的序列起始
last：待洗牌的序列末尾
result：已洗牌的目标序列
g：一个均匀随机位生成器

另请参阅

shuffle

2.1.5.3. ‌‍流压缩（Stream Compaction）

‌‍流压缩

template <typename DerivedPolicy,
  typename InputIterator,
  typename OutputIterator,
  typename Predicate>
__host__ __device__ OutputIterator
thrust::copy_if(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  OutputIterator result,
  Predicate pred);

template <typename InputIterator,
  typename OutputIterator,
  typename Predicate>
OutputIterator
thrust::copy_if(InputIterator first,
  InputIterator last,
  OutputIterator result,
  Predicate pred);

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename Predicate>
__host__ __device__ OutputIterator
thrust::copy_if(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first,
  InputIterator1 last,
  InputIterator2 stencil,
  OutputIterator result,
   Predicate pred);

 template <typename InputIterator1,
   typename InputIterator2,
   typename OutputIterator,
   typename Predicate>
 OutputIterator
 thrust::copy_if(InputIterator1 first,
   InputIterator1 last,
   InputIterator2 stencil,
   OutputIterator result,
   Predicate pred);

 template <typename DerivedPolicy,
   typename ForwardIterator,
   typename T>
 __host__ __device__ ForwardIterator
 thrust::remove(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
   ForwardIterator first,
   ForwardIterator last,
   const T & value);

 template <typename ForwardIterator,
    typename T>
  ForwardIterator
  thrust::remove(ForwardIterator first,
    ForwardIterator last,
    const T & value);

  template <typename DerivedPolicy,
    typename InputIterator,
    typename OutputIterator,
    typename T>
  __host__ __device__ OutputIterator
  thrust::remove_copy(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    const T & value);

  template <typename InputIterator,
    typename OutputIterator,
    typename T>
  OutputIterator
  thrust::remove_copy(InputIterator first,
    InputIterator last,
    OutputIterator result,
    const T & value);

  template <typename DerivedPolicy,
    typename ForwardIterator,
    typename Predicate>
  __host__ __device__ ForwardIterator
  thrust::remove_if(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
    ForwardIterator first,
    ForwardIterator last,
    Predicate pred);

  template <typename ForwardIterator,
    typename Predicate>
  ForwardIterator
  thrust::remove_if(ForwardIterator first,
    ForwardIterator last,
    Predicate pred);

  template <typename DerivedPolicy,
    typename InputIterator,
    typename OutputIterator,
    typename Predicate>
  __host__ __device__ OutputIterator
  thrust::remove_copy_if(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    Predicate pred);

  template <typename InputIterator,
    typename OutputIterator,
    typename Predicate>
  OutputIterator
  thrust::remove_copy_if(InputIterator first,
    InputIterator last,
    OutputIterator result,
    Predicate pred);

  template <typename DerivedPolicy,
    typename ForwardIterator,
    typename InputIterator,
    typename Predicate>
  __host__ __device__ ForwardIterator
  thrust::remove_if(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
    ForwardIterator first,
    ForwardIterator last,
    InputIterator stencil,
    Predicate pred);

  template <typename ForwardIterator,
    typename InputIterator,
    typename Predicate>
  ForwardIterator
  thrust::remove_if(ForwardIterator first,
    ForwardIterator last,
    InputIterator stencil,
    Predicate pred);

  template <typename DerivedPolicy,
    typename InputIterator1,
    typename InputIterator2,
    typename OutputIterator,
    typename Predicate>
  __host__ __device__ OutputIterator
  thrust::remove_copy_if(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
    InputIterator1 first,
    InputIterator1 last,
    InputIterator2 stencil,
    OutputIterator result,
    Predicate pred);

  template <typename InputIterator1,
    typename InputIterator2,
    typename OutputIterator,
    typename Predicate>
OutputIterator
thrust::remove_copy_if(InputIterator1 first,
  InputIterator1 last,
  InputIterator2 stencil,
  OutputIterator result,
  Predicate pred);

template <typename DerivedPolicy,
  typename ForwardIterator>
__host__ __device__ ForwardIterator
thrust::unique(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last);

template <typename ForwardIterator>
ForwardIterator thrust::unique(ForwardIterator first,
  ForwardIterator last);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename BinaryPredicate>
__host__ __device__ ForwardIterator
thrust::unique(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  BinaryPredicate binary_pred);

template <typename ForwardIterator,
  typename BinaryPredicate>
ForwardIterator
thrust::unique(ForwardIterator first,
  ForwardIterator last,
  BinaryPredicate binary_pred);

template <typename DerivedPolicy,
  typename InputIterator,
  typename OutputIterator>
__host__ __device__ OutputIterator
thrust::unique_copy(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  OutputIterator result);

template <typename InputIterator,
  typename OutputIterator>
OutputIterator
thrust::unique_copy(InputIterator first,
  InputIterator last,
  OutputIterator result);

template <typename DerivedPolicy,
  typename InputIterator,
  typename OutputIterator,
  typename BinaryPredicate>
__host__ __device__ OutputIterator
thrust::unique_copy(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  OutputIterator result,
  BinaryPredicate binary_pred);

template <typename InputIterator,
  typename OutputIterator,
  typename BinaryPredicate>
OutputIterator
thrust::unique_copy(InputIterator first,
  InputIterator last,
  OutputIterator result,
  BinaryPredicate binary_pred);

template <typename DerivedPolicy,
  typename ForwardIterator1,
  typename ForwardIterator2>
__host__ __device__ thrust::pair< ForwardIterator1, ForwardIterator2 >
thrust::unique_by_key(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator1 keys_first,
  ForwardIterator1 keys_last,
  ForwardIterator2 values_first);

template <typename ForwardIterator1,
  typename ForwardIterator2>
thrust::pair< ForwardIterator1, ForwardIterator2 >
thrust::unique_by_key(ForwardIterator1 keys_first,
  ForwardIterator1 keys_last,
  ForwardIterator2 values_first);

template <typename DerivedPolicy,
  typename ForwardIterator1,
  typename ForwardIterator2,
  typename BinaryPredicate>
__host__ __device__ thrust::pair< ForwardIterator1, ForwardIterator2 >
thrust::unique_by_key(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator1 keys_first,
  ForwardIterator1 keys_last,
  ForwardIterator2 values_first,
  BinaryPredicate binary_pred);

template <typename ForwardIterator1,
  typename ForwardIterator2,
  typename BinaryPredicate>
thrust::pair< ForwardIterator1, ForwardIterator2 >
thrust::unique_by_key(ForwardIterator1 keys_first,
  ForwardIterator1 keys_last,
  ForwardIterator2 values_first,
  BinaryPredicate binary_pred);

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator1,
  typename OutputIterator2>
__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);

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);

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);

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

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename BinaryPredicate>
__host__ __device__ thrust::iterator_traits< ForwardIterator >::difference_type
thrust::unique_count(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  BinaryPredicate binary_pred);

template <typename DerivedPolicy,
  typename ForwardIterator>
__host__ __device__ thrust::iterator_traits< ForwardIterator >::difference_type
thrust::unique_count(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last);

template <typename ForwardIterator,
  typename BinaryPredicate>
__host__ __device__ thrust::iterator_traits< ForwardIterator >::difference_type
thrust::unique_count(ForwardIterator first,
  ForwardIterator last,
  BinaryPredicate binary_pred);

template <typename ForwardIterator>
__host__ __device__ thrust::iterator_traits< ForwardIterator >::difference_type
thrust::unique_count(ForwardIterator first,
  ForwardIterator last);

thrust::copy_if

template <typename DerivedPolicy,
  typename InputIterator,
  typename OutputIterator,
  typename Predicate>
__host__ __device__ OutputIterator
copy_if(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  OutputIterator result,
  Predicate pred);

‍此版本的 copy_if 将范围 [first,last) 内除了使得 pred 为 false ‍之外的其他元素复制到从 result 开始的范围。 copy_if 是稳定的，指的是复制的元素的相对顺序不变。

具体而言，对于满足 0 <= n < last-first 的每个整数 n ， copy_if 执行赋值 *result = *(first+n)，并且如果 pred(*(first+n)) ， result 前进一个位置。否则，不会发生赋值， result 也不会提前。

算法的执行由 system 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 copy_if 执行流压缩以将偶数复制到输出范围：

#include <thrust/copy.h>
#include <thrust/execution_policy.h>
...
struct is_even
{
__host__ __device__
bool operator()(const int x)
{
   return (x % 2) == 0;
}
};
...
const int N = 6;
int V[N] = {-2, 0, -1, 0, 1, 2};
int result[4];

thrust::copy_if(thrust::host, V, V + N, result, is_even());

// V remains {-2, 0, -1, 0, 1, 2}
// result is now {-2, 0, 0, 2}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 Predicate 的 argument_type
OutputIterator：是 Output Iterator 的模型
Predicate：是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：待从中复制的序列的起始
last：待从中复制的序列的末尾
result：待复制到的序列的起始
pred：对范围 [first, last) 内每个值进行测试的谓词

前提条件

范围 [first, last) ‍不应与范围 [result, result + (last - first)) 重叠

返回值

result + n，其中 n 等于 pred 在范围 [first, last) 内计算为 true 的次数

另请参阅

remove_copy_if

thrust::copy_if

template <typename InputIterator,
  typename OutputIterator,
  typename Predicate>
OutputIterator
copy_if(InputIterator first,
  InputIterator last,
  OutputIterator result,
  Predicate pred);

‍此版本的 copy_if 将范围 [first,last) 内除了使得 pred 为 false 之外的其他元素复制到从 result 开始的范围。 copy_if 是稳定的，指的是复制的元素的相对顺序不变。

具体而言，对于满足 0 <= n < last-first 的每个整数 n ， copy_if 执行赋值 *result = *(first+n)，并且如果 pred(*(first+n)) ， result 前进一个位置。否则，不会发生赋值， result 也不会提前。

以下代码片段演示了如何使用 copy_if 执行流压缩以将偶数复制到输出范围：

#include <thrust/copy.h>
...
struct is_even
{
__host__ __device__
bool operator()(const int x)
{
   return (x % 2) == 0;
}
};
...
const int N = 6;
int V[N] = {-2, 0, -1, 0, 1, 2};
int result[4];

thrust::copy_if(V, V + N, result, is_even());

// V remains {-2, 0, -1, 0, 1, 2}
// result is now {-2, 0, 0, 2}

模板参数

InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 Predicate 的 argument_type
OutputIterator：是 Output Iterator 的模型
Predicate：是 Predicate 的模型

函数参数

first：待从中复制的序列的起始
last：待从中复制的序列的末尾
result：待复制到的序列的起始
pred：对范围 [first, last) 内每个值进行测试的谓词

前提条件

范围 [first, last) ‍不应与范围 [result, result + (last - first)) 重叠

返回值

result + n，其中 n 等于 pred 在范围 [first, last) 内计算为 true 的次数

另请参阅

remove_copy_if

thrust::copy_if

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename Predicate>
__host__ __device__ OutputIterator
copy_if(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first,
  InputIterator1 last,
  InputIterator2 stencil,
  OutputIterator result,
  Predicate pred);

‍此版本的 copy_if 将范围 [first,last) 内除了其相应模版元素使得 pred 为 false ‍之外的其他元素复制到从 result 开始的范围。 copy_if 是稳定的，指的是复制的元素的相对顺序不变。

具体而言，对于满足 0 <= n < last-first 的每个整数 n ， copy_if 执行赋值 *result = *(first+n)，并且如果 pred(*(stencil+n)) ， result 前进一个位置。否则，不会发生赋值， result 也不会提前。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，当对应的模版元素为偶数时，使用 copy_if 执行流压缩以将数字复制到输出范围：

#include <thrust/copy.h>
#include <thrust/execution_policy.h>
...
struct is_even
{
__host__ __device__
bool operator()(const int x)
{
   return (x % 2) == 0;
}
};
...
int N = 6;
int data[N]    = { 0, 1,  2, 3, 4, 5};
int stencil[N] = {-2, 0, -1, 0, 1, 2};
int result[4];

thrust::copy_if(thrust::host, data, data + N, stencil, result, is_even());

// data remains    = { 0, 1,  2, 3, 4, 5};
// stencil remains = {-2, 0, -1, 0, 1, 2};
// result is now     { 0, 1,  3, 5}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型
InputIterator2：是 Input Iterator 的模型， InputIterator2 的 value_type 可转换为 Predicate 的 argument_type
OutputIterator：是 Output Iterator 的模型
Predicate：是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：待从中复制的序列的起始
last：待从中复制的序列的末尾
stencil：模版序列的起始
result：待复制到的序列的起始
pred：对范围 [stencil, stencil + (last-first)) 内每个值进行测试的谓词

前提条件

范围 [first, last) ‍不应与范围 [result, result + (last - first)) 重叠
范围 [stencil, stencil + (last - first)) ‍不应与范围 [result, result + (last - first)) 重叠

返回值

result + n，其中 n 等于 pred 在范围 [stencil, stencil + (last-first)) 内计算为 true 的次数

另请参阅

remove_copy_if

thrust::copy_if

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename Predicate>
OutputIterator
copy_if(InputIterator1 first,
  InputIterator1 last,
  InputIterator2 stencil,
  OutputIterator result,
  Predicate pred);

‍此版本的 copy_if 将范围 [first,last) 内除了其相应模版元素使得 pred 为 false ‍之外的其他元素复制到从 result 开始的范围。 copy_if 是稳定的，指的是复制的元素的相对顺序不变。

具体而言，对于满足 0 <= n < last-first 的每个整数 n ， copy_if 执行赋值 *result = *(first+n)，并且如果 pred(*(stencil+n)) ， result 前进一个位置。否则，不会发生赋值， result 也不会提前。

以下代码片段演示了当对应的模版元素为偶数时，使用 copy_if 执行流压缩以将数字复制到输出范围：

#include <thrust/copy.h>
...
struct is_even
{
__host__ __device__
bool operator()(const int x)
{
   return (x % 2) == 0;
}
};
...
int N = 6;
int data[N]    = { 0, 1,  2, 3, 4, 5};
int stencil[N] = {-2, 0, -1, 0, 1, 2};
int result[4];

thrust::copy_if(data, data + N, stencil, result, is_even());

// data remains    = { 0, 1,  2, 3, 4, 5};
// stencil remains = {-2, 0, -1, 0, 1, 2};
// result is now     { 0, 1,  3, 5}

模板参数

InputIterator1：是 Input Iterator 的模型
InputIterator2：是 Input Iterator 的模型， InputIterator2 的 value_type 可转换为 Predicate 的 argument_type
OutputIterator：是 Output Iterator 的模型
Predicate：是 Predicate 的模型

函数参数

first：待从中复制的序列的起始
last：待从中复制的序列的末尾
stencil：模版序列的起始
result：待复制到的序列的起始
pred：对范围 [stencil, stencil + (last-first)) 内每个值进行测试的谓词

前提条件

范围 [first, last) ‍不应与范围 [result, result + (last - first)) 重叠
范围 [stencil, stencil + (last - first)) ‍不应与范围 [result, result + (last - first)) 重叠

返回值

result + n，其中 n 等于 pred 在范围 [stencil, stencil + (last-first)) 内计算为 true 的次数

另请参阅

remove_copy_if

thrust::remove

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename T>
__host__ __device__ ForwardIterator
remove(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  const T & value);

remove ‍从范围 [first, last) 内删除所有等于 value 的值。即， remove 返回迭代器 new_last ，使得范围 [first, new_last) 不包含等于 value 的元素。范围 [new_first,last) 内的迭代器仍然是可解引用的，但它们所指向的元素是未指定的。 remove 是稳定的，指的是不等于 value 的元素的相对顺序保持不变。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 remove 从范围内删除感兴趣的数字：

#include <thrust/remove.h>
#include <thrust/execution_policy.h>
...
const int N = 6;
int A[N] = {3, 1, 4, 1, 5, 9};
int *new_end = thrust::remove(A, A + N, 1);
// The first four values of A are now {3, 4, 5, 9}
// Values beyond new_end are unspecified

备注

removal 含义有些微妙。 remove 不会销毁任何迭代器，也不会更改 first 和 last 之间的距离。（它不可能做任何类似的事情。） ‍所以，比如，如果 V 是一个 device_vector ， remove(V.begin(), V.end(), 0) 不会改变 V.size()： V 将包含与以前一样多的元素。

remove 返回一个迭代器，该迭代器在从结果范围内删除元素后指向结果范围的末尾；由此可见，该迭代器之后的元素不在感兴趣范围内，可能会被丢弃。如果要从 Sequence 中删除元素，可以简单地擦除它们。即，从 Sequence 中删除元素的合理方法是 S.erase(remove(S.begin(), S.end(), x), S.end())。

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型，且 ForwardIterator 是可变的
T：是 Equality Comparable 的模型，且类型 T 的对象可以和 ForwardIterator 的 value_type 的对象进行相等性比较

函数参数

exec：用于并行化的执行策略
first：感兴趣范围的起始
last：感兴趣范围的末尾
value：待从范围 [first, last) 内删除的值。等于 value 的元素将从序列中删除

返回值

ForwardIterator ，指向不等于 value 的元素结果范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/remove
remove_if
remove_copy
remove_copy_if

thrust::remove

template <typename ForwardIterator,
  typename T>
ForwardIterator
remove(ForwardIterator first,
  ForwardIterator last,
  const T & value);

remove ‍从范围 [first, last) 内删除所有等于 value 的值。即， remove 返回迭代器 new_last ，使得范围 [first, new_last) 不包含等于 value 的元素。范围 [new_first,last) 内的迭代器仍然是可解引用的，但它们所指向的元素是未指定的。 remove 是稳定的，指的是不等于 value 的元素的相对顺序保持不变。

以下代码片段演示了如何使用 remove 从范围内删除感兴趣的数字：

#include <thrust/remove.h>
...
const int N = 6;
int A[N] = {3, 1, 4, 1, 5, 9};
int *new_end = thrust::remove(A, A + N, 1);
// The first four values of A are now {3, 4, 5, 9}
// Values beyond new_end are unspecified

备注

removal 含义有些微妙。 remove 不会销毁任何迭代器，也不会更改 first 和 last 之间的距离。（它不可能做任何类似的事情。） ‍所以，比如，如果 V 是一个 device_vector ， remove(V.begin(), V.end(), 0) 不会改变 V.size()： V 将包含与以前一样多的元素。

remove 返回一个迭代器，该迭代器在从结果范围内删除元素后指向结果范围的末尾；由此可见，该迭代器之后的元素不在感兴趣范围内，可能会被丢弃。如果要从 Sequence 中删除元素，可以简单地擦除它们。即，从 Sequence 中删除元素的合理方法是 S.erase(remove(S.begin(), S.end(), x), S.end())。

模板参数

ForwardIterator：是 Forward Iterator 的模型，且 ForwardIterator 是可变的
T：是 Equality Comparable 的模型，且类型 T 的对象可以和 ForwardIterator 的 value_type 的对象进行相等性比较

函数参数

first：感兴趣范围的起始
last：感兴趣范围的末尾
value：待从范围 [first, last) 内删除的值。等于 value 的元素将从序列中删除

返回值

ForwardIterator ，指向不等于 value 的元素结果范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/remove
remove_if
remove_copy
remove_copy_if

thrust::remove_copy

template <typename DerivedPolicy,
  typename InputIterator,
  typename OutputIterator,
  typename T>
__host__ __device__ OutputIterator
remove_copy(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  OutputIterator result,
  const T & value);

remove_copy 将不等于 value 的元素从范围 [first, last) 复制到从 result 开始的范围。返回值是结果范围的末尾。此运算是稳定的，指的是复制的元素的相对顺序与范围 [first, last) 内的顺序相同。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 remove_copy 将数字序列复制到输出范围，同时忽略感兴趣的值：

#include <thrust/remove.h>
#include <thrust/execution_policy.h>
...
const int N = 6;
int V[N] = {-2, 0, -1, 0, 1, 2};
int result[N-2];
thrust::remove_copy(thrust::host, V, V + N, result, 0);
// V remains {-2, 0, -1, 0, 1, 2}
// result is now {-2, -1, 1, 2}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型
T：是 Equality Comparable 的模型，且类型 T 的对象可以和 InputIterator 的 value_type 的对象进行相等性比较

函数参数

exec：用于并行化的执行策略
first：感兴趣范围的起始
last：感兴趣范围的末尾
result：结果范围被复制到从此位置开始的序列中
value：待从范围‍内忽略的值

前提条件

范围 [first, last) 不应与范围 [result, result + (last - first)) 重叠

返回值

OutputIterator ，指向不等于 value 的元素结果范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/remove_copy
remove
remove_if
remove_copy_if

thrust::remove_copy

template <typename InputIterator,
  typename OutputIterator,
  typename T>
OutputIterator
remove_copy(InputIterator first,
  InputIterator last,
  OutputIterator result,
  const T & value);

remove_copy 将不等于 value 的元素从范围 [first, last) 复制到从 result 开始的范围。返回值是结果范围的末尾。此运算是稳定的，指的是复制的元素的相对顺序与范围 [first, last) 内的顺序相同。

以下代码片段演示了如何使用 remove_copy 将数字序列复制到输出范围，同时忽略感兴趣的值：

#include <thrust/remove.h>
...
const int N = 6;
int V[N] = {-2, 0, -1, 0, 1, 2};
int result[N-2];
thrust::remove_copy(V, V + N, result, 0);
// V remains {-2, 0, -1, 0, 1, 2}
// result is now {-2, -1, 1, 2}

模板参数

InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型
T：是 Equality Comparable 的模型，且类型 T 的对象可以和 InputIterator 的 value_type 的对象进行相等性比较

函数参数

first：感兴趣范围的起始
last：感兴趣范围的末尾
result：结果范围被复制到从此位置开始的序列中
value：待从范围‍内忽略的值

前提条件

范围 [first, last) 不应与范围 [result, result + (last - first)) 重叠

返回值

OutputIterator ，指向不等于 value 的元素结果范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/remove_copy
remove
remove_if
remove_copy_if

thrust::remove_if

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename Predicate>
__host__ __device__ ForwardIterator
remove_if(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  Predicate pred);

remove_if 从范围 [first, last) 内删除使得 pred(x) 为 true 的每个元素 x。即， remove_if 返回迭代器 new_last ，使得范围 [first,new_last) 不包含满足 pred 为 true 的元素。范围 [new_last,last) 内的迭代器仍然是可解引用的，但它们所指向的元素是未指定的。 remove_if 是稳定的，指的是未被删除的元素的相对顺序不变。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 remove_if 从整数数组中删除所有偶数：

#include <thrust/remove.h>
#include <thrust/execution_policy.h>
...
struct is_even
{
__host__ __device__
bool operator()(const int x)
{
   return (x % 2) == 0;
}
};
...
const int N = 6;
int A[N] = {1, 4, 2, 8, 5, 7};
int *new_end = thrust::remove_if(thrust::host, A, A + N, is_even());
// The first three values of A are now {1, 5, 7}
// Values beyond new_end are unspecified

备注

removal 含义有些微妙。 remove_if 不会销毁任何迭代器，也不会更改 first 和 last 之间的距离。（它不可能做任何类似的事情。） ‍所以，比如，如果 V 是一个 device_vector ， remove_if(V.begin(), V.end(), pred) 不会改变 V.size()： V 将包含与以前一样多的元素。

remove_if 返回一个迭代器，该迭代器在从结果范围内删除元素后指向结果范围的末尾；由此可见，该迭代器之后的元素不在感兴趣范围内，可能会被丢弃。如果要从 Sequence 中删除元素，可以简单地擦除它们。即，从 Sequence 中删除元素的合理方法是 S.erase(remove_if(S.begin(), S.end(), pred), S.end())。

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 是可变的，并且 ForwardIterator 的 value_type 可转换为 Predicate 的 argument_type
Predicate：是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：感兴趣范围的起始
last：感兴趣范围的末尾
pred：计算范围 [first,last) 内每个元素的值的谓词。将 pred ‍计算为 true 的元素从序列中删除

返回值

ForwardIterator ，指向 pred 计算为 true 的元素结果范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/remove
remove
remove_copy
remove_copy_if

thrust::remove_if

template <typename ForwardIterator,
  typename Predicate>
ForwardIterator
remove_if(ForwardIterator first,
  ForwardIterator last,
  Predicate pred);

remove_if 从范围 [first, last) 内删除使得 pred(x) 为 true 的每个元素 x。即， remove_if 返回迭代器 new_last ，使得范围 [first,new_last) 不包含满足 pred 为 true 的元素。范围 [new_last,last) 内的迭代器仍然是可解引用的，但它们所指向的元素是未指定的。 remove_if 是稳定的，指的是未被删除的元素的相对顺序不变。

以下代码片段演示了如何使用 remove_if 从整数数组中删除所有偶数：

#include <thrust/remove.h>
...
struct is_even
{
__host__ __device__
bool operator()(const int x)
{
   return (x % 2) == 0;
}
};
...
const int N = 6;
int A[N] = {1, 4, 2, 8, 5, 7};
int *new_end = thrust::remove_if(A, A + N, is_even());
// The first three values of A are now {1, 5, 7}
// Values beyond new_end are unspecified

备注

removal 含义有些微妙。 remove_if 不会销毁任何迭代器，也不会更改 first 和 last 之间的距离。（它不可能做任何类似的事情。） ‍所以，比如，如果 V 是一个 device_vector ， remove_if(V.begin(), V.end(), pred) 不会改变 V.size()： V 将包含与以前一样多的元素。

remove_if 返回一个迭代器，该迭代器在从结果范围内删除元素后指向结果范围的末尾；由此可见，该迭代器之后的元素不在感兴趣范围内，可能会被丢弃。如果要从 Sequence 中删除元素，可以简单地擦除它们。即，从 Sequence 中删除元素的合理方法是 S.erase(remove_if(S.begin(), S.end(), pred), S.end())。

模板参数

ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 是可变的，并且 ForwardIterator 的 value_type 可转换为 Predicate 的 argument_type
Predicate：是 Predicate 的模型

函数参数

first：感兴趣范围的起始
last：感兴趣范围的末尾
pred：计算范围 [first,last) 内每个元素的值的谓词。将 pred ‍计算为 true 的元素从序列中删除

返回值

ForwardIterator ，指向 pred 计算为 true 的元素结果范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/remove
remove
remove_copy
remove_copy_if

thrust::remove_copy_if

template <typename DerivedPolicy,
  typename InputIterator,
  typename OutputIterator,
  typename Predicate>
__host__ __device__ OutputIterator
remove_copy_if(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  OutputIterator result,
  Predicate pred);

remove_copy_if 将范围 [first,last) 内除了使得 pred 为 true 之外的其他元素复制到从 result 开始的范围。返回值是结果范围的末尾。此运算是稳定的，指的是复制的元素的相对顺序与范围 [first,last) 内的顺序相同。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 remove_copy_if 将数字序列复制到输出范围，同时忽略偶数：

#include <thrust/remove.h>
#include <thrust/execution_policy.h>
...
struct is_even
{
__host__ __device__
bool operator()(const int x)
{
   return (x % 2) == 0;
}
};
...
const int N = 6;
int V[N] = {-2, 0, -1, 0, 1, 2};
int result[2];
thrust::remove_copy_if(thrust::host, V, V + N, result, is_even());
// V remains {-2, 0, -1, 0, 1, 2}
// result is now {-1, 1}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 OutputIterator 的 value_types 集合中的类型和 Predicate 的 argument_type
OutputIterator：是 Output Iterator 的模型
Predicate：是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：感兴趣范围的起始
last：感兴趣范围的末尾
result：结果范围被复制到从此位置开始的序列中
pred：计算范围 [first,last) 内每个元素的值的谓词。不会将 pred 计算为 false 的元素复制到结果序列中

前提条件

范围 [first, last) 不应与范围 [result, result + (last - first)) 重叠

返回值

指向结果范围末尾的 OutputIterator

另请参阅

https://en.cppreference.com/w/cpp/algorithm/remove_copy
remove
remove_copy
remove_if

thrust::remove_copy_if

template <typename InputIterator,
  typename OutputIterator,
  typename Predicate>
OutputIterator
remove_copy_if(InputIterator first,
  InputIterator last,
  OutputIterator result,
  Predicate pred);

remove_copy_if 将范围 [first,last) 内除了使得 pred 为 true 之外的其他元素复制到从 result 开始的范围。返回值是结果范围的末尾。此运算是稳定的，指的是复制的元素的相对顺序与范围 [first,last) 内的顺序相同。

以下代码片段演示了如何使用 remove_copy_if 将数字序列复制到输出范围，同时忽略偶数：

#include <thrust/remove.h>
...
struct is_even
{
__host__ __device__
bool operator()(const int x)
{
   return (x % 2) == 0;
}
};
...
const int N = 6;
int V[N] = {-2, 0, -1, 0, 1, 2};
int result[2];
thrust::remove_copy_if(V, V + N, result, is_even());
// V remains {-2, 0, -1, 0, 1, 2}
// result is now {-1, 1}

模板参数

InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 OutputIterator 的 value_types 集合中的类型和 Predicate 的 argument_type
OutputIterator：是 Output Iterator 的模型
Predicate：是 Predicate 的模型

函数参数

first：感兴趣范围的起始
last：感兴趣范围的末尾
result：结果范围被复制到从此位置开始的序列中
pred：计算范围 [first,last) 内每个元素的值的谓词。不会将 pred 计算为 false 的元素复制到结果序列中

前提条件

范围 [first, last) 不应与范围 [result, result + (last - first)) 重叠

返回值

指向结果范围末尾的 OutputIterator

另请参阅

https://en.cppreference.com/w/cpp/algorithm/remove_copy
remove
remove_copy
remove_if

thrust::remove_if

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename InputIterator,
  typename Predicate>
__host__ __device__ ForwardIterator
remove_if(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  InputIterator stencil,
  Predicate pred);

remove_if 从范围 [first, last) 内删除使得 pred(x) 为 true 的每个元素 x。即， remove_if 返回迭代器 new_last ，使得范围 [first, new_last) 不包含对应模板值的 pred 为 true 的元素。范围 [new_last,last) 内的迭代器仍然是可解引用的，但它们所指向的元素是未指定的。 remove_if 是稳定的，指的是未被删除的元素的相对顺序不变。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 remove_if 从整数数组中删除特定元素：

#include <thrust/remove.h>
#include <thrust/execution_policy.h>
...
const int N = 6;
int A[N] = {1, 4, 2, 8, 5, 7};
int S[N] = {0, 1, 1, 1, 0, 0};

int *new_end = thrust::remove_if(thrust::host, A, A + N, S, thrust::identity<int>());
// The first three values of A are now {1, 5, 7}
// Values beyond new_end are unspecified

备注

范围 [first, last) ‍不可与范围 [stencil, stencil + (last - first)) 重叠

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型，且 ForwardIterator 是可变的
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 Predicate 的 argument_type
Predicate：是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：感兴趣范围的起始
last：感兴趣范围的末尾
stencil：模版序列的起始
pred：计算范围 [stencil, stencil + (last - first)) 内每个元素的值的谓词。将 pred 计算为 true 的元素从序列 [first, last) 中删除

前提条件

范围 [first, last) 不应与范围 [result, result + (last - first)) 重叠
范围 [stencil, stencil + (last - first)) 不应与范围 [result, result + (last - first)) 重叠

返回值

ForwardIterator ，指向 pred 计算为 true 的元素结果范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/remove
remove
remove_copy
remove_copy_if

thrust::remove_if

template <typename ForwardIterator,
  typename InputIterator,
  typename Predicate>
ForwardIterator
remove_if(ForwardIterator first,
  ForwardIterator last,
  InputIterator stencil,
  Predicate pred);

remove_if 从范围 [first, last) 内删除使得 pred(x) 为 true 的每个元素 x。即， remove_if 返回迭代器 new_last ，使得范围 [first, new_last) 不包含对应模板值的 pred 为 true 的元素。范围 [new_last,last) 内的迭代器仍然是可解引用的，但它们所指向的元素是未指定的。 remove_if 是稳定的，指的是未被删除的元素的相对顺序不变。

以下代码片段演示了如何使用 remove_if 从整数数组中删除特定元素：

#include <thrust/remove.h>
...
const int N = 6;
int A[N] = {1, 4, 2, 8, 5, 7};
int S[N] = {0, 1, 1, 1, 0, 0};

int *new_end = thrust::remove_if(A, A + N, S, thrust::identity<int>());
// The first three values of A are now {1, 5, 7}
// Values beyond new_end are unspecified

备注

范围 [first, last) ‍不可与范围 [stencil, stencil + (last - first)) 重叠

模板参数

ForwardIterator：是 Forward Iterator 的模型，且 ForwardIterator 是可变的
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 Predicate 的 argument_type
Predicate：是 Predicate 的模型

函数参数

first：感兴趣范围的起始
last：感兴趣范围的末尾
stencil：模版序列的起始
pred：计算范围 [stencil, stencil + (last - first)) 内每个元素的值的谓词。将 pred 计算为 true 的元素从序列 [first, last) 中删除

前提条件

范围 [first, last) 不应与范围 [result, result + (last - first)) 重叠
范围 [stencil, stencil + (last - first)) 不应与范围 [result, result + (last - first)) 重叠

返回值

ForwardIterator ，指向 pred 计算为 true 的元素结果范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/remove
remove
remove_copy
remove_copy_if

thrust::remove_copy_if

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename Predicate>
__host__ __device__ OutputIterator
remove_copy_if(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first,
  InputIterator1 last,
  InputIterator2 stencil,
  OutputIterator result,
  Predicate pred);

remove_copy_if 将范围 [first,last) ‍内除了使得对应模板值的 pred 为 true 之外的其他元素复制到从 result 开始的范围。返回值是结果范围的末尾。此运算是稳定的，指的是复制的元素的相对顺序与范围 [first,last) 内的顺序相同。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 remove_copy_if 将数字序列复制到输出范围，同时忽略特定元素：

#include <thrust/remove.h>
#include <thrust/execution_policy.h>
...
const int N = 6;
int V[N] = {-2, 0, -1, 0, 1, 2};
int S[N] = { 1, 1,  0, 1, 0, 1};
int result[2];
thrust::remove_copy_if(thrust::host, V, V + N, S, result, thrust::identity<int>());
// V remains {-2, 0, -1, 0, 1, 2}
// result is now {-1, 1}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型， InputIterator1 的 value_type 可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型， InputIterator2 的 value_type 可转换为 Predicate 的 argument_type
OutputIterator：是 Output Iterator 的模型
Predicate：是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：感兴趣范围的起始
last：感兴趣范围的末尾
stencil：模版序列的起始
result：结果范围被复制到从此位置开始的序列中
pred：计算范围 [first,last) 内每个元素的值的谓词。不会将 pred 计算为 false 的元素复制到结果序列中

前提条件

范围 [stencil, stencil + (last - first)) 不应与范围 [result, result + (last - first)) 重叠

返回值

指向结果范围末尾的 OutputIterator

另请参阅

https://en.cppreference.com/w/cpp/algorithm/remove_copy
remove
remove_copy
remove_if
copy_if

thrust::remove_copy_if

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename Predicate>
OutputIterator
remove_copy_if(InputIterator1 first,
  InputIterator1 last,
  InputIterator2 stencil,
  OutputIterator result,
  Predicate pred);

remove_copy_if 将范围 [first,last) ‍内除了使得对应模板值的 pred 为 true 之外的其他元素复制到从 result 开始的范围。返回值是结果范围的末尾。此运算是稳定的，指的是复制的元素的相对顺序与范围 [first,last) 内的顺序相同。

以下代码片段演示了如何使用 remove_copy_if 将数字序列复制到输出范围，同时忽略特定元素：

#include <thrust/remove.h>
...
const int N = 6;
int V[N] = {-2, 0, -1, 0, 1, 2};
int S[N] = { 1, 1,  0, 1, 0, 1};
int result[2];
thrust::remove_copy_if(V, V + N, S, result, thrust::identity<int>());
// V remains {-2, 0, -1, 0, 1, 2}
// result is now {-1, 1}

模板参数

InputIterator1：是 Input Iterator 的模型， InputIterator1 的 value_type 可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型， InputIterator2 的 value_type 可转换为 Predicate 的 argument_type
OutputIterator：是 Output Iterator 的模型
Predicate：是 Predicate 的模型

函数参数

first：感兴趣范围的起始
last：感兴趣范围的末尾
stencil：模版序列的起始
result：结果范围被复制到从此位置开始的序列中
pred：计算范围 [first,last) 内每个元素的值的谓词。不会将 pred 计算为 false 的元素复制到结果序列中

前提条件

范围 [stencil, stencil + (last - first)) 不应与范围 [result, result + (last - first)) 重叠

返回值

指向结果范围末尾的 OutputIterator

另请参阅

https://en.cppreference.com/w/cpp/algorithm/remove_copy
remove
remove_copy
remove_if
copy_if

thrust::unique

template <typename DerivedPolicy,
  typename ForwardIterator>
__host__ __device__ ForwardIterator
unique(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last);

对于范围 [first, last) 内每组具有相同值的连续元素， unique 删除每组除第一个元素以外的所有元素。返回值是迭代器 new_last ，使得范围 [first, new_last) ‍内任意两个连续元素都不相等。范围 [new_last, last) 内的迭代器仍然是可解引用的，但它们所指向的元素是未指定的。 unique 是稳定的，指的是未被删除的元素的相对顺序不变。

此版本的 unique 使用 operator== 测试相等性。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 unique 压缩数字序列以删除连续的重复项：

#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.

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 是可变的，且 ForwardIterator 的 value_type 是 Equality Comparable 的模型

函数参数

exec：用于并行化的执行策略
first：输入范围的起始
last：输入范围的末尾

返回值

唯一范围 [first, new_last) 的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/unique
unique_copy

thrust::unique

template <typename ForwardIterator>
ForwardIterator
unique(ForwardIterator first,
  ForwardIterator last);

对于范围 [first, last) 内每组具有相同值的连续元素， unique 删除每组除第一个元素以外的所有元素。返回值是迭代器 new_last ，使得范围 [first, new_last) ‍内任意两个连续元素都不相等。范围 [new_last, last) 内的迭代器仍然是可解引用的，但它们所指向的元素是未指定的。 unique 是稳定的，指的是未被删除的元素的相对顺序不变。

此版本的 unique 使用 operator== 测试相等性。

以下代码片段演示了如何使用 unique 压缩数字序列以删除连续的重复项：

#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.

模板参数

ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 是可变的，且 ForwardIterator 的 value_type 是 Equality Comparable 的模型

函数参数

first：输入范围的起始
last：输入范围的末尾

返回值

唯一范围 [first, new_last) 的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/unique
unique_copy

thrust::unique

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename BinaryPredicate>
__host__ __device__ ForwardIterator
unique(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  BinaryPredicate binary_pred);

对于范围 [first, last) 内每组具有相同值的连续元素， unique 删除每组除第一个元素以外的所有元素。返回值是迭代器 new_last ，使得范围 [first, new_last) ‍内任意两个连续元素都不相等。范围 [new_last, last) 内的迭代器仍然是可解引用的，但它们所指向的元素是未指定的。 unique 是稳定的，指的是未被删除的元素的相对顺序不变。

此版本的 unique 使用函数对象 binary_pred 测试相等性。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 unique 压缩数字序列以删除连续的重复项：

#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.

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator`是可变的，并且 `ForwardIterator 的 value_type 可转换为 BinaryPredicate 的 first_argument_type 和 second_argument_type
BinaryPredicate：是 Binary Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：输入范围的起始
last：输入范围的末尾
binary_pred：用于确定相等性的二元谓词

返回值

唯一范围 [first, new_last) 的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/unique
unique_copy

thrust::unique

template <typename ForwardIterator,
typename BinaryPredicate>
ForwardIterator
unique(ForwardIterator first,
  ForwardIterator last,
  BinaryPredicate binary_pred);

对于范围 [first, last) 内每组具有相同值的连续元素， unique 删除每组除第一个元素以外的所有元素。返回值是迭代器 new_last ，使得范围 [first, new_last) ‍内任意两个连续元素都不相等。范围 [new_last, last) 内的迭代器仍然是可解引用的，但它们所指向的元素是未指定的。 unique 是稳定的，指的是未被删除的元素的相对顺序不变。

此版本的 unique 使用函数对象 binary_pred 测试相等性。

以下代码片段演示了如何使用 unique 压缩数字序列以删除连续的重复项：

#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.

模板参数

ForwardIterator：是 Forward Iterator 的模型， ForwardIterator`是可变的，并且 `ForwardIterator 的 value_type 可转换为 BinaryPredicate 的 first_argument_type 和 second_argument_type
BinaryPredicate：是 Binary Predicate 的模型

函数参数

first：输入范围的起始
last：输入范围的末尾
binary_pred：用于确定相等性的二元谓词

返回值

唯一范围 [first, new_last) 的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/unique
unique_copy

thrust::unique_copy

template <typename DerivedPolicy,
  typename InputIterator,
  typename OutputIterator>
__host__ __device__ OutputIterator
unique_copy(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  OutputIterator result);

unique_copy 将范围 [first, last) 内的元素复制到从 result 开始的范围，只不过仅复制每组连续重复元素的第一个元素。返回值是结果范围的的末尾。

unique_copy 有两个不同版本的原因在于，它对于一组连续重复的元素，有两种不同的定义。在第一个版本中，测试简单的相等性：如果对于范围内的每个迭代器 i ，要么 i == f ‍，要么 *i == *(i-1) ，则范围 [f, l) 内元素是重复的。在第二个版本中，测试任意 BinaryPredicate binary_pred：如果对于该范围内的每个迭代器 i ，要么 i == f ‍，要么 binary_pred(*i, *(i-1)) 为 true ，则 [f, l) 内的元素是重复的。

此版本的 unique_copy 使用 operator== 测试相等性。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 unique_copy 压缩数字序列以删除连续的重复项：

#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

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 是 Equality Comparable 的模型
OutputIterator：是 Output Iterator 的模型， InputIterator 的 value_type 可转换为 OutputIterator 的 value_type

函数参数

exec：用于并行化的执行策略
first：输入范围的起始
last：输入范围的末尾
result：输出范围的起始

前提条件

范围 [first,last) ‍不应与范围 [result, result + (last - first)) 重叠

返回值

唯一范围 [result, result_end) 的末尾

另请参阅

thrust::unique_copy

template <typename InputIterator,
  typename OutputIterator>
OutputIterator
unique_copy(InputIterator first,
  InputIterator last,
  OutputIterator result);

unique_copy 将范围 [first, last) 内的元素复制到从 result 开始的范围，只不过仅复制每组连续重复元素的第一个元素。返回值是结果范围的的末尾。

unique_copy 有两个不同版本的原因在于，它对于一组连续重复的元素，有两种不同的定义。在第一个版本中，测试简单的相等性：如果对于范围内的每个迭代器 i ，要么 i == f ‍，要么 *i == *(i-1) ，则范围 [f, l) 内元素是重复的。在第二个版本中，测试任意 BinaryPredicate binary_pred：如果对于该范围内的每个迭代器 i ，要么 i == f ‍，要么 binary_pred(*i, *(i-1)) 为 true ，则 [f, l) 内的元素是重复的。

此版本的 unique_copy 使用 operator== 测试相等性。

以下代码片段演示了如何使用 unique_copy 压缩数字序列以删除连续的重复项：

#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

模板参数

InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 是 Equality Comparable 的模型
OutputIterator：是 Output Iterator 的模型， InputIterator 的 value_type 可转换为 OutputIterator 的 value_type

函数参数

first：输入范围的起始
last：输入范围的末尾
result：输出范围的起始

前提条件

范围 [first,last) ‍不应与范围 [result, result + (last - first)) 重叠

返回值

唯一范围 [result, result_end) 的末尾

另请参阅

thrust::unique_copy

template <typename DerivedPolicy,
  typename InputIterator,
  typename OutputIterator,
  typename BinaryPredicate>
__host__ __device__ OutputIterator
unique_copy(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  OutputIterator result,
  BinaryPredicate binary_pred);

unique_copy 将范围 [first, last) 内的元素复制到从 result 开始的范围，只不过仅复制每组连续重复元素的第一个元素。返回值是结果范围的的末尾。

此版本的 unique_copy 使用函数对象 binary_pred 测试相等性。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 unique_copy 压缩数字序列以删除连续的重复项：

#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.

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 是 Equality Comparable 的模型
OutputIterator：是 Output Iterator 的模型， InputIterator 的 value_type 可转换为 OutputIterator 的 value_type
BinaryPredicate：是 Binary Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：输入范围的起始
last：输入范围的末尾
result：输出范围的起始
binary_pred：用于确定相等性的二元谓词

前提条件

范围 [first,last) ‍不应与范围 [result, result + (last - first)) 重叠

返回值

唯一范围 [result, result_end) 的末尾

另请参阅

thrust::unique_copy

template <typename InputIterator,
  typename OutputIterator,
  typename BinaryPredicate>
OutputIterator
unique_copy(InputIterator first,
  InputIterator last,
  OutputIterator result,
  BinaryPredicate binary_pred);

unique_copy 将范围 [first, last) 内的元素复制到从 result 开始的范围，只不过仅复制每组连续重复元素的第一个元素。返回值是结果范围的的末尾。

此版本的 unique_copy 使用函数对象 binary_pred 测试相等性。

以下代码片段演示了如何使用 unique_copy 压缩数字序列以删除连续的重复项：

#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.

模板参数

InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 是 Equality Comparable 的模型
OutputIterator：是 Output Iterator 的模型， InputIterator 的 value_type 可转换为 OutputIterator 的 value_type
BinaryPredicate：是 Binary Predicate 的模型

函数参数

first：输入范围的起始
last：输入范围的末尾
result：输出范围的起始
binary_pred：用于确定相等性的二元谓词

前提条件

范围 [first,last) ‍不应与范围 [result, result + (last - first)) 重叠

返回值

唯一范围 [result, result_end) 的末尾

另请参阅

thrust::unique_by_key

template <typename DerivedPolicy,
  typename ForwardIterator1,
  typename ForwardIterator2>
__host__ __device__ thrust::pair< ForwardIterator1, ForwardIterator2 >
unique_by_key(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator1 keys_first,
  ForwardIterator1 keys_last,
  ForwardIterator2 values_first);

unique_by_key 是 unique 到键值对的泛化。对于范围 [keys_first, keys_last) 内每一组相等的连续键， unique_by_key 删除组中除第一个元素以外的所有元素。‍同样地，范围 [values_first, values_first + (keys_last - keys_first)) 内的相应值也将删除。

返回值是一对迭代器 (new_keys_last,new_values_last) ，使得范围 [keys_first, new_keys_last) ‍内不存在两个相等的连续元素。

此版本的 unique_by_key 使用 operator== 测试相等性，并使用 project1st 对具有相等键的值进行归约。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 unique_by_key 压缩键值对序列以删除连续的重复项：

#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.

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator1：是 Forward Iterator 的模型， ForwardIterator1 是可变动，且 ForwardIterator 的 value_type 是 Equality Comparable 的模型
ForwardIterator2：是 Forward Iterator 的模型，且 ForwardIterator2 是可变的

函数参数

exec：用于并行化的执行策略
keys_first：键范围的起始
keys_last：键范围的末尾
values_first：值范围的起始

前提条件

范围 [keys_first, keys_last) ‍不应与范围 [values_first, values_first + (keys_last - keys_first)) 重叠

返回值

范围 [key_first, keys_new_last) 和 [values_first, values_new_last) 末尾的一对迭代器

另请参阅

unique
unique_by_key_copy
reduce_by_key

thrust::unique_by_key

template <typename ForwardIterator1,
typename ForwardIterator2>
thrust::pair< ForwardIterator1, ForwardIterator2 >
unique_by_key(ForwardIterator1 keys_first,
  ForwardIterator1 keys_last,
  ForwardIterator2 values_first);

unique_by_key 是 unique 到键值对的泛化。对于范围 [keys_first, keys_last) 内每一组相等的连续键， unique_by_key 删除组中除第一个元素以外的所有元素。‍同样地，范围 [values_first, values_first + (keys_last - keys_first)) 内的相应值也将删除。

返回值是一对迭代器 (new_keys_last,new_values_last) ，使得范围 [keys_first, new_keys_last) ‍内不存在两个相等的连续元素。

此版本的 unique_by_key 使用 operator== 测试相等性，并使用 project1st 对具有相等键的值进行归约。

以下代码片段演示了如何使用 unique_by_key 压缩键值对数字序列以删除连续的重复项：

#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.

模板参数

ForwardIterator1：是 Forward Iterator 的模型， ForwardIterator1 是可变动，且 ForwardIterator 的 value_type 是 Equality Comparable 的模型
ForwardIterator：是 Forward Iterator 的模型，且 ForwardIterator2 是可变的

函数参数

keys_first：键范围的起始
keys_last：键范围的末尾
values_first：值范围的起始

前提条件

范围 [keys_first, keys_last) ‍不应与范围 [values_first, values_first + (keys_last - keys_first)) 重叠

返回值

范围 [key_first, keys_new_last) 和 [values_first, values_new_last) 末尾的一对迭代器

另请参阅

unique
unique_by_key_copy
reduce_by_key

thrust::unique_by_key

template <typename DerivedPolicy,
  typename ForwardIterator1,
  typename ForwardIterator2,
  typename BinaryPredicate>
__host__ __device__ 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);

unique_by_key 是 unique 到键值对的泛化。对于范围 [keys_first, keys_last) 内每一组相等的连续键， unique_by_key 删除组中除第一个元素以外的所有元素。‍同样地，范围 [values_first, values_first + (keys_last - keys_first)) 内的相应值也将删除。

此版本的 unique_by_key 使用函数对象 binary_pred 测试相等性，并使用 project1st 对具有相等键的值进行归约。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 unique_by_key 压缩键值对序列以删除连续的重复项：

#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.

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator1：是 Forward Iterator 的模型， ForwardIterator1 是可变动，且 ForwardIterator 的 value_type 是 Equality Comparable 的模型
ForwardIterator：是 Forward Iterator 的模型，且 ForwardIterator2 是可变的
BinaryPredicate：是 Binary Predicate 的模型

函数参数

exec：用于并行化的执行策略
keys_first：键范围的起始
keys_last：键范围的末尾
values_first：值范围的起始
binary_pred：用于确定相等性的二元谓词

前提条件

范围 [keys_first, keys_last) ‍不应与范围 [values_first, values_first + (keys_last - keys_first)) 重叠

返回值

唯一范围 [first, new_last) 的末尾

另请参阅

unique
unique_by_key_copy
reduce_by_key

thrust::unique_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);

unique_by_key 是 unique 到键值对的泛化。对于范围 [keys_first, keys_last) 内每一组相等的连续键， unique_by_key 删除组中除第一个元素以外的所有元素。‍同样地，范围 [values_first, values_first + (keys_last - keys_first)) 内的相应值也将删除。

此版本的 unique_by_key 使用函数对象 binary_pred 测试相等性，并使用 project1st 对具有相等键的值进行归约。

以下代码片段演示了如何使用 unique_by_key 压缩键值对数字序列以删除连续的重复项：

#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.

模板参数

ForwardIterator1：是 Forward Iterator 的模型， ForwardIterator1 是可变动，且 ForwardIterator 的 value_type 是 Equality Comparable 的模型
ForwardIterator：是 Forward Iterator 的模型，且 ForwardIterator2 是可变的
BinaryPredicate：是 Binary Predicate 的模型

函数参数

keys_first：键范围的起始
keys_last：键范围的末尾
values_first：值范围的起始
binary_pred：用于确定相等性的二元谓词

前提条件

范围 [keys_first, keys_last) ‍不应与范围 [values_first, values_first + (keys_last - keys_first)) 重叠

返回值

唯一范围 [first, new_last) 的末尾

另请参阅

unique
unique_by_key_copy
reduce_by_key

thrust::unique_by_key_copy

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator1,
  typename OutputIterator2>
__host__ __device__ 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);

unique_by_key_copy 是 unique_copy 到键值对的泛化。对于范围 [keys_first, keys_last) 内每一组相等的连续键， unique_by_key_copy 将组内第一个元素复制到从 keys_result 开始的范围，并且将范围 [values_first, values_first + (keys_last - keys_first)) 内的相应值复制到从 values_result 开始的范围。

此版本的 unique_by_key_copy 使用 operator== 测试相等性，并使用 project1st 对具有相等键的值进行归约。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 unique_by_key_copy 压缩键值对序列以删除建相同的重复项：

#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.

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型
InputIterator2：是 Input Iterator 的模型
OutputIterator1：是 Output Iterator 的模型， InputIterator1 的 value_type 可转换为 OutputIterator1 的 value_type
OutputIterator2：是 Output Iterator 的模型， InputIterator2 的 value_type 可转换为 OutputIterator2 的 value_type

函数参数

exec：用于并行化的执行策略
keys_first：输入键范围的起始
keys_last：输入键范围的末尾
values_first：输入值范围的起始
keys_result：输出键范围的起始
values_result：输出值范围的起始

前提条件

输入范围不应与任何一个输出范围重叠

返回值

范围 [keys_result, keys_result_last) 和 [values_result, values_result_last) 末尾的一对迭代器

另请参阅

unique_copy
unique_by_key
reduce_by_key

thrust::unique_by_key_copy

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);

unique_by_key_copy 是 unique_copy 到键值对的泛化。对于范围 [keys_first, keys_last) 内每一组相等的连续键， unique_by_key_copy 将组内第一个元素复制到从 keys_result 开始的范围，并且将范围 [values_first, values_first + (keys_last - keys_first)) 内的相应值复制到从 values_result 开始的范围。

此版本的 unique_by_key_copy 使用 operator== 测试相等性，并使用 project1st 对具有相等键的值进行归约。

以下代码片段演示了如何使用 unique_by_key_copy 压缩键值对序列和相等的键：

#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.

模板参数

InputIterator1：是 Input Iterator 的模型
InputIterator2：是 Input Iterator 的模型
OutputIterator1：是 Output Iterator 的模型， InputIterator1 的 value_type 可转换为 OutputIterator1 的 value_type
OutputIterator2：是 Output Iterator 的模型， InputIterator2 的 value_type 可转换为 OutputIterator2 的 value_type

函数参数

keys_first：输入键范围的起始
keys_last：输入键范围的末尾
values_first：输入值范围的起始
keys_result：输出键范围的起始
values_result：输出值范围的起始

前提条件

输入范围不应与任何一个输出范围重叠

返回值

范围 [keys_result, keys_result_last) 和 [values_result, values_result_last) 末尾的一对迭代器

另请参阅

unique_copy
unique_by_key
reduce_by_key

thrust::unique_by_key_copy

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator1,
  typename OutputIterator2,
  typename BinaryPredicate>
__host__ __device__ 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);

unique_by_key_copy 是 unique_copy 到键值对的泛化。对于范围 [keys_first, keys_last) 内每一组相等的连续键， unique_by_key_copy 将组内第一个元素复制到从 keys_result 开始的范围，并且将范围 [values_first, values_first + (keys_last - keys_first)) 内的相应值复制到从 values_result 开始的范围。

此版本的 unique_by_key_copy 使用函数对象 binary_pred 测试相等性，并使用 project1st 对具有相等键的值进行归约。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 unique_by_key_copy 压缩键值对序列和相等的键：

#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.

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型
InputIterator2：是 Input Iterator 的模型
OutputIterator1：是 Output Iterator 的模型， InputIterator1 的 value_type 可转换为 OutputIterator1 的 value_type
OutputIterator2：是 Output Iterator 的模型， InputIterator2 的 value_type 可转换为 OutputIterator2 的 value_type
BinaryPredicate：是 Binary Predicate 的模型

函数参数

exec：用于并行化的执行策略
keys_first：输入键范围的起始
keys_last：输入键范围的末尾
values_first：输入值范围的起始
keys_result：输出键范围的起始
values_result：输出值范围的起始
binary_pred：用于确定相等性的二元谓词

前提条件

输入范围不应与任何一个输出范围重叠

返回值

范围 [keys_result, keys_result_last) 和 [values_result, values_result_last) 末尾的一对迭代器

另请参阅

unique_copy
unique_by_key
reduce_by_key

thrust::unique_by_key_copy

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);

unique_by_key_copy 是 unique_copy 到键值对的泛化。对于相等范围 [keys_first, keys_last) 内的每一组连续键， unique_by_key_copy 将组内第一个元素复制到从 keys_result 开始的范围，并且将范围 [values_first, values_first + (keys_last - keys_first)) 内的相应值复制到从 values_result 开始的范围。

此版本的 unique_by_key_copy 使用函数对象 binary_pred 测试相等性，并使用 project1st 对具有相等键的值进行归约。

以下代码片段演示了如何使用 unique_by_key_copy 压缩键值对序列和相等的键：

#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.

模板参数

InputIterator1：是 Input Iterator 的模型
InputIterator2：是 Input Iterator 的模型
OutputIterator1：是 Output Iterator 的模型， InputIterator1 的 value_type 可转换为 OutputIterator1 的 value_type
OutputIterator2：是 Output Iterator 的模型， InputIterator2 的 value_type 可转换为 OutputIterator2 的 value_type
BinaryPredicate：是 Binary Predicate 的模型

函数参数

keys_first：输入键范围的起始
keys_last：输入键范围的末尾
values_first：输入值范围的起始
keys_result：输出键范围的起始
values_result：输出值范围的起始
binary_pred：用于确定相等性的二元谓词

前提条件

输入范围不应与任何一个输出范围重叠

返回值

范围 [keys_result, keys_result_last) 和 [values_result, values_result_last) 末尾的一对迭代器

另请参阅

unique_copy
unique_by_key
reduce_by_key

thrust::unique_count

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename BinaryPredicate>
__host__ __device__ thrust::iterator_traits< ForwardIterator >::difference_type
unique_count(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  BinaryPredicate binary_pred);

unique_count 计算范围 [first, last) 内具有相同值的相等元素的运行次数。此版本的 unique_count ‍使用函数对象 binary_pred ‍测试相等性。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 unique_count 确定相等元素的运行次数：

#include <thrust/unique.h>
#include <thrust/execution_policy.h>
...
const int N = 7;
int A[N] = {1, 3, 3, 3, 2, 2, 1};
int count = thrust::unique_count(thrust::host, A, A + N, thrust::equal_to<int>());
// count is now 4

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 可转换为 BinaryPredicate 的 first_argument_type 和 second_argument_type
BinaryPredicate：是 Binary Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：输入范围的起始
last：输入范围的末尾
binary_pred：用于确定相等性的二元谓词

返回值

[first, new_last) 内相等元素的运行次数

另请参阅

unique_copy
unique_by_key_copy
reduce_by_key_copy

thrust::unique_count

template <typename DerivedPolicy,
  typename ForwardIterator>
__host__ __device__ thrust::iterator_traits< ForwardIterator >::difference_type
unique_count(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last);

unique_count 计算范围 [first, last) 内具有相同值的相等元素的运行次数。

此版本的 unique_count 使用 operator== 测试相等性。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 unique_count 确定相等元素的运行次数：

#include <thrust/unique.h>
#include <thrust/execution_policy.h>
...
const int N = 7;
int A[N] = {1, 3, 3, 3, 2, 2, 1};
int count = thrust::unique_count(thrust::host, A, A + N);
// count is now 4

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 可转换为 BinaryPredicate 的 first_argument_type 和 second_argument_type
BinaryPredicate：是 Binary Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：输入范围的起始
last：输入范围的末尾
binary_pred：用于确定相等性的二元谓词

返回值

[first, new_last) 内相等元素的运行次数

另请参阅

unique_copy
unique_by_key_copy
reduce_by_key_copy

thrust::unique_count

template <typename ForwardIterator,
  typename BinaryPredicate>
__host__ __device__ thrust::iterator_traits< ForwardIterator >::difference_type
unique_count(ForwardIterator first,
  ForwardIterator last,
  BinaryPredicate binary_pred);

unique_count 计算范围 [first, last) 内相等元素的运行次数。

此版本的 unique_count 使用函数对象 binary_pred 测试相等性。

以下代码片段演示了如何使用 unique_count 确定相等元素的运行次数：

#include <thrust/unique.h>
#include <thrust/execution_policy.h>
...
const int N = 7;
int A[N] = {1, 3, 3, 3, 2, 2, 1};
int count = thrust::unique_count(A, A + N, thrust::equal_to<int>());
// count is now 4

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 可转换为 BinaryPredicate 的 first_argument_type 和 second_argument_type
BinaryPredicate：是 Binary Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：输入范围的起始
last：输入范围的末尾
binary_pred：用于确定相等性的二元谓词

返回值

[first, new_last) 内相等元素的运行次数

另请参阅

unique_copy
unique_by_key_copy
reduce_by_key_copy

thrust::unique_count

template <typename ForwardIterator>
__host__ __device__ thrust::iterator_traits< ForwardIterator >::difference_type
unique_count(ForwardIterator first,
  ForwardIterator last);

unique_count 计算范围 [first, last) 内具有相同值的相等元素的运行次数。

此版本的 unique_count 使用 operator== 测试相等性。

以下代码片段演示了如何使用 unique_count 确定相等元素的运行次数：

#include <thrust/unique.h>
#include <thrust/execution_policy.h>
...
const int N = 7;
int A[N] = {1, 3, 3, 3, 2, 2, 1};
int count = thrust::unique_count(thrust::host, A, A + N);
// count is now 4

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 可转换为 BinaryPredicate 的 first_argument_type 和 second_argument_type
BinaryPredicate：是 Binary Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：输入范围的起始
last：输入范围的末尾
binary_pred：用于确定相等性的二元谓词

返回值

[first, new_last) 内相等元素的运行次数

另请参阅

unique_copy
unique_by_key_copy
reduce_by_key_copy

2.1.6. 搜索（Searching）

2.1.6.1. 搜索

函数

template <typename DerivedPolicy,
  typename InputIterator,
  typename T>
__host__ __device__ InputIterator
thrust::find(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  const T & value);

template <typename InputIterator,
  typename T>
InputIterator
thrust::find(InputIterator first,
  InputIterator last,
  const T & value);

template <typename DerivedPolicy,
  typename InputIterator,
  typename Predicate>
__host__ __device__ InputIterator
thrust::find_if(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  Predicate pred);

template <typename InputIterator,
  typename Predicate>
InputIterator t
hrust::find_if(InputIterator first,
  InputIterator last,
  Predicate pred);

template <typename DerivedPolicy,
  typename InputIterator,
  typename Predicate>
__host__ __device__ InputIterator
thrust::find_if_not(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  Predicate pred);

template <typename InputIterator,
  typename Predicate>
InputIterator
thrust::find_if_not(InputIterator first,
  InputIterator last,
  Predicate pred);

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2>
__host__ __device__ thrust::pair< InputIterator1, InputIterator2 >
thrust::mismatch(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2);

template <typename InputIterator1,
  typename InputIterator2>
thrust::pair< InputIterator1, InputIterator2 >
thrust::mismatch(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2);
template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename BinaryPredicate>
__host__ __device__ thrust::pair< InputIterator1, InputIterator2 >
thrust::mismatch(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  BinaryPredicate pred);

 template <typename InputIterator1,
   typename InputIterator2,
   typename BinaryPredicate>
 thrust::pair< InputIterator1, InputIterator2 >
 thrust::mismatch(InputIterator1 first1,
   InputIterator1 last1,
   InputIterator2 first2,
   BinaryPredicate pred);

 template <typename DerivedPolicy,
   typename ForwardIterator,
   typename Predicate>
 __host__ __device__ ForwardIterator
 thrust::partition_point(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
   ForwardIterator first,
   ForwardIterator last,
   Predicate pred);

 template <typename ForwardIterator,
   typename Predicate>
 ForwardIterator
 thrust::partition_point(ForwardIterator first,
   ForwardIterator last,
   Predicate pred);

thrust::find

template <typename DerivedPolicy,
  typename InputIterator,
  typename T>
__host__ __device__ InputIterator
find(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  const T & value);

find 返回范围 [first, last) 内使得 *i == value 的第一个迭代器 i ；没有这种迭代器时返回 last ‍。

算法的执行由 exec 确定并行化。

#include <thrust/find.h>
#include <thrust/device_vector.h>
#include <thrust/execution_policy.h>
...
thrust::device_vector<int> input(4);

input[0] = 0;
input[1] = 5;
input[2] = 3;
input[3] = 7;

thrust::device_vector<int>::iterator iter;

iter = thrust::find(thrust::device, input.begin(), input.end(), 3); // returns input.first() + 2
iter = thrust::find(thrust::device, input.begin(), input.end(), 5); // returns input.first() + 1
iter = thrust::find(thrust::device, input.begin(), input.end(), 9); // returns input.end()

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type ‍等价于类型 T
T：是 EqualityComparable 的模型

函数参数

exec：用于并行化的执行策略
first：待搜索的序列的起始
last：待搜索的序列的末尾
value：要查找的值

返回值

‍返回使得 *i == value 的第一个迭代器 i；否则，返回 last

另请参阅

find_if
mismatch

thrust::find

template <typename InputIterator,
  typename T>
InputIterator
find(InputIterator first,
  InputIterator last,
  const T & value);

find 返回范围 [first, last) 内使得 *i == value 的第一个迭代器 i；没有这种迭代器时返回 last。

#include <thrust/find.h>
#include <thrust/device_vector.h>
...
thrust::device_vector<int> input(4);

input[0] = 0;
input[1] = 5;
input[2] = 3;
input[3] = 7;

thrust::device_vector<int>::iterator iter;

iter = thrust::find(input.begin(), input.end(), 3); // returns input.first() + 2
iter = thrust::find(input.begin(), input.end(), 5); // returns input.first() + 1
iter = thrust::find(input.begin(), input.end(), 9); // returns input.end()

模板参数

InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type ‍等价于类型 T
T：是 EqualityComparable 的模型

函数参数

first：待搜索的序列的起始
last：待搜索的序列的末尾
value：要查找的值

返回值

‍返回使得 *i == value 的第一个迭代器 i；否则，返回 last

另请参阅

find_if
mismatch

thrust::find_if

template <typename DerivedPolicy,
  typename InputIterator,
  typename Predicate>
__host__ __device__ InputIterator
find_if(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  Predicate pred);

find_if 返回范围 [first, last) 内使得 pred(*i) 为 true 的第一个迭代器 i；没有这种迭代器时返回 last。

算法的执行由 exec 确定并行化。

#include <thrust/find.h>
#include <thrust/device_vector.h>
#include <thrust/execution_policy.h>
...

struct greater_than_four
{
__host__ __device__
bool operator()(int x)
{
return x > 4;
}
};

struct greater_than_ten
{
__host__ __device__
bool operator()(int x)
{
return x > 10;
}
};

...
thrust::device_vector<int> input(4);

input[0] = 0;
input[1] = 5;
input[2] = 3;
input[3] = 7;

thrust::device_vector<int>::iterator iter;

iter = thrust::find_if(thrust::device, input.begin(), input.end(), greater_than_four()); // returns input.first() + 1

iter = thrust::find_if(thrust::device, input.begin(), input.end(), greater_than_ten());  // returns input.end()

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator：是 Input Iterator 的模型
Predicate：是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：待搜索的序列的起始
last：待搜索的序列的末尾
pred：用于测试范围内元素的谓词

返回值

‍返回使得 pred(*i) 为 true 的第一个迭代器 i；否则，返回 last

另请参阅

find
find_if_not
mismatch

thrust::find_if

template <typename InputIterator,
  typename Predicate>
InputIterator
find_if(InputIterator first,
  InputIterator last,
  Predicate pred);

find_if 返回范围 [first, last) 内使得 pred(*i) 为 true 的第一个迭代器 i；没有这种迭代器时返回 last。

#include <thrust/find.h>
#include <thrust/device_vector.h>

struct greater_than_four
{
__host__ __device__
bool operator()(int x)
{
return x > 4;
}
};

struct greater_than_ten
{
__host__ __device__
bool operator()(int x)
{
return x > 10;
}
};

...
thrust::device_vector<int> input(4);

input[0] = 0;
input[1] = 5;
input[2] = 3;
input[3] = 7;

thrust::device_vector<int>::iterator iter;

iter = thrust::find_if(input.begin(), input.end(), greater_than_four()); // returns input.first() + 1

iter = thrust::find_if(input.begin(), input.end(), greater_than_ten());  // returns input.end()

模板参数

InputIterator：是 Input Iterator 的模型
Predicate：是 Predicate 的模型

函数参数

first：待搜索的序列的起始
last：待搜索的序列的末尾
pred：用于测试范围内元素的谓词

返回值

‍返回使得 pred(*i) 为 true 的第一个迭代器 i；否则，返回 last

另请参阅

find
find_if_not
mismatch

thrust::find_if_not

template <typename DerivedPolicy,
  typename InputIterator,
  typename Predicate>
__host__ __device__ InputIterator
find_if_not(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  Predicate pred);

find_if_not 返回范围 [first, last) 内使得 pred(*i) 为 false 的第一个迭代器 i；没有这种迭代器时返回 last。

算法的执行由 exec 确定并行化。

#include <thrust/find.h>
#include <thrust/device_vector.h>
#include <thrust/execution_policy.h>
...

struct greater_than_four
{
__host__ __device__
bool operator()(int x)
{
return x > 4;
}
};

struct greater_than_ten
{
__host__ __device__
bool operator()(int x)
{
return x > 10;
}
};

...
thrust::device_vector<int> input(4);

input[0] = 0;
input[1] = 5;
input[2] = 3;
input[3] = 7;

thrust::device_vector<int>::iterator iter;

iter = thrust::find_if_not(thrust::device, input.begin(), input.end(), greater_than_four()); // returns input.first()

iter = thrust::find_if_not(thrust::device, input.begin(), input.end(), greater_than_ten());  // returns input.first()

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator：是 Input Iterator 的模型
Predicate：是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：待搜索的序列的起始
last：待搜索的序列的末尾
pred：用于测试范围内元素的谓词

返回值

‍返回使得 pred(*i) 为 false 的第一个迭代器 i；否则，返回 last

另请参阅

find
find_if
mismatch

thrust::find_if_not

template <typename InputIterator,
  typename Predicate>
InputIterator
find_if_not(InputIterator first,
  InputIterator last,
  Predicate pred);

find_if_not 返回范围 [first, last) 内使得 pred(*i) 为 false 的第一个迭代器 i；没有这种迭代器时返回 last。

#include <thrust/find.h>
#include <thrust/device_vector.h>

struct greater_than_four
{
__host__ __device__
bool operator()(int x)
{
return x > 4;
}
};

struct greater_than_ten
{
__host__ __device__
bool operator()(int x)
{
return x > 10;
}
};

...
thrust::device_vector<int> input(4);

input[0] = 0;
input[1] = 5;
input[2] = 3;
input[3] = 7;

thrust::device_vector<int>::iterator iter;

iter = thrust::find_if_not(input.begin(), input.end(), greater_than_four()); // returns input.first()

iter = thrust::find_if_not(input.begin(), input.end(), greater_than_ten());  // returns input.first()

模板参数

InputIterator：是 Input Iterator 的模型
Predicate：是 Predicate 的模型

函数参数

first：待搜索的序列的起始
last：待搜索的序列的末尾
pred：用于测试范围内元素的谓词

返回值

‍返回使得 pred(*i) 为 false 的第一个迭代器 i；否则，返回 last

另请参阅

find
find_if
mismatch

thrust::mismatch

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2>
__host__ __device__ thrust::pair< InputIterator1, InputIterator2 >
mismatch(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2);

mismatch 查找两个范围 [first1, last1) 和 [first2, first2 + (last1 - first1)) 不同的第一个位置。 mismatch 的两个版本使用不同的测试来判断元素是否不同。

此版本的 mismatch ‍查找 [first1, last1) 内使得 *i == *(first2 + (i - first1)) 为 false 的第一个迭代器 i。返回值为一个 pair：第一个元素是 i，第二个元素是 *(first2 + (i - first1))。如果不存在这样的迭代器 i ，则返回的 pair ‍为：第一个元素是 last1 ，第二个元素是 *(first2 + (last1 - first1))。

算法的执行由 exec 确定并行化。

#include <thrust/mismatch.h>
#include <thrust/device_vector.h>
#include <thrust/execution_policy.h>
...
thrust::device_vector<int> vec1(4);
thrust::device_vector<int> vec2(4);

vec1[0] = 0;  vec2[0] = 0;
vec1[1] = 5;  vec2[1] = 5;
vec1[2] = 3;  vec2[2] = 8;
vec1[3] = 7;  vec2[3] = 7;

typedef thrust::device_vector<int>::iterator Iterator;
thrust::pair<Iterator,Iterator> result;

result = thrust::mismatch(thrust::device, vec1.begin(), vec1.end(), vec2.begin());

// result.first  is vec1.begin() + 2
// result.second is vec2.begin() + 2

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型， InputIterator1 的 value_type ‍等价于 InputIterator2 的 value_type
InputIterator2：是 Input Iterator 的模型

函数参数

exec：用于并行化的执行策略
first1：第一个序列的起始
last1：第一个序列的末尾
first2：第二个序列的起始

返回值

序列出现不同的第一个位置

另请参阅

find
find_if

thrust::mismatch

template <typename InputIterator1,
  typename InputIterator2>
thrust::pair< InputIterator1, InputIterator2 >
mismatch(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2);

mismatch 查找两个范围 [first1, last1) 和 [first2, first2 + (last1 - first1)) 不同的第一个位置。 mismatch 的两个版本使用不同的测试来判断元素是否不同。

此版本的 mismatch ‍查找 [first1, last1) 内使得 *i == *(first2 + (i - first1)) 为 false 的第一个迭代器 i。返回值为一个 pair：第一个元素是 i，第二个元素是 *(first2 + (i - first1))。如果不存在这样的迭代器 i ，则返回的 pair ‍为：第一个元素是 last1 ，第二个元素是 *(first2 + (last1 - first1))。

#include <thrust/mismatch.h>
#include <thrust/device_vector.h>
...
thrust::device_vector<int> vec1(4);
thrust::device_vector<int> vec2(4);

vec1[0] = 0;  vec2[0] = 0;
vec1[1] = 5;  vec2[1] = 5;
vec1[2] = 3;  vec2[2] = 8;
vec1[3] = 7;  vec2[3] = 7;

typedef thrust::device_vector<int>::iterator Iterator;
thrust::pair<Iterator,Iterator> result;

result = thrust::mismatch(vec1.begin(), vec1.end(), vec2.begin());

// result.first  is vec1.begin() + 2
// result.second is vec2.begin() + 2

模板参数

InputIterator1：是 Input Iterator 的模型， InputIterator1 的 value_type ‍等价于 InputIterator2 的 value_type
InputIterator2：是 Input Iterator 的模型

函数参数

first1：第一个序列的起始
last1：第一个序列的末尾
first2：第二个序列的起始

返回值

序列出现不同的第一个位置

另请参阅

find
find_if

thrust::mismatch

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename BinaryPredicate>
__host__ __device__ thrust::pair< InputIterator1, InputIterator2 >
mismatch(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  BinaryPredicate pred);

mismatch 查找两个范围 [first1, last1) 和 [first2, first2 + (last1 - first1)) 不同的第一个位置。 mismatch 的两个版本使用不同的测试来判断元素是否不同。

此版本的 mismatch ‍查找 [first1, last1) 内使得 pred(*i, *(first2 + (i - first1)) 为 false 的第一个迭代器 i。返回值为一个 pair：第一个元素是 i，第二个元素是 *(first2 + (i - first1))。如果不存在这样的迭代器 i ，则返回的 pair ‍为：第一个元素是 last1 ，第二个元素是 *(first2 + (last1 - first1))。

算法的执行由 exec 确定并行化。

#include <thrust/mismatch.h>
#include <thrust/device_vector.h>
#include <thrust/execution_policy.h>
...
thrust::device_vector<int> vec1(4);
thrust::device_vector<int> vec2(4);

vec1[0] = 0;  vec2[0] = 0;
vec1[1] = 5;  vec2[1] = 5;
vec1[2] = 3;  vec2[2] = 8;
vec1[3] = 7;  vec2[3] = 7;

typedef thrust::device_vector<int>::iterator Iterator;
thrust::pair<Iterator,Iterator> result;

result = thrust::mismatch(thrust::device, vec1.begin(), vec1.end(), vec2.begin(), thrust::equal_to<int>());

// result.first  is vec1.begin() + 2
// result.second is vec2.begin() + 2

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型
InputIterator2：是 Input Iterator 的模型
Predicate：是 Input Iterator 的模型

函数参数

exec：用于并行化的执行策略
first1：第一个序列的起始
last1：第一个序列的末尾
first2：第二个序列的起始
pred：比较元素的二元谓词

返回值

序列出现不同的第一个位置

另请参阅

find
find_if

thrust::mismatch

template <typename InputIterator1,
  typename InputIterator2,
  typename BinaryPredicate>
thrust::pair< InputIterator1, InputIterator2 >
mismatch(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  BinaryPredicate pred);

mismatch 查找两个范围 [first1, last1) 和 [first2, first2 + (last1 - first1)) 不同的第一个位置。 mismatch 的两个版本使用不同的测试来判断元素是否不同。

此版本的 mismatch ‍查找 [first1, last1) 内使得 pred(*i, *(first2 + (i - first1)) 为 false 的第一个迭代器 i。返回值为一个 pair：第一个元素是 i ，第二个元素是 *(first2 + (i - first1))。如果不存在这样的迭代器 i ，则返回的 pair ‍为：第一个元素是 last1 ，第二个元素是 *(first2 + (last1 - first1))。

#include <thrust/mismatch.h>
#include <thrust/device_vector.h>
...
thrust::device_vector<int> vec1(4);
thrust::device_vector<int> vec2(4);

vec1[0] = 0;  vec2[0] = 0;
vec1[1] = 5;  vec2[1] = 5;
vec1[2] = 3;  vec2[2] = 8;
vec1[3] = 7;  vec2[3] = 7;

typedef thrust::device_vector<int>::iterator Iterator;
thrust::pair<Iterator,Iterator> result;

result = thrust::mismatch(vec1.begin(), vec1.end(), vec2.begin(), thrust::equal_to<int>());

// result.first  is vec1.begin() + 2
// result.second is vec2.begin() + 2

模板参数

InputIterator1：是 Input Iterator 的模型
InputIterator2：是 Input Iterator 的模型
Predicate：是 Input Iterator 的模型

函数参数

first1：第一个序列的起始
last1：第一个序列的末尾
first2：第二个序列的起始
pred：比较元素的二元谓词

返回值

序列出现不同的第一个位置

另请参阅

find
find_if

thrust::partition_point

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename Predicate>
__host__ __device__ ForwardIterator
partition_point(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  Predicate pred);

partition_point 返回指向分区范围内 true 分区末尾的迭代器。 partition_point 要求输入范围 [first,last) 是这样一个分区：所有满足 pred 的元素都应先于不满足 pred 的元素。

算法的执行由 exec 确定并行化。

#include <thrust/partition.h>
#include <thrust/execution_policy.h>

struct is_even
{
__host__ __device__
bool operator()(const int &x)
{
return (x % 2) == 0;
}
};

...

int A[] = {2, 4, 6, 8, 10, 1, 3, 5, 7, 9};
int * B = thrust::partition_point(thrust::host, A, A + 10, is_even());
// B - A is 5
// [A, B) contains only even values

备注

partition_point 与 find_if_not 尽管类似，但并不冗余。 partition_point 的前提条件为更快的实现提供了机会。

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 的 value_type 可转换为 Predicate 的 argument_type
Predicate：是 Predicate 的模型

函数参数

exec：用于并行化的执行策略
first：待检查的范围的起始
last：待检查的范围的末尾
pred：决定范围 [first, last) 内每个元素属于哪个分区的函数对象

前提条件

‍范围 [first, last) 应根据 pred 划分

返回值

‍使得 all_of(first, mid, pred) 和 none_of(mid, last, pred) 都为 true ‍的迭代器 mid

另请参阅

partition
find_if_not

thrust::partition_point

template <typename ForwardIterator,
  typename Predicate>
ForwardIterator
partition_point(ForwardIterator first,
  ForwardIterator last,
  Predicate pred);

partition_point 返回指向分区范围内 true 分区末尾的迭代器。 partition_point 要求输入范围 [first,last) 是这样一个分区：所有满足 pred 的元素都应先于不满足 pred 的元素。

#include <thrust/partition.h>

struct is_even
{
__host__ __device__
bool operator()(const int &x)
{
return (x % 2) == 0;
}
};

...

int A[] = {2, 4, 6, 8, 10, 1, 3, 5, 7, 9};
int * B = thrust::partition_point(A, A + 10, is_even());
// B - A is 5
// [A, B) contains only even values

备注

partition_point 与 find_if_not 尽管类似，但并不冗余。 partition_point 的前提条件为更快的实现提供了机会。

模板参数

ForwardIterator：是 Forward Iterator 的模型，并且 ForwardIterator 的 value_type 可转换为 Predicate 的 argument_type
Predicate：是 Predicate 的模型

函数参数

first：待检查的范围的起始
last：待检查的范围的末尾
pred：决定范围 [first, last) 内每个元素属于哪个分区的函数对象

前提条件

‍范围 [first, last) 应根据 pred 划分

返回值

‍使得 all_of(first, mid, pred) 和 none_of(mid, last, pred) 都为 true ‍的迭代器 mid

另请参阅

partition
find_if_not

2.1.6.2. 二分搜索（Binary Search）

函数

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename LessThanComparable>
__host__ __device__ ForwardIterator
thrust::lower_bound(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  const LessThanComparable & value);

template <class ForwardIterator,
  class LessThanComparable>
ForwardIterator
thrust::lower_bound(ForwardIterator first,
  ForwardIterator last,
  const LessThanComparable & value);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename T,
  typename StrictWeakOrdering>
__host__ __device__ ForwardIterator
thrust::lower_bound(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  const T & value,
  StrictWeakOrdering comp);

template <class ForwardIterator,
  class T,
  class StrictWeakOrdering>
ForwardIterator
thrust::lower_bound(ForwardIterator first,
  ForwardIterator last,
  const T & value,
  StrictWeakOrdering comp);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename LessThanComparable>
__host__ __device__ ForwardIterator
thrust::upper_bound(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  const LessThanComparable & value);

template <class ForwardIterator,
  class LessThanComparable>
ForwardIterator
thrust::upper_bound(ForwardIterator first,
  ForwardIterator last,
  const LessThanComparable & value);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename T,
  typename StrictWeakOrdering>
__host__ __device__ ForwardIterator
thrust::upper_bound(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  const T & value,
  StrictWeakOrdering comp);

template <class ForwardIterator,
  class T,
  class StrictWeakOrdering>
ForwardIterator
thrust::upper_bound(ForwardIterator first,
  ForwardIterator last,
  const T & value,
  StrictWeakOrdering comp);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename LessThanComparable>
__host__ __device__ bool
thrust::binary_search(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  const LessThanComparable & value);

template <class ForwardIterator,
  class LessThanComparable>
bool
thrust::binary_search(ForwardIterator first,
  ForwardIterator last,
  const LessThanComparable & value);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename T,
  typename StrictWeakOrdering>
__host__ __device__ bool
thrust::binary_search(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  const T & value,
  StrictWeakOrdering comp);

template <class ForwardIterator,
  class T,
  class StrictWeakOrdering>
bool
thrust::binary_search(ForwardIterator first,
  ForwardIterator last,
  const T & value,
  StrictWeakOrdering comp);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename LessThanComparable>
__host__ __device__ thrust::pair< ForwardIterator, ForwardIterator >
thrust::equal_range(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  const LessThanComparable & value);

template <class ForwardIterator,
  class LessThanComparable>
thrust::pair< ForwardIterator, ForwardIterator >
thrust::equal_range(ForwardIterator first,
  ForwardIterator last,
  const LessThanComparable & value);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename T,
  typename StrictWeakOrdering>
__host__ __device__ thrust::pair< ForwardIterator, ForwardIterator >
thrust::equal_range(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  const T & value,
  StrictWeakOrdering comp);

template <class ForwardIterator,
  class T,
  class StrictWeakOrdering>
thrust::pair< ForwardIterator, ForwardIterator >
thrust::equal_range(ForwardIterator first,
  ForwardIterator last,
  const T & value,
  StrictWeakOrdering comp);

thrust::lower_bound

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename LessThanComparable>
__host__ __device__ ForwardIterator lower_bound(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  const LessThanComparable & value);

lower_bound 是二分搜索的一个版本：它试图在有序范围 [first, last) 内查找元素值。具体而言，它返回可以在不打乱顺序的情况下插入值的第一个位置。 ‍此版本的 lower_bound 使用 operator< ‍进行比较，返回 [first, last) 内最远的迭代器 i ，使得 [first, i) 内的每一个迭代器 j ，满足 *j < value。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::device 并行化执行策略，使用 lower_bound 搜索有序范围内的值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/execution_policy.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::lower_bound(thrust::device, input.begin(), input.end(), 0); // returns input.begin()
thrust::lower_bound(thrust::device, input.begin(), input.end(), 1); // returns input.begin() + 1
thrust::lower_bound(thrust::device, input.begin(), input.end(), 2); // returns input.begin() + 1
thrust::lower_bound(thrust::device, input.begin(), input.end(), 3); // returns input.begin() + 2
thrust::lower_bound(thrust::device, input.begin(), input.end(), 8); // returns input.begin() + 4
thrust::lower_bound(thrust::device, input.begin(), input.end(), 9); // returns input.end()

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator ‍的模型
LessThanComparable：是 LessThanComparable 的模型

函数参数

exec：用于并行化的执行策略
first：有序序列的起始
last：有序序列的末尾
value：要查找的值

返回值

‍‍使得 *i < value ‍的最远的迭代器 i

另请参阅

https://en.cppreference.com/w/cpp/algorithm/lower_bound
upper_bound
equal_range
Binary Search

thrust::lower_bound

template <class ForwardIterator,
  class LessThanComparable>
ForwardIterator
lower_bound(ForwardIterator first,
  ForwardIterator last,
  const LessThanComparable & value);

lower_bound 是二分搜索的一个版本：它试图在有序范围 [first, last) 内查找元素值。具体而言，它返回可以在不打乱顺序的情况下插入值的第一个位置。 ‍此版本的 lower_bound 使用 operator< ‍进行比较，返回 [first, last) 内最远的迭代器 i ，使得 [first, i) 内的每一个迭代器 j ，满足 *j < value。

以下代码片段演示了如何使用 lower_bound 搜索有序范围内的值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::lower_bound(input.begin(), input.end(), 0); // returns input.begin()
thrust::lower_bound(input.begin(), input.end(), 1); // returns input.begin() + 1
thrust::lower_bound(input.begin(), input.end(), 2); // returns input.begin() + 1
thrust::lower_bound(input.begin(), input.end(), 3); // returns input.begin() + 2
thrust::lower_bound(input.begin(), input.end(), 8); // returns input.begin() + 4
thrust::lower_bound(input.begin(), input.end(), 9); // returns input.end()

模板参数

ForwardIterator：是 Forward Iterator ‍的模型
LessThanComparable：是 LessThanComparable 的模型

函数参数

first：有序序列的起始
last：有序序列的末尾
value：要查找的值

返回值

‍‍使得 *i < value ‍的最远的迭代器 i

另请参阅

https://en.cppreference.com/w/cpp/algorithm/lower_bound
upper_bound
equal_range
Binary Search

thrust::lower_bound

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename T,
  typename StrictWeakOrdering>
__host__ __device__ ForwardIterator
lower_bound(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  const T & value,
  StrictWeakOrdering comp);

lower_bound 是二分搜索的一个版本：它试图在有序范围 [first, last) 内查找元素值。具体而言，它返回可以在不打乱顺序的情况下插入值的第一个位置。 ‍此版本的 lower_bound 使用函数对象 comp 进行比较，返回 [first, last) 内最远的迭代器 i ，使得 [first, i) 内的每一个迭代器 j ，满足 comp(*j, value) 为 true。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::device 并行化执行策略，使用 lower_bound 搜索有序范围内的值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::lower_bound(input.begin(), input.end(), 0, thrust::less<int>()); // returns input.begin()
thrust::lower_bound(input.begin(), input.end(), 1, thrust::less<int>()); // returns input.begin() + 1
thrust::lower_bound(input.begin(), input.end(), 2, thrust::less<int>()); // returns input.begin() + 1
thrust::lower_bound(input.begin(), input.end(), 3, thrust::less<int>()); // returns input.begin() + 2
thrust::lower_bound(input.begin(), input.end(), 8, thrust::less<int>()); // returns input.begin() + 4
thrust::lower_bound(input.begin(), input.end(), 9, thrust::less<int>()); // returns input.end()

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator ‍的模型
T：与 ForwardIterator 的 value_type 类似‍
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

exec：用于并行化的执行策略
first：有序序列的起始
last：有序序列的末尾
value：要查找的值
comp：比较运算符

返回值

‍使得 comp(*i, value) 为 true ‍的最远的迭代器 i

另请参阅

https://en.cppreference.com/w/cpp/algorithm/lower_bound
upper_bound
equal_range
Binary Search

thrust::lower_bound

template <class ForwardIterator,
  class T,
  class StrictWeakOrdering>
ForwardIterator
lower_bound(ForwardIterator first,
  ForwardIterator last,
  const T & value,
  StrictWeakOrdering comp);

lower_bound 是二分搜索的一个版本：它试图在有序范围 [first, last) 内查找元素值。具体而言，它返回可以在不打乱顺序的情况下插入值的第一个位置。 ‍此版本的 lower_bound 使用函数对象 comp 进行比较，返回 [first, last) 内最远的迭代器 i ，使得 [first, i) 内的每一个迭代器 j ，满足 comp(*j, value) 为 true。

以下代码片段演示了如何使用 lower_bound 搜索有序范围内的值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/functional.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::lower_bound(input.begin(), input.end(), 0, thrust::less<int>()); // returns input.begin()
thrust::lower_bound(input.begin(), input.end(), 1, thrust::less<int>()); // returns input.begin() + 1
thrust::lower_bound(input.begin(), input.end(), 2, thrust::less<int>()); // returns input.begin() + 1
thrust::lower_bound(input.begin(), input.end(), 3, thrust::less<int>()); // returns input.begin() + 2
thrust::lower_bound(input.begin(), input.end(), 8, thrust::less<int>()); // returns input.begin() + 4
thrust::lower_bound(input.begin(), input.end(), 9, thrust::less<int>()); // returns input.end()

模板参数

ForwardIterator：是 Forward Iterator ‍的模型
T：与 ForwardIterator 的 value_type 类似‍
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

first：有序序列的起始
last：有序序列的末尾
value：要查找的值
comp：比较运算符

返回值

‍使得 comp(*i, value) 为 true ‍的最远的迭代器 i

另请参阅

https://en.cppreference.com/w/cpp/algorithm/lower_bound
upper_bound
equal_range
Binary Search

thrust::upper_bound

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename LessThanComparable>
__host__ __device__ ForwardIterator
upper_bound(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  const LessThanComparable & value);

upper_bound 是二分搜索的一个版本：它试图在有序范围 [first, last) 内查找元素值。具体而言，它返回可以在不打乱顺序的情况下插入值的最后一个位置。 ‍此版本的 upper_bound 使用 operator< ‍进行比较，返回 [first, last) 内最远的迭代器 i ，使得 [first, i) 内的每一个迭代器 j ，满足 value < *j 为 false。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::device 并行化执行策略，使用 upper_bound 搜索有序范围内的值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/execution_policy.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::upper_bound(thrust::device, input.begin(), input.end(), 0); // returns input.begin() + 1
thrust::upper_bound(thrust::device, input.begin(), input.end(), 1); // returns input.begin() + 1
thrust::upper_bound(thrust::device, input.begin(), input.end(), 2); // returns input.begin() + 2
thrust::upper_bound(thrust::device, input.begin(), input.end(), 3); // returns input.begin() + 2
thrust::upper_bound(thrust::device, input.begin(), input.end(), 8); // returns input.end()
thrust::upper_bound(thrust::device, input.begin(), input.end(), 9); // returns input.end()

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator ‍的模型
LessThanComparable：是 LessThanComparable 的模型

函数参数

exec：用于并行化的执行策略
first：有序序列的起始
last：有序序列的末尾
value：要查找的值

返回值

‍使得 value < *i 为 false ‍的最远的迭代器 i

另请参阅

https://en.cppreference.com/w/cpp/algorithm/upper_bound
lower_bound
equal_range
Binary Search

thrust::upper_bound

template <class ForwardIterator,
  class LessThanComparable>
ForwardIterator
upper_bound(ForwardIterator first,
  ForwardIterator last,
  const LessThanComparable & value);

upper_bound 是二分搜索的一个版本：它试图在有序范围 [first, last) 内查找元素值。具体而言，它返回可以在不打乱顺序的情况下插入值的最后一个位置。 ‍此版本的 upper_bound 使用 operator< ‍进行比较，返回 [first, last) 内最远的迭代器 i ，使得 [first, i) 内的每一个迭代器 j ，满足 value < *j 为 false。

以下代码片段演示了如何使用 upper_bound 搜索有序范围内的值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::upper_bound(input.begin(), input.end(), 0); // returns input.begin() + 1
thrust::upper_bound(input.begin(), input.end(), 1); // returns input.begin() + 1
thrust::upper_bound(input.begin(), input.end(), 2); // returns input.begin() + 2
thrust::upper_bound(input.begin(), input.end(), 3); // returns input.begin() + 2
thrust::upper_bound(input.begin(), input.end(), 8); // returns input.end()
thrust::upper_bound(input.begin(), input.end(), 9); // returns input.end()

模板参数

ForwardIterator：是 Forward Iterator ‍的模型
LessThanComparable：是 LessThanComparable 的模型

函数参数

first：有序序列的起始
last：有序序列的末尾
value：要查找的值

返回值

‍使得 value < *i 为 false ‍的最远的迭代器 i

另请参阅

https://en.cppreference.com/w/cpp/algorithm/upper_bound
lower_bound
equal_range
Binary Search

thrust::upper_bound

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename T,
  typename StrictWeakOrdering>
__host__ __device__ ForwardIterator
upper_bound(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  const T & value,
  StrictWeakOrdering comp);

upper_bound 是二分搜索的一个版本：它试图在有序范围 [first, last) 内查找元素值。具体而言，它返回可以在不打乱顺序的情况下插入值的最后一个位置。 ‍此版本的 upper_bound 使用函数对象 comp 进行比较，返回 [first, last) 内最远的迭代器 i ，使得 [first, i) 内的每一个迭代器 j ，满足 comp(value, *j) 为 false。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::device 并行化执行策略，使用 upper_bound 搜索有序范围内的值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::upper_bound(thrust::device, input.begin(), input.end(), 0, thrust::less<int>()); // returns input.begin() + 1
thrust::upper_bound(thrust::device, input.begin(), input.end(), 1, thrust::less<int>()); // returns input.begin() + 1
thrust::upper_bound(thrust::device, input.begin(), input.end(), 2, thrust::less<int>()); // returns input.begin() + 2
thrust::upper_bound(thrust::device, input.begin(), input.end(), 3, thrust::less<int>()); // returns input.begin() + 2
thrust::upper_bound(thrust::device, input.begin(), input.end(), 8, thrust::less<int>()); // returns input.end()
thrust::upper_bound(thrust::device, input.begin(), input.end(), 9, thrust::less<int>()); // returns input.end()

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator ‍的模型
T：与 ForwardIterator 的 value_type 类似‍
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

exec：用于并行化的执行策略
first：有序序列的起始
last：有序序列的末尾
value：要查找的值
comp：比较运算符

返回值

‍使得 comp(value, *i) 为 false ‍的最远的迭代器 i

另请参阅

https://en.cppreference.com/w/cpp/algorithm/upper_bound
lower_bound
equal_range
Binary Search

thrust::upper_bound

template <class ForwardIterator,
  class T,
  class StrictWeakOrdering>
ForwardIterator
upper_bound(ForwardIterator first,
  ForwardIterator last,
  const T & value,
  StrictWeakOrdering comp);

upper_bound 是二分搜索的一个版本：它试图在有序范围 [first, last) 内查找元素值。具体而言，它返回可以在不打乱顺序的情况下插入值的最后一个位置。 ‍此版本的 upper_bound 使用函数对象 comp 进行比较，返回 [first, last) 内最远的迭代器 i ，使得 [first, i) 内的每一个迭代器 j ，满足 comp(value, *j) 为 false。

以下代码片段演示了如何使用 upper_bound 搜索有序范围内的值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/functional.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::upper_bound(input.begin(), input.end(), 0, thrust::less<int>()); // returns input.begin() + 1
thrust::upper_bound(input.begin(), input.end(), 1, thrust::less<int>()); // returns input.begin() + 1
thrust::upper_bound(input.begin(), input.end(), 2, thrust::less<int>()); // returns input.begin() + 2
thrust::upper_bound(input.begin(), input.end(), 3, thrust::less<int>()); // returns input.begin() + 2
thrust::upper_bound(input.begin(), input.end(), 8, thrust::less<int>()); // returns input.end()
thrust::upper_bound(input.begin(), input.end(), 9, thrust::less<int>()); // returns input.end()

模板参数

ForwardIterator：是 Forward Iterator ‍的模型
T：与 ForwardIterator 的 value_type 类似‍
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

first：有序序列的起始
last：有序序列的末尾
value：要查找的值
comp：比较运算符

返回值

‍使得 comp(value, *i) 为 false ‍的最远的迭代器 i

另请参阅

https://en.cppreference.com/w/cpp/algorithm/upper_bound
lower_bound
equal_range
Binary Search

thrust::binary_search

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename LessThanComparable>
__host__ __device__ bool
binary_search(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  const LessThanComparable & value);

binary_search 是二分搜索的一个版本：它试图在有序范围 [first, last) 内查找元素值。如果在 [first, last) 中存在与 value 等价的元素，则返回 true；如果不存在这样的元素，那么返回 false。具体而言，当且仅当 [first, last) 内存在使得 *i < value 和 value < *i 都为 false ‍的迭代器 i，此版本返回 true。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::device 并行化执行策略，使用 binary_search 搜索有序范围内的值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/execution_policy.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::binary_search(thrust::device, input.begin(), input.end(), 0); // returns true
thrust::binary_search(thrust::device, input.begin(), input.end(), 1); // returns false
thrust::binary_search(thrust::device, input.begin(), input.end(), 2); // returns true
thrust::binary_search(thrust::device, input.begin(), input.end(), 3); // returns false
thrust::binary_search(thrust::device, input.begin(), input.end(), 8); // returns true
thrust::binary_search(thrust::device, input.begin(), input.end(), 9); // returns false

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator ‍的模型
LessThanComparable：是 LessThanComparable 的模型

函数参数

exec：用于并行化的执行策略
first：有序序列的起始
last：有序序列的末尾
value：要查找的值

返回值

如果 [first, last) 内存在等价元素，返回 true；否则，返回 false

另请参阅

https://en.cppreference.com/w/cpp/algorithm/binary_search
lower_bound
upper_bound
equal_range

thrust::binary_search

template <class ForwardIterator,
  class LessThanComparable>
bool
binary_search(ForwardIterator first,
  ForwardIterator last,
  const LessThanComparable & value);

binary_search 是二分搜索的一个版本：它试图在有序范围 [first, last) 内查找元素值。如果在 [first, last) 中存在与 value 等价的元素，则返回 true；如果不存在这样的元素，那么返回 false。具体而言，当且仅当 [first, last) 内存在使得 *i < value 和 value < *i 都为 false ‍的迭代器 i，此版本返回 true。

以下代码片段演示了如何使用 binary_search 搜索有序范围内的值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::binary_search(input.begin(), input.end(), 0); // returns true
thrust::binary_search(input.begin(), input.end(), 1); // returns false
thrust::binary_search(input.begin(), input.end(), 2); // returns true
thrust::binary_search(input.begin(), input.end(), 3); // returns false
thrust::binary_search(input.begin(), input.end(), 8); // returns true
thrust::binary_search(input.begin(), input.end(), 9); // returns false

模板参数

ForwardIterator：是 Forward Iterator ‍的模型
LessThanComparable：是 LessThanComparable 的模型

函数参数

first：有序序列的起始
last：有序序列的末尾
value：要查找的值

返回值

如果 [first, last) 内存在等价元素，返回 true；否则，返回 false

另请参阅

https://en.cppreference.com/w/cpp/algorithm/binary_search
lower_bound
upper_bound
equal_range

thrust::binary_search

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename T,
  typename StrictWeakOrdering>
__host__ __device__ bool
binary_search(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  const T & value,
  StrictWeakOrdering comp);

binary_search 是二分搜索的一个版本：它试图在有序范围 [first, last) 内查找元素值。如果在 [first, last) 中存在与 value 等价的元素，则返回 true；如果不存在这样的元素，那么返回 false。具体而言，当且仅当 [first, last) 内存在使得 comp(*i, value) 和 comp(value, *i) 都为 false ‍的迭代器 i，此版本返回 true。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::device 并行化执行策略，使用 binary_search 搜索有序范围内的值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::binary_search(thrust::device, input.begin(), input.end(), 0, thrust::less<int>()); // returns true
thrust::binary_search(thrust::device, input.begin(), input.end(), 1, thrust::less<int>()); // returns false
thrust::binary_search(thrust::device, input.begin(), input.end(), 2, thrust::less<int>()); // returns true
thrust::binary_search(thrust::device, input.begin(), input.end(), 3, thrust::less<int>()); // returns false
thrust::binary_search(thrust::device, input.begin(), input.end(), 8, thrust::less<int>()); // returns true
thrust::binary_search(thrust::device, input.begin(), input.end(), 9, thrust::less<int>()); // returns false

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator ‍的模型
T：与 ForwardIterator 的 value_type 类似‍
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

exec：用于并行化的执行策略
first：有序序列的起始
last：有序序列的末尾
value：要查找的值
comp：比较运算符

返回值

如果 [first, last) 内存在等价元素，返回 true；否则，返回 false

另请参阅

https://en.cppreference.com/w/cpp/algorithm/binary_search
lower_bound
upper_bound
equal_range

thrust::binary_search

template <class ForwardIterator,
  class T,
  class StrictWeakOrdering>
bool
binary_search(ForwardIterator first,
  ForwardIterator last,
  const T & value,
  StrictWeakOrdering comp);

binary_search 是二分搜索的一个版本：它试图在有序范围 [first, last) 内查找元素值。如果在 [first, last) 中存在与 value 等价的元素，则返回 true；如果不存在这样的元素，那么返回 false。具体而言，当且仅当 [first, last) 内存在使得 comp(*i, value) 和 comp(value, *i) 都为 false ‍的迭代器 i，此版本返回 true。

以下代码片段演示了如何使用 binary_search 搜索有序范围内的值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/functional.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::binary_search(input.begin(), input.end(), 0, thrust::less<int>()); // returns true
thrust::binary_search(input.begin(), input.end(), 1, thrust::less<int>()); // returns false
thrust::binary_search(input.begin(), input.end(), 2, thrust::less<int>()); // returns true
thrust::binary_search(input.begin(), input.end(), 3, thrust::less<int>()); // returns false
thrust::binary_search(input.begin(), input.end(), 8, thrust::less<int>()); // returns true
thrust::binary_search(input.begin(), input.end(), 9, thrust::less<int>()); // returns false

模板参数

ForwardIterator：是 Forward Iterator ‍的模型
T：与 ForwardIterator 的 value_type 类似‍
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

first：有序序列的起始
last：有序序列的末尾
value：要查找的值
comp：比较运算符

返回值

如果 [first, last) 内存在等价元素，返回 true；否则，返回 false

另请参阅

https://en.cppreference.com/w/cpp/algorithm/binary_search
lower_bound
upper_bound
equal_range

thrust::equal_range

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename LessThanComparable>
__host__ __device__ thrust::pair< ForwardIterator, ForwardIterator >
equal_range(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  const LessThanComparable & value);

equal_range 是二分搜索的一个版本：它试图在有序范围 [first, last) 内查找元素值。 equal_range 的返回值本质上是 lower_bound 和 upper_bound 返回值的组合：它返回一对迭代器 i 和 j ，其中 i 是在不打乱顺序的情况下插入值的第一个位置， j 是在不打乱顺序的情况下插入值的最后一个位置。由此可见，范围 [i, j) 内的每个元素都等价于 value ，并且 [i, j) 是 [first, last) ‍内具有此属性的最大的子范围。

‍此版本的 equal_range 返回一对迭代器 [i, j)。其中 i 是 [first, last) 内，使得 [first, i) 内的每一个迭代器 k 满足 *k < value，最远的迭代器。 j 是 [first, last) 内，使得 [first, j) 内的每一个迭代器 k 满足 value < *k 为 false ，最远的迭代器。对于 [i, j) 中的每个迭代器 k ， value < *k 和 *k < value 都不为 true。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::device 并行化执行策略，使用 equal_range 搜索有序范围内的值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/execution_policy.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::equal_range(thrust::device, input.begin(), input.end(), 0); // returns [input.begin(), input.begin() + 1)
thrust::equal_range(thrust::device, input.begin(), input.end(), 1); // returns [input.begin() + 1, input.begin() + 1)
thrust::equal_range(thrust::device, input.begin(), input.end(), 2); // returns [input.begin() + 1, input.begin() + 2)
thrust::equal_range(thrust::device, input.begin(), input.end(), 3); // returns [input.begin() + 2, input.begin() + 2)
thrust::equal_range(thrust::device, input.begin(), input.end(), 8); // returns [input.begin() + 4, input.end)
thrust::equal_range(thrust::device, input.begin(), input.end(), 9); // returns [input.end(), input.end)

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator ‍的模型
LessThanComparable：是 LessThanComparable 的模型

函数参数

exec：用于并行化的执行策略
first：有序序列的起始
last：有序序列的末尾
value：要查找的值

返回值

定义等价元素范围的一对迭代器 [i, j)

另请参阅

https://en.cppreference.com/w/cpp/algorithm/equal_range
lower_bound
upper_bound
Binary Search

thrust::equal_range

template <class ForwardIterator,
  class LessThanComparable>
thrust::pair< ForwardIterator, ForwardIterator >
equal_range(ForwardIterator first,
  ForwardIterator last,
  const LessThanComparable & value);

equal_range 是二分搜索的一个版本：它试图在有序范围 [first, last) 内查找元素值。 equal_range 的返回值本质上是 lower_bound 和 upper_bound 返回值的组合：它返回一对迭代器 i 和 j ，其中 i 是在不打乱顺序的情况下插入值的第一个位置， j 是在不打乱顺序的情况下插入值的最后一个位置。由此可见，范围 [i, j) 内的每个元素都等价于 value ，并且 [i, j) 是 [first, last) ‍内具有此属性的最大的子范围。

‍此版本的 equal_range 返回一对迭代器 [i, j)。其中 i 是 [first, last) 内，使得 [first, i) 内的每一个迭代器 k 满足 *k < value，最远的迭代器。 j 是 [first, last) 内，使得 [first, j) 内的每一个迭代器 k 满足 value < *k 为 false ，最远的迭代器。对于 [i, j) 中的每个迭代器 k ， value < *k 和 *k < value 都不为 true。

以下代码片段演示了如何使用 equal_range 搜索有序范围内的值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::equal_range(input.begin(), input.end(), 0); // returns [input.begin(), input.begin() + 1)
thrust::equal_range(input.begin(), input.end(), 1); // returns [input.begin() + 1, input.begin() + 1)
thrust::equal_range(input.begin(), input.end(), 2); // returns [input.begin() + 1, input.begin() + 2)
thrust::equal_range(input.begin(), input.end(), 3); // returns [input.begin() + 2, input.begin() + 2)
thrust::equal_range(input.begin(), input.end(), 8); // returns [input.begin() + 4, input.end)
thrust::equal_range(input.begin(), input.end(), 9); // returns [input.end(), input.end)

模板参数

ForwardIterator：是 Forward Iterator ‍的模型
LessThanComparable：是 LessThanComparable 的模型

函数参数

first：有序序列的起始
last：有序序列的末尾
value：要查找的值

返回值

定义等价元素范围的一对迭代器 [i, j)

另请参阅

https://en.cppreference.com/w/cpp/algorithm/equal_range
lower_bound
upper_bound
Binary Search

thrust::equal_range

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename T,
  typename StrictWeakOrdering>
__host__ __device__ thrust::pair< ForwardIterator, ForwardIterator >
equal_range(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  const T & value,
  StrictWeakOrdering comp);

equal_range 是二分搜索的一个版本：它试图在有序范围 [first, last) 内查找元素值。 equal_range 的返回值本质上是 lower_bound 和 upper_bound 返回值的组合：它返回一对迭代器 i 和 j ，其中 i 是在不打乱顺序的情况下插入值的第一个位置， j 是在不打乱顺序的情况下插入值的最后一个位置。由此可见，范围 [i, j) 内的每个元素都等价于 value ，并且 [i, j) 是 [first, last) ‍内具有此属性的最大的子范围。

‍此版本的 equal_range 返回一对迭代器 [i, j)。 i 是 [first, last) 内，使得 [first, i) 内的每一个迭代器 k 满足 comp(*k, value) 为 true ，最远的迭代器。 j 是 [first, last) 内，使得 [first, last) 内的每一个迭代器 k 满足 comp(value, *k) 为 false ，最远的迭代器。对于 [i, j) 中的每个迭代器 k ， comp(value, *k) 和 comp(*k, value) 都不为 true。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::device 并行化执行策略，使用 equal_range 搜索有序范围内的值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::equal_range(thrust::device, input.begin(), input.end(), 0, thrust::less<int>()); // returns [input.begin(), input.begin() + 1)
thrust::equal_range(thrust::device, input.begin(), input.end(), 1, thrust::less<int>()); // returns [input.begin() + 1, input.begin() + 1)
thrust::equal_range(thrust::device, input.begin(), input.end(), 2, thrust::less<int>()); // returns [input.begin() + 1, input.begin() + 2)
thrust::equal_range(thrust::device, input.begin(), input.end(), 3, thrust::less<int>()); // returns [input.begin() + 2, input.begin() + 2)
thrust::equal_range(thrust::device, input.begin(), input.end(), 8, thrust::less<int>()); // returns [input.begin() + 4, input.end)
thrust::equal_range(thrust::device, input.begin(), input.end(), 9, thrust::less<int>()); // returns [input.end(), input.end)

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator ‍的模型
T：与 ForwardIterator 的 value_type 类似‍
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

exec：用于并行化的执行策略
first：有序序列的起始
last：有序序列的末尾
value：要查找的值
comp：比较运算符

返回值

定义等价元素范围的一对迭代器 [i, j)

另请参阅

https://en.cppreference.com/w/cpp/algorithm/equal_range
lower_bound
upper_bound
Binary Search

thrust::equal_range

template <class ForwardIterator,
  class T,
  class StrictWeakOrdering>
thrust::pair< ForwardIterator, ForwardIterator >
equal_range(ForwardIterator first,
  ForwardIterator last,
  const T & value,
  StrictWeakOrdering comp);

equal_range 是二分搜索的一个版本：它试图在有序范围 [first, last) 内查找元素值。 equal_range 的返回值本质上是 lower_bound 和 upper_bound 返回值的组合：它返回一对迭代器 i 和 j ，其中 i 是在不打乱顺序的情况下插入值的第一个位置， j 是在不打乱顺序的情况下插入值的最后一个位置。由此可见，范围 [i, j) 内的每个元素都等价于 value ，并且 [i, j) 是 [first, last) ‍内具有此属性的最大的子范围。

‍此版本的 equal_range 返回一对迭代器 [i, j)。 i 是 [first, last) 内，使得 [first, i) 内的每一个迭代器 k 满足 comp(*k, value) 为 true ，最远的迭代器。 j 是 [first, last) 内，使得 [first, last) 内的每一个迭代器 k 满足 comp(value, *k) 为 false，最远的迭代器。对于 [i, j) 中的每个迭代器 k ， comp(value, *k) 和 comp(*k, value) 都不为 true。

以下代码片段演示了如何使用 equal_range 搜索有序范围内的值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/functional.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::equal_range(input.begin(), input.end(), 0, thrust::less<int>()); // returns [input.begin(), input.begin() + 1)
thrust::equal_range(input.begin(), input.end(), 1, thrust::less<int>()); // returns [input.begin() + 1, input.begin() + 1)
thrust::equal_range(input.begin(), input.end(), 2, thrust::less<int>()); // returns [input.begin() + 1, input.begin() + 2)
thrust::equal_range(input.begin(), input.end(), 3, thrust::less<int>()); // returns [input.begin() + 2, input.begin() + 2)
thrust::equal_range(input.begin(), input.end(), 8, thrust::less<int>()); // returns [input.begin() + 4, input.end)
thrust::equal_range(input.begin(), input.end(), 9, thrust::less<int>()); // returns [input.end(), input.end)

模板参数

ForwardIterator：是 Forward Iterator ‍的模型
T：与 ForwardIterator 的 value_type 类似‍
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

first：有序序列的起始
last：有序序列的末尾
value：要查找的值
comp：比较运算符

返回值

定义等价元素范围的一对迭代器 [i, j)

另请参阅

https://en.cppreference.com/w/cpp/algorithm/equal_range
lower_bound
upper_bound
Binary Search

‌‍向量化搜索（Vectorized Search）

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename InputIterator,
  typename OutputIterator>
__host__ __device__ OutputIterator
thrust::lower_bound(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result);

template <class ForwardIterator,
  class InputIterator,
  class OutputIterator>
OutputIterator
thrust::lower_bound(ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename InputIterator,
  typename OutputIterator,
  typename StrictWeakOrdering>
__host__ __device__ OutputIterator
thrust::lower_bound(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result,
  StrictWeakOrdering comp);

template <class ForwardIterator,
  class InputIterator,
  class OutputIterator,
  class StrictWeakOrdering>
OutputIterator
thrust::lower_bound(ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result,
  StrictWeakOrdering comp);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename InputIterator,
  typename OutputIterator>
__host__ __device__ OutputIterator
thrust::upper_bound(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result);

template <class ForwardIterator,
  class InputIterator,
  class OutputIterator>
OutputIterator
thrust::upper_bound(ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename InputIterator,
  typename OutputIterator,
  typename StrictWeakOrdering>
__host__ __device__ OutputIterator
thrust::upper_bound(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result,
  StrictWeakOrdering comp);

template <class ForwardIterator,
  class InputIterator,
  class OutputIterator,
  class StrictWeakOrdering>
OutputIterator
thrust::upper_bound(ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result,
  StrictWeakOrdering comp);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename InputIterator,
  typename OutputIterator>
__host__ __device__ OutputIterator
thrust::binary_search(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result);

template <class ForwardIterator,
  class InputIterator,
  class OutputIterator>
OutputIterator
thrust::binary_search(ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename InputIterator,
  typename OutputIterator,
  typename StrictWeakOrdering>
 __host__ __device__ OutputIterator
 thrust::binary_search(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
   ForwardIterator first,
   ForwardIterator last,
   InputIterator values_first,
   InputIterator values_last,
   OutputIterator result,
   StrictWeakOrdering comp);

 template <class ForwardIterator,
   class InputIterator,
   class OutputIterator,
   class StrictWeakOrdering>
 OutputIterator
 thrust::binary_search(ForwardIterator first,
   ForwardIterator last,
   InputIterator values_first,
   InputIterator values_last,
   OutputIterator result,
   StrictWeakOrdering comp);

thrust::lower_bound

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename InputIterator,
  typename OutputIterator>
__host__ __device__ OutputIterator
lower_bound(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result);

lower_bound 是二分搜索的一个向量化版本：对于 [values_first, values_last) 范围内的每个迭代器 v，它试图在有序范围 [first, last) 内查找值 *v。具体而言，它返回在不打乱顺序的情况下插入值的第一个位置的索引。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::device 并行化执行策略，使用 lower_bound 在有序范围内搜索多个值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/execution_policy.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::device_vector<int> values(6);
values[0] = 0;
values[1] = 1;
values[2] = 2;
values[3] = 3;
values[4] = 8;
values[5] = 9;

thrust::device_vector<unsigned int> output(6);

thrust::lower_bound(thrust::device,
input.begin(), input.end(),
values.begin(), values.end(),
output.begin());

// output is now [0, 1, 1, 2, 4, 5]

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator ‍的模型
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type ‍为 LessThanComparable
OutputIterator：是 Output Iterator 的模型， ForwardIterator 的 difference_type 可转换为 OutputIterator 的 value_type

函数参数

exec：用于并行化的执行策略
first：有序序列的起始
last：有序序列的末尾
values_first：搜索值序列的起始
values_last：搜索值序列的末尾
result：输出序列的起始

前提条件

范围 [first,last) ‍不应与范围 [result, result + (last - first)) 重叠

另请参阅

https://en.cppreference.com/w/cpp/algorithm/lower_bound
upper_bound
equal_range
Binary Search

thrust::lower_bound

template <class ForwardIterator,
  class InputIterator,
  class OutputIterator>
OutputIterator
lower_bound(ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result);

lower_bound 是二分搜索的一个向量化版本：对于 [values_first, values_last) ‍范围内的每个迭代器 v，它试图在有序范围 [first, last) 内查找值 *v。具体而言，它返回在不打乱顺序的情况下插入值的第一个位置的索引。

以下代码片段演示了如何使用 lower_bound 在有序范围内搜索多个值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::device_vector<int> values(6);
values[0] = 0;
values[1] = 1;
values[2] = 2;
values[3] = 3;
values[4] = 8;
values[5] = 9;

thrust::device_vector<unsigned int> output(6);

thrust::lower_bound(input.begin(), input.end(),
values.begin(), values.end(),
output.begin());

// output is now [0, 1, 1, 2, 4, 5]

模板参数

ForwardIterator：是 Forward Iterator ‍的模型
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type ‍为 LessThanComparable
OutputIterator：是 Output Iterator 的模型， ForwardIterator 的 difference_type 可转换为 OutputIterator 的 value_type

函数参数

first：有序序列的起始
last：有序序列的末尾
values_first：搜索值序列的起始
values_last：搜索值序列的末尾
result：输出序列的起始

前提条件

范围 [first,last) ‍不应与范围 [result, result + (last - first)) 重叠

另请参阅

https://en.cppreference.com/w/cpp/algorithm/lower_bound
upper_bound
equal_range
Binary Search

thrust::lower_bound

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename InputIterator,
 typename OutputIterator,
  typename StrictWeakOrdering>
__host__ __device__ OutputIterator
lower_bound(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result,
  StrictWeakOrdering comp);

lower_bound 是二分搜索的一个向量化版本：对于 [values_first, values_last) ‍范围内的每个迭代器 v，它试图在有序范围 [first, last) 内查找值 *v。具体而言，它返回在不打乱顺序的情况下插入值的第一个位置的索引。此版本的 lower_bound 使用函数对象 comp ‍进行比较。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何使用 lower_bound 在有序范围内搜索多个值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::device_vector<int> values(6);
values[0] = 0;
values[1] = 1;
values[2] = 2;
values[3] = 3;
values[4] = 8;
values[5] = 9;

thrust::device_vector<unsigned int> output(6);

thrust::lower_bound(input.begin(), input.end(),
values.begin(), values.end(),
output.begin(),
thrust::less<int>());

// output is now [0, 1, 1, 2, 4, 5]

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator ‍的模型
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 类似 ForwardIterator 的 value_type
OutputIterator：是 Output Iterator 的模型， ForwardIterator 的 difference_type 可转换为 OutputIterator 的 value_type
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

exec：用于并行化的执行策略
first：有序序列的起始
last：有序序列的末尾
values_first：搜索值序列的起始
values_last：搜索值序列的末尾
result：输出序列的起始
comp：比较运算符

前提条件

范围 [first,last) ‍不应与范围 [result, result + (last - first)) 重叠

另请参阅

https://en.cppreference.com/w/cpp/algorithm/lower_bound
upper_bound
equal_range
Binary Search

thrust::lower_bound

template <class ForwardIterator,
  class InputIterator,
  class OutputIterator,
  class StrictWeakOrdering>
OutputIterator
lower_bound(ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result,
  StrictWeakOrdering comp);

lower_bound 是二分搜索的一个向量化版本：对于 [values_first, values_last) ‍范围内的每个迭代器 v，它试图在有序范围 [first, last) 内查找值 *v。具体而言，它返回在不打乱顺序的情况下插入值的第一个位置的索引。此版本的 lower_bound 使用函数对象 comp ‍进行比较。

以下代码片段演示了如何使用 lower_bound 在有序范围内搜索多个值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/functional.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::device_vector<int> values(6);
values[0] = 0;
values[1] = 1;
values[2] = 2;
values[3] = 3;
values[4] = 8;
values[5] = 9;

thrust::device_vector<unsigned int> output(6);

thrust::lower_bound(input.begin(), input.end(),
values.begin(), values.end(),
output.begin(),
thrust::less<int>());

// output is now [0, 1, 1, 2, 4, 5]

模板参数

ForwardIterator：是 Forward Iterator ‍的模型
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 类似 ForwardIterator 的 value_type
OutputIterator：是 Output Iterator 的模型， ForwardIterator 的 difference_type 可转换为 OutputIterator 的 value_type
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

first：有序序列的起始
last：有序序列的末尾
values_first：搜索值序列的起始
values_last：搜索值序列的末尾
result：输出序列的起始
comp：比较运算符

前提条件

范围 [first,last) ‍不应与范围 [result, result + (last - first)) 重叠

另请参阅

https://en.cppreference.com/w/cpp/algorithm/lower_bound
upper_bound
equal_range
Binary Search

thrust::upper_bound

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename InputIterator,
  typename OutputIterator>
__host__ __device__ OutputIterator
upper_bound(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result);

upper_bound 是二分搜索的一个向量化版本：对于 [values_first, values_last) ‍范围内的每个迭代器 v，它试图在有序范围 [first, last) 内查找值 *v。具体而言，它返回在不打乱顺序的情况下插入值的最后一个位置的索引。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::device 并行化执行策略，使用 upper_bound 在有序范围内搜索多个值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/execution_policy.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::device_vector<int> values(6);
values[0] = 0;
values[1] = 1;
values[2] = 2;
values[3] = 3;
values[4] = 8;
values[5] = 9;

thrust::device_vector<unsigned int> output(6);

thrust::upper_bound(thrust::device,
input.begin(), input.end(),
values.begin(), values.end(),
output.begin());

// output is now [1, 1, 2, 2, 5, 5]

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator ‍的模型
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type ‍为 LessThanComparable
OutputIterator：是 Output Iterator 的模型， ForwardIterator 的 difference_type 可转换为 OutputIterator 的 value_type

函数参数

exec：用于并行化的执行策略
first：有序序列的起始
last：有序序列的末尾
values_first：搜索值序列的起始
values_last：搜索值序列的末尾
result：输出序列的起始

前提条件

范围 [first,last) ‍不应与范围 [result, result + (last - first)) 重叠

另请参阅

https://en.cppreference.com/w/cpp/algorithm/upper_bound
upper_bound
equal_range
Binary Search

thrust::upper_bound

template <class ForwardIterator,
  class InputIterator,
  class OutputIterator>
OutputIterator
upper_bound(ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result);

upper_bound 是二分搜索的一个向量化版本：对于 [values_first, values_last) ‍范围内的每个迭代器 v，它试图在有序范围 [first, last) 内查找值 *v。具体而言，它返回在不打乱顺序的情况下插入值的最后一个位置的索引。

以下代码片段演示了如何使用 upper_bound 在有序范围内搜索多个值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::device_vector<int> values(6);
values[0] = 0;
values[1] = 1;
values[2] = 2;
values[3] = 3;
values[4] = 8;
values[5] = 9;

thrust::device_vector<unsigned int> output(6);

thrust::upper_bound(input.begin(), input.end(),
values.begin(), values.end(),
output.begin());

// output is now [1, 1, 2, 2, 5, 5]

模板参数

ForwardIterator：是 Forward Iterator ‍的模型
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type ‍为 LessThanComparable
OutputIterator：是 Output Iterator 的模型， ForwardIterator 的 difference_type 可转换为 OutputIterator 的 value_type

函数参数

first：有序序列的起始
last：有序序列的末尾
values_first：搜索值序列的起始
values_last：搜索值序列的末尾
result：输出序列的起始

前提条件

范围 [first,last) ‍不应与范围 [result, result + (last - first)) 重叠

另请参阅

https://en.cppreference.com/w/cpp/algorithm/upper_bound
upper_bound
equal_range
Binary Search

thrust::upper_bound

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename InputIterator,
  typename OutputIterator,
  typename StrictWeakOrdering>
__host__ __device__ OutputIterator
upper_bound(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result,
  StrictWeakOrdering comp);

upper_bound 是二分搜索的一个向量化版本：对于 [values_first, values_last) ‍范围内的每个迭代器 v，它试图在有序范围 [first, last) 内查找值 *v。具体而言，它返回在不打乱顺序的情况下插入值的第一个位置的索引。此版本的 upper_bound 使用函数对象 comp ‍进行比较。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::device 并行化执行策略，使用 upper_bound 在有序范围内搜索多个值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::device_vector<int> values(6);
values[0] = 0;
values[1] = 1;
values[2] = 2;
values[3] = 3;
values[4] = 8;
values[5] = 9;

thrust::device_vector<unsigned int> output(6);

thrust::upper_bound(thrust::device,
input.begin(), input.end(),
values.begin(), values.end(),
output.begin(),
thrust::less<int>());

// output is now [1, 1, 2, 2, 5, 5]

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator ‍的模型
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 类似 ForwardIterator 的 value_type
OutputIterator：是 Output Iterator 的模型， ForwardIterator 的 difference_type 可转换为 OutputIterator 的 value_type
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

exec：用于并行化的执行策略
first：有序序列的起始
last：有序序列的末尾
values_first：搜索值序列的起始
values_last：搜索值序列的末尾
result：输出序列的起始
comp：比较运算符

前提条件

范围 [first,last) ‍不应与范围 [result, result + (last - first)) 重叠

另请参阅

https://en.cppreference.com/w/cpp/algorithm/upper_bound
lower_bound
equal_range
Binary Search

thrust::upper_bound

template <class ForwardIterator,
  class InputIterator,
  class OutputIterator,
  class StrictWeakOrdering>
OutputIterator
upper_bound(ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result,
  StrictWeakOrdering comp);

upper_bound 是二分搜索的一个向量化版本：对于 [values_first, values_last) ‍范围内的每个迭代器 v，它试图在有序范围 [first, last) 内查找值 *v。具体而言，它返回在不打乱顺序的情况下插入值的第一个位置的索引。

此版本的 upper_bound 使用函数对象 comp ‍进行比较。

以下代码片段演示了如何使用 upper_bound 在有序范围内搜索多个值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/functional.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::device_vector<int> values(6);
values[0] = 0;
values[1] = 1;
values[2] = 2;
values[3] = 3;
values[4] = 8;
values[5] = 9;

thrust::device_vector<unsigned int> output(6);

thrust::upper_bound(input.begin(), input.end(),
values.begin(), values.end(),
output.begin(),
thrust::less<int>());

// output is now [1, 1, 2, 2, 5, 5]

模板参数

ForwardIterator：是 Forward Iterator ‍的模型
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 类似 ForwardIterator 的 value_type
OutputIterator：是 Output Iterator 的模型， ForwardIterator 的 difference_type 可转换为 OutputIterator 的 value_type
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

first：有序序列的起始
last：有序序列的末尾
values_first：搜索值序列的起始
values_last：搜索值序列的末尾
result：输出序列的起始
comp：比较运算符

前提条件

范围 [first,last) ‍不应与范围 [result, result + (last - first)) 重叠

另请参阅

https://en.cppreference.com/w/cpp/algorithm/upper_bound
lower_bound
equal_range
Binary Search

thrust::binary_search

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename InputIterator,
  typename OutputIterator>
__host__ __device__ OutputIterator
binary_search(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result);

binary_search 是二分搜索的一个向量化版本：对于 [values_first, values_last) ‍范围内的每个迭代器 v，它试图在有序范围 [first, last) 内查找值 *v。如果在 [first, last) 中存在与 value 等价的元素，则返回 true；如果不存在这样的元素，那么返回 false。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::device 并行化执行策略，使用 binary_search 在有序范围内搜索多个值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/execution_policy.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::device_vector<int> values(6);
values[0] = 0;
values[1] = 1;
values[2] = 2;
values[3] = 3;
values[4] = 8;
values[5] = 9;

thrust::device_vector<bool> output(6);

thrust::binary_search(thrust::device,
input.begin(), input.end(),
values.begin(), values.end(),
output.begin());

// output is now [true, false, true, false, true, false]

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator ‍的模型
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type ‍为 LessThanComparable
OutputIterator：是 Output Iterator 的模型， bool 可转换为 OutputIterator 的 value_type

函数参数

exec：用于并行化的执行策略
first：有序序列的起始
last：有序序列的末尾
values_first：搜索值序列的起始
values_last：搜索值序列的末尾
result：输出序列的起始

前提条件

范围 [first,last) ‍不应与范围 [result, result + (last - first)) 重叠

另请参阅

https://en.cppreference.com/w/cpp/algorithm/binary_search
lower_bound
upper_bound
equal_range

thrust::binary_search

template <class ForwardIterator,
  class InputIterator,
  class OutputIterator>
OutputIterator
binary_search(ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result);

binary_search 是二分搜索的一个向量化版本：对于 [values_first, values_last) ‍范围内的每个迭代器 v，它试图在有序范围 [first, last) 内查找值 *v。如果在 [first, last) 中存在与 value 等价的元素，则返回 true；如果不存在这样的元素，那么返回 false。

以下代码片段演示了如何使用 binary_search 在有序范围内搜索多个值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::device_vector<int> values(6);
values[0] = 0;
values[1] = 1;
values[2] = 2;
values[3] = 3;
values[4] = 8;
values[5] = 9;

thrust::device_vector<bool> output(6);

thrust::binary_search(input.begin(), input.end(),
values.begin(), values.end(),
output.begin());

// output is now [true, false, true, false, true, false]

模板参数

ForwardIterator：是 Forward Iterator ‍的模型
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type ‍为 LessThanComparable
OutputIterator：是 Output Iterator 的模型， bool 可转换为 OutputIterator 的 value_type

函数参数

first：有序序列的起始
last：有序序列的末尾
values_first：搜索值序列的起始
values_last：搜索值序列的末尾
result：输出序列的起始

前提条件

范围 [first,last) ‍不应与范围 [result, result + (last - first)) 重叠

另请参阅

https://en.cppreference.com/w/cpp/algorithm/binary_search
lower_bound
upper_bound
equal_range

thrust::binary_search

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename InputIterator,
  typename OutputIterator,
  typename StrictWeakOrdering>
__host__ __device__ OutputIterator binary_search(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result,
  StrictWeakOrdering comp);

binary_search 是二分搜索的一个向量化版本：对于 [values_first, values_last) ‍范围内的每个迭代器 v，它试图在有序范围 [first, last) 内查找值 *v。如果在 [first, last) 中存在与 value 等价的元素，则返回 true；如果不存在这样的元素，那么返回 false。此版本的 binary_search 使用函数对象 comp ‍进行比较。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::device 并行化执行策略，使用 binary_search 在有序范围内搜索多个值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::device_vector<int> values(6);
values[0] = 0;
values[1] = 1;
values[2] = 2;
values[3] = 3;
values[4] = 8;
values[5] = 9;

thrust::device_vector<bool> output(6);

thrust::binary_search(thrust::device,
input.begin(), input.end(),
values.begin(), values.end(),
output.begin(),
thrust::less<T>());

// output is now [true, false, true, false, true, false]

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator ‍的模型
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type ‍为 LessThanComparable
OutputIterator：是 Output Iterator 的模型， bool 可转换为 OutputIterator 的 value_type
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

exec：用于并行化的执行策略
first：有序序列的起始
last：有序序列的末尾
values_first：搜索值序列的起始
values_last：搜索值序列的末尾
result：输出序列的起始
comp：比较运算符

前提条件

范围 [first,last) ‍不应与范围 [result, result + (last - first)) 重叠

另请参阅

https://en.cppreference.com/w/cpp/algorithm/binary_search
lower_bound
upper_bound
equal_range

thrust::binary_search

template <class ForwardIterator,
  class InputIterator,
  class OutputIterator,
  class StrictWeakOrdering>
OutputIterator
binary_search(ForwardIterator first,
  ForwardIterator last,
  InputIterator values_first,
  InputIterator values_last,
  OutputIterator result,
  StrictWeakOrdering comp);

binary_search 是二分搜索的一个向量化版本：对于 [values_first, values_last) ‍范围内的每个迭代器 v，它试图在有序范围 [first, last) 内查找值 *v。如果在 [first, last) 中存在与 value 等价的元素，则返回 true；如果不存在这样的元素，那么返回 false。此版本的 binary_search 使用函数对象 comp ‍进行比较。

以下代码片段演示了如何使用 binary_search 在有序范围内搜索多个值：

#include <thrust/binary_search.h>
#include <thrust/device_vector.h>
#include <thrust/functional.h>
...
thrust::device_vector<int> input(5);

input[0] = 0;
input[1] = 2;
input[2] = 5;
input[3] = 7;
input[4] = 8;

thrust::device_vector<int> values(6);
values[0] = 0;
values[1] = 1;
values[2] = 2;
values[3] = 3;
values[4] = 8;
values[5] = 9;

thrust::device_vector<bool> output(6);

thrust::binary_search(input.begin(), input.end(),
values.begin(), values.end(),
output.begin(),
thrust::less<T>());

// output is now [true, false, true, false, true, false]

模板参数

ForwardIterator：是 Forward Iterator ‍的模型
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type ‍为 LessThanComparable
OutputIterator：是 Output Iterator 的模型， bool 可转换为 OutputIterator 的 value_type
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

first：有序序列的起始
last：有序序列的末尾
values_first：搜索值序列的起始
values_last：搜索值序列的末尾
result：输出序列的起始
comp：比较运算符

前提条件

范围 [first,last) ‍不应与范围 [result, result + (last - first)) 重叠

另请参阅

https://en.cppreference.com/w/cpp/algorithm/binary_search
lower_bound
upper_bound
equal_range

2.1.7. ‌‍集合运算（Set Operation）

函数

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator>
__host__ __device__ OutputIterator
thrust::set_difference(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result);

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator>
OutputIterator
thrust::set_difference(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result);

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename StrictWeakCompare>
__host__ __device__ OutputIterator
thrust::set_difference(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result,
  StrictWeakCompare comp);

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename StrictWeakCompare>
OutputIterator
thrust::set_difference(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result,
  StrictWeakCompare comp);

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator>
__host__ __device__ OutputIterator
thrust::set_intersection(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result);

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator>
OutputIterator
thrust::set_intersection(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result);

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename StrictWeakCompare>
__host__ __device__ OutputIterator
thrust::set_intersection(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result,
  StrictWeakCompare comp);

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename StrictWeakCompare>
OutputIterator
thrust::set_intersection(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result,
  StrictWeakCompare comp);

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator>
__host__ __device__ OutputIterator
thrust::set_symmetric_difference(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result);

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator>
OutputIterator
thrust::set_symmetric_difference(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result);

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename StrictWeakCompare>
__host__ __device__ OutputIterator
thrust::set_symmetric_difference(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result,
  StrictWeakCompare comp);

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename StrictWeakCompare>
OutputIterator
thrust::set_symmetric_difference(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result,
  StrictWeakCompare comp);

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator>
__host__ __device__ OutputIterator
thrust::set_union(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result);

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator>
OutputIterator
thrust::set_union(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result);

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename StrictWeakCompare>
__host__ __device__ OutputIterator
thrust::set_union(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result,
  StrictWeakCompare comp);

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename StrictWeakCompare>
OutputIterator
thrust::set_union(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result,
  StrictWeakCompare comp);

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename InputIterator4,
  typename OutputIterator1,
  typename OutputIterator2>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
thrust::set_difference_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);

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

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename InputIterator4,
  typename OutputIterator1,
  typename OutputIterator2,
  typename StrictWeakCompare>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
thrust::set_difference_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,
  StrictWeakCompare comp);

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

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename OutputIterator1,
  typename OutputIterator2>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
thrust::set_intersection_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,
  OutputIterator1 keys_result,
  OutputIterator2 values_result);

template <typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename OutputIterator1,
  typename OutputIterator2>
thrust::pair< OutputIterator1, OutputIterator2 >
thrust::set_intersection_by_key(InputIterator1 keys_first1,
  InputIterator1 keys_last1,
  InputIterator2 keys_first2,
  InputIterator2 keys_last2,
  InputIterator3 values_first1,
  OutputIterator1 keys_result,
  OutputIterator2 values_result);

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename OutputIterator1,
  typename OutputIterator2,
  typename StrictWeakCompare>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
thrust::set_intersection_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,
  OutputIterator1 keys_result,
  OutputIterator2 values_result,
  StrictWeakCompare comp);

template <typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename OutputIterator1,
  typename OutputIterator2,
  typename StrictWeakCompare>
thrust::pair< OutputIterator1, OutputIterator2 >
thrust::set_intersection_by_key(InputIterator1 keys_first1,
  InputIterator1 keys_last1,
  InputIterator2 keys_first2,
  InputIterator2 keys_last2,
  InputIterator3 values_first1,
  OutputIterator1 keys_result,
  OutputIterator2 values_result,
  StrictWeakCompare comp);

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename InputIterator4,
  typename OutputIterator1,
  typename OutputIterator2>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
thrust::set_symmetric_difference_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);

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

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename InputIterator4,
  typename OutputIterator1,
  typename OutputIterator2,
  typename StrictWeakCompare>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
thrust::set_symmetric_difference_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,
  StrictWeakCompare comp);

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

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename InputIterator4,
  typename OutputIterator1,
  typename OutputIterator2>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
thrust::set_union_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);

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

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename InputIterator4,
  typename OutputIterator1,
  typename OutputIterator2,
  typename StrictWeakCompare>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
thrust::set_union_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,
  StrictWeakCompare comp);

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

2.1.7.1. thrust::set_difference

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator>
__host__ __device__ OutputIterator
set_difference(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result);

set_difference 构造一个有序范围，是有序范围 [first1, last1) 和 [first2, last2) 的差集。返回值是输出范围的末尾。

在最简单的情况下， set_difference ‍执行集合的差运算：输出范围由所有属于 [first1, last1) 而不属于 [first2, last1) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [first1, last1) 包含 m 个彼此等价的元素，且 [first2, last2) 包含 n 个与它们等价的元素，则 [first1, last1) 内最后 max(m-n,0) 个元素会被复制到输出范围。

此版本的 set_difference 使用 operator< 比较元素。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 set_difference 计算两组升序整数集合的差集：

#include <thrust/set_operations.h>
#include <thrust/execution_policy.h>
...
int A1[7] = {0, 1, 3, 4, 5, 6, 9};
int A2[5] = {1, 3, 5, 7, 9};

int result[3];

int *result_end = thrust::set_difference(thrust::host, A1, A1 + 7, A2, A2 + 5, result);
// result is now {0, 4, 6}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型

函数参数

exec：用于并行化的执行策略
first1：第一个输入范围的起始
last1-：第一个输入范围的末尾
first2：第二个输入范围的起始
last2：第二个输入范围的末尾
result：输出范围的起始

前提条件

范围 [first1, last1) 和 [first2, last2) 应按照 operator< 进行排序
结果范围不应与任何一个输入范围重叠

返回值

输出范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/set_difference
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted

2.1.7.2. thrust::set_difference

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator>
OutputIterator
set_difference(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result);

set_difference 构造一个有序范围，是有序范围 [first1, last1) 和 [first2, last2) 的差集。返回值是输出范围的末尾。

在最简单的情况下， set_difference ‍执行集合的差运算：输出范围由所有属于 [first1, last1) 而不属于 [first2, last1) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [first1, last1) 包含 m 个彼此等价的元素，且 [first2, last2) 包含 n 个与它们等价的元素，则 [first1, last1) 内最后 max(m-n,0) 个元素会被复制到输出范围。

此版本的 set_difference 使用 operator< 比较元素。

以下代码片段演示了如何使用 set_difference 计算两组升序排序整数集合的差集：

#include <thrust/set_operations.h>
...
int A1[7] = {0, 1, 3, 4, 5, 6, 9};
int A2[5] = {1, 3, 5, 7, 9};

int result[3];

int *result_end = thrust::set_difference(A1, A1 + 7, A2, A2 + 5, result);
// result is now {0, 4, 6}

模板参数

InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型

函数参数

first1：第一个输入范围的起始
last1-：第一个输入范围的末尾
first2：第二个输入范围的起始
last2：第二个输入范围的末尾
result：输出范围的起始

前提条件

范围 [first1, last1) 和 [first2, last2) 应按照 operator< 进行排序
结果范围不应与任何一个输入范围重叠

返回值

输出范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/set_difference
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted

2.1.7.3. thrust::set_difference

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename StrictWeakCompare>
__host__ __device__ OutputIterator
set_difference(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result,
  StrictWeakCompare comp);

set_difference 构造一个有序范围，是有序范围 [first1, last1) 和 [first2, last2) 的差集。返回值是输出范围的末尾。

在最简单的情况下， set_difference ‍执行集合的差运算：输出范围由所有属于 [first1, last1) 而不属于 [first2, last1) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [first1, last1) 包含 m 个彼此等价的元素，且 [first2, last2) 包含 n 个与它们等价的元素，则 [first1, last1) 内最后 max(m-n,0) 个元素会被复制到输出范围。

此版本的 set_difference 使用函数对象 comp 比较元素。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 set_difference 计算两组降序整数集合的差集：

#include <thrust/set_operations.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
int A1[7] = {9, 6, 5, 4, 3, 1, 0};
int A2[5] = {9, 7, 5, 3, 1};

int result[3];

int *result_end = thrust::set_difference(thrust::host, A1, A1 + 7, A2, A2 + 5, result, thrust::greater<int>());
// result is now {6, 4, 0}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型， InputIterator1 的 value_type 可转换为 StrictWeakCompare 的 first_argument_type 以及 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型， InputIterator2 的 value_type 可转换为 StrictWeakCompare 的 second_argument_type 以及 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型
StrictWeakCompare：是 Strict Weak Ordering 的模型

函数参数

exec：用于并行化的执行策略
first1：第一个输入范围的起始
last1-：第一个输入范围的末尾
first2：第二个输入范围的起始
last2：第二个输入范围的末尾
result：输出范围的起始
comp：比较运算符

前提条件

范围 [first1, last1) 和 [first2, last2) 应按照 comp 进行排序
结果范围不应与任何一个输入范围重叠

返回值

输出范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/set_difference
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted

2.1.7.4. thrust::set_difference

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename StrictWeakCompare>
OutputIterator
set_difference(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result,
  StrictWeakCompare comp);

set_difference 构造一个有序范围，是有序范围 [first1, last1) 和 [first2, last2) 的差集。返回值是输出范围的末尾。

在最简单的情况下， set_difference ‍执行集合的差运算：输出范围由所有属于 [first1, last1) 而不属于 [first2, last1) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [first1, last1) 包含 m 个彼此等价的元素，且 [first2, last2) 包含 n 个与它们等价的元素，则 [first1, last1) 内最后 max(m-n,0) 个元素会被复制到输出范围。

此版本的 set_difference 使用函数对象 comp 比较元素。

以下代码片段演示了如何使用 set_difference 计算两组降序整数集合的差集：

#include <thrust/set_operations.h>
#include <thrust/functional.h>
...
int A1[7] = {9, 6, 5, 4, 3, 1, 0};
int A2[5] = {9, 7, 5, 3, 1};

int result[3];

int *result_end = thrust::set_difference(A1, A1 + 7, A2, A2 + 5, result, thrust::greater<int>());
// result is now {6, 4, 0}

模板参数

InputIterator1：是 Input Iterator 的模型， InputIterator1 的 value_type 可转换为 StrictWeakCompare 的 first_argument_type 以及 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型， InputIterator2 的 value_type 可转换为 StrictWeakCompare 的 second_argument_type 以及 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型
StrictWeakCompare：是 Strict Weak Ordering 的模型

函数参数

first1：第一个输入范围的起始
last1-：第一个输入范围的末尾
first2：第二个输入范围的起始
last2：第二个输入范围的末尾
result：输出范围的起始
comp：比较运算符

前提条件

范围 [first1, last1) 和 [first2, last2) 应按照 comp 进行排序
结果范围不应与任何一个输入范围重叠

返回值

输出范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/set_difference
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted

2.1.7.5. thrust::set_intersection

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator>
__host__ __device__ OutputIterator
set_intersection(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result);

set_intersection 构造一个有序范围，是有序范围 [first1, last1) 和 [first2, last2) 的交集。返回值是输出范围的末尾。

在最简单的情况下， set_intersection ‍执行集合的交运算：输出范围由属于 [first1, last1) ‍和 [first2, last2) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果一个值在 [first1, last1) 内出现 m 次，在 [first2, last2) 内出现 n 次（其中 m 可能为零），则它在输出范围中会出现 min(m,n) 次。 set_intersection 是稳定的，指的是元素都是从第一个范围而不是第二个范围复制的，并且输出范围中元素的相对顺序与第一个输入范围中的相同。

此版本的 set_intersection 使用 operator< 比较对象。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 set_intersection 计算两组升序整数集合的交集：

#include <thrust/set_operations.h>
#include <thrust/execution_policy.h>
...
int A1[6] = {1, 3, 5, 7, 9, 11};
int A2[7] = {1, 1, 2, 3, 5,  8, 13};

int result[7];

int *result_end = thrust::set_intersection(thrust::host, A1, A1 + 6, A2, A2 + 7, result);
// result is now {1, 3, 5}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型

函数参数

exec：用于并行化的执行策略
first1：第一个输入范围的起始
last1-：第一个输入范围的末尾
first2：第二个输入范围的起始
last2：第二个输入范围的末尾
result：输出范围的起始

前提条件

范围 [first1, last1) 和 [first2, last2) 应按照 operator< 进行排序
结果范围不应与任何一个输入范围重叠

返回值

输出范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/set_intersection
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted

2.1.7.6. thrust::set_intersection

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator>
OutputIterator
set_intersection(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result);

set_intersection 构造一个有序范围，是有序范围 [first1, last1) 和 [first2, last2) 的交集。返回值是输出范围的末尾。

在最简单的情况下， set_intersection ‍执行集合的交运算：输出范围由属于 [first1, last1) ‍和 [first2, last2) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果一个值在 [first1, last1) 内出现 m 次，在 [first2, last2) 内出现 n 次（其中 m 可能为零），则它在输出范围中会出现 min(m,n) 次。 set_intersection 是稳定的，指的是元素都是从第一个范围而不是第二个范围复制的，并且输出范围中元素的相对顺序与第一个输入范围中的相同。

此版本的 set_intersection 使用 operator< 比较对象。

以下代码片段演示了如何使用 set_intersection 计算两组升序整数集合的交集：

#include <thrust/set_operations.h>
...
int A1[6] = {1, 3, 5, 7, 9, 11};
int A2[7] = {1, 1, 2, 3, 5,  8, 13};

int result[7];

int *result_end = thrust::set_intersection(A1, A1 + 6, A2, A2 + 7, result);
// result is now {1, 3, 5}

模板参数

InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型

函数参数

first1：第一个输入范围的起始
last1-：第一个输入范围的末尾
first2：第二个输入范围的起始
last2：第二个输入范围的末尾
result：输出范围的起始

前提条件

范围 [first1, last1) 和 [first2, last2) 应按照 operator< 进行排序
结果范围不应与任何一个输入范围重叠

返回值

输出范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/set_intersection
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted

2.1.7.7. thrust::set_intersection

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename StrictWeakCompare>
__host__ __device__ OutputIterator
set_intersection(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result,
  StrictWeakCompare comp);

set_intersection 构造一个有序范围，是有序范围 [first1, last1) 和 [first2, last2) 的交集。返回值是输出范围的末尾。

在最简单的情况下， set_intersection ‍执行集合的交运算：输出范围由属于 [first1, last1) ‍和 [first2, last2) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果一个值在 [first1, last1) 内出现 m 次，在 [first2, last2) 内出现 n 次（其中 m 可能为零），则它在输出范围中会出现 min(m,n) 次。 set_intersection 是稳定的，指的是元素都是从第一个范围而不是第二个范围复制的，并且输出范围中元素的相对顺序与第一个输入范围中的相同。

此版本的 set_intersection 使用函数对象 comp 比较元素。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 set_intersection 计算两组降序整数集合的交集：

#include <thrust/set_operations.h>
#include <thrust/execution_policy.h>
...
int A1[6] = {11, 9, 7, 5, 3, 1};
int A2[7] = {13, 8, 5, 3, 2,  1, 1};

int result[3];

int *result_end = thrust::set_intersection(thrust::host, A1, A1 + 6, A2, A2 + 7, result, thrust::greater<int>());
// result is now {5, 3, 1}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型

函数参数

exec：用于并行化的执行策略
first1：第一个输入范围的起始
last1-：第一个输入范围的末尾
first2：第二个输入范围的起始
last2：第二个输入范围的末尾
result：输出范围的起始
comp：比较运算符

前提条件

范围 [first1, last1) 和 [first2, last2) 应按照 comp 进行排序
结果范围不应与任何一个输入范围重叠

返回值

输出范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/set_intersection
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted

2.1.7.8. thrust::set_intersection

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename StrictWeakCompare>
OutputIterator
set_intersection(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result,
  StrictWeakCompare comp);

set_intersection 构造一个有序范围，是有序范围 [first1, last1) 和 [first2, last2) 的交集。返回值是输出范围的末尾。

在最简单的情况下， set_intersection ‍执行集合的交运算：输出范围由属于 [first1, last1) ‍和 [first2, last2) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果一个值在 [first1, last1) 内出现 m 次，在 [first2, last2) 内出现 n 次（其中 m 可能为零），则它在输出范围中会出现 min(m,n) 次。 set_intersection 是稳定的，指的是元素都是从第一个范围而不是第二个范围复制的，并且输出范围中元素的相对顺序与第一个输入范围中的相同。

此版本的 set_intersection 使用函数对象 comp 比较元素。

以下代码片段演示了如何使用 set_intersection 计算两组降序整数集合的交集：

#include <thrust/set_operations.h>
...
int A1[6] = {11, 9, 7, 5, 3, 1};
int A2[7] = {13, 8, 5, 3, 2,  1, 1};

int result[3];

int *result_end = thrust::set_intersection(A1, A1 + 6, A2, A2 + 7, result, thrust::greater<int>());
// result is now {5, 3, 1}

模板参数

InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型

函数参数

first1：第一个输入范围的起始
last1-：第一个输入范围的末尾
first2：第二个输入范围的起始
last2：第二个输入范围的末尾
result：输出范围的起始
comp：比较运算符

前提条件

范围 [first1, last1) 和 [first2, last2) 应按照 comp 进行排序
结果范围不应与任何一个输入范围重叠

返回值

输出范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/set_intersection
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted

2.1.7.9. thrust::set_symmetric_difference

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator>
__host__ __device__ OutputIterator
set_symmetric_difference(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result);

set_symmetric_difference ‍构造一个有序范围，是有序范围 [first1, last1) 和 [first2, last2) 的对称差集。返回值是输出范围的末尾。

在最简单的情况下， set_symmetric_difference ‍实现以下集合运算：构造两个集合A - B和B - A的并集，其中A和B是两个输入范围。即，输出范围由属于 [first1, last1) 但不属于 [first2, last1) 的元素副本，和属于 [first2, last2) 但不属于 [first1, last1) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [first1, last1) 包含 m 个彼此等价的元素， [first2, last1) 包含 n 个彼此等价的元素，则 |m - n| 个这样的元素应被复制到输出范围：如果 m > n ，则复制 [first1, last1) ‍内最后 m - n 个元素；如果 m < n ，则复制 [first2, last2) 中最后 n - m 个元素。

此版本的 set_union 使用 operator< 比较元素。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 set_symmetric_difference 计算两组升序整数集合的对称差集：

#include <thrust/set_operations.h>
#include <thrust/execution_policy.h>
...
int A1[7] = {0, 1, 2, 2, 4, 6, 7};
int A2[5] = {1, 1, 2, 5, 8};

int result[6];

int *result_end = thrust::set_symmetric_difference(thrust::host, A1, A1 + 7, A2, A2 + 5, result);
// result = {0, 4, 5, 6, 7, 8}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型

函数参数

exec：用于并行化的执行策略
first1：第一个输入范围的起始
last1：第一个输入范围的末尾
first2：第二个输入范围的起始
last2：第二个输入范围的末尾
result：输出范围的起始

前提条件

范围 [first1, last1) 和 [first2, last2) 应按照 operator< 进行排序
结果范围不应与任何一个输入范围重叠

返回值

输出范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/set_symmetric_difference
merge
includes
set_difference
set_union
set_intersection
sort
is_sorted

2.1.7.10. thrust::set_symmetric_difference

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator>
OutputIterator
set_symmetric_difference(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result);

set_symmetric_difference ‍构造一个有序范围，是有序范围 [first1, last1) 和 [first2, last2) 的对称差集。返回值是输出范围的末尾。

在最简单的情况下， set_symmetric_difference ‍实现以下集合运算：构造两个集合A - B和B - A的并集，其中A和B是两个输入范围。即，输出范围由属于 [first1, last1) 但不属于 [first2, last1) 的元素副本，和属于 [first2, last2) 但不属于 [first1, last1) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [first1, last1) 包含 m 个彼此等价的元素， [first2, last1) 包含 n 个彼此等价的元素，则 |m - n| 个这样的元素应被复制到输出范围：如果 m > n ，则复制 [first1, last1) ‍内最后 m - n 个元素；如果 m < n ，则复制 [first2, last2) 中最后 n - m 个元素。

此版本的 set_union 使用 operator< 比较元素。

以下代码片段演示了如何使用 set_symmetric_difference 计算两组升序整数集合的对称差集：

#include <thrust/set_operations.h>
...
int A1[7] = {0, 1, 2, 2, 4, 6, 7};
int A2[5] = {1, 1, 2, 5, 8};

int result[6];

int *result_end = thrust::set_symmetric_difference(A1, A1 + 7, A2, A2 + 5, result);
// result = {0, 4, 5, 6, 7, 8}

模板参数

InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型

函数参数

first1：第一个输入范围的起始
last1-：第一个输入范围的末尾
first2：第二个输入范围的起始
last2：第二个输入范围的末尾
result：输出范围的起始

前提条件

范围 [first1, last1) 和 [first2, last2) 应按照 operator< 进行排序
结果范围不应与任何一个输入范围重叠

返回值

输出范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/set_symmetric_difference
merge
includes
set_difference
set_union
set_intersection
sort
is_sorted

2.1.7.11. thrust::set_symmetric_difference

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename StrictWeakCompare>
__host__ __device__ OutputIterator
set_symmetric_difference(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result,
  StrictWeakCompare comp);

set_symmetric_difference ‍构造一个有序范围，是有序范围 [first1, last1) 和 [first2, last2) 的对称差集。返回值是输出范围的末尾。

在最简单的情况下， set_symmetric_difference ‍实现以下集合运算：构造两个集合A - B和B - A的并集，其中A和B是两个输入范围。即，输出范围由属于 [first1, last1) 但不属于 [first2, last1) 的元素副本，和属于 [first2, last2) 但不属于 [first1, last1) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [first1, last1) 包含 m 个彼此等价的元素， [first2, last1) 包含 n 个彼此等价的元素，则 |m - n| 个这样的元素应被复制到输出范围：如果 m > n ，则复制 [first1, last1) ‍内最后 m - n 个元素；如果 m < n ，则复制 [first2, last2) 中最后 n - m 个元素。

此版本的 set_union 使用函数对象 comp 比较元素。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 set_symmetric_difference 计算两组降序整数集合的对称差集：

#include <thrust/set_operations.h>
#include <thrust/execution_policy.h>
...
int A1[7] = {7, 6, 4, 2, 2, 1, 0};
int A2[5] = {8, 5, 2, 1, 1};

int result[6];

int *result_end = thrust::set_symmetric_difference(thrust::host, A1, A1 + 7, A2, A2 + 5, result);
// result = {8, 7, 6, 5, 4, 0}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型

函数参数

exec：用于并行化的执行策略
first1：第一个输入范围的起始
last1-：第一个输入范围的末尾
first2：第二个输入范围的起始
last2：第二个输入范围的末尾
result：输出范围的起始
comp：比较运算符

前提条件

范围 [first1, last1) 和 [first2, last2) 应按照 comp 进行排序
结果范围不应与任何一个输入范围重叠

返回值

输出范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/set_symmetric_difference
merge
includes
set_difference
set_union
set_intersection
sort
is_sorted

2.1.7.12. thrust::set_symmetric_difference

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename StrictWeakCompare>
OutputIterator
set_symmetric_difference(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result,
  StrictWeakCompare comp);

set_symmetric_difference ‍构造一个有序范围，是有序范围 [first1, last1) 和 [first2, last2) 的对称差集。返回值是输出范围的末尾。

在最简单的情况下， set_symmetric_difference ‍实现以下集合运算：构造两个集合A - B和B - A的并集，其中A和B是两个输入范围。即，输出范围由属于 [first1, last1) 但不属于 [first2, last1) 的元素副本，和属于 [first2, last2) 但不属于 [first1, last1) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [first1, last1) 包含 m 个彼此等价的元素， [first2, last1) 包含 n 个彼此等价的元素，则 |m - n| 个这样的元素应被复制到输出范围：如果 m > n ，则复制 [first1, last1) ‍内最后 m - n 个元素；如果 m < n ，则复制 [first2, last2) 中最后 n - m 个元素。

此版本的 set_union 使用函数对象 comp 比较元素。

以下代码片段演示了如何使用 set_symmetric_difference 计算两组降序整数集合的对称差集：

#include <thrust/set_operations.h>
...
int A1[7] = {7, 6, 4, 2, 2, 1, 0};
int A2[5] = {8, 5, 2, 1, 1};

int result[6];

int *result_end = thrust::set_symmetric_difference(A1, A1 + 7, A2, A2 + 5, result);
// result = {8, 7, 6, 5, 4, 0}

模板参数

InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型

函数参数

first1：第一个输入范围的起始
last1-：第一个输入范围的末尾
first2：第二个输入范围的起始
last2：第二个输入范围的末尾
result：输出范围的起始
comp：比较运算符

前提条件

范围 [first1, last1) 和 [first2, last2) 应按照 comp 进行排序
结果范围不应与任何一个输入范围重叠

返回值

输出范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/set_symmetric_difference
merge
includes
set_difference
set_union
set_intersection
sort
is_sorted

2.1.7.13. thrust::set_union

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator>
__host__ __device__ OutputIterator
set_union(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result);

set_union ‍构造一个有序范围，是有序范围 [first1, last1) 和 [first2, last2) 的并集。返回值是输出范围的末尾。

在最简单的情况下， set_union ‍执行集合的并运算：输出范围由属于 [first2, last1) 或 [first1, last1)，或者属于两者的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [first1, last1) 包含 m 个彼此等价的元素， [first2, last2) 包含 n 个彼此等价的元素，则第一个范围内的所有 m 个元素都应按顺序复制到输出范围，第二个范围内的 max(n - m, 0) 个元素应按顺序复制到输出范围。

此版本的 set_union 使用 operator< 比较元素。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 set_union 计算两组升序整数集合的并集：

#include <thrust/set_operations.h>
#include <thrust/execution_policy.h>
...
int A1[7] = {0, 2, 4, 6, 8, 10, 12};
int A2[5] = {1, 3, 5, 7, 9};

int result[11];

int *result_end = thrust::set_union(thrust::host, A1, A1 + 7, A2, A2 + 5, result);
// result = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型

函数参数

exec：用于并行化的执行策略
first1：第一个输入范围的起始
last1-：第一个输入范围的末尾
first2：第二个输入范围的起始
last2：第二个输入范围的末尾
result：输出范围的起始

前提条件

范围 [first1, last1) 和 [first2, last2) 应按照 operator< 进行排序
结果范围不应与任何一个输入范围重叠

返回值

输出范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/set_union
merge
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted

2.1.7.14. thrust::set_union

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator>
OutputIterator
set_union(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result);

set_union ‍构造一个有序范围，是有序范围 [first1, last1) 和 [first2, last2) 的并集。返回值是输出范围的末尾。

在最简单的情况下， set_union ‍执行集合的并运算：输出范围由属于 [first2, last1) 或 [first1, last1)，或者属于两者的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [first1, last1) 包含 m 个彼此等价的元素， [first2, last2) 包含 n 个彼此等价的元素，则第一个范围内的所有 m 个元素都应按顺序复制到输出范围，第二个范围内的 max(n - m, 0) 个元素应按顺序复制到输出范围。

此版本的 set_union 使用 operator< 比较元素。

以下代码片段演示了如何使用 set_union 计算两组升序整数集合的并集：

#include <thrust/set_operations.h>
...
int A1[7] = {0, 2, 4, 6, 8, 10, 12};
int A2[5] = {1, 3, 5, 7, 9};

int result[11];

int *result_end = thrust::set_union(A1, A1 + 7, A2, A2 + 5, result);
// result = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12}

模板参数

InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型

函数参数

first1：第一个输入范围的起始
last1-：第一个输入范围的末尾
first2：第二个输入范围的起始
last2：第二个输入范围的末尾
result：输出范围的起始

前提条件

范围 [first1, last1) 和 [first2, last2) 应按照 operator< 进行排序
结果范围不应与任何一个输入范围重叠

返回值

输出范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/set_union
merge
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted

2.1.7.15. thrust::set_union

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename StrictWeakCompare>
__host__ __device__ OutputIterator
set_union(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result,
  StrictWeakCompare comp);

set_union ‍构造一个有序范围，是有序范围 [first1, last1) 和 [first2, last2) 的并集。返回值是输出范围的末尾。

在最简单的情况下， set_union ‍执行集合的并运算：输出范围由属于 [first2, last1) 或 [first1, last1)，或者属于两者的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [first1, last1) 包含 m 个彼此等价的元素， [first2, last2) 包含 n 个彼此等价的元素，则第一个范围内的所有 m 个元素都应按顺序复制到输出范围，第二个范围内的 max(n - m, 0) 个元素应按顺序复制到输出范围。

此版本的 set_union 使用函数对象 comp 比较元素。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 set_union 计算两组降序整数集合的并集：

#include <thrust/set_operations.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
int A1[7] = {12, 10, 8, 6, 4, 2, 0};
int A2[5] = {9, 7, 5, 3, 1};

int result[11];

int *result_end = thrust::set_union(thrust::host, A1, A1 + 7, A2, A2 + 5, result, thrust::greater<int>());
// result = {12, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型， InputIterator1 的 value_type 可转换为 StrictWeakCompare 的 first_argument_type 以及 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型， InputIterator2 的 value_type 可转换为 StrictWeakCompare 的 second_argument_type 以及 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型
StrictWeakCompare：是 Strict Weak Ordering 的模型

函数参数

exec：用于并行化的执行策略
first1：第一个输入范围的起始
last1-：第一个输入范围的末尾
first2：第二个输入范围的起始
last2：第二个输入范围的末尾
result：输出范围的起始
comp：比较运算符

前提条件

范围 [first1, last1) 和 [first2, last2) 应按照 comp 进行排序
结果范围不应与任何一个输入范围重叠

返回值

输出范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/set_union
merge
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted

2.1.7.16. thrust::set_union

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename StrictWeakCompare>
OutputIterator
set_union(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator2 last2,
  OutputIterator result,
  StrictWeakCompare comp);

set_union ‍构造一个有序范围，是有序范围 [first1, last1) 和 [first2, last2) 的并集。返回值是输出范围的末尾。

在最简单的情况下， set_union ‍执行集合的并运算：输出范围由属于 [first2, last1) 或 [first1, last1)，或者属于两者的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [first1, last1) 包含 m 个彼此等价的元素， [first2, last2) 包含 n 个彼此等价的元素，则第一个范围内的所有 m 个元素都应按顺序复制到输出范围，第二个范围内的 max(n - m, 0) 个元素应按顺序复制到输出范围。

此版本的 set_union 使用函数对象 comp 比较元素。

以下代码片段演示了如何使用 set_union 计算两组降序整数集合的并集：

#include <thrust/set_operations.h>
#include <thrust/functional.h>
...
int A1[7] = {12, 10, 8, 6, 4, 2, 0};
int A2[5] = {9, 7, 5, 3, 1};

int result[11];

int *result_end = thrust::set_union(A1, A1 + 7, A2, A2 + 5, result, thrust::greater<int>());
// result = {12, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}

模板参数

InputIterator1：是 Input Iterator 的模型， InputIterator1 的 value_type 可转换为 StrictWeakCompare 的 first_argument_type 以及 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型， InputIterator2 的 value_type 可转换为 StrictWeakCompare 的 second_argument_type 以及 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型
StrictWeakCompare：是 Strict Weak Ordering 的模型

函数参数

first1：第一个输入范围的起始
last1-：第一个输入范围的末尾
first2：第二个输入范围的起始
last2：第二个输入范围的末尾
result：输出范围的起始
comp：比较运算符

前提条件

范围 [first1, last1) 和 [first2, last2) 应按照 comp 进行排序
结果范围不应与任何一个输入范围重叠

返回值

输出范围的末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/set_union
merge
includes
set_union
set_intersection
set_symmetric_difference
sort
is_sorted

2.1.7.17. thrust::set_difference_by_key

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename InputIterator4,
  typename OutputIterator1,
  typename OutputIterator2>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
set_difference_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);

set_difference_by_key ‍执行集合的键值差运算。 set_difference_by_key ‍构造一个有序范围，是有序范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 的差集。与输入和输出键范围内的每个元素相关联的是一个值元素。关联的输入值范围不需要排序。

在最简单的情况下， set_difference_by_key 执行集合的键值差运算：键输出范围由‍属于 [keys_first1, keys_last1) 而不属于 [keys_first2, keys_last2) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [keys_first1, keys_last1) 包含 m 个彼此等价的元素，且 [keys_first2, keys_last2) 包含 n 个与它们等价的元素，则 [keys_first1, keys_last1) 内最后 max(m-n,0) 个元素会被复制到输出范围。

每次将键元素从 [keys_first1, keys_last1) 或 [keys_first2, keys_last2) 复制到键输出范围时，将相应的值元素从相应的值输入范围（从 values_first1 或 values_first2 开始）复制到值输出范围。

此版本的 set_difference_by_key 使用 operator< 比较键元素。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 set_difference_by_key 计算两组键为升序整数的键-值对集合的差集：

#include <thrust/set_operations.h>
#include <thrust/execution_policy.h>
...
int A_keys[6] = {0, 1, 3, 4, 5, 6, 9};
int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};

int B_keys[5] = {1, 3, 5, 7, 9};
int B_vals[5] = {1, 1, 1, 1, 1};

int keys_result[3];
int vals_result[3];

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

// keys_result is now {0, 4, 6}
// vals_result is now {0, 0, 0}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator3：是 Input Iterator 的模型， InputIterator3 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
InputIterator4：是 Input Iterator 的模型， InputIterator4 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型

函数参数

exec：用于并行化的执行策略
keys_first1：第一个键输入范围的起始
keys_last1：第一个键输入范围的末尾
keys_first2：第二个键输入范围的起始
keys_last2：第二个键输入范围的末尾
values_first1：第一个值输入范围的起始
values_first2：第二个值输入范围的起始
keys_result：键输出范围的起始
values_result：值输出范围的起始

前提条件

范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 应按照 operator< 进行排序
结果范围不应与任何一个输入范围重叠

返回值

p pair ，其中 p.first 是键输出范围的末尾， p.second 是值输出范围的末尾

另请参阅

set_union_by_key
set_intersection_by_key
set_symmetric_difference_by_key
sort_by_key
is_sorted

2.1.7.18. thrust::set_difference_by_key

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

set_difference_by_key ‍执行集合的键值差运算。 set_difference_by_key ‍构造一个有序范围，是有序范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 的差集。与输入和输出键范围内的每个元素相关联的是一个值元素。关联的输入值范围不需要排序。

在最简单的情况下， set_difference_by_key 执行集合的键值差运算：键输出范围由‍属于 [keys_first1, keys_last1) 而不属于 [keys_first2, keys_last2) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [keys_first1, keys_last1) 包含 m 个彼此等价的元素，且 [keys_first2, keys_last2) 包含 n 个与它们等价的元素，则 [keys_first1, keys_last1) 内最后 max(m-n,0) 个元素会被复制到输出范围。

每次将键元素从 [keys_first1, keys_last1) 或 [keys_first2, keys_last2) 复制到键输出范围时，将相应的值元素从相应的值输入范围（从 values_first1 或 values_first2 开始）复制到值输出范围。

此版本的 set_difference_by_key 使用 operator< 比较键元素。

以下代码片段演示了如何使用 set_difference_by_key 计算两组升序整数集合与其值的差集：

#include <thrust/set_operations.h>
...
int A_keys[6] = {0, 1, 3, 4, 5, 6, 9};
int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};

int B_keys[5] = {1, 3, 5, 7, 9};
int B_vals[5] = {1, 1, 1, 1, 1};

int keys_result[3];
int vals_result[3];

thrust::pair<int*,int*> end = thrust::set_difference_by_key(A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
// keys_result is now {0, 4, 6}
// vals_result is now {0, 0, 0}

模板参数

InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator3：是 Input Iterator 的模型， InputIterator3 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
InputIterator4：是 Input Iterator 的模型， InputIterator4 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型

函数参数

keys_first1：第一个键输入范围的起始
keys_last1：第一个键输入范围的末尾
keys_first2：第二个键输入范围的起始
keys_last2：第二个键输入范围的末尾
values_first1：第一个值输入范围的起始
values_first2：第二个值输入范围的起始
keys_result：键输出范围的起始
values_result：值输出范围的起始

前提条件

范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 应按照 operator< 进行排序
结果范围不应与任何一个输入范围重叠

返回值

p pair ，其中 p.first 是键输出范围的末尾， p.second 是值输出范围的末尾

另请参阅

set_union_by_key
set_intersection_by_key
set_symmetric_difference_by_key
sort_by_key
is_sorted

2.1.7.19. thrust::set_difference_by_key

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename InputIterator4,
  typename OutputIterator1,
  typename OutputIterator2,
  typename StrictWeakCompare>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
set_difference_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,
  StrictWeakCompare comp);

set_difference_by_key ‍执行集合的键值差运算。 set_difference_by_key ‍构造一个有序范围，是有序范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 的差集。与输入和输出键范围内的每个元素相关联的是一个值元素。关联的输入值范围不需要排序。

在最简单的情况下， set_difference_by_key 执行集合的键值差运算：键输出范围由‍属于 [keys_first1, keys_last1) 而不属于 [keys_first2, keys_last2) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [keys_first1, keys_last1) 包含 m 个彼此等价的元素，且 [keys_first2, keys_last2) 包含 n 个与它们等价的元素，则 [keys_first1, keys_last1) 内最后 max(m-n,0) 个元素会被复制到输出范围。

每次将键元素从 [keys_first1, keys_last1) 或 [keys_first2, keys_last2) 复制到键输出范围时，将相应的值元素从相应的值输入范围（从 values_first1 或 values_first2 开始）复制到值输出范围。

此版本的 set_difference_by_key 使用函数对象 comp 比较键元素。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 set_difference_by_key 计算两组降序整数集合与其值的差集：

#include <thrust/set_operations.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
int A_keys[6] = {9, 6, 5, 4, 3, 1, 0};
int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};

int B_keys[5] = {9, 7, 5, 3, 1};
int B_vals[5] = {1, 1, 1, 1, 1};

int keys_result[3];
int vals_result[3];

thrust::pair<int*,int*> end = thrust::set_difference_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result, thrust::greater<int>());
// keys_result is now {0, 4, 6}
// vals_result is now {0, 0, 0}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator3：是 Input Iterator 的模型， InputIterator3 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
InputIterator4：是 Input Iterator 的模型， InputIterator4 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型
StrictWeakCompare：是 Strict Weak Ordering 的模型

函数参数

exec：用于并行化的执行策略
keys_first1：第一个键输入范围的起始
keys_last1：第一个键输入范围的末尾
keys_first2：第二个键输入范围的起始
keys_last2：第二个键输入范围的末尾
values_first1：第一个值输入范围的起始
values_first2：第二个值输入范围的起始
keys_result：键输出范围的起始
values_result：值输出范围的起始
comp：比较运算符

前提条件

范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 应按照 comp 进行排序
结果范围不应与任何一个输入范围重叠

返回值

p pair ，其中 p.first 是键输出范围的末尾， p.second 是值输出范围的末尾

另请参阅

set_union_by_key
set_intersection_by_key
set_symmetric_difference_by_key
sort_by_key
is_sorted

2.1.7.20. thrust::set_difference_by_key

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

set_difference_by_key ‍执行集合的键值差运算。 set_difference_by_key ‍构造一个有序范围，是有序范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 的差集。与输入和输出键范围内的每个元素相关联的是一个值元素。关联的输入值范围不需要排序。

在最简单的情况下， set_difference_by_key 执行集合的键值差运算：键输出范围由‍属于 [keys_first1, keys_last1) 而不属于 [keys_first2, keys_last2) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [keys_first1, keys_last1) 包含 m 个彼此等价的元素，且 [keys_first2, keys_last2) 包含 n 个与它们等价的元素，则 [keys_first1, keys_last1) 内最后 max(m-n,0) 个元素会被复制到输出范围。

每次将键元素从 [keys_first1, keys_last1) 或 [keys_first2, keys_last2) 复制到键输出范围时，将相应的值元素从相应的值输入范围（从 values_first1 或 values_first2 开始）复制到值输出范围。

此版本的 set_difference_by_key 使用函数对象 comp 比较键元素。

以下代码片段演示了如何使用 set_difference_by_key 计算两组降序整数集合与其值的差集：

#include <thrust/set_operations.h>
#include <thrust/functional.h>
...
int A_keys[6] = {9, 6, 5, 4, 3, 1, 0};
int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};

int B_keys[5] = {9, 7, 5, 3, 1};
int B_vals[5] = {1, 1, 1, 1, 1};

int keys_result[3];
int vals_result[3];

thrust::pair<int*,int*> end = thrust::set_difference_by_key(A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result, thrust::greater<int>());
// keys_result is now {0, 4, 6}
// vals_result is now {0, 0, 0}

模板参数

InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator3：是 Input Iterator 的模型， InputIterator3 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
InputIterator4：是 Input Iterator 的模型， InputIterator4 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型
StrictWeakCompare：是 Strict Weak Ordering 的模型

函数参数

keys_first1：第一个键输入范围的起始
keys_last1：第一个键输入范围的末尾
keys_first2：第二个键输入范围的起始
keys_last2：第二个键输入范围的末尾
values_first1：第一个值输入范围的起始
values_first2：第二个值输入范围的起始
keys_result：键输出范围的起始
values_result：值输出范围的起始
comp：比较运算符

前提条件

范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 应按照 comp 进行排序
结果范围不应与任何一个输入范围重叠

返回值

p pair ，其中 p.first 是键输出范围的末尾， p.second 是值输出范围的末尾

另请参阅

set_union_by_key
set_intersection_by_key
set_symmetric_difference_by_key
sort_by_key
is_sorted

2.1.7.21. thrust::set_intersection_by_key

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename OutputIterator1,
  typename OutputIterator2>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
set_intersection_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,
  OutputIterator1 keys_result,
  OutputIterator2 values_result);

set_intersection_by_key 执行集合的键值交运算。 set_intersection_by_key ‍构造一个有序范围，是有序范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 的交集。与输入和输出键范围内的每个元素相关联的是一个值元素。关联的输入值范围不需要排序。

在最简单的情况下， set_intersection_by_key 执行集合的键值交运算：键输出范围由属于 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果一个元素在 [keys_first1, keys_last1) 内出现 m 次，在 [keys_first2, keys_last2) 内出现 n 次（其中 m 可能为零），则它在键输出范围中会出现 min(m,n) 次。 set_intersection_by_key 是稳定的，指的是元素都是从第一个输入范围而不是第二个范围复制的，并且输出范围中元素的相对顺序与第一个输入范围中的相同。

每次将键元素从 [keys_first1, keys_last1) 复制到键输出范围时，将相应的值元素从 [values_first1, values_last1) 复制到值输出范围。

此版本的 set_intersection_by_key 使用 operator< 比较对象。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 set_intersection_by_key 计算两组升序整数集合与其值的交集：

#include <thrust/set_operations.h>
#include <thrust/execution_policy.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 keys_result[7];
int vals_result[7];

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

// keys_result is now {1, 3, 5}
// vals_result is now {0, 0, 0}

备注

与其他键值集合运算不同， set_intersection_by_key 的唯一性在于它没有 values_first2 参数，因为第二个输入范围中的元素从未复制到输出范围。

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator3：是 Input Iterator 的模型， InputIterator3 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型

函数参数

exec：用于并行化的执行策略
keys_first1：第一个键输入范围的起始
keys_last1：第一个键输入范围的末尾
keys_first2：第二个键输入范围的起始
keys_last2：第二个键输入范围的末尾
values_first1：第一个值输入范围的起始
keys_result：键输出范围的起始
values_result：值输出范围的起始

前提条件

范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 应按照 operator< 进行排序
结果范围不应与任何一个输入范围重叠

返回值

p pair ，其中 p.first 是键输出范围的末尾， p.second 是值输出范围的末尾

另请参阅

set_union_by_key
set_difference_by_key
set_symmetric_difference_by_key
sort_by_key
is_sorted

2.1.7.22. thrust::set_intersection_by_key

template <typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename OutputIterator1,
  typename OutputIterator2>
thrust::pair< OutputIterator1, OutputIterator2 >
set_intersection_by_key(InputIterator1 keys_first1,
  InputIterator1 keys_last1,
  InputIterator2 keys_first2,
  InputIterator2 keys_last2,
  InputIterator3 values_first1,
  OutputIterator1 keys_result,
  OutputIterator2 values_result);

set_intersection_by_key 执行集合的键值交运算。 set_intersection_by_key ‍构造一个有序范围，是有序范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 的交集。与输入和输出键范围内的每个元素相关联的是一个值元素。关联的输入值范围不需要排序。

在最简单的情况下， set_intersection_by_key 执行集合的交运算：键输出范围由属于 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果一个元素在 [keys_first1, keys_last1) 内出现 m 次，在 [keys_first2, keys_last2) 内出现 n 次（其中 m 可能为零），则它在键输出范围中会出现 min(m,n) 次。 set_intersection_by_key 是稳定的，指的是元素都是从第一个输入范围而不是第二个范围复制的，并且输出范围中元素的相对顺序与第一个输入范围中的相同。

每次将键元素从 [keys_first1, keys_last1) 复制到键输出范围时，将相应的值元素从 [values_first1, values_last1) 复制到值输出范围。

此版本的 set_intersection_by_key 使用 operator< 比较对象。

以下代码片段演示了如何使用 set_intersection_by_key 计算两组升序整数集合与其值的交集：

#include <thrust/set_operations.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 keys_result[7];
int vals_result[7];

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

// keys_result is now {1, 3, 5}
// vals_result is now {0, 0, 0}

备注

与其他键值集合运算不同， set_intersection_by_key 的唯一性在于它没有 values_first2 参数，因为第二个输入范围中的元素从未复制到输出范围。

模板参数

InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator3：是 Input Iterator 的模型， InputIterator3 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型

函数参数

keys_first1：第一个键输入范围的起始
keys_last1：第一个键输入范围的末尾
keys_first2：第二个键输入范围的起始
keys_last2：第二个键输入范围的末尾
values_first1：第一个值输入范围的起始
keys_result：键输出范围的起始
values_result：值输出范围的起始

前提条件

范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 应按照 operator< 进行排序
结果范围不应与任何一个输入范围重叠

返回值

p pair ，其中 p.first 是键输出范围的末尾， p.second 是值输出范围的末尾

另请参阅

set_union_by_key
set_difference_by_key
set_symmetric_difference_by_key
sort_by_key
is_sorted

2.1.7.23. thrust::set_intersection_by_key

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename OutputIterator1,
  typename OutputIterator2,
  typename StrictWeakCompare>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
set_intersection_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,
  OutputIterator1 keys_result,
  OutputIterator2 values_result,
  StrictWeakCompare comp);

set_intersection_by_key 执行集合的键值交运算。 set_intersection_by_key ‍构造一个有序范围，是有序范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 的交集。与输入和输出键范围内的每个元素相关联的是一个值元素。关联的输入值范围不需要排序。

在最简单的情况下， set_intersection_by_key 执行集合的键值交运算：键输出范围由属于 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果一个元素在 [keys_first1, keys_last1) 内出现 m 次，在 [keys_first2, keys_last2) 内出现 n 次（其中 m 可能为零），则它在键输出范围中会出现 min(m,n) 次。 set_intersection_by_key 是稳定的，指的是元素都是从第一个输入范围而不是第二个范围复制的，并且输出范围中元素的相对顺序与第一个输入范围中的相同。

每次将键元素从 [keys_first1, keys_last1) 复制到键输出范围时，将相应的值元素从 [values_first1, values_last1) 复制到值输出范围。

此版本的 set_intersection_by_key 使用函数对象 comp 比较对象。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 set_intersection_by_key 计算两组降序整数集合与其值的交集：

#include <thrust/set_operations.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 keys_result[7];
int vals_result[7];

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

// keys_result is now {5, 3, 1}
// vals_result is now {0, 0, 0}

备注

与其他键值集合运算不同， set_intersection_by_key 的唯一性在于它没有 values_first2 参数，因为第二个输入范围中的元素从未复制到输出范围。

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator3：是 Input Iterator 的模型， InputIterator3 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型
StrictWeakCompare：是 Strict Weak Ordering 的模型

函数参数

exec：用于并行化的执行策略
keys_first1：第一个键输入范围的起始
keys_last1：第一个键输入范围的末尾
keys_first2：第二个键输入范围的起始
keys_last2：第二个键输入范围的末尾
values_first1：第一个值输入范围的起始
keys_result：键输出范围的起始
values_result：值输出范围的起始
comp：比较运算符

前提条件

范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 应按照 comp 进行排序
结果范围不应与任何一个输入范围重叠

返回值

p pair ，其中 p.first 是键输出范围的末尾， p.second 是值输出范围的末尾

另请参阅

set_union_by_key
set_difference_by_key
set_symmetric_difference_by_key
sort_by_key
is_sorted

2.1.7.24. thrust::set_intersection_by_key

template <typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename OutputIterator1,
  typename OutputIterator2,
  typename StrictWeakCompare>
thrust::pair< OutputIterator1, OutputIterator2 >
set_intersection_by_key(InputIterator1 keys_first1,
  InputIterator1 keys_last1,
  InputIterator2 keys_first2,
  InputIterator2 keys_last2,
  InputIterator3 values_first1,
  OutputIterator1 keys_result,
  OutputIterator2 values_result,
  StrictWeakCompare comp);

set_intersection_by_key 执行集合的键值交运算。 set_intersection_by_key ‍构造一个有序范围，是有序范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 的交集。与输入和输出键范围内的每个元素相关联的是一个值元素。关联的输入值范围不需要排序。

在最简单的情况下， set_intersection_by_key 执行集合的键值交运算：键输出范围由属于 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果一个元素在 [keys_first1, keys_last1) 内出现 m 次，在 [keys_first2, keys_last2) 内出现 n 次（其中 m 可能为零），则它在键输出范围中会出现 min(m,n) 次。 set_intersection_by_key 是稳定的，指的是元素都是从第一个输入范围而不是第二个范围复制的，并且输出范围中元素的相对顺序与第一个输入范围中的相同。

每次将键元素从 [keys_first1, keys_last1) 复制到键输出范围时，将相应的值元素从 [values_first1, values_last1) 复制到值输出范围。

此版本的 set_intersection_by_key 使用函数对象 comp 比较对象。

以下代码片段演示了如何使用 set_intersection_by_key 两组降序整数集合与其值的交集：

#include <thrust/set_operations.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 keys_result[7];
int vals_result[7];

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

// keys_result is now {5, 3, 1}
// vals_result is now {0, 0, 0}

备注

与其他键值集合运算不同， set_intersection_by_key 的唯一性在于它没有 values_first2 参数，因为第二个输入范围中的元素从未复制到输出范围。

模板参数

InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator3：是 Input Iterator 的模型， InputIterator3 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型
StrictWeakCompare：是 Strict Weak Ordering 的模型

函数参数

keys_first1：第一个键输入范围的起始
keys_last1：第一个键输入范围的末尾
keys_first2：第二个键输入范围的起始
keys_last2：第二个键输入范围的末尾
values_first1：第一个值输入范围的起始
keys_result：键输出范围的起始
values_result：值输出范围的起始
comp：比较运算符

前提条件

范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 应按照 comp 进行排序
结果范围不应与任何一个输入范围重叠

返回值

p pair ，其中 p.first 是键输出范围的末尾， p.second 是值输出范围的末尾

另请参阅

set_union_by_key
set_difference_by_key
set_symmetric_difference_by_key
sort_by_key
is_sorted

2.1.7.25. thrust::set_symmetric_difference_by_key

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename InputIterator4,
  typename OutputIterator1,
  typename OutputIterator2>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
set_symmetric_difference_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);

set_symmetric_difference_by_key 执行集合的键值对称差运算。 set_difference_by_key ‍构造一个有序范围，是有序范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 的对称差集。与输入和输出键范围内的每个元素相关联的是一个值元素。关联的输入值范围不需要排序。

在最简单的情况下， set_symmetric_difference_by_key 执行以下集合运算：构造两个集合A - B和B - A的并集，其中A和B是两个输入范围。即，输出范围由属于 [keys_first1, keys_last1) 但不属于 [keys_first2, keys_last1) 的元素副本，和属于 [keys_first2, keys_last2) 但不属于 [keys_first1, keys_last1) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [keys_first1, keys_last1) 包含 m 个彼此等价的元素， [keys_first2, keys_last1) 包含 n 个彼此等价的元素，则 |m - n| 个这样的元素应被复制到输出范围：如果 m > n ，则复制 [keys_first1, keys_last1) ‍内最后 m - n 个元素；如果 m < n ，则复制 [keys_first2, keys_last2) 中最后 n - m 个元素。

每次将键元素从 [keys_first1, keys_last1) 或 [keys_first2, keys_last2) 复制到键输出范围时，将相应的值元素从相应的值输入范围（从 values_first1 或 values_first2 开始）复制到值输出范围。此版本的 set_symmetric_difference_by_key 使用 operator< 比较键元素。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 set_symmetric_difference_by_key 计算两组升序整数集合与其值的对称差集：

#include <thrust/set_operations.h>
#include <thrust/execution_policy.h>
...
int A_keys[6] = {0, 1, 2, 2, 4, 6, 7};
int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};

int B_keys[5] = {1, 1, 2, 5, 8};
int B_vals[5] = {1, 1, 1, 1, 1};

int keys_result[6];
int vals_result[6];

thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
// keys_result is now {0, 4, 5, 6, 7, 8}
// vals_result is now {0, 0, 1, 0, 0, 1}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator3：是 Input Iterator 的模型， InputIterator3 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
InputIterator4：是 Input Iterator 的模型， InputIterator4 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型

函数参数

exec：用于并行化的执行策略
keys_first1：第一个键输入范围的起始
keys_last1：第一个键输入范围的末尾
keys_first2：第二个键输入范围的起始
keys_last2：第二个键输入范围的末尾
values_first1：第一个值输入范围的起始
values_first2：第二个值输入范围的起始
keys_result：键输出范围的起始
values_result：值输出范围的起始

前提条件

范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 应按照 operator< 进行排序
结果范围不应与任何一个输入范围重叠

返回值

p pair ，其中 p.first 是键输出范围的末尾， p.second 是值输出范围的末尾

另请参阅

set_union_by_key
set_intersection_by_key
set_difference_by_key
sort_by_key
is_sorted

2.1.7.26. thrust::set_symmetric_difference_by_key

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

set_symmetric_difference_by_key 执行集合的键值对称差运算。 set_difference_by_key ‍构造一个有序范围，是有序范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 的对称差集。与输入和输出键范围内的每个元素相关联的是一个值元素。关联的输入值范围不需要排序。

在最简单的情况下， set_symmetric_difference_by_key 执行以下集合运算：构造两个集合A - B和B - A的并集，其中A和B是两个输入范围。即，输出范围由属于 [keys_first1, keys_last1) 但不属于 [keys_first2, keys_last1) 的元素副本，和属于 [keys_first2, keys_last2) 但不属于 [keys_first1, keys_last1) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [keys_first1, keys_last1) 包含 m 个彼此等价的元素， [keys_first2, keys_last1) 包含 n 个彼此等价的元素，则 |m - n| 个这样的元素应被复制到输出范围：如果 m > n ，则复制 [keys_first1, keys_last1) ‍内最后 m - n 个元素；如果 m < n ，则复制 [keys_first2, keys_last2) 中最后 n - m 个元素。

每次将键元素从 [keys_first1, keys_last1) 或 [keys_first2, keys_last2) 复制到键输出范围时，将相应的值元素从相应的值输入范围（从 values_first1 或 values_first2 开始）复制到值输出范围。

此版本的 set_symmetric_difference_by_key 使用 operator< 比较键元素。

以下代码片段演示了如何使用 set_symmetric_difference_by_key 计算两组升序整数集合与其值的对称差集：

#include <thrust/set_operations.h>
...
int A_keys[6] = {0, 1, 2, 2, 4, 6, 7};
int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};

int B_keys[5] = {1, 1, 2, 5, 8};
int B_vals[5] = {1, 1, 1, 1, 1};

int keys_result[6];
int vals_result[6];

thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
// keys_result is now {0, 4, 5, 6, 7, 8}
// vals_result is now {0, 0, 1, 0, 0, 1}

模板参数

InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator3：是 Input Iterator 的模型， InputIterator3 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
InputIterator4：是 Input Iterator 的模型， InputIterator4 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型

函数参数

keys_first1：第一个键输入范围的起始
keys_last1：第一个键输入范围的末尾
keys_first2：第二个键输入范围的起始
keys_last2：第二个键输入范围的末尾
values_first1：第一个值输入范围的起始
values_first2：第二个值输入范围的起始
keys_result：键输出范围的起始
values_result：值输出范围的起始

前提条件

范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 应按照 operator< 进行排序
结果范围不应与任何一个输入范围重叠

返回值

p pair ，其中 p.first 是键输出范围的末尾， p.second 是值输出范围的末尾

另请参阅

set_union_by_key
set_intersection_by_key
set_difference_by_key
sort_by_key
is_sorted

2.1.7.27. thrust::set_symmetric_difference_by_key

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename InputIterator4,
  typename OutputIterator1,
  typename OutputIterator2,
  typename StrictWeakCompare>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
set_symmetric_difference_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,
  StrictWeakCompare comp);

set_symmetric_difference_by_key 执行集合的键值对称差运算。 set_difference_by_key ‍构造一个有序范围，是有序范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 的对称差集。与输入和输出键范围内的每个元素相关联的是一个值元素。关联的输入值范围不需要排序。

在最简单的情况下， set_symmetric_difference_by_key 执行以下集合运算：构造两个集合A - B和B - A的并集，其中A和B是两个输入范围。即，输出范围由属于 [keys_first1, keys_last1) 但不属于 [keys_first2, keys_last1) 的元素副本，和属于 [keys_first2, keys_last2) 但不属于 [keys_first1, keys_last1) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [keys_first1, keys_last1) 包含 m 个彼此等价的元素， [keys_first2, keys_last1) 包含 n 个彼此等价的元素，则 |m - n| 个这样的元素应被复制到输出范围：如果 m > n ，则复制 [keys_first1, keys_last1) ‍内最后 m - n 个元素；如果 m < n ，则复制 [keys_first2, keys_last2) 中最后 n - m 个元素。

每次将键元素从 [keys_first1, keys_last1) 或 [keys_first2, keys_last2) 复制到键输出范围时，将相应的值元素从相应的值输入范围（从 values_first1 或 values_first2 开始）复制到值输出范围。

此版本的 set_symmetric_difference_by_key 使用函数对象 comp 比较键元素。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 set_symmetric_difference_by_key 计算两组降序整数集合与其值的对称差集：

#include <thrust/set_operations.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
int A_keys[6] = {7, 6, 4, 2, 2, 1, 0};
int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};

int B_keys[5] = {8, 5, 2, 1, 1};
int B_vals[5] = {1, 1, 1, 1, 1};

int keys_result[6];
int vals_result[6];

thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
// keys_result is now {8, 7, 6, 5, 4, 0}
// vals_result is now {1, 0, 0, 1, 0, 0}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator3：是 Input Iterator 的模型， InputIterator3 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
InputIterator4：是 Input Iterator 的模型， InputIterator4 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型
StrictWeakCompare：是 Strict Weak Ordering 的模型

函数参数

exec：用于并行化的执行策略
keys_first1：第一个键输入范围的起始
keys_last1：第一个键输入范围的末尾
keys_first2：第二个键输入范围的起始
keys_last2：第二个键输入范围的末尾
values_first1：第一个值输入范围的起始
values_first2：第二个值输入范围的起始
keys_result：键输出范围的起始
values_result：值输出范围的起始
comp：比较运算符

前提条件

范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 应按照 comp 进行排序
结果范围不应与任何一个输入范围重叠

返回值

p pair ，其中 p.first 是键输出范围的末尾， p.second 是值输出范围的末尾

另请参阅

set_union_by_key
set_intersection_by_key
set_difference_by_key
sort_by_key
is_sorted

2.1.7.28. thrust::set_symmetric_difference_by_key

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

set_symmetric_difference_by_key 执行集合的键值对称差运算。 set_difference_by_key ‍构造一个有序范围，是有序范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 的对称差集。与输入和输出键范围内的每个元素相关联的是一个值元素。关联的输入值范围不需要排序。

在最简单的情况下， set_symmetric_difference_by_key 执行以下集合运算：构造两个集合A - B和B - A的并集，其中A和B是两个输入范围。即，输出范围由属于 [keys_first1, keys_last1) 但不属于 [keys_first2, keys_last1) 的元素副本，和属于 [keys_first2, keys_last2) 但不属于 [keys_first1, keys_last1) 的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [keys_first1, keys_last1) 包含 m 个彼此等价的元素， [keys_first2, keys_last1) 包含 n 个彼此等价的元素，则 |m - n| 个这样的元素应被复制到输出范围：如果 m > n ，则复制 [keys_first1, keys_last1) ‍内最后 m - n 个元素；如果 m < n ，则复制 [keys_first2, keys_last2) 中最后 n - m 个元素。

每次将键元素从 [keys_first1, keys_last1) 或 [keys_first2, keys_last2) 复制到键输出范围时，将相应的值元素从相应的值输入范围（从 values_first1 或 values_first2 开始）复制到值输出范围。

此版本的 set_symmetric_difference_by_key 使用函数对象 comp 比较键元素。

以下代码片段演示了如何使用 set_symmetric_difference_by_key 计算两组降序整数集合与其值的对称差集：

#include <thrust/set_operations.h>
#include <thrust/functional.h>
...
int A_keys[6] = {7, 6, 4, 2, 2, 1, 0};
int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};

int B_keys[5] = {8, 5, 2, 1, 1};
int B_vals[5] = {1, 1, 1, 1, 1};

int keys_result[6];
int vals_result[6];

thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
// keys_result is now {8, 7, 6, 5, 4, 0}
// vals_result is now {1, 0, 0, 1, 0, 0}

模板参数

InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator3：是 Input Iterator 的模型， InputIterator3 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
InputIterator4：是 Input Iterator 的模型， InputIterator4 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型
StrictWeakCompare：是 Strict Weak Ordering 的模型

函数参数

keys_first1：第一个键输入范围的起始
keys_last1：第一个键输入范围的末尾
keys_first2：第二个键输入范围的起始
keys_last2：第二个键输入范围的末尾
values_first1：第一个值输入范围的起始
values_first2：第二个值输入范围的起始
keys_result：键输出范围的起始
values_result：值输出范围的起始
comp：比较运算符

前提条件

范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 应按照 comp 进行排序
结果范围不应与任何一个输入范围重叠

返回值

p pair ，其中 p.first 是键输出范围的末尾， p.second 是值输出范围的末尾

另请参阅

set_union_by_key
set_intersection_by_key
set_difference_by_key
sort_by_key
is_sorted

2.1.7.29. thrust::set_union_by_key

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename InputIterator4,
  typename OutputIterator1,
  typename OutputIterator2>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
set_union_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);

set_union_by_key 执行集合的键值并运算。 set_union_by_key ‍构造一个有序范围，是有序范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 的并集。与输入和输出键范围内的每个元素相关联的是一个值元素。关联的输入值范围不需要排序。

在最简单的情况下， set_union_by_key ‍执行集合的并运算：输出范围由属于 [keys_first2, keys_last1) 或 [keys_first1, keys_last1)，或者属于两者的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [keys_first1, keys_last1) 包含 m 个彼此等价的元素， [keys_first2, keys_last2) 包含 n 个彼此等价的元素，则第一个范围内的所有 m 个元素都应按顺序复制到输出范围，第二个范围内的 max(n - m, 0) 个元素应按顺序复制到输出范围。

每次将键元素从 [keys_first1, keys_last1) 或 [keys_first2, keys_last2) 复制到键输出范围时，将相应的值元素从相应的值输入范围（从 values_first1 或 values_first2 开始）复制到值输出范围。

此版本的 set_union_by_key 使用 operator< 比较键元素。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 set_symmetric_difference_by_key 计算两组升序整数集合与其值的对称差集：

#include <thrust/set_operations.h>
#include <thrust/execution_policy.h>
...
int A_keys[6] = {0, 2, 4, 6, 8, 10, 12};
int A_vals[6] = {0, 0, 0, 0, 0,  0,  0};

int B_keys[5] = {1, 3, 5, 7, 9};
int B_vals[5] = {1, 1, 1, 1, 1};

int keys_result[11];
int vals_result[11];

thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
// keys_result is now {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12}
// vals_result is now {0, 1, 0, 1, 0, 1, 0, 1, 0, 1,  0,  0}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator3：是 Input Iterator 的模型， InputIterator3 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
InputIterator4：是 Input Iterator 的模型， InputIterator4 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型

函数参数

exec：用于并行化的执行策略
keys_first1：第一个键输入范围的起始
keys_last1：第一个键输入范围的末尾
keys_first2：第二个键输入范围的起始
keys_last2：第二个键输入范围的末尾
values_first1：第一个值输入范围的起始
values_first2：第二个值输入范围的起始
keys_result：键输出范围的起始
values_result：值输出范围的起始

前提条件

范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 应按照 operator< 进行排序
结果范围不应与任何一个输入范围重叠

返回值

p pair ，其中 p.first 是键输出范围的末尾， p.second 是值输出范围的末尾

另请参阅

set_symmetric_difference_by_key
set_intersection_by_key
set_difference_by_key
sort_by_key
is_sorted

2.1.7.30. thrust::set_union_by_key

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

set_union_by_key 执行集合的键值并运算。 set_union_by_key ‍构造一个有序范围，是有序范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 的并集。与输入和输出键范围内的每个元素相关联的是一个值元素。关联的输入值范围不需要排序。

在最简单的情况下， set_union_by_key ‍执行集合的并运算：输出范围由属于 [keys_first2, keys_last1) 或 [keys_first1, keys_last1)，或者属于两者的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [keys_first1, keys_last1) 包含 m 个彼此等价的元素， [keys_first2, keys_last2) 包含 n 个彼此等价的元素，则第一个范围内的所有 m 个元素都应按顺序复制到输出范围，第二个范围内的 max(n - m, 0) 个元素应按顺序复制到输出范围。

每次将键元素从 [keys_first1, keys_last1) 或 [keys_first2, keys_last2) 复制到键输出范围时，将相应的值元素从相应的值输入范围（从 values_first1 或 values_first2 开始）复制到值输出范围。

此版本的 set_union_by_key 使用 operator< 比较键元素。

以下代码片段演示了如何使用 set_symmetric_difference_by_key 计算两组升序整数集合与其值的对称差集：

#include <thrust/set_operations.h>
...
int A_keys[6] = {0, 2, 4, 6, 8, 10, 12};
int A_vals[6] = {0, 0, 0, 0, 0,  0,  0};

int B_keys[5] = {1, 3, 5, 7, 9};
int B_vals[5] = {1, 1, 1, 1, 1};

int keys_result[11];
int vals_result[11];

thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
// keys_result is now {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12}
// vals_result is now {0, 1, 0, 1, 0, 1, 0, 1, 0, 1,  0,  0}

模板参数

InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator3：是 Input Iterator 的模型， InputIterator3 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
InputIterator4：是 Input Iterator 的模型， InputIterator4 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型

函数参数

keys_first1：第一个键输入范围的起始
keys_last1：第一个键输入范围的末尾
keys_first2：第二个键输入范围的起始
keys_last2：第二个键输入范围的末尾
values_first1：第一个值输入范围的起始
values_first2：第二个值输入范围的起始
keys_result：键输出范围的起始
values_result：值输出范围的起始

前提条件

范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 应按照 operator< 进行排序
结果范围不应与任何一个输入范围重叠

返回值

p pair ，其中 p.first 是键输出范围的末尾， p.second 是值输出范围的末尾

另请参阅

set_symmetric_difference_by_key
set_intersection_by_key
set_difference_by_key
sort_by_key
is_sorted

2.1.7.31. thrust::set_union_by_key

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename InputIterator4,
  typename OutputIterator1,
  typename OutputIterator2,
  typename StrictWeakCompare>
__host__ __device__ thrust::pair< OutputIterator1, OutputIterator2 >
set_union_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,
  StrictWeakCompare comp);

set_union_by_key 执行集合的键值并运算。 set_union_by_key ‍构造一个有序范围，是有序范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 的并集。与输入和输出键范围内的每个元素相关联的是一个值元素。关联的输入值范围不需要排序。

在最简单的情况下， set_union_by_key ‍执行集合的并运算：输出范围由属于 [keys_first2, keys_last1) 或 [keys_first1, keys_last1)，或者属于两者的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [keys_first1, keys_last1) 包含 m 个彼此等价的元素， [keys_first2, keys_last2) 包含 n 个彼此等价的元素，则第一个范围内的所有 m 个元素都应按顺序复制到输出范围，第二个范围内的 max(n - m, 0) 个元素应按顺序复制到输出范围。

每次将键元素从 [keys_first1, keys_last1) 或 [keys_first2, keys_last2) 复制到键输出范围时，将相应的值元素从相应的值输入范围（从 values_first1 或 values_first2 开始）复制到值输出范围。

此版本的 set_union_by_key 使用函数对象 comp 比较键元素。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 set_symmetric_difference_by_key 计算两组降序整数集合与其值的对称差集：

#include <thrust/set_operations.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
int A_keys[6] = {12, 10, 8, 6, 4, 2, 0};
int A_vals[6] = { 0,  0, 0, 0, 0, 0, 0};

int B_keys[5] = {9, 7, 5, 3, 1};
int B_vals[5] = {1, 1, 1, 1, 1};

int keys_result[11];
int vals_result[11];

thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result, thrust::greater<int>());
// keys_result is now {12, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
// vals_result is now { 0,  1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0}

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator3：是 Input Iterator 的模型， InputIterator3 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
InputIterator4：是 Input Iterator 的模型， InputIterator4 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型
StrictWeakCompare：是 Strict Weak Ordering 的模型

函数参数

exec：用于并行化的执行策略
keys_first1：第一个键输入范围的起始
keys_last1：第一个键输入范围的末尾
keys_first2：第二个键输入范围的起始
keys_last2：第二个键输入范围的末尾
values_first1：第一个值输入范围的起始
values_first2：第二个值输入范围的起始
keys_result：键输出范围的起始
values_result：值输出范围的起始
comp：比较运算符

前提条件

范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 应按照 comp 进行排序
结果范围不应与任何一个输入范围重叠

返回值

p pair ，其中 p.first 是键输出范围的末尾， p.second 是值输出范围的末尾

另请参阅

set_symmetric_difference_by_key
set_intersection_by_key
set_difference_by_key
sort_by_key
is_sorted

2.1.7.32. thrust::set_union_by_key

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

set_union_by_key 执行集合的键值并运算。 set_union_by_key ‍构造一个有序范围，是有序范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 的并集。与输入和输出键范围内的每个元素相关联的是一个值元素。关联的输入值范围不需要排序。

在最简单的情况下， set_union_by_key ‍执行集合的并运算：输出范围由属于 [keys_first2, keys_last1) 或 [keys_first1, keys_last1)，或者属于两者的元素副本组成。一般情况更为复杂，因为输入范围内可能包含重复元素。总而言之，如果 [keys_first1, keys_last1) 包含 m 个彼此等价的元素， [keys_first2, keys_last2) 包含 n 个彼此等价的元素，则第一个范围内的所有 m 个元素都应按顺序复制到输出范围，第二个范围内的 max(n - m, 0) 个元素应按顺序复制到输出范围。

每次将键元素从 [keys_first1, keys_last1) 或 [keys_first2, keys_last2) 复制到键输出范围时，将相应的值元素从相应的值输入范围（从 values_first1 或 values_first2 开始）复制到值输出范围。

此版本的 set_union_by_key 使用函数对象 comp 比较键元素。

以下代码片段演示了如何使用 set_symmetric_difference_by_key 计算两组降序整数集合与其值的对称差集：

#include <thrust/set_operations.h>
#include <thrust/functional.h>
...
int A_keys[6] = {12, 10, 8, 6, 4, 2, 0};
int A_vals[6] = { 0,  0, 0, 0, 0, 0, 0};

int B_keys[5] = {9, 7, 5, 3, 1};
int B_vals[5] = {1, 1, 1, 1, 1};

int keys_result[11];
int vals_result[11];

thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result, thrust::greater<int>());
// keys_result is now {12, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
// vals_result is now { 0,  1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0}

模板参数

InputIterator1：是 Input Iterator 的模型。 InputIterator1 和 InputIterator2 具有相同的 value_type ， InputIterator1 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator1 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator2：是 Input Iterator 的模型。 InputIterator2 和 InputIterator1 具有相同的 value_type ， InputIterator2 的 value_type 是 LessThan Comparable 的模型，如 LessThan Comparable 要求中定义的， InputIterator2 的 value_type 上的排序是严格弱序，并且可转换为 OutputIterator 的 value_types 集合中的类型
InputIterator3：是 Input Iterator 的模型， InputIterator3 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
InputIterator4：是 Input Iterator 的模型， InputIterator4 的 value_type 可转换为 OutputIterator2 的 value_types 集合中的类型
OutputIterator1：是 Output Iterator 的模型
OutputIterator2：是 Output Iterator 的模型
StrictWeakCompare：是 Strict Weak Ordering 的模型

函数参数

keys_first1：第一个键输入范围的起始
keys_last1：第一个键输入范围的末尾
keys_first2：第二个键输入范围的起始
keys_last2：第二个键输入范围的末尾
values_first1：第一个值输入范围的起始
values_first2：第二个值输入范围的起始
keys_result：键输出范围的起始
values_result：值输出范围的起始
comp：比较运算符

前提条件

范围 [keys_first1, keys_last1) 和 [keys_first2, keys_last2) 应按照 comp 进行排序
结果范围不应与任何一个输入范围重叠

返回值

p pair ，其中 p.first 是键输出范围的末尾， p.second 是值输出范围的末尾

另请参阅

set_symmetric_difference_by_key
set_intersection_by_key
set_difference_by_key
sort_by_key
is_sorted

2.1.8. 排序（Sorting）

函数

template <typename DerivedPolicy,
  typename RandomAccessIterator>
__host__ __device__ void
thrust::sort(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  RandomAccessIterator first,
  RandomAccessIterator last);

template <typename RandomAccessIterator>
void
thrust::sort(RandomAccessIterator first,
  RandomAccessIterator last);

template <typename DerivedPolicy,
  typename RandomAccessIterator,
  typename StrictWeakOrdering>
__host__ __device__ void
thrust::sort(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  RandomAccessIterator first,
  RandomAccessIterator last,
  StrictWeakOrdering comp);

template <typename RandomAccessIterator,
  typename StrictWeakOrdering>
__host__ __device__ void
thrust::sort(RandomAccessIterator first,
  RandomAccessIterator last,
  StrictWeakOrdering comp);

template <typename DerivedPolicy,
  typename RandomAccessIterator>
__host__ __device__ void
thrust::stable_sort(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  RandomAccessIterator first,
  RandomAccessIterator last);

template <typename RandomAccessIterator>
void
thrust::stable_sort(RandomAccessIterator first,
  RandomAccessIterator last);

template <typename DerivedPolicy,
  typename RandomAccessIterator,
  typename StrictWeakOrdering>
__host__ __device__ void
thrust::stable_sort(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  RandomAccessIterator first,
  RandomAccessIterator last,
  StrictWeakOrdering comp);

template <typename RandomAccessIterator,
  typename StrictWeakOrdering>
void
thrust::stable_sort(RandomAccessIterator first,
  RandomAccessIterator last,
  StrictWeakOrdering comp);

template <typename DerivedPolicy,
  typename RandomAccessIterator1,
  typename RandomAccessIterator2>
__host__ __device__ void
thrust::sort_by_key(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  RandomAccessIterator1 keys_first,
  RandomAccessIterator1 keys_last,
  RandomAccessIterator2 values_first);

template <typename RandomAccessIterator1,
  typename RandomAccessIterator2>
void
thrust::sort_by_key(RandomAccessIterator1 keys_first,
  RandomAccessIterator1 keys_last,
  RandomAccessIterator2 values_first);

template <typename DerivedPolicy,
  typename RandomAccessIterator1,
  typename RandomAccessIterator2,
  typename StrictWeakOrdering>
__host__ __device__ void
thrust::sort_by_key(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  RandomAccessIterator1 keys_first,
  RandomAccessIterator1 keys_last,
  RandomAccessIterator2 values_first,
  StrictWeakOrdering comp);

template <typename RandomAccessIterator1,
  typename RandomAccessIterator2,
  typename StrictWeakOrdering>
void
thrust::sort_by_key(RandomAccessIterator1 keys_first,
  RandomAccessIterator1 keys_last,
  RandomAccessIterator2 values_first,
  StrictWeakOrdering comp);

template <typename DerivedPolicy,
  typename RandomAccessIterator1,
  typename RandomAccessIterator2>
__host__ __device__ void
thrust::stable_sort_by_key(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  RandomAccessIterator1 keys_first,
  RandomAccessIterator1 keys_last,
  RandomAccessIterator2 values_first);

template <typename RandomAccessIterator1,
  typename RandomAccessIterator2>
void
thrust::stable_sort_by_key(RandomAccessIterator1 keys_first,
 RandomAccessIterator1 keys_last,
  RandomAccessIterator2 values_first);

template <typename DerivedPolicy,
  typename RandomAccessIterator1,
  typename RandomAccessIterator2,
  typename StrictWeakOrdering>
__host__ __device__ void
thrust::stable_sort_by_key(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  RandomAccessIterator1 keys_first,
  RandomAccessIterator1 keys_last,
  RandomAccessIterator2 values_first,
  StrictWeakOrdering comp);

template <typename RandomAccessIterator1,
  typename RandomAccessIterator2,
  typename StrictWeakOrdering>
void
thrust::stable_sort_by_key(RandomAccessIterator1 keys_first,
  RandomAccessIterator1 keys_last,
  RandomAccessIterator2 values_first,
  StrictWeakOrdering comp);

2.1.8.1. thrust::sort

template <typename DerivedPolicy,
  typename RandomAccessIterator>
__host__ __device__ void
sort(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  RandomAccessIterator first,
  RandomAccessIterator last);

sort 按升序对 [first, last) ‍内的元素进行排序，指的是如果 i 和 j 是 [first, last) ‍内任意满足 i 先于 j ‍的两个有效迭代器，那么 *j 不小于 *i。

不能保证 sort 是稳定的。即，假设 *i 和 *j 是等价的（两者都不小于另一个），不能保证 sort 会保留这两个元素的相对顺序。

此版本的 sort 使用 operator< 比较对象。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 sort 对整数序列进行排序：

#include <thrust/sort.h>
#include <thrust/execution_policy.h>
...
const int N = 6;
int A[N] = {1, 4, 2, 8, 5, 7};
thrust::sort(thrust::host, A, A + N);
// A is now {1, 2, 4, 5, 7, 8}

模板参数

DerivedPolicy：派生执行策略的名称
RandomAccessIterator：是 Random Access Iterator 的模型， RandomAccessIterator 是可变的。 RandomAccessIterator 的 value_type 是 LessThan Comparable 的模型，如在 LessThan Comparable 要求中定义的， RandomAccessIterator 的 value_type 上的排序是 严格弱序

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/sort
stable_sort
sort_by_key

2.1.8.2. thrust::sort

template <typename RandomAccessIterator>
void
sort(RandomAccessIterator first,
  RandomAccessIterator last);

sort 按升序对 [first, last) ‍内的元素进行排序，指的是如果 i 和 j 是 [first, last) ‍内任意满足 i 先于 j ‍的两个有效迭代器，那么 *j 不小于 *i。

不能保证 sort 是稳定的。即，假设 *i 和 *j 是等价的（两者都不小于另一个），不能保证 sort 会保留这两个元素的相对顺序。

此版本的 sort 使用 operator< 比较对象。

以下代码片段演示了如何使用 sort 对整数序列进行排序：

#include <thrust/sort.h>
...
const int N = 6;
int A[N] = {1, 4, 2, 8, 5, 7};
thrust::sort(A, A + N);
// A is now {1, 2, 4, 5, 7, 8}

模板参数

RandomAccessIterator：是 Random Access Iterator 的模型， RandomAccessIterator 是可变的。 RandomAccessIterator 的 value_type 是 LessThan Comparable 的模型，如在 LessThan Comparable 要求中定义的， RandomAccessIterator 的 value_type 上的排序是 严格弱序

函数参数

first：序列起始
last：序列末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/sort
stable_sort
sort_by_key

2.1.8.3. thrust::sort

template <typename DerivedPolicy,
  typename RandomAccessIterator,
  typename StrictWeakOrdering>
__host__ __device__ void
sort(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  RandomAccessIterator first,
  RandomAccessIterator last,
  StrictWeakOrdering comp);

sort 按升序对 [first, last) ‍内的元素进行排序，指的是如果 i 和 j 是 [first, last) ‍内任意满足 i 先于 j ‍的两个有效迭代器，那么 *j 不小于 *i。

不能保证 sort 是稳定的。即，假设 *i 和 *j 是等价的（两者都不小于另一个），不能保证 sort 会保留这两个元素的相对顺序。

此版本的 sort 使用函数对象 comp 比较对象。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用大于比较运算符按降序对整数进行排序：

#include <thrust/sort.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
const int N = 6;
int A[N] = {1, 4, 2, 8, 5, 7};
thrust::sort(thrust::host, A, A + N, thrust::greater<int>());
// A is now {8, 7, 5, 4, 2, 1};

模板参数

DerivedPolicy：派生执行策略的名称
RandomAccessIterator：是 Random Access Iterator 的模型， RandomAccessIterator`是可变的，并且 `RandomAccessIterator 的 value_type 可转换为 StrictWeakOrdering 的 first_argument_type 和 second_argument_type
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾
comp：比较运算符

另请参阅

https://en.cppreference.com/w/cpp/algorithm/sort
stable_sort
sort_by_key

2.1.8.4. thrust::sort

template <typename RandomAccessIterator,
  typename StrictWeakOrdering>
__host__ __device__ void
sort(RandomAccessIterator first,
  RandomAccessIterator last,
  StrictWeakOrdering comp);

sort 按升序对 [first, last) ‍内的元素进行排序，这意味着如果 i 和 j 是 [first, last) ‍内任意两个有效迭代器，其中 i 在 j 之前，那么 *j 不小于 *i。

不能保证 sort 是稳定的。即，假设 *i 和 *j 是等价的（两者都不小于另一个），不能保证 sort 会保留这两个元素的相对顺序。

此版本的 sort 使用函数对象 comp 比较对象。

以下代码片段演示了如何使用大于比较运算符按降序对整数进行排序：

#include <thrust/sort.h>
#include <thrust/functional.h>
...
const int N = 6;
int A[N] = {1, 4, 2, 8, 5, 7};
thrust::sort(A, A + N, thrust::greater<int>());
// A is now {8, 7, 5, 4, 2, 1};

模板参数

RandomAccessIterator：是 Random Access Iterator 的模型， RandomAccessIterator`是可变的，并且 `RandomAccessIterator 的 value_type 可转换为 StrictWeakOrdering 的 first_argument_type 和 second_argument_type
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

first：序列起始
last：序列末尾
comp：比较运算符

另请参阅

https://en.cppreference.com/w/cpp/algorithm/sort
stable_sort
sort_by_key

2.1.8.5. thrust::stable_sort

template <typename DerivedPolicy,
  typename RandomAccessIterator>
__host__ __device__ void
stable_sort(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  RandomAccessIterator first,
  RandomAccessIterator last);

stable_sort 很像 sort，按升序对 [first, last) ‍内的元素进行排序，指的是如果 i 和 j 是 [first, last) 内任意满足 i 先于 j 的两个有效迭代器，那么 *j 不小于 *i。

顾名思义， stable_sort 是稳定的：它保留了等价元素的相对顺序。即，如果 x 和 y 是 [first, last) 中的元素，满足 x ‍先于 y ，并且如果这两个元素是等价的（既不是 x < y 也不是 y < x），那么 stable_sort 的后置条件是 x 仍然先于 y。

此版本的 stable_sort 使用 operator< 比较对象。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 sort 对整数序列进行排序：

#include <thrust/sort.h>
#include <thrust/execution_policy.h>
...
const int N = 6;
int A[N] = {1, 4, 2, 8, 5, 7};
thrust::stable_sort(thrust::host, A, A + N);
// A is now {1, 2, 4, 5, 7, 8}

模板参数

DerivedPolicy：派生执行策略的名称
RandomAccessIterator：是 Random Access Iterator 的模型， RandomAccessIterator 是可变的。 RandomAccessIterator 的 value_type 是 LessThan Comparable 的模型，如在 LessThan Comparable 要求中定义的， RandomAccessIterator 的 value_type 上的排序是 严格弱序

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/stable_sort
sort
stable_sort_by_key

2.1.8.6. thrust::stable_sort

template <typename RandomAccessIterator>
void
stable_sort(RandomAccessIterator first,
  RandomAccessIterator last);

stable_sort 很像 sort，按升序对 [first, last) ‍内的元素进行排序，指的是如果 i 和 j 是 [first, last) 内任意满足 i 先于 j 的两个有效迭代器，那么 *j 不小于 *i。

顾名思义， stable_sort 是稳定的：它保留了等价元素的相对顺序。即，如果 x 和 y 是 [first, last) 中的元素，满足 x ‍先于 y ，并且如果这两个元素是等价的（既不是 x < y 也不是 y < x），那么 stable_sort 的后置条件是 x 仍然先于 y。

此版本的 stable_sort 使用 operator< 比较对象。

以下代码片段演示了如何使用 sort 对整数序列进行排序：

#include <thrust/sort.h>
...
const int N = 6;
int A[N] = {1, 4, 2, 8, 5, 7};
thrust::stable_sort(A, A + N);
// A is now {1, 2, 4, 5, 7, 8}

模板参数

RandomAccessIterator：是 Random Access Iterator 的模型， RandomAccessIterator 是可变的。 RandomAccessIterator 的 value_type 是 LessThan Comparable 的模型，如在 LessThan Comparable 要求中定义的， RandomAccessIterator 的 value_type 上的排序是 严格弱序

函数参数

first：序列起始
last：序列末尾

另请参阅

https://en.cppreference.com/w/cpp/algorithm/stable_sort
sort
stable_sort_by_key

2.1.8.7. thrust::stable_sort

template <typename DerivedPolicy,
  typename RandomAccessIterator,
  typename StrictWeakOrdering>
__host__ __device__ void
stable_sort(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  RandomAccessIterator first,
  RandomAccessIterator last,
  StrictWeakOrdering comp);

stable_sort 很像 sort，按升序对 [first, last) ‍内的元素进行排序，指的是如果 i 和 j 是 [first, last) 内任意满足 i 先于 j 的两个有效迭代器，那么 *j 不小于 *i。

顾名思义， stable_sort 是稳定的：它保留了等价元素的相对顺序。即，如果 x 和 y 是 [first, last) 中的元素，满足 x ‍先于 y ，并且如果这两个元素是等价的（既不是 x < y 也不是 y < x），那么 stable_sort 的后置条件是 x 仍然先于 y。

此版本的 stable_sort 使用函数对象 comp 比较对象。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用大于比较运算符按降序对整数进行排序：

#include <thrust/sort.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
const int N = 6;
int A[N] = {1, 4, 2, 8, 5, 7};
thrust::sort(A, A + N, thrust::greater<int>());
// A is now {8, 7, 5, 4, 2, 1};

模板参数

DerivedPolicy：派生执行策略的名称
RandomAccessIterator：是 Random Access Iterator 的模型， RandomAccessIterator`是可变的，并且 `RandomAccessIterator 的 value_type 可转换为 StrictWeakOrdering 的 first_argument_type 和 second_argument_type
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾
comp：比较运算符

另请参阅

https://en.cppreference.com/w/cpp/algorithm/stable_sort
sort
stable_sort_by_key

2.1.8.8. thrust::stable_sort

template <typename RandomAccessIterator,
  typename StrictWeakOrdering>
void
stable_sort(RandomAccessIterator first,
  RandomAccessIterator last,
  StrictWeakOrdering comp);

stable_sort 很像 sort，按升序对 [first, last) ‍内的元素进行排序，指的是如果 i 和 j 是 [first, last) 内任意满足 i 先于 j 的两个有效迭代器，那么 *j 不小于 *i。

顾名思义， stable_sort 是稳定的：它保留了等价元素的相对顺序。即，如果 x 和 y 是 [first, last) 中的元素，满足 x ‍先于 y ，并且如果这两个元素是等价的（既不是 x < y 也不是 y < x），那么 stable_sort 的后置条件是 x 仍然先于 y。

此版本的 stable_sort 使用函数对象 comp 比较对象。

以下代码片段演示了如何使用大于比较运算符按降序对整数进行排序：

#include <thrust/sort.h>
#include <thrust/functional.h>
...
const int N = 6;
int A[N] = {1, 4, 2, 8, 5, 7};
thrust::sort(A, A + N, thrust::greater<int>());
// A is now {8, 7, 5, 4, 2, 1};

模板参数

RandomAccessIterator：是 Random Access Iterator 的模型， RandomAccessIterator`是可变的，并且 `RandomAccessIterator 的 value_type 可转换为 StrictWeakOrdering 的 first_argument_type 和 second_argument_type
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

first：序列起始
last：序列末尾
comp：比较运算符

另请参阅

https://en.cppreference.com/w/cpp/algorithm/stable_sort
sort
stable_sort_by_key

2.1.8.9. thrust::sort_by_key

template <typename DerivedPolicy,
  typename RandomAccessIterator1,
  typename RandomAccessIterator2>
__host__ __device__ void
sort_by_key(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  RandomAccessIterator1 keys_first,
  RandomAccessIterator1 keys_last,
  RandomAccessIterator2 values_first);

sort_by_key 执行键值排序。即， sort_by_key 将 [keys_first, keys_last) 和 [values_first, values_first + (keys_last - keys_first)) ‍内的元素按升序排序，指的是如果 i 和 j 是 [keys_first, keys_last) ‍内任意两个有效迭代器，其中 i 在 j 之前，且 p 和 q 是 [values_first, values_first + (keys_last - keys_first)) ‍内 i 和 j 分别对应的迭代器，则 *j 不小于 *i。

不能保证 sort_by_key 是稳定的。即，假设 *i 和 *j 是等价的（两者都不小于另一个），不能保证 sort_by_key 会保留这两个键的相对顺序或它们对应值的相对顺序。

此版本的 sort_by_key 使用 operator< 比较键对象。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 sort_by_key 以整数作为排序键对字符值数组进行排序：

#include <thrust/sort.h>
#include <thrust/execution_policy.h>
...
const int N = 6;
int    keys[N] = {  1,   4,   2,   8,   5,   7};
char values[N] = {'a', 'b', 'c', 'd', 'e', 'f'};
thrust::sort_by_key(thrust::host, keys, keys + N, values);
// keys is now   {  1,   2,   4,   5,   7,   8}
// values is now {'a', 'c', 'b', 'e', 'f', 'd'}

模板参数

DerivedPolicy：派生执行策略的名称
RandomAccessIterator1：是 Random Access Iterator 的模型， RandomAccessIterator1 是可变的。 RandomAccessIterator1 的 value_type 是 LessThan Comparable 的模型，如在 LessThan Comparable 要求中定义的， RandomAccessIterator1 的 value_type 上的排序是 严格弱序
RandomAccessIterator2：是 Random Access Iterator 的模型，且 RandomAccessIterator2 是可变的

函数参数

exec：用于并行化的执行策略
keys_first：键序列的起始
keys_last：键序列的末尾
values_first：值序列的起始

前提条件

范围 [keys_first, keys_last)) 不应与范围 [values_first, values_first + (keys_last - keys_first)) 重叠

另请参阅

https://en.cppreference.com/w/cpp/algorithm/sort
stable_sort_by_key
sort

2.1.8.10. thrust::sort_by_key

template <typename RandomAccessIterator1,
  typename RandomAccessIterator2>
void
sort_by_key(RandomAccessIterator1 keys_first,
  RandomAccessIterator1 keys_last,
  RandomAccessIterator2 values_first);

sort_by_key 执行键值排序。即， sort_by_key 将 [keys_first, keys_last) 和 [values_first, values_first + (keys_last - keys_first)) ‍内的元素按升序排序，指的是如果 i 和 j 是 [keys_first, keys_last) ‍内任意两个有效迭代器，其中 i 在 j 之前，且 p 和 q 是 [values_first, values_first + (keys_last - keys_first)) ‍内 i 和 j 分别对应的迭代器，则 *j 不小于 *i。

不能保证 sort_by_key 是稳定的。即，假设 *i 和 *j 是等价的（两者都不小于另一个），不能保证 sort_by_key 会保留这两个键的相对顺序或它们对应值的相对顺序。

此版本的 sort_by_key 使用 operator< 比较键对象。

以下代码片段演示了如何使用 sort_by_key 以整数作为排序键对字符值数组进行排序：

#include <thrust/sort.h>
...
const int N = 6;
int    keys[N] = {  1,   4,   2,   8,   5,   7};
char values[N] = {'a', 'b', 'c', 'd', 'e', 'f'};
thrust::sort_by_key(keys, keys + N, values);
// keys is now   {  1,   2,   4,   5,   7,   8}
// values is now {'a', 'c', 'b', 'e', 'f', 'd'}

模板参数

RandomAccessIterator1：是 Random Access Iterator 的模型， RandomAccessIterator1 是可变的。 RandomAccessIterator1 的 value_type 是 LessThan Comparable 的模型，如在 LessThan Comparable 要求中定义的， RandomAccessIterator1 的 value_type 上的排序是 严格弱序
RandomAccessIterator2：是 Random Access Iterator 的模型，且 RandomAccessIterator2 是可变的

函数参数

keys_first：键序列的起始
keys_last：键序列的末尾
values_first：值序列的起始

前提条件

范围 [keys_first, keys_last)) 不应与范围 [values_first, values_first + (keys_last - keys_first)) 重叠

另请参阅

https://en.cppreference.com/w/cpp/algorithm/sort
stable_sort_by_key
sort

2.1.8.11. thrust::sort_by_key

template <typename DerivedPolicy,
  typename RandomAccessIterator1,
  typename RandomAccessIterator2,
  typename StrictWeakOrdering>
__host__ __device__ void
sort_by_key(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  RandomAccessIterator1 keys_first,
  RandomAccessIterator1 keys_last,
  RandomAccessIterator2 values_first,
  StrictWeakOrdering comp);

sort_by_key 执行键值排序。即， sort_by_key 将 [keys_first, keys_last) 和 [values_first, values_first + (keys_last - keys_first)) ‍内的元素按升序排序，指的是如果 i 和 j 是 [keys_first, keys_last) ‍内任意两个有效迭代器，其中 i 在 j 之前，且 p 和 q 是 [values_first, values_first + (keys_last - keys_first)) ‍内 i 和 j 分别对应的迭代器，则 *j 不小于 *i。

不能保证 sort_by_key 是稳定的。即，假设 *i 和 *j 是等价的（两者都不小于另一个），不能保证 sort_by_key 会保留这两个键的相对顺序或它们对应值的相对顺序。

此版本的 sort_by_key 使用函数对象 comp 比较键对象。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 sort_by_key 以整数作为排序键对字符值数组进行排序，并使用 greater<int> 比较运算符按降序对键进行排序：

#include <thrust/sort.h>
#include <thrust/execution_policy.h>
...
const int N = 6;
int    keys[N] = {  1,   4,   2,   8,   5,   7};
char values[N] = {'a', 'b', 'c', 'd', 'e', 'f'};
thrust::sort_by_key(thrust::host, keys, keys + N, values, thrust::greater<int>());
// keys is now   {  8,   7,   5,   4,   2,   1}
// values is now {'d', 'f', 'e', 'b', 'c', 'a'}

模板参数

DerivedPolicy：派生执行策略的名称
RandomAccessIterator1：是 Random Access Iterator 的模型， RandomAccessIterator1 是可变的，并且 RandomAccessIterator1 的 value_type 可转换为 StrictWeakOrdering 的 first_argument_type 和 second_argument_type
RandomAccessIterator2：是 Random Access Iterator 的模型，且 RandomAccessIterator2 是可变的
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

exec：用于并行化的执行策略
keys_first：键序列的起始
keys_last：键序列的末尾
values_first：值序列的起始
comp：比较运算符

前提条件

范围 [keys_first, keys_last)) 不应与范围 [values_first, values_first + (keys_last - keys_first)) 重叠

另请参阅

https://en.cppreference.com/w/cpp/algorithm/sort
stable_sort_by_key
sort

2.1.8.12. thrust::sort_by_key

template <typename RandomAccessIterator1,
  typename RandomAccessIterator2,
  typename StrictWeakOrdering>
void
sort_by_key(RandomAccessIterator1 keys_first,
  RandomAccessIterator1 keys_last,
  RandomAccessIterator2 values_first,
  StrictWeakOrdering comp);

sort_by_key 执行键值排序。即， sort_by_key 将 [keys_first, keys_last) 和 [values_first, values_first + (keys_last - keys_first)) ‍内的元素按升序排序，指的是如果 i 和 j 是 [keys_first, keys_last) ‍内任意两个有效迭代器，其中 i 在 j 之前，且 p 和 q 是 [values_first, values_first + (keys_last - keys_first)) ‍内 i 和 j 分别对应的迭代器，则 *j 不小于 *i。

不能保证 sort_by_key 是稳定的。即，假设 *i 和 *j 是等价的（两者都不小于另一个），不能保证 sort_by_key 会保留这两个键的相对顺序或它们对应值的相对顺序。

此版本的 sort_by_key 使用函数对象 comp 比较键对象。

以下代码片段演示了如何使用 sort_by_key 以整数作为排序键对字符值数组进行排序，使用大于比较运算符按降序对键进行排序：

#include <thrust/sort.h>
...
const int N = 6;
int    keys[N] = {  1,   4,   2,   8,   5,   7};
char values[N] = {'a', 'b', 'c', 'd', 'e', 'f'};
thrust::sort_by_key(keys, keys + N, values, thrust::greater<int>());
// keys is now   {  8,   7,   5,   4,   2,   1}
// values is now {'d', 'f', 'e', 'b', 'c', 'a'}

模板参数

RandomAccessIterator1：是 Random Access Iterator 的模型， RandomAccessIterator1 是可变的，并且 RandomAccessIterator1 的 value_type 可转换为 StrictWeakOrdering 的 first_argument_type 和 second_argument_type
RandomAccessIterator2：是 Random Access Iterator 的模型，且 RandomAccessIterator2 是可变的
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

keys_first：键序列的起始
keys_last：键序列的末尾
values_first：值序列的起始
comp：比较运算符

前提条件

范围 [keys_first, keys_last)) 不应与范围 [values_first, values_first + (keys_last - keys_first)) 重叠

另请参阅

https://en.cppreference.com/w/cpp/algorithm/sort
stable_sort_by_key
sort

2.1.8.13. thrust::stable_sort_by_key

template <typename DerivedPolicy,
  typename RandomAccessIterator1,
  typename RandomAccessIterator2>
__host__ __device__ void
stable_sort_by_key(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  RandomAccessIterator1 keys_first,
  RandomAccessIterator1 keys_last,
  RandomAccessIterator2 values_first);

stable_sort_by_key 执行键值排序。即， stable_sort_by_key 将 [keys_first, keys_last) 和 [values_first, values_first + (keys_last - keys_first)) ‍内的元素按升序排序，指的是如果 i 和 j 是 [keys_first, keys_last) ‍内任意两个有效迭代器，其中 i 在 j 之前，且 p 和 q 是 [values_first, values_first + (keys_last - keys_first)) ‍内 i 和 j 分别对应的迭代器，则 *j 不小于 *i。

顾名思义， stable_sort_by_key 是稳定的：它保留了等价元素的相对顺序。即，如果 x 和 y 是 [keys_first, keys_last) 中的元素，满足 x ‍先于 y ，并且如果这两个元素是等价的（既不是 x < y 也不是 y < x），那么 stable_sort_by_key 的后置条件是 x 仍然先于 y。

此版本的 stable_sort_by_key 使用 operator< 比较键对象。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 stable_sort_by_key 以整数作为排序键对字符数组进行排序：

#include <thrust/sort.h>
#include <thrust/execution_policy.h>
...
const int N = 6;
int    keys[N] = {  1,   4,   2,   8,   5,   7};
char values[N] = {'a', 'b', 'c', 'd', 'e', 'f'};
thrust::stable_sort_by_key(thrust::host, keys, keys + N, values);
// keys is now   {  1,   2,   4,   5,   7,   8}
// values is now {'a', 'c', 'b', 'e', 'f', 'd'}

模板参数

DerivedPolicy：派生执行策略的名称
RandomAccessIterator1：是 Random Access Iterator 的模型， RandomAccessIterator1 是可变的。 RandomAccessIterator1 的 value_type 是 LessThan Comparable 的模型，如在 LessThan Comparable 要求中定义的， RandomAccessIterator1 的 value_type 上的排序是 严格弱序
RandomAccessIterator2：是 Random Access Iterator 的模型，且 RandomAccessIterator2 是可变的

函数参数

exec：用于并行化的执行策略
keys_first：键序列的起始
keys_last：键序列的末尾
values_first：值序列的起始

前提条件

范围 [keys_first, keys_last)) 不应与范围 [values_first, values_first + (keys_last - keys_first)) 重叠

另请参阅

https://en.cppreference.com/w/cpp/algorithm/sort
sort_by_key
stable_sort

2.1.8.14. thrust::stable_sort_by_key

template <typename RandomAccessIterator1,
  typename RandomAccessIterator2>
void
stable_sort_by_key(RandomAccessIterator1 keys_first,
  RandomAccessIterator1 keys_last,
  RandomAccessIterator2 values_first);

stable_sort_by_key 执行键值排序。即， stable_sort_by_key 将 [keys_first, keys_last) 和 [values_first, values_first + (keys_last - keys_first)) ‍内的元素按升序排序，指的是如果 i 和 j 是 [keys_first, keys_last) ‍内任意两个有效迭代器，其中 i 在 j 之前，且 p 和 q 是 [values_first, values_first + (keys_last - keys_first)) ‍内 i 和 j 分别对应的迭代器，则 *j 不小于 *i。

顾名思义， stable_sort_by_key 是稳定的：它保留了等价元素的相对顺序。即，如果 x 和 y 是 [keys_first, keys_last) 中的元素，满足 x ‍先于 y ，并且如果这两个元素是等价的（既不是 x < y 也不是 y < x），那么 stable_sort_by_key 的后置条件是 x 仍然先于 y。

此版本的 stable_sort_by_key 使用 operator< 比较键对象。以下代码片段演示了如何使用 stable_sort_by_key 以整数作为排序键对字符数组进行排序：

#include <thrust/sort.h>
...
const int N = 6;
int    keys[N] = {  1,   4,   2,   8,   5,   7};
char values[N] = {'a', 'b', 'c', 'd', 'e', 'f'};
thrust::stable_sort_by_key(keys, keys + N, values);
// keys is now   {  1,   2,   4,   5,   7,   8}
// values is now {'a', 'c', 'b', 'e', 'f', 'd'}

模板参数

RandomAccessIterator1：是 Random Access Iterator 的模型， RandomAccessIterator1 是可变的。 RandomAccessIterator1 的 value_type 是 LessThan Comparable 的模型，如在 LessThan Comparable 要求中定义的， RandomAccessIterator1 的 value_type 上的排序是 严格弱序
RandomAccessIterator2：是 Random Access Iterator 的模型，且 RandomAccessIterator2 是可变的

函数参数

keys_first：键序列的起始
keys_last：键序列的末尾
values_first：值序列的起始

前提条件

范围 [keys_first, keys_last)) 不应与范围 [values_first, values_first + (keys_last - keys_first)) 重叠

另请参阅

https://en.cppreference.com/w/cpp/algorithm/sort
sort_by_key
stable_sort

2.1.8.15. thrust::stable_sort_by_key

template <typename DerivedPolicy,
  typename RandomAccessIterator1,
  typename RandomAccessIterator2,
  typename StrictWeakOrdering>
__host__ __device__ void
stable_sort_by_key(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  RandomAccessIterator1 keys_first,
  RandomAccessIterator1 keys_last,
  RandomAccessIterator2 values_first,
  StrictWeakOrdering comp);

stable_sort_by_key 执行键值排序。即， stable_sort_by_key 将 [keys_first, keys_last) 和 [values_first, values_first + (keys_last - keys_first)) ‍内的元素按升序排序，指的是如果 i 和 j 是 [keys_first, keys_last) ‍内任意两个有效迭代器，其中 i 在 j 之前，且 p 和 q 是 [values_first, values_first + (keys_last - keys_first)) ‍内 i 和 j 分别对应的迭代器，则 *j 不小于 *i。

顾名思义， stable_sort_by_key 是稳定的：它保留了等价元素的相对顺序。即，如果 x 和 y 是 [keys_first, keys_last) 中的元素，满足 x ‍先于 y ，并且如果这两个元素是等价的（既不是 x < y 也不是 y < x），那么 stable_sort_by_key 的后置条件是 x 仍然先于 y。

此版本的 stable_sort_by_key 使用函数对象 comp 比较键对象。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 sort_by_key 以整数作为排序键对字符值数组进行排序：使用 greater<int> 比较运算符按降序对键进行排序。

#include <thrust/sort.h>
#include <thrust/execution_policy.h>
...
const int N = 6;
int    keys[N] = {  1,   4,   2,   8,   5,   7};
char values[N] = {'a', 'b', 'c', 'd', 'e', 'f'};
thrust::stable_sort_by_key(thrust::host, keys, keys + N, values, thrust::greater<int>());
// keys is now   {  8,   7,   5,   4,   2,   1}
// values is now {'d', 'f', 'e', 'b', 'c', 'a'}

模板参数

DerivedPolicy：派生执行策略的名称
RandomAccessIterator1：是 Random Access Iterator 的模型， RandomAccessIterator1 是可变的，并且 RandomAccessIterator1 的 value_type 可转换为 StrictWeakOrdering 的 first_argument_type 和 second_argument_type
RandomAccessIterator2：是 Random Access Iterator 的模型，且 RandomAccessIterator2 是可变的
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

exec：用于并行化的执行策略
keys_first：键序列的起始
keys_last：键序列的末尾
values_first：值序列的起始
comp：比较运算符

前提条件

范围 [keys_first, keys_last)) 不应与范围 [values_first, values_first + (keys_last - keys_first)) 重叠

另请参阅

https://en.cppreference.com/w/cpp/algorithm/sort
sort_by_key
stable_sort

2.1.8.16. thrust::stable_sort_by_key

template <typename RandomAccessIterator1,
  typename RandomAccessIterator2,
  typename StrictWeakOrdering>
void
stable_sort_by_key(RandomAccessIterator1 keys_first,
  RandomAccessIterator1 keys_last,
  RandomAccessIterator2 values_first,
  StrictWeakOrdering comp);

stable_sort_by_key 执行键值排序。即， stable_sort_by_key 将 [keys_first, keys_last) 和 [values_first, values_first + (keys_last - keys_first)) ‍内的元素按升序排序，指的是如果 i 和 j 是 [keys_first, keys_last) ‍内任意两个有效迭代器，其中 i 在 j 之前，且 p 和 q 是 [values_first, values_first + (keys_last - keys_first)) ‍内 i 和 j 分别对应的迭代器，则 *j 不小于 *i。

顾名思义， stable_sort_by_key 是稳定的：它保留了等价元素的相对顺序。即，如果 x 和 y 是 [keys_first, keys_last) 中的元素，满足 x ‍先于 y ，并且如果这两个元素是等价的（既不是 x < y 也不是 y < x），那么 stable_sort_by_key 的后置条件是 x 仍然先于 y。

此版本的 stable_sort_by_key 使用函数对象 comp 比较键对象。

以下代码片段演示了如何使用 sort_by_key 以整数作为排序键对字符值数组进行排序，使用大于比较运算符按降序对键进行排序：

#include <thrust/sort.h>
...
const int N = 6;
int    keys[N] = {  1,   4,   2,   8,   5,   7};
char values[N] = {'a', 'b', 'c', 'd', 'e', 'f'};
thrust::stable_sort_by_key(keys, keys + N, values, thrust::greater<int>());
// keys is now   {  8,   7,   5,   4,   2,   1}
// values is now {'d', 'f', 'e', 'b', 'c', 'a'}

模板参数

RandomAccessIterator1：是 Random Access Iterator 的模型， RandomAccessIterator1 是可变的，并且 RandomAccessIterator1 的 value_type 可转换为 StrictWeakOrdering 的 first_argument_type 和 second_argument_type
RandomAccessIterator2：是 Random Access Iterator 的模型，且 RandomAccessIterator2 是可变的
StrictWeakOrdering：是 Strict Weak Ordering 的模型

函数参数

keys_first：键序列的起始
keys_last：键序列的末尾
values_first：值序列的起始
comp：比较运算符

前提条件

范围 [keys_first, keys_last)) 不应与范围 [values_first, values_first + (keys_last - keys_first)) 重叠

另请参阅

https://en.cppreference.com/w/cpp/algorithm/sort
sort_by_key
stable_sort

2.1.9. 变换（Transformation）

2.1.9.1. 变换

函数

template <typename DerivedPolicy,
  typename InputIterator,
  typename OutputIterator>
__host__ __device__ OutputIterator
thrust::adjacent_difference(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  OutputIterator result);

template <typename DerivedPolicy,
  typename InputIterator,
  typename OutputIterator,
  typename BinaryFunction>
__host__ __device__ OutputIterator
thrust::adjacent_difference(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  OutputIterator result,
  BinaryFunction binary_op);

template <typename InputIterator,
  typename OutputIterator>
OutputIterator
thrust::adjacent_difference(InputIterator first,
  InputIterator last,
  OutputIterator result);

template <typename InputIterator,
  typename OutputIterator,
  typename BinaryFunction>
OutputIterator
thrust::adjacent_difference(InputIterator first,
  InputIterator last,
  OutputIterator result,
  BinaryFunction binary_op);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename Generator>
__host__ __device__ void
thrust::generate(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  Generator gen);

template <typename ForwardIterator,
  typename Generator>
void
thrust::generate(ForwardIterator first,
  ForwardIterator last,
  Generator gen);

template <typename DerivedPolicy,
  typename OutputIterator,
  typename Size,
  typename Generator>
__host__ __device__ OutputIterator
thrust::generate_n(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  OutputIterator first,
  Size n,
  Generator gen);

template <typename OutputIterator,
  typename Size,
  typename Generator>
OutputIterator
thrust::generate_n(OutputIterator first,
  Size n,
  Generator gen);

template <typename DerivedPolicy,
  typename ForwardIterator>
__host__ __device__ void
thrust::sequence(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last);

template <typename ForwardIterator>
void
thrust::sequence(ForwardIterator first,
  ForwardIterator last);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename T>
__host__ __device__ void
thrust::sequence(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  T init);

template <typename ForwardIterator,
  typename T>
void
thrust::sequence(ForwardIterator first,
  ForwardIterator last,
  T init);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename T>
__host__ __device__ void
thrust::sequence(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  T init,
  T step);

template <typename ForwardIterator,
  typename T>
void
thrust::sequence(ForwardIterator first,
  ForwardIterator last,
  T init,
  T step);

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename UnaryOperation>
__host__ __device__ void
thrust::tabulate(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  UnaryOperation unary_op);

template <typename ForwardIterator,
  typename UnaryOperation>
void
thrust::tabulate(ForwardIterator first,
  ForwardIterator last,
  UnaryOperation unary_op);

template <typename DerivedPolicy,
  typename InputIterator,
 typename OutputIterator,
  typename UnaryFunction>
__host__ __device__ OutputIterator
thrust::transform(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  OutputIterator result,
  UnaryFunction op);

template <typename InputIterator,
  typename OutputIterator,
  typename UnaryFunction>
OutputIterator
thrust::transform(InputIterator first,
  InputIterator last,
  OutputIterator result,
  UnaryFunction op);

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename BinaryFunction>
__host__ __device__ OutputIterator
thrust::transform(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  OutputIterator result,
  BinaryFunction op);

template <typename InputIterator1,
  typename InputIterator2,
  typename OutputIterator,
  typename BinaryFunction>
OutputIterator
thrust::transform(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  OutputIterator result,
  BinaryFunction op);

template <typename DerivedPolicy,
  typename InputIterator,
  typename ForwardIterator,
  typename UnaryFunction,
  typename Predicate>
__host__ __device__ ForwardIterator
thrust::transform_if(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  ForwardIterator result,
  UnaryFunction op,
  Predicate pred);

template <typename InputIterator,
  typename ForwardIterator,
  typename UnaryFunction,
  typename Predicate>
ForwardIterator
thrust::transform_if(InputIterator first,
  InputIterator last,
  ForwardIterator result,
  UnaryFunction op,
  Predicate pred);

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename ForwardIterator,
  typename UnaryFunction,
  typename Predicate>
__host__ __device__ ForwardIterator
thrust::transform_if(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first,
  InputIterator1 last,
  InputIterator2 stencil,
  ForwardIterator result,
  UnaryFunction op,
  Predicate pred);

template <typename InputIterator1,
  typename InputIterator2,
  typename ForwardIterator,
  typename UnaryFunction,
  typename Predicate>
ForwardIterator
thrust::transform_if(InputIterator1 first,
  InputIterator1 last,
  InputIterator2 stencil,
  ForwardIterator result,
  UnaryFunction op,
 Predicate pred);

template <typename DerivedPolicy,
  typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename ForwardIterator,
  typename BinaryFunction,
  typename Predicate>
__host__ __device__ ForwardIterator
thrust::transform_if(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator3 stencil,
  ForwardIterator result,
  BinaryFunction binary_op,
  Predicate pred);

template <typename InputIterator1,
  typename InputIterator2,
  typename InputIterator3,
  typename ForwardIterator,
  typename BinaryFunction,
  typename Predicate>
orwardIterator
thrust::transform_if(InputIterator1 first1,
  InputIterator1 last1,
  InputIterator2 first2,
  InputIterator3 stencil,
  ForwardIterator result,
  BinaryFunction binary_op,
  Predicate pred);

thrust::adjacent_difference

template <typename DerivedPolicy,
  typename InputIterator,
  typename OutputIterator>
__host__ __device__ OutputIterator
adjacent_difference(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  OutputIterator result);

adjacent_difference 计算 [first, last) 内相邻元素的差。即，将 *first 赋给 *result ，并且对于范围 [first + 1, last) 内的每个迭代器 i ，将 *i 和 *(i - 1) 的差赋给 *(result + (i - first))。

此版本的 adjacent_difference 使用 operator- 计算差。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::device 执行策略，使用 adjacent_difference 计算范围内相邻元素的差：

#include <thrust/adjacent_difference.h>
#include <thrust/device_vector.h>
#include <thrust/execution_policy.h>
...
int h_data[8] = {1, 2, 1, 2, 1, 2, 1, 2};
thrust::device_vector<int> d_data(h_data, h_data + 8);
thrust::device_vector<int> d_result(8);

thrust::adjacent_difference(thrust::device, d_data.begin(), d_data.end(), d_result.begin());

// d_result is now [1, 1, -1, 1, -1, 1, -1, 1]

备注

允许 result 与 first 是同一个迭代器。这对于就地计算差非常有用。

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator：是 Input Iterator 的模型， x 和 y ‍是 InputIterator 的 value_type 的对象，定义 x - is。 InputIterator 的 value_type ‍可转换为 OutputIterator 的 value_types ‍集合中的类型， x - y 的返回类型可转换为 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型

函数参数

exec：用于并行化的执行策略
first：输入范围的起始
last：输入范围的末尾
result：输出范围的起始

返回值

迭代器 result + (last - first)

另请参阅

https://en.cppreference.com/w/cpp/algorithm/adjacent_difference
inclusive_scan

thrust::adjacent_difference

template <typename DerivedPolicy,
  typename InputIterator,
  typename OutputIterator,
  typename BinaryFunction>
__host__ __device__ OutputIterator
adjacent_difference(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  InputIterator first,
  InputIterator last,
  OutputIterator result,
  BinaryFunction binary_op);

adjacent_difference 计算 [first, last) 内相邻元素的差。即，将 *first 赋给 *result ，并且对于范围 [first + 1, last) 内的每个迭代器 i ，将 binary_op(*i, *(i - 1)) 赋给 *(result + (i - first))。

此版本的 adjacent_difference 使用二元函数 binary_op 计算差。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::device 执行策略，使用 adjacent_difference 计算范围内相邻元素的和：

#include <thrust/adjacent_difference.h>
#include <thrust/functional.h>
#include <thrust/device_vector.h>
#include <thrust/execution_policy.h>
...
int h_data[8] = {1, 2, 1, 2, 1, 2, 1, 2};
thrust::device_vector<int> d_data(h_data, h_data + 8);
thrust::device_vector<int> d_result(8);

thrust::adjacent_difference(thrust::device, d_data.begin(), d_data.end(), d_result.begin(), thrust::plus<int>());

// d_result is now [1, 3, 3, 3, 3, 3, 3, 3]

备注

允许 result 与 first 是同一个迭代器。这对于就地计算差非常有用。

模板参数

DerivedPolicy：派生执行策略的名称
InputIterator：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 BinaryFunction 的 first_argument_type 和 second_argument_type ，以及 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型
BinaryFunction的 result_type：可转换为 OutputIterator 的 value_types 集合中的类型

函数参数

exec：用于并行化的执行策略
first：输入范围的起始
last：输入范围的末尾
result：输出范围的起始
binary_op：计算差的二元函数

返回值

迭代器 result + (last - first)

另请参阅

https://en.cppreference.com/w/cpp/algorithm/adjacent_difference
inclusive_scan

thrust::adjacent_difference

template <typename InputIterator,
  typename OutputIterator>
OutputIterator
adjacent_difference(InputIterator first,
  InputIterator last,
  OutputIterator result);

adjacent_difference 计算 [first, last) 内相邻元素的差。即，将 *first 赋给 *result ，并且对于范围 [first + 1, last) 内的每个迭代器 i ，将 *i 和 *(i - 1) 的差赋给 *(result + (i - first))。

此版本的 adjacent_difference 使用 operator- 计算差。

以下代码片段演示了如何使用 adjacent_difference 计算范围内相邻元素的差：

#include <thrust/adjacent_difference.h>
#include <thrust/device_vector.h>
...
int h_data[8] = {1, 2, 1, 2, 1, 2, 1, 2};
thrust::device_vector<int> d_data(h_data, h_data + 8);
thrust::device_vector<int> d_result(8);

thrust::adjacent_difference(d_data.begin(), d_data.end(), d_result.begin());

// d_result is now [1, 1, -1, 1, -1, 1, -1, 1]

备注

允许 result 与 first 是同一个迭代器。这对于就地计算差非常有用。

模板参数

InputIterator：是 Input Iterator 的模型， x 和 y ‍是 InputIterator 的 value_type 的对象，定义 x - is。 InputIterator 的 value_type ‍可转换为 OutputIterator 的 value_types ‍集合中的类型， x - y 的返回类型可转换为 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型

函数参数

first：输入范围的起始
last：输入范围的末尾
result：输出范围的起始

返回值

迭代器 result + (last - first)

另请参阅

https://en.cppreference.com/w/cpp/algorithm/adjacent_difference
inclusive_scan

thrust::adjacent_difference

template <typename InputIterator,
  typename OutputIterator,
  typename BinaryFunction>
OutputIterator
adjacent_difference(InputIterator first,
  InputIterator last,
  OutputIterator result,
  BinaryFunction binary_op);

adjacent_difference 计算 [first, last) 内相邻元素的差。即，将 *first 赋给 *result ，并且对于范围 [first + 1, last) 内的每个迭代器 i ，将 binary_op(*i, *(i - 1)) 赋给 *(result + (i - first))。

此版本的 adjacent_difference 使用二元函数 binary_op 计算差。

以下代码片段演示了如何使用 adjacent_difference 计算范围内相邻元素的和：

#include <thrust/adjacent_difference.h>
#include <thrust/functional.h>
#include <thrust/device_vector.h>
...
int h_data[8] = {1, 2, 1, 2, 1, 2, 1, 2};
thrust::device_vector<int> d_data(h_data, h_data + 8);
thrust::device_vector<int> d_result(8);

thrust::adjacent_difference(d_data.begin(), d_data.end(), d_result.begin(), thrust::plus<int>());

// d_result is now [1, 3, 3, 3, 3, 3, 3, 3]

备注

允许 result 与 first 是同一个迭代器。这对于就地计算差非常有用。

模板参数

InputIterator1：是 Input Iterator 的模型， InputIterator 的 value_type 可转换为 BinaryFunction 的 first_argument_type 和 second_argument_type ，以及 OutputIterator 的 value_types 集合中的类型
OutputIterator：是 Output Iterator 的模型
BinaryFunction的 result_type：可转换为 OutputIterator 的 value_types 集合中的类型

函数参数

first：输入范围的起始
last：输入范围的末尾
result：输出范围的起始
binary_op：计算差的二元函数

返回值

迭代器 result + (last - first)

另请参阅

https://en.cppreference.com/w/cpp/algorithm/adjacent_difference
inclusive_scan

thrust::generate

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename Generator>
__host__ __device__ void
generate(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  Generator gen);

generate 将调用 gen （无参函数对象）的结果赋给范围 [first,last) 内每个元素。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用标准的C库函数 rand 用随机数填充 host_vector：

#include <thrust/generate.h>
#include <thrust/host_vector.h>
#include <thrust/execution_policy.h>
#include <cstdlib>
...
thrust::host_vector<int> v(10);
srand(13);
thrust::generate(thrust::host, v.begin(), v.end(), rand);

// the elements of v are now pseudo-random numbers

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型，且 ForwardIterator 是可变的
Generator：是 Generator 的模型， Generator 的 result_type 可转换为 ForwardIterator 的 value_type

函数参数

exec：用于并行化的执行策略
first：感兴趣范围中的第一个元素
last：感兴趣范围中的最后一个元素
gen：无参函数对象，用于生成要赋给范围 [first,last) 内元素的值

另请参阅

generate_n
https://en.cppreference.com/w/cpp/algorithm/generate

thrust::generate

template <typename ForwardIterator,
  typename Generator>
void
generate(ForwardIterator first,
  ForwardIterator last,
   Generator gen);

generate 将调用 gen （无参函数对象）的结果赋给范围 [first,last) 内每个元素。

以下代码片段演示了如何使用标准的C库函数 rand 用随机数填充 host_vector：

#include <thrust/generate.h>
#include <thrust/host_vector.h>
#include <thrust/execution_policy.h>
#include <cstdlib>
...
thrust::host_vector<int> v(10);
srand(13);
thrust::generate(v.begin(), v.end(), rand);

// the elements of v are now pseudo-random numbers

模板参数

ForwardIterator：是 Forward Iterator 的模型，且 ForwardIterator 是可变的
Generator：是 Generator 的模型， Generator 的 result_type 可转换为 ForwardIterator 的 value_type

函数参数

first：感兴趣范围中的第一个元素
last：感兴趣范围中的最后一个元素
gen：无参函数对象，用于生成要赋给范围 [first,last) 内元素的值

另请参阅

generate_n
https://en.cppreference.com/w/cpp/algorithm/generate

thrust::generate_n

template <typename DerivedPolicy,
  typename OutputIterator,
  typename Size,
  typename Generator>
__host__ __device__ OutputIterator
generate_n(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  OutputIterator first,
  Size n,
  Generator gen);

generate_n 将调用 gen （无参函数对象）的结果赋给范围 [first,first + n) 内每个元素。

返回值是 first + n。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用标准的C库函数 rand 用随机数填充 host_vector：

#include <thrust/generate.h>
#include <thrust/host_vector.h>
#include <thrust/execution_policy.h>
#include <cstdlib>
...
thrust::host_vector<int> v(10);
srand(13);
thrust::generate_n(thrust::host, v.begin(), 10, rand);

// the elements of v are now pseudo-random numbers

模板参数

DerivedPolicy：派生执行策略的名称
OutputIterator：是 Output Iterator 的模型
Size：整型类型（有符号或无符号）
Generator：是 Generator 的模型， Generator 的 result_type 可转换为 OutputIterator 的 value_types 集合中的类型

函数参数

exec：用于并行化的执行策略
first：感兴趣范围中的第一个元素
n：感兴趣范围的大小
gen：无参函数对象，用于生成要赋给范围 [first,first + n) 内元素的值

另请参阅

generate
https://en.cppreference.com/w/cpp/algorithm/generate

thrust::generate_n

template <typename OutputIterator,
  typename Size,
  typename Generator>
OutputIterator
generate_n(OutputIterator first,
  Size n,
  Generator gen);

generate_n 将调用 gen （无参函数对象）的结果赋给范围 [first,first + n) 内每个元素。返回值是 first + n。

以下代码片段演示了如何使用标准的C库函数 rand 用随机数填充 host_vector：

#include <thrust/generate.h>
#include <thrust/host_vector.h>
#include <stdlib.h>
...
thrust::host_vector<int> v(10);
srand(13);
thrust::generate_n(v.begin(), 10, rand);

// the elements of v are now pseudo-random numbers

模板参数

OutputIterator：是 Output Iterator 的模型
Size：整型类型（有符号或无符号）
Generator：是 Generator 的模型， Generator 的 result_type 可转换为 OutputIterator 的 value_types 集合中的类型

函数参数

first：感兴趣范围中的第一个元素
n：感兴趣范围的大小
gen：无参函数对象，用于生成要赋给范围 [first,first + n) 内元素的值

另请参阅

generate
https://en.cppreference.com/w/cpp/algorithm/generate

thrust::sequence

template <typename DerivedPolicy,
  typename ForwardIterator>
__host__ __device__ void
sequence(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last);

sequence 用数字序列填充范围 [first, last)。

对于范围 [first, last) ‍内的每个迭代器 i ，此版本的 sequence 执行赋值 *i = (i - first)。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 sequence 用数字序列填充范围：

#include <thrust/sequence.h>
#include <thrust/execution_policy.h>
...
const int N = 10;
int A[N];
thrust::sequence(thrust::host, A, A + 10);
// A is now {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

备注

与类似的C++STL函数 std::iota 不同， sequence 不能保证执行顺序。

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 是可变的。如果 x 和 y 是 ForwardIterator 的 value_type 的对象，则定义 x + y ；如果 T 是 ForwardIterator 的 value_type ，则定义 T(0)

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾

另请参阅

thrust::sequence

template <typename ForwardIterator>
void
sequence(ForwardIterator first,
  ForwardIterator last);

sequence 用数字序列填充范围 [first, last)。

对于范围 [first, last) ‍内的每个迭代器 i ，此版本的 sequence 执行赋值 *i = (i - first)。

以下代码片段演示了如何使用 sequence 用数字序列填充范围：

#include <thrust/sequence.h>
...
const int N = 10;
int A[N];
thrust::sequence(A, A + 10);
// A is now {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

备注

与类似的C++STL函数 std::iota 不同， sequence 不能保证执行顺序。

模板参数

ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 是可变的。如果 x 和 y 是 ForwardIterator 的 value_type 的对象，则定义 x + y ；如果 T 是 ForwardIterator 的 value_type ，则定义 T(0)

函数参数

first：序列起始
last：序列末尾

另请参阅

thrust::sequence

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename T>
__host__ __device__ void
sequence(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  T init);

sequence 用数字序列填充范围 [first, last)。

对于范围 [first, last) ‍内的每个迭代器 i ，此版本的 sequence 执行赋值 *i = init + (i - first)。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 sequence 用从1开始的数字序列填充范围：

#include <thrust/sequence.h>
#include <thrust/execution_policy.h>
...
const int N = 10;
int A[N];
thrust::sequence(thrust::host, A, A + 10, 1);
// A is now {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

备注

与类似的C++STL函数 std::iota 不同， sequence 不能保证执行顺序。

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 是可变的。如果 x 和 y 是 ForwardIterator 的 value_type 的对象，则定义 x + y ；如果 T 是 ForwardIterator 的 value_type ，则定义 T(0)
T：是 Assignable 的模型，且 T 可转换为 ForwardIterator 的 value_type

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾
init：数字序列的第一个值

另请参阅

thrust::sequence

template <typename ForwardIterator,
  typename T>
void
sequence(ForwardIterator first,
  ForwardIterator last,
  T init);

sequence 用数字序列填充范围 [first, last)。

对于范围 [first, last) ‍内的每个迭代器 i ，此版本的 sequence 执行赋值 *i = init + (i - first)。

以下代码片段演示了如何使用 sequence 用从1开始的数字序列填充范围：

#include <thrust/sequence.h>
...
const int N = 10;
int A[N];
thrust::sequence(A, A + 10, 1);
// A is now {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

备注

与类似的C++STL函数 std::iota 不同， sequence 不能保证执行顺序。

模板参数

ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 是可变的。如果 x 和 y 是 ForwardIterator 的 value_type 的对象，则定义 x + y ；如果 T 是 ForwardIterator 的 value_type ，则定义 T(0)
T：是 Assignable 的模型，且 T 可转换为 ForwardIterator 的 value_type

函数参数

first：序列起始
last：序列末尾
init：数字序列的第一个值

另请参阅

thrust::sequence

template <typename DerivedPolicy,
  typename ForwardIterator,
  typename T>
__host__ __device__ void
sequence(const thrust::detail::execution_policy_base< DerivedPolicy > & exec,
  ForwardIterator first,
  ForwardIterator last,
  T init,
  T step);

sequence 用数字序列填充范围 [first, last)。

对于范围 [first, last) ‍内的每个迭代器 i ，此版本的 sequence 执行赋值 *i = init + step * (i - first)。

算法的执行由 exec 确定并行化。

以下代码片段演示了如何通过 thrust::host 并行化执行策略，使用 sequence 用从1开始，步长为3的数字序列填充范围：

#include <thrust/sequence.h>
#include <thrust/execution_policy.h>
...
const int N = 10;
int A[N];
thrust::sequence(thrust::host, A, A + 10, 1, 3);
// A is now {1, 4, 7, 10, 13, 16, 19, 22, 25, 28}

备注

与类似的C++STL函数 std::iota 不同， sequence 不能保证执行顺序。

模板参数

DerivedPolicy：派生执行策略的名称
ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 是可变的。如果 x 和 y 是 ForwardIterator 的 value_type 的对象，则定义 x + y ；如果 T 是 ForwardIterator 的 value_type ，则定义 T(0)
T：是 Assignable 的模型，且 T 可转换为 ForwardIterator 的 value_type

函数参数

exec：用于并行化的执行策略
first：序列起始
last：序列末尾
init：数字序列的第一个值
step：连续元素之间的差

另请参阅

thrust::sequence

template <typename ForwardIterator,
  typename T>
void
sequence(ForwardIterator first,
  ForwardIterator last,
  T init,
  T step);

sequence 用数字序列填充范围 [first, last)。

对于范围 [first, last) ‍内的每个迭代器 i ，此版本的 sequence 执行赋值 *i = init + step * (i - first)。

以下代码片段演示了如何使用 sequence 用从1开始，步长为3的数字序列填充范围：

#include <thrust/sequence.h>
...
const int N = 10;
int A[N];
thrust::sequence(A, A + 10, 1, 3);
// A is now {1, 4, 7, 10, 13, 16, 19, 22, 25, 28}

备注

与类似的C++STL函数 std::iota 不同， sequence 不能保证执行顺序。

模板参数

ForwardIterator：是 Forward Iterator 的模型， ForwardIterator 是可变的。如果 x 和 y 是 ForwardIterator 的 value_type 的对象，则定义 x + y ；如果 T 是 ForwardIterator 的 value_type ，则定义 T(0)
T：是 Assignable 的模型，且 T 可转换为 ForwardIterator 的 value_type

函数参数

first：序列起始
last：序列末尾
init：数字序列的第一个值
step：连续元素之间的差

另请参阅