ceph/src/boost/libs/compute/include/boost/compute/algorithm/reduce_by_key.hpp

   1 //---------------------------------------------------------------------------//
   2 // Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com>
   3 //
   4 // Distributed under the Boost Software License, Version 1.0
   5 // See accompanying file LICENSE_1_0.txt or copy at
   6 // http://www.boost.org/LICENSE_1_0.txt
   7 //
   8 // See http://boostorg.github.com/compute for more information.
   9 //---------------------------------------------------------------------------//
  10
  11 #ifndef BOOST_COMPUTE_ALGORITHM_REDUCE_BY_KEY_HPP
  12 #define BOOST_COMPUTE_ALGORITHM_REDUCE_BY_KEY_HPP
  13
  14 #include <iterator>
  15 #include <utility>
  16
  17 #include <boost/compute/command_queue.hpp>
  18 #include <boost/compute/device.hpp>
  19 #include <boost/compute/functional.hpp>
  20 #include <boost/compute/system.hpp>
  21 #include <boost/compute/algorithm/detail/reduce_by_key.hpp>
  22
  23 namespace boost {
  24 namespace compute {
  25
  26 /// The \c reduce_by_key() algorithm performs reduction for each contiguous
  27 /// subsequence of values determinate by equivalent keys.
  28 ///
  29 /// Returns a pair of iterators at the end of the ranges [\p keys_result, keys_result_last)
  30 /// and [\p values_result, \p values_result_last).
  31 ///
  32 /// If no function is specified, \c plus will be used.
  33 /// If no predicate is specified, \c equal_to will be used.
  34 ///
  35 /// \param keys_first the first key
  36 /// \param keys_last the last key
  37 /// \param values_first the first input value
  38 /// \param keys_result iterator pointing to the key output
  39 /// \param values_result iterator pointing to the reduced value output
  40 /// \param function binary reduction function
  41 /// \param predicate binary predicate which returns true only if two keys are equal
  42 /// \param queue command queue to perform the operation
  43 ///
  44 /// The \c reduce_by_key() algorithm assumes that the binary reduction function
  45 /// is associative. When used with non-associative functions the result may
  46 /// be non-deterministic and vary in precision. Notably this affects the
  47 /// \c plus<float>() function as floating-point addition is not associative
  48 /// and may produce slightly different results than a serial algorithm.
  49 ///
  50 /// For example, to calculate the sum of the values for each key:
  51 ///
  52 /// \snippet test/test_reduce_by_key.cpp reduce_by_key_int
  53 ///
  54 /// \see reduce()
  55 template<class InputKeyIterator, class InputValueIterator,
  56          class OutputKeyIterator, class OutputValueIterator,
  57          class BinaryFunction, class BinaryPredicate>
  58 inline std::pair<OutputKeyIterator, OutputValueIterator>
  59 reduce_by_key(InputKeyIterator keys_first,
  60               InputKeyIterator keys_last,
  61               InputValueIterator values_first,
  62               OutputKeyIterator keys_result,
  63               OutputValueIterator values_result,
  64               BinaryFunction function,
  65               BinaryPredicate predicate,
  66               command_queue &queue = system::default_queue())
  67 {
  68     return detail::dispatch_reduce_by_key(keys_first, keys_last, values_first,
  69                                           keys_result, values_result,
  70                                           function, predicate,
  71                                           queue);
  72 }
  73
  74 /// \overload
  75 template<class InputKeyIterator, class InputValueIterator,
  76          class OutputKeyIterator, class OutputValueIterator,
  77          class BinaryFunction>
  78 inline std::pair<OutputKeyIterator, OutputValueIterator>
  79 reduce_by_key(InputKeyIterator keys_first,
  80               InputKeyIterator keys_last,
  81               InputValueIterator values_first,
  82               OutputKeyIterator keys_result,
  83               OutputValueIterator values_result,
  84               BinaryFunction function,
  85               command_queue &queue = system::default_queue())
  86 {
  87     typedef typename std::iterator_traits<InputKeyIterator>::value_type key_type;
  88
  89     return reduce_by_key(keys_first, keys_last, values_first,
  90                          keys_result, values_result,
  91                          function, equal_to<key_type>(),
  92                          queue);
  93 }
  94
  95 /// \overload
  96 template<class InputKeyIterator, class InputValueIterator,
  97          class OutputKeyIterator, class OutputValueIterator>
  98 inline std::pair<OutputKeyIterator, OutputValueIterator>
  99 reduce_by_key(InputKeyIterator keys_first,
 100               InputKeyIterator keys_last,
 101               InputValueIterator values_first,
 102               OutputKeyIterator keys_result,
 103               OutputValueIterator values_result,
 104               command_queue &queue = system::default_queue())
 105 {
 106     typedef typename std::iterator_traits<InputKeyIterator>::value_type key_type;
 107     typedef typename std::iterator_traits<InputValueIterator>::value_type value_type;
 108
 109     return reduce_by_key(keys_first, keys_last, values_first,
 110                          keys_result, values_result,
 111                          plus<value_type>(), equal_to<key_type>(),
 112                          queue);
 113 }
 114
 115 } // end compute namespace
 116 } // end boost namespace
 117
 118 #endif // BOOST_COMPUTE_ALGORITHM_REDUCE_BY_KEY_HPP