thrust

Functions  
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) 
__host__ __device__ void thrust::sort  (  const thrust::detail::execution_policy_base< DerivedPolicy > &  exec, 
RandomAccessIterator  first,  
RandomAccessIterator  last  
) 
sort
sorts the elements in [first, last)
into ascending order, meaning that if i
and j
are any two valid iterators in [first, last)
such that i
precedes j
, then *j
is not less than *i
. Note: sort
is not guaranteed to be stable. That is, suppose that *i
and *j
are equivalent: neither one is less than the other. It is not guaranteed that the relative order of these two elements will be preserved by sort
.
This version of sort
compares objects using operator<
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
first  The beginning of the sequence. 
last  The end of the sequence. 
DerivedPolicy  The name of the derived execution policy. 
RandomAccessIterator  is a model of Random Access Iterator, RandomAccessIterator is mutable, and RandomAccessIterator's value_type is a model of LessThan Comparable, and the ordering relation on RandomAccessIterator's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements. 
The following code snippet demonstrates how to use sort
to sort a sequence of integers using the thrust::host
execution policy for parallelization:
void thrust::sort  (  RandomAccessIterator  first, 
RandomAccessIterator  last  
) 
sort
sorts the elements in [first, last)
into ascending order, meaning that if i
and j
are any two valid iterators in [first, last)
such that i
precedes j
, then *j
is not less than *i
. Note: sort
is not guaranteed to be stable. That is, suppose that *i
and *j
are equivalent: neither one is less than the other. It is not guaranteed that the relative order of these two elements will be preserved by sort
.
This version of sort
compares objects using operator<
.
first  The beginning of the sequence. 
last  The end of the sequence. 
RandomAccessIterator  is a model of Random Access Iterator, RandomAccessIterator is mutable, and RandomAccessIterator's value_type is a model of LessThan Comparable, and the ordering relation on RandomAccessIterator's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements. 
The following code snippet demonstrates how to use sort
to sort a sequence of integers.
__host__ __device__ void thrust::sort  (  const thrust::detail::execution_policy_base< DerivedPolicy > &  exec, 
RandomAccessIterator  first,  
RandomAccessIterator  last,  
StrictWeakOrdering  comp  
) 
sort
sorts the elements in [first, last)
into ascending order, meaning that if i
and j
are any two valid iterators in [first, last)
such that i
precedes j
, then *j
is not less than *i
. Note: sort
is not guaranteed to be stable. That is, suppose that *i
and *j
are equivalent: neither one is less than the other. It is not guaranteed that the relative order of these two elements will be preserved by sort
.
This version of sort
compares objects using a function object comp
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
first  The beginning of the sequence. 
last  The end of the sequence. 
comp  Comparison operator. 
DerivedPolicy  The name of the derived execution policy. 
RandomAccessIterator  is a model of Random Access Iterator, RandomAccessIterator is mutable, and RandomAccessIterator's value_type is convertible to StrictWeakOrdering's first_argument_type and second_argument_type . 
StrictWeakOrdering  is a model of Strict Weak Ordering. 
The following code demonstrates how to sort integers in descending order using the greater<int> comparison operator using the thrust::host
execution policy for parallelization:
__host__ __device__ void thrust::sort  (  RandomAccessIterator  first, 
RandomAccessIterator  last,  
StrictWeakOrdering  comp  
) 
sort
sorts the elements in [first, last)
into ascending order, meaning that if i
and j
are any two valid iterators in [first, last)
such that i
precedes j
, then *j
is not less than *i
. Note: sort
is not guaranteed to be stable. That is, suppose that *i
and *j
are equivalent: neither one is less than the other. It is not guaranteed that the relative order of these two elements will be preserved by sort
.
This version of sort
compares objects using a function object comp
.
first  The beginning of the sequence. 
last  The end of the sequence. 
comp  Comparison operator. 
RandomAccessIterator  is a model of Random Access Iterator, RandomAccessIterator is mutable, and RandomAccessIterator's value_type is convertible to StrictWeakOrdering's first_argument_type and second_argument_type . 
StrictWeakOrdering  is a model of Strict Weak Ordering. 
The following code demonstrates how to sort integers in descending order using the greater<int> comparison operator.
__host__ __device__ void thrust::sort_by_key  (  const thrust::detail::execution_policy_base< DerivedPolicy > &  exec, 
RandomAccessIterator1  keys_first,  
RandomAccessIterator1  keys_last,  
RandomAccessIterator2  values_first  
) 
sort_by_key
performs a keyvalue sort. That is, sort_by_key
sorts the elements in [keys_first, keys_last)
and [values_first, values_first + (keys_last  keys_first))
into ascending key order, meaning that if i
and j
are any two valid iterators in [keys_first, keys_last)
such that i
precedes j
, and p
and q
are iterators in [values_first, values_first + (keys_last  keys_first))
corresponding to i
and j
respectively, then *j
is not less than *i
.
Note: sort_by_key
is not guaranteed to be stable. That is, suppose that *i
and *j
are equivalent: neither one is less than the other. It is not guaranteed that the relative order of these two keys or the relative order of their corresponding values will be preserved by sort_by_key
.
This version of sort_by_key
compares key objects using operator<
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
keys_first  The beginning of the key sequence. 
keys_last  The end of the key sequence. 
values_first  The beginning of the value sequence. 
DerivedPolicy  The name of the derived execution policy. 
RandomAccessIterator1  is a model of Random Access Iterator, RandomAccessIterator1 is mutable, and RandomAccessIterator1's value_type is a model of LessThan Comparable, and the ordering relation on RandomAccessIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements. 
RandomAccessIterator2  is a model of Random Access Iterator, and RandomAccessIterator2 is mutable. 
[keys_first, keys_last))
shall not overlap the range [values_first, values_first + (keys_last  keys_first))
.The following code snippet demonstrates how to use sort_by_key
to sort an array of character values using integers as sorting keys using the thrust::host
execution policy for parallelization:
void thrust::sort_by_key  (  RandomAccessIterator1  keys_first, 
RandomAccessIterator1  keys_last,  
RandomAccessIterator2  values_first  
) 
sort_by_key
performs a keyvalue sort. That is, sort_by_key
sorts the elements in [keys_first, keys_last)
and [values_first, values_first + (keys_last  keys_first))
into ascending key order, meaning that if i
and j
are any two valid iterators in [keys_first, keys_last)
such that i
precedes j
, and p
and q
are iterators in [values_first, values_first + (keys_last  keys_first))
corresponding to i
and j
respectively, then *j
is not less than *i
.
Note: sort_by_key
is not guaranteed to be stable. That is, suppose that *i
and *j
are equivalent: neither one is less than the other. It is not guaranteed that the relative order of these two keys or the relative order of their corresponding values will be preserved by sort_by_key
.
This version of sort_by_key
compares key objects using operator<
.
keys_first  The beginning of the key sequence. 
keys_last  The end of the key sequence. 
values_first  The beginning of the value sequence. 
RandomAccessIterator1  is a model of Random Access Iterator, RandomAccessIterator1 is mutable, and RandomAccessIterator1's value_type is a model of LessThan Comparable, and the ordering relation on RandomAccessIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements. 
RandomAccessIterator2  is a model of Random Access Iterator, and RandomAccessIterator2 is mutable. 
[keys_first, keys_last))
shall not overlap the range [values_first, values_first + (keys_last  keys_first))
.The following code snippet demonstrates how to use sort_by_key
to sort an array of character values using integers as sorting keys.
__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  
) 
sort_by_key
performs a keyvalue sort. That is, sort_by_key
sorts the elements in [keys_first, keys_last)
and [values_first, values_first + (keys_last  keys_first))
into ascending key order, meaning that if i
and j
are any two valid iterators in [keys_first, keys_last)
such that i
precedes j
, and p
and q
are iterators in [values_first, values_first + (keys_last  keys_first))
corresponding to i
and j
respectively, then *j
is not less than *i
.
Note: sort_by_key
is not guaranteed to be stable. That is, suppose that *i
and *j
are equivalent: neither one is less than the other. It is not guaranteed that the relative order of these two keys or the relative order of their corresponding values will be preserved by sort_by_key
.
This version of sort_by_key
compares key objects using a function object comp
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
keys_first  The beginning of the key sequence. 
keys_last  The end of the key sequence. 
values_first  The beginning of the value sequence. 
comp  Comparison operator. 
DerivedPolicy  The name of the derived execution policy. 
RandomAccessIterator1  is a model of Random Access Iterator, RandomAccessIterator1 is mutable, and RandomAccessIterator1's value_type is convertible to StrictWeakOrdering's first_argument_type and second_argument_type . 
RandomAccessIterator2  is a model of Random Access Iterator, and RandomAccessIterator2 is mutable. 
StrictWeakOrdering  is a model of Strict Weak Ordering. 
[keys_first, keys_last))
shall not overlap the range [values_first, values_first + (keys_last  keys_first))
.The following code snippet demonstrates how to use sort_by_key
to sort an array of character values using integers as sorting keys using the thrust::host
execution policy for parallelization.The keys are sorted in descending order using the greater<int>
comparison operator.
void thrust::sort_by_key  (  RandomAccessIterator1  keys_first, 
RandomAccessIterator1  keys_last,  
RandomAccessIterator2  values_first,  
StrictWeakOrdering  comp  
) 
sort_by_key
performs a keyvalue sort. That is, sort_by_key
sorts the elements in [keys_first, keys_last)
and [values_first, values_first + (keys_last  keys_first))
into ascending key order, meaning that if i
and j
are any two valid iterators in [keys_first, keys_last)
such that i
precedes j
, and p
and q
are iterators in [values_first, values_first + (keys_last  keys_first))
corresponding to i
and j
respectively, then *j
is not less than *i
.
Note: sort_by_key
is not guaranteed to be stable. That is, suppose that *i
and *j
are equivalent: neither one is less than the other. It is not guaranteed that the relative order of these two keys or the relative order of their corresponding values will be preserved by sort_by_key
.
This version of sort_by_key
compares key objects using a function object comp
.
keys_first  The beginning of the key sequence. 
keys_last  The end of the key sequence. 
values_first  The beginning of the value sequence. 
comp  Comparison operator. 
RandomAccessIterator1  is a model of Random Access Iterator, RandomAccessIterator1 is mutable, and RandomAccessIterator1's value_type is convertible to StrictWeakOrdering's first_argument_type and second_argument_type . 
RandomAccessIterator2  is a model of Random Access Iterator, and RandomAccessIterator2 is mutable. 
StrictWeakOrdering  is a model of Strict Weak Ordering. 
[keys_first, keys_last))
shall not overlap the range [values_first, values_first + (keys_last  keys_first))
.The following code snippet demonstrates how to use sort_by_key
to sort an array of character values using integers as sorting keys. The keys are sorted in descending order using the greater<int> comparison operator.
__host__ __device__ void thrust::stable_sort  (  const thrust::detail::execution_policy_base< DerivedPolicy > &  exec, 
RandomAccessIterator  first,  
RandomAccessIterator  last  
) 
stable_sort
is much like sort:
it sorts the elements in [first, last)
into ascending order, meaning that if i
and j
are any two valid iterators in [first, last)
such that i
precedes j
, then *j
is not less than *i
.
As the name suggests, stable_sort
is stable: it preserves the relative ordering of equivalent elements. That is, if x
and y
are elements in [first, last)
such that x
precedes y
, and if the two elements are equivalent (neither x < y
nor y < x
) then a postcondition of stable_sort
is that x
still precedes y
.
This version of stable_sort
compares objects using operator<
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
first  The beginning of the sequence. 
last  The end of the sequence. 
DerivedPolicy  The name of the derived execution policy. 
RandomAccessIterator  is a model of Random Access Iterator, RandomAccessIterator is mutable, and RandomAccessIterator's value_type is a model of LessThan Comparable, and the ordering relation on RandomAccessIterator's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements. 
The following code snippet demonstrates how to use sort
to sort a sequence of integers using the thrust::host
execution policy for parallelization:
void thrust::stable_sort  (  RandomAccessIterator  first, 
RandomAccessIterator  last  
) 
stable_sort
is much like sort:
it sorts the elements in [first, last)
into ascending order, meaning that if i
and j
are any two valid iterators in [first, last)
such that i
precedes j
, then *j
is not less than *i
.
As the name suggests, stable_sort
is stable: it preserves the relative ordering of equivalent elements. That is, if x
and y
are elements in [first, last)
such that x
precedes y
, and if the two elements are equivalent (neither x < y
nor y < x
) then a postcondition of stable_sort
is that x
still precedes y
.
This version of stable_sort
compares objects using operator<
.
first  The beginning of the sequence. 
last  The end of the sequence. 
RandomAccessIterator  is a model of Random Access Iterator, RandomAccessIterator is mutable, and RandomAccessIterator's value_type is a model of LessThan Comparable, and the ordering relation on RandomAccessIterator's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements. 
The following code snippet demonstrates how to use sort
to sort a sequence of integers.
__host__ __device__ void thrust::stable_sort  (  const thrust::detail::execution_policy_base< DerivedPolicy > &  exec, 
RandomAccessIterator  first,  
RandomAccessIterator  last,  
StrictWeakOrdering  comp  
) 
stable_sort
is much like sort:
it sorts the elements in [first, last)
into ascending order, meaning that if i
and j
are any two valid iterators in [first, last)
such that i
precedes j
, then *j
is not less than *i
.
As the name suggests, stable_sort
is stable: it preserves the relative ordering of equivalent elements. That is, if x
and y
are elements in [first, last)
such that x
precedes y
, and if the two elements are equivalent (neither x < y
nor y < x
) then a postcondition of stable_sort
is that x
still precedes y
.
This version of stable_sort
compares objects using a function object comp
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
first  The beginning of the sequence. 
last  The end of the sequence. 
comp  Comparison operator. 
DerivedPolicy  The name of the derived execution policy. 
RandomAccessIterator  is a model of Random Access Iterator, RandomAccessIterator is mutable, and RandomAccessIterator's value_type is convertible to StrictWeakOrdering's first_argument_type and second_argument_type . 
StrictWeakOrdering  is a model of Strict Weak Ordering. 
The following code demonstrates how to sort integers in descending order using the greater<int> comparison operator using the thrust::host
execution policy for parallelization:
void thrust::stable_sort  (  RandomAccessIterator  first, 
RandomAccessIterator  last,  
StrictWeakOrdering  comp  
) 
stable_sort
is much like sort:
it sorts the elements in [first, last)
into ascending order, meaning that if i
and j
are any two valid iterators in [first, last)
such that i
precedes j
, then *j
is not less than *i
.
As the name suggests, stable_sort
is stable: it preserves the relative ordering of equivalent elements. That is, if x
and y
are elements in [first, last)
such that x
precedes y
, and if the two elements are equivalent (neither x < y
nor y < x
) then a postcondition of stable_sort
is that x
still precedes y
.
This version of stable_sort
compares objects using a function object comp
.
first  The beginning of the sequence. 
last  The end of the sequence. 
comp  Comparison operator. 
RandomAccessIterator  is a model of Random Access Iterator, RandomAccessIterator is mutable, and RandomAccessIterator's value_type is convertible to StrictWeakOrdering's first_argument_type and second_argument_type . 
StrictWeakOrdering  is a model of Strict Weak Ordering. 
The following code demonstrates how to sort integers in descending order using the greater<int> comparison operator.
__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  
) 
stable_sort_by_key
performs a keyvalue sort. That is, stable_sort_by_key
sorts the elements in [keys_first, keys_last)
and [values_first, values_first + (keys_last  keys_first))
into ascending key order, meaning that if i
and j
are any two valid iterators in [keys_first, keys_last)
such that i
precedes j
, and p
and q
are iterators in [values_first, values_first + (keys_last  keys_first))
corresponding to i
and j
respectively, then *j
is not less than *i
.
As the name suggests, stable_sort_by_key
is stable: it preserves the relative ordering of equivalent elements. That is, if x
and y
are elements in [keys_first, keys_last)
such that x
precedes y
, and if the two elements are equivalent (neither x < y
nor y < x
) then a postcondition of stable_sort_by_key
is that x
still precedes y
.
This version of stable_sort_by_key
compares key objects using operator<
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
keys_first  The beginning of the key sequence. 
keys_last  The end of the key sequence. 
values_first  The beginning of the value sequence. 
DerivedPolicy  The name of the derived execution policy. 
RandomAccessIterator1  is a model of Random Access Iterator, RandomAccessIterator1 is mutable, and RandomAccessIterator1's value_type is a model of LessThan Comparable, and the ordering relation on RandomAccessIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements. 
RandomAccessIterator2  is a model of Random Access Iterator, and RandomAccessIterator2 is mutable. 
[keys_first, keys_last))
shall not overlap the range [values_first, values_first + (keys_last  keys_first))
.The following code snippet demonstrates how to use stable_sort_by_key
to sort an array of characters using integers as sorting keys using the thrust::host
execution policy for parallelization:
void thrust::stable_sort_by_key  (  RandomAccessIterator1  keys_first, 
RandomAccessIterator1  keys_last,  
RandomAccessIterator2  values_first  
) 
stable_sort_by_key
performs a keyvalue sort. That is, stable_sort_by_key
sorts the elements in [keys_first, keys_last)
and [values_first, values_first + (keys_last  keys_first))
into ascending key order, meaning that if i
and j
are any two valid iterators in [keys_first, keys_last)
such that i
precedes j
, and p
and q
are iterators in [values_first, values_first + (keys_last  keys_first))
corresponding to i
and j
respectively, then *j
is not less than *i
.
As the name suggests, stable_sort_by_key
is stable: it preserves the relative ordering of equivalent elements. That is, if x
and y
are elements in [keys_first, keys_last)
such that x
precedes y
, and if the two elements are equivalent (neither x < y
nor y < x
) then a postcondition of stable_sort_by_key
is that x
still precedes y
.
This version of stable_sort_by_key
compares key objects using operator<
.
keys_first  The beginning of the key sequence. 
keys_last  The end of the key sequence. 
values_first  The beginning of the value sequence. 
RandomAccessIterator1  is a model of Random Access Iterator, RandomAccessIterator1 is mutable, and RandomAccessIterator1's value_type is a model of LessThan Comparable, and the ordering relation on RandomAccessIterator1's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements. 
RandomAccessIterator2  is a model of Random Access Iterator, and RandomAccessIterator2 is mutable. 
[keys_first, keys_last))
shall not overlap the range [values_first, values_first + (keys_last  keys_first))
.The following code snippet demonstrates how to use stable_sort_by_key
to sort an array of characters using integers as sorting keys.
__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  
) 
stable_sort_by_key
performs a keyvalue sort. That is, stable_sort_by_key
sorts the elements in [keys_first, keys_last)
and [values_first, values_first + (keys_last  keys_first))
into ascending key order, meaning that if i
and j
are any two valid iterators in [keys_first, keys_last)
such that i
precedes j
, and p
and q
are iterators in [values_first, values_first + (keys_last  keys_first))
corresponding to i
and j
respectively, then *j
is not less than *i
.
As the name suggests, stable_sort_by_key
is stable: it preserves the relative ordering of equivalent elements. That is, if x
and y
are elements in [keys_first, keys_last)
such that x
precedes y
, and if the two elements are equivalent (neither x < y
nor y < x
) then a postcondition of stable_sort_by_key
is that x
still precedes y
.
This version of stable_sort_by_key
compares key objects using the function object comp
.
The algorithm's execution is parallelized as determined by exec
.
exec  The execution policy to use for parallelization. 
keys_first  The beginning of the key sequence. 
keys_last  The end of the key sequence. 
values_first  The beginning of the value sequence. 
comp  Comparison operator. 
DerivedPolicy  The name of the derived execution policy. 
RandomAccessIterator1  is a model of Random Access Iterator, RandomAccessIterator1 is mutable, and RandomAccessIterator1's value_type is convertible to StrictWeakOrdering's first_argument_type and second_argument_type . 
RandomAccessIterator2  is a model of Random Access Iterator, and RandomAccessIterator2 is mutable. 
StrictWeakOrdering  is a model of Strict Weak Ordering. 
[keys_first, keys_last))
shall not overlap the range [values_first, values_first + (keys_last  keys_first))
.The following code snippet demonstrates how to use sort_by_key
to sort an array of character values using integers as sorting keys using the thrust::host
execution policy for parallelization. The keys are sorted in descending order using the greater<int>
comparison operator.
void thrust::stable_sort_by_key  (  RandomAccessIterator1  keys_first, 
RandomAccessIterator1  keys_last,  
RandomAccessIterator2  values_first,  
StrictWeakOrdering  comp  
) 
stable_sort_by_key
performs a keyvalue sort. That is, stable_sort_by_key
sorts the elements in [keys_first, keys_last)
and [values_first, values_first + (keys_last  keys_first))
into ascending key order, meaning that if i
and j
are any two valid iterators in [keys_first, keys_last)
such that i
precedes j
, and p
and q
are iterators in [values_first, values_first + (keys_last  keys_first))
corresponding to i
and j
respectively, then *j
is not less than *i
.
As the name suggests, stable_sort_by_key
is stable: it preserves the relative ordering of equivalent elements. That is, if x
and y
are elements in [keys_first, keys_last)
such that x
precedes y
, and if the two elements are equivalent (neither x < y
nor y < x
) then a postcondition of stable_sort_by_key
is that x
still precedes y
.
This version of stable_sort_by_key
compares key objects using the function object comp
.
keys_first  The beginning of the key sequence. 
keys_last  The end of the key sequence. 
values_first  The beginning of the value sequence. 
comp  Comparison operator. 
RandomAccessIterator1  is a model of Random Access Iterator, RandomAccessIterator1 is mutable, and RandomAccessIterator1's value_type is convertible to StrictWeakOrdering's first_argument_type and second_argument_type . 
RandomAccessIterator2  is a model of Random Access Iterator, and RandomAccessIterator2 is mutable. 
StrictWeakOrdering  is a model of Strict Weak Ordering. 
[keys_first, keys_last))
shall not overlap the range [values_first, values_first + (keys_last  keys_first))
.The following code snippet demonstrates how to use sort_by_key
to sort an array of character values using integers as sorting keys. The keys are sorted in descending order using the greater<int> comparison operator.