thrust

Functions  
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) 
__host__ __device__ ForwardIterator thrust::partition  (  const thrust::detail::execution_policy_base< DerivedPolicy > &  exec, 
ForwardIterator  first,  
ForwardIterator  last,  
Predicate  pred  
) 
partition
reorders the elements [first, last)
based on the function object pred
, such that all of the elements that satisfy pred
precede the elements that fail to satisfy it. The postcondition is that, for some iterator middle
in the range [first, last)
, pred(*i)
is true
for every iterator i
in the range [first,middle)
and false
for every iterator i
in the range [middle, last)
. The return value of partition
is middle
.
Note that the relative order of elements in the two reordered sequences is not necessarily the same as it was in the original sequence. A different algorithm, stable_partition, does guarantee to preserve the relative order.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
first  The beginning of the sequence to reorder. 
last  The end of the sequence to reorder. 
pred  A function object which decides to which partition each element of the sequence [first, last) belongs. 
pred
.DerivedPolicy  The name of the derived execution policy. 
ForwardIterator  is a model of Forward Iterator, and ForwardIterator's value_type is convertible to Predicate's argument_type , and ForwardIterator is mutable. 
Predicate  is a model of Predicate. 
The following code snippet demonstrates how to use partition
to reorder a sequence so that even numbers precede odd numbers using the thrust::host
execution policy for parallelization:
ForwardIterator thrust::partition  (  ForwardIterator  first, 
ForwardIterator  last,  
Predicate  pred  
) 
partition
reorders the elements [first, last)
based on the function object pred
, such that all of the elements that satisfy pred
precede the elements that fail to satisfy it. The postcondition is that, for some iterator middle
in the range [first, last)
, pred(*i)
is true
for every iterator i
in the range [first,middle)
and false
for every iterator i
in the range [middle, last)
. The return value of partition
is middle
.
Note that the relative order of elements in the two reordered sequences is not necessarily the same as it was in the original sequence. A different algorithm, stable_partition, does guarantee to preserve the relative order.
first  The beginning of the sequence to reorder. 
last  The end of the sequence to reorder. 
pred  A function object which decides to which partition each element of the sequence [first, last) belongs. 
pred
.ForwardIterator  is a model of Forward Iterator, and ForwardIterator's value_type is convertible to Predicate's argument_type , and ForwardIterator is mutable. 
Predicate  is a model of Predicate. 
The following code snippet demonstrates how to use partition
to reorder a sequence so that even numbers precede odd numbers.
__host__ __device__ ForwardIterator thrust::partition  (  const thrust::detail::execution_policy_base< DerivedPolicy > &  exec, 
ForwardIterator  first,  
ForwardIterator  last,  
InputIterator  stencil,  
Predicate  pred  
) 
partition
reorders the elements [first, last)
based on the function object pred
applied to a stencil range [stencil, stencil + (last  first))
, such that all of the elements whose corresponding stencil element satisfies pred
precede all of the elements whose corresponding stencil element fails to satisfy it. The postcondition is that, for some iterator middle
in the range [first, last)
, pred(*stencil_i)
is true
for every iterator stencil_i
in the range [stencil,stencil + (middle  first))
and false
for every iterator stencil_i
in the range [stencil + (middle  first), stencil + (last  first))
. The return value of stable_partition
is middle
.
Note that the relative order of elements in the two reordered sequences is not necessarily the same as it was in the original sequence. A different algorithm, stable_partition, does guarantee to preserve the relative order.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
first  The beginning of the sequence to reorder. 
last  The end of the sequence to reorder. 
stencil  The beginning of the stencil sequence. 
pred  A function object which decides to which partition each element of the sequence [first, last) belongs. 
pred
.DerivedPolicy  The name of the derived execution policy. 
ForwardIterator  is a model of Forward Iterator, and ForwardIterator is mutable. 
InputIterator  is a model of Input Iterator, and InputIterator's value_type is convertible to Predicate's argument_type . 
Predicate  is a model of Predicate. 
[first,last)
and [stencil, stencil + (last  first))
shall not overlap.The following code snippet demonstrates how to use partition
to reorder a sequence so that even numbers precede odd numbers using the thrust::host
execution policy for parallelization:
ForwardIterator thrust::partition  (  ForwardIterator  first, 
ForwardIterator  last,  
InputIterator  stencil,  
Predicate  pred  
) 
partition
reorders the elements [first, last)
based on the function object pred
applied to a stencil range [stencil, stencil + (last  first))
, such that all of the elements whose corresponding stencil element satisfies pred
precede all of the elements whose corresponding stencil element fails to satisfy it. The postcondition is that, for some iterator middle
in the range [first, last)
, pred(*stencil_i)
is true
for every iterator stencil_i
in the range [stencil,stencil + (middle  first))
and false
for every iterator stencil_i
in the range [stencil + (middle  first), stencil + (last  first))
. The return value of stable_partition
is middle
.
Note that the relative order of elements in the two reordered sequences is not necessarily the same as it was in the original sequence. A different algorithm, stable_partition, does guarantee to preserve the relative order.
first  The beginning of the sequence to reorder. 
last  The end of the sequence to reorder. 
stencil  The beginning of the stencil sequence. 
pred  A function object which decides to which partition each element of the sequence [first, last) belongs. 
pred
.ForwardIterator  is a model of Forward Iterator, and ForwardIterator is mutable. 
InputIterator  is a model of Input Iterator, and InputIterator's value_type is convertible to Predicate's argument_type . 
Predicate  is a model of Predicate. 
[first,last)
and [stencil, stencil + (last  first))
shall not overlap.The following code snippet demonstrates how to use partition
to reorder a sequence so that even numbers precede odd numbers.
__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  
) 
partition_copy
differs from partition only in that the reordered sequence is written to difference output sequences, rather than in place.
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
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
first  The beginning of the sequence to reorder. 
last  The end of the sequence to reorder. 
out_true  The destination of the resulting sequence of elements which satisfy pred . 
out_false  The destination of the resulting sequence of elements which fail to satisfy pred . 
pred  A function object which decides to which partition each element of the sequence [first, last) belongs. 
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
.DerivedPolicy  The name of the derived execution policy. 
InputIterator  is 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 . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
Predicate  is a model of Predicate. 
The following code snippet demonstrates how to use partition_copy
to separate a sequence into two output sequences of even and odd numbers using the thrust::host
execution policy for parallelization:
thrust::pair<OutputIterator1,OutputIterator2> thrust::partition_copy  (  InputIterator  first, 
InputIterator  last,  
OutputIterator1  out_true,  
OutputIterator2  out_false,  
Predicate  pred  
) 
partition_copy
differs from partition only in that the reordered sequence is written to difference output sequences, rather than in place.
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
.
first  The beginning of the sequence to reorder. 
last  The end of the sequence to reorder. 
out_true  The destination of the resulting sequence of elements which satisfy pred . 
out_false  The destination of the resulting sequence of elements which fail to satisfy pred . 
pred  A function object which decides to which partition each element of the sequence [first, last) belongs. 
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
.InputIterator  is 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 . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
Predicate  is a model of Predicate. 
The following code snippet demonstrates how to use partition_copy
to separate a sequence into two output sequences of even and odd numbers.
__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  
) 
partition_copy
differs from partition only in that the reordered sequence is written to difference output sequences, rather than in place.
partition_copy
copies the elements [first, last)
based on the function object pred
which is applied to a range of stencil elements. All of the elements whose corresponding stencil element satisfies pred
are copied to the range beginning at out_true
and all the elements whose stencil element fails to satisfy it are copied to the range beginning at out_false
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
first  The beginning of the sequence to reorder. 
last  The end of the sequence to reorder. 
stencil  The beginning of the stencil sequence. 
out_true  The destination of the resulting sequence of elements which satisfy pred . 
out_false  The destination of the resulting sequence of elements which fail to satisfy pred . 
pred  A function object which decides to which partition each element of the sequence [first, last) belongs. 
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
.DerivedPolicy  The name of the derived execution policy. 
InputIterator1  is a model of Input Iterator, and InputIterator's value_type is convertible to OutputIterator1 and OutputIterator2's value_types . 
InputIterator2  is a model of Input Iterator, and InputIterator2's value_type is convertible to Predicate's argument_type . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
Predicate  is a model of Predicate. 
The following code snippet demonstrates how to use partition_copy
to separate a sequence into two output sequences of even and odd numbers using the thrust::host
execution policy for parallelization.
thrust::pair<OutputIterator1,OutputIterator2> thrust::partition_copy  (  InputIterator1  first, 
InputIterator1  last,  
InputIterator2  stencil,  
OutputIterator1  out_true,  
OutputIterator2  out_false,  
Predicate  pred  
) 
partition_copy
differs from partition only in that the reordered sequence is written to difference output sequences, rather than in place.
partition_copy
copies the elements [first, last)
based on the function object pred
which is applied to a range of stencil elements. All of the elements whose corresponding stencil element satisfies pred
are copied to the range beginning at out_true
and all the elements whose stencil element fails to satisfy it are copied to the range beginning at out_false
.
first  The beginning of the sequence to reorder. 
last  The end of the sequence to reorder. 
stencil  The beginning of the stencil sequence. 
out_true  The destination of the resulting sequence of elements which satisfy pred . 
out_false  The destination of the resulting sequence of elements which fail to satisfy pred . 
pred  A function object which decides to which partition each element of the sequence [first, last) belongs. 
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
.InputIterator1  is a model of Input Iterator, and InputIterator's value_type is convertible to OutputIterator1 and OutputIterator2's value_types . 
InputIterator2  is a model of Input Iterator, and InputIterator2's value_type is convertible to Predicate's argument_type . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
Predicate  is a model of Predicate. 
The following code snippet demonstrates how to use partition_copy
to separate a sequence into two output sequences of even and odd numbers.
__host__ __device__ ForwardIterator thrust::stable_partition  (  const thrust::detail::execution_policy_base< DerivedPolicy > &  exec, 
ForwardIterator  first,  
ForwardIterator  last,  
Predicate  pred  
) 
stable_partition
is much like partition : it reorders the elements in the range [first, last)
based on the function object pred
, such that all of the elements that satisfy pred
precede all of the elements that fail to satisfy it. The postcondition is that, for some iterator middle
in the range [first, last)
, pred(*i)
is true
for every iterator i
in the range [first,middle)
and false
for every iterator i
in the range [middle, last)
. The return value of stable_partition
is middle
.
stable_partition
differs from partition in that stable_partition
is guaranteed to preserve relative order. That is, if x
and y
are elements in [first, last)
, and stencil_x
and stencil_y
are the stencil elements in corresponding positions within [stencil, stencil + (last  first))
, and pred(stencil_x) == pred(stencil_y)
, and if x
precedes y
, then it will still be true after stable_partition
that x
precedes y
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
first  The first element of the sequence to reorder. 
last  One position past the last element of the sequence to reorder. 
pred  A function object which decides to which partition each element of the sequence [first, last) belongs. 
DerivedPolicy  The name of the derived execution policy. 
ForwardIterator  is a model of Forward Iterator, and ForwardIterator's value_type is convertible to Predicate's argument_type , and ForwardIterator is mutable. 
Predicate  is a model of Predicate. 
The following code snippet demonstrates how to use stable_partition
to reorder a sequence so that even numbers precede odd numbers using the thrust::host
execution policy for parallelization:
ForwardIterator thrust::stable_partition  (  ForwardIterator  first, 
ForwardIterator  last,  
Predicate  pred  
) 
stable_partition
is much like partition : it reorders the elements in the range [first, last)
based on the function object pred
, such that all of the elements that satisfy pred
precede all of the elements that fail to satisfy it. The postcondition is that, for some iterator middle
in the range [first, last)
, pred(*i)
is true
for every iterator i
in the range [first,middle)
and false
for every iterator i
in the range [middle, last)
. The return value of stable_partition
is middle
.
stable_partition
differs from partition in that stable_partition
is guaranteed to preserve relative order. That is, if x
and y
are elements in [first, last)
, and stencil_x
and stencil_y
are the stencil elements in corresponding positions within [stencil, stencil + (last  first))
, and pred(stencil_x) == pred(stencil_y)
, and if x
precedes y
, then it will still be true after stable_partition
that x
precedes y
.
first  The first element of the sequence to reorder. 
last  One position past the last element of the sequence to reorder. 
pred  A function object which decides to which partition each element of the sequence [first, last) belongs. 
ForwardIterator  is a model of Forward Iterator, and ForwardIterator's value_type is convertible to Predicate's argument_type , and ForwardIterator is mutable. 
Predicate  is a model of Predicate. 
The following code snippet demonstrates how to use stable_partition
to reorder a sequence so that even numbers precede odd numbers.
__host__ __device__ ForwardIterator thrust::stable_partition  (  const thrust::detail::execution_policy_base< DerivedPolicy > &  exec, 
ForwardIterator  first,  
ForwardIterator  last,  
InputIterator  stencil,  
Predicate  pred  
) 
stable_partition
is much like partition:
it reorders the elements in the range [first, last)
based on the function object pred
applied to a stencil range [stencil, stencil + (last  first))
, such that all of the elements whose corresponding stencil element satisfies pred
precede all of the elements whose corresponding stencil element fails to satisfy it. The postcondition is that, for some iterator middle
in the range [first, last)
, pred(*stencil_i)
is true
for every iterator stencil_i
in the range [stencil,stencil + (middle  first))
and false
for every iterator stencil_i
in the range [stencil + (middle  first), stencil + (last  first))
. The return value of stable_partition
is middle
.
stable_partition
differs from partition in that stable_partition
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
that x
precedes y
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
first  The first element of the sequence to reorder. 
last  One position past the last element of the sequence to reorder. 
stencil  The beginning of the stencil sequence. 
pred  A function object which decides to which partition each element of the sequence [first, last) belongs. 
pred
.DerivedPolicy  The name of the derived execution policy. 
ForwardIterator  is a model of Forward Iterator, and ForwardIterator is mutable. 
InputIterator  is a model of Input Iterator, and InputIterator's value_type is convertible to Predicate's argument_type . 
Predicate  is a model of Predicate. 
[first, last)
shall not overlap with the range [stencil, stencil + (last  first))
.The following code snippet demonstrates how to use stable_partition
to reorder a sequence so that even numbers precede odd numbers using the thrust::host
execution policy for parallelization:
ForwardIterator thrust::stable_partition  (  ForwardIterator  first, 
ForwardIterator  last,  
InputIterator  stencil,  
Predicate  pred  
) 
stable_partition
is much like partition:
it reorders the elements in the range [first, last)
based on the function object pred
applied to a stencil range [stencil, stencil + (last  first))
, such that all of the elements whose corresponding stencil element satisfies pred
precede all of the elements whose corresponding stencil element fails to satisfy it. The postcondition is that, for some iterator middle
in the range [first, last)
, pred(*stencil_i)
is true
for every iterator stencil_i
in the range [stencil,stencil + (middle  first))
and false
for every iterator stencil_i
in the range [stencil + (middle  first), stencil + (last  first))
. The return value of stable_partition
is middle
.
stable_partition
differs from partition in that stable_partition
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
that x
precedes y
.
first  The first element of the sequence to reorder. 
last  One position past the last element of the sequence to reorder. 
stencil  The beginning of the stencil sequence. 
pred  A function object which decides to which partition each element of the sequence [first, last) belongs. 
pred
.ForwardIterator  is a model of Forward Iterator, and ForwardIterator is mutable. 
InputIterator  is a model of Input Iterator, and InputIterator's value_type is convertible to Predicate's argument_type . 
Predicate  is a model of Predicate. 
[first, last)
shall not overlap with the range [stencil, stencil + (last  first))
.The following code snippet demonstrates how to use stable_partition
to reorder a sequence so that even numbers precede odd numbers.
__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
.
exec  The execution policy to use for parallelization. 
first  The first element of the sequence to reorder. 
last  One position past the last element of the sequence to reorder. 
out_true  The destination of the resulting sequence of elements which satisfy pred . 
out_false  The destination of the resulting sequence of elements which fail to satisfy pred . 
pred  A function object which decides to which partition each element of the sequence [first, last) belongs. 
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
.DerivedPolicy  The name of the derived execution policy. 
InputIterator  is 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 . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
Predicate  is a model of Predicate. 
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:
thrust::pair<OutputIterator1,OutputIterator2> thrust::stable_partition_copy  (  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.
first  The first element of the sequence to reorder. 
last  One position past the last element of the sequence to reorder. 
out_true  The destination of the resulting sequence of elements which satisfy pred . 
out_false  The destination of the resulting sequence of elements which fail to satisfy pred . 
pred  A function object which decides to which partition each element of the sequence [first, last) belongs. 
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
.InputIterator  is 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 . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
Predicate  is a model of Predicate. 
The following code snippet demonstrates how to use stable_partition_copy
to reorder a sequence so that even numbers precede odd numbers.
__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  
) 
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
which is applied to a range of stencil elements. All of the elements whose corresponding stencil element satisfies pred
are copied to the range beginning at out_true
and all the elements whose stencil element fails 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
.
exec  The execution policy to use for parallelization. 
first  The first element of the sequence to reorder. 
last  One position past the last element of the sequence to reorder. 
stencil  The beginning of the stencil sequence. 
out_true  The destination of the resulting sequence of elements which satisfy pred . 
out_false  The destination of the resulting sequence of elements which fail to satisfy pred . 
pred  A function object which decides to which partition each element of the sequence [first, last) belongs. 
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
.DerivedPolicy  The name of the derived execution policy. 
InputIterator1  is a model of Input Iterator, and InputIterator's value_type is convertible to OutputIterator1 and OutputIterator2's value_types . 
InputIterator2  is a model of Input Iterator, and InputIterator2's value_type is convertible to Predicate's argument_type . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
Predicate  is a model of Predicate. 
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:
thrust::pair<OutputIterator1,OutputIterator2> thrust::stable_partition_copy  (  InputIterator1  first, 
InputIterator1  last,  
InputIterator2  stencil,  
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
which is applied to a range of stencil elements. All of the elements whose corresponding stencil element satisfies pred
are copied to the range beginning at out_true
and all the elements whose stencil element fails 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.
first  The first element of the sequence to reorder. 
last  One position past the last element of the sequence to reorder. 
stencil  The beginning of the stencil sequence. 
out_true  The destination of the resulting sequence of elements which satisfy pred . 
out_false  The destination of the resulting sequence of elements which fail to satisfy pred . 
pred  A function object which decides to which partition each element of the sequence [first, last) belongs. 
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
.InputIterator1  is a model of Input Iterator, and InputIterator's value_type is convertible to OutputIterator1 and OutputIterator2's value_types . 
InputIterator2  is a model of Input Iterator, and InputIterator2's value_type is convertible to Predicate's argument_type . 
OutputIterator1  is a model of Output Iterator. 
OutputIterator2  is a model of Output Iterator. 
Predicate  is a model of Predicate. 
The following code snippet demonstrates how to use stable_partition_copy
to reorder a sequence so that even numbers precede odd numbers.