◆ minmax_element() [3/4]

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 

minmax_element finds the smallest and largest elements in the range [first, last). It returns a pair of iterators (imin, imax) where imin is the same iterator returned by min_element and imax is the same iterator returned by max_element. This function is potentially more efficient than separate calls to min_element and max_element.

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

execThe execution policy to use for parallelization.
firstThe beginning of the sequence.
lastThe end of the sequence.
compA binary predicate used for comparison.
A pair of iterator pointing to the smallest and largest elements of the range [first, last), if it is not an empty range; last, otherwise.
Template Parameters
DerivedPolicyThe name of the derived execution policy.
ForwardIteratoris a model of Forward Iterator, and ForwardIterator's value_type is convertible to both comp's first_argument_type and second_argument_type.
BinaryPredicateis a model of Binary Predicate.

The following code snippet demonstrates how to use minmax_element to find the smallest and largest elements of a collection of key-value pairs using the thrust::host execution policy for parallelization:

#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(thrust::host, data, data + 4, compare_key_value());
// extrema.first == data + 1
// *extrema.first == {0,7}
// extrema.second == data + 3
// *extrema.second == {6,1}
See also