thrust

◆ stable_partition_copy() [1/4]

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 
)

stable_partition_copy differs from stable_partition only in that the reordered sequence is written to different output sequences, rather than in place.

stable_partition_copy copies the elements [first, last) based on the function object pred. All of the elements that satisfy pred are copied to the range beginning at out_true and all the elements that fail to satisfy it are copied to the range beginning at out_false.

stable_partition_copy differs from partition_copy in that stable_partition_copy is guaranteed to preserve relative order. That is, if x and y are elements in [first, last), such that pred(x) == pred(y), and if x precedes y, then it will still be true after stable_partition_copy that x precedes y in the output.

The algorithm's execution is parallelized as determined by exec.

Parameters
execThe execution policy to use for parallelization.
firstThe first element of the sequence to reorder.
lastOne position past the last element of the sequence to reorder.
out_trueThe destination of the resulting sequence of elements which satisfy pred.
out_falseThe destination of the resulting sequence of elements which fail to satisfy pred.
predA function object which decides to which partition each element of the sequence [first, last) belongs.
Returns
A pair p such that p.first is the end of the output range beginning at out_true and p.second is the end of the output range beginning at out_false.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
InputIteratoris a model of Input Iterator, and InputIterator's value_type is convertible to Predicate's argument_type and InputIterator's value_type is convertible to OutputIterator1 and OutputIterator2's value_types.
OutputIterator1is a model of Output Iterator.
OutputIterator2is a model of Output Iterator.
Predicateis a model of Predicate.
Precondition
The input ranges shall not overlap with either output range.

The following code snippet demonstrates how to use stable_partition_copy to reorder a sequence so that even numbers precede odd numbers using the thrust::host execution policy for parallelization:

...
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}
See also
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2569.pdf
partition_copy
stable_partition