Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      std::experimental::parallel::reduce

      From cppreference.com
      <cpp‎ |experimental
       
       
       
       
      Defined in header<experimental/numeric>
      template<class InputIt>

      typenamestd::iterator_traits<InputIt>::value_type reduce(

          InputIt first, InputIt last);
      		 (1)(parallelism TS)
      template<class ExecutionPolicy,class InputIterator>

      typenamestd::iterator_traits<InputIt>::value_type reduce(

          ExecutionPolicy&& policy, InputIt first, InputIt last);
      		 (2)(parallelism TS)
      template<class InputIt,class T>
      T reduce( InputIt first, InputIt last, T init);
      		 (3)(parallelism TS)
      template<class ExecutionPolicy,class InputIt,class T>
      T reduce( ExecutionPolicy&& policy, InputIt first, InputIt last, T init);
      		 (4)(parallelism TS)
      template<class InputIt,class T,class BinaryOp>
      T reduce( InputIt first, InputIt last, T init, BinaryOp binary_op);
      		 (5)(parallelism TS)
      template<class ExecutionPolicy,class InputIt,class T,class BinaryOp>

      T reduce( ExecutionPolicy&& policy,

                InputIt first, InputIt last, T init, BinaryOp binary_op);
      		 (6)(parallelism TS)
      1) Same asreduce(first, last,typenamestd::iterator_traits<InputIt>::value_type{}).
      3) Same asreduce(first, last, init,std::plus<>()).
      5) Reduces the range[first, last), possibly permuted and aggregated in unspecified manner, along with the initial valueinit overbinary_op.
      2,4,6) Same as(1,3,5), but executed according topolicy.

      The behavior is non-deterministic ifbinary_op is not associative or not commutative.

      The behavior is undefined ifbinary_op modifies any element or invalidates any iterator in[first, last).

      Contents

      [edit]Parameters

      first, last - the range of elements to apply the algorithm to
      init - the initial value of the generalized sum
      policy - theexecution policy
      binary_op - binaryFunctionObject that will be applied in unspecified order to the result of dereferencing the input iterators, the results of otherbinary_op andinit
      Type requirements
      -
      InputIt must meet the requirements ofLegacyInputIterator.

      [edit]Return value

      Generalized sum ofinit and*first,*(first+1), ...*(last-1) overbinary_op,

      where generalized sumGSUM(op, a1, ..., aN) is defined as follows:

      • ifN=1,a1
      • ifN > 1,op(GSUM(op, b1, ..., bK), GSUM(op, bM, ..., bN)) where
      • b1, ..., bN may be any permutation ofa1, ..., aN and
      • 1 < K+1 = M ≤ N

      in other words, the elements of the range may be grouped and rearranged in arbitrary order.

      [edit]Complexity

      O(last - first) applications ofbinary_op.

      [edit]Exceptions

      • If execution of a function invoked as part of the algorithm throws an exception,
      • ifpolicy isparallel_vector_execution_policy,std::terminate is called.
      • ifpolicy issequential_execution_policy orparallel_execution_policy, the algorithm exits with anexception_list containing all uncaught exceptions. If there was only one uncaught exception, the algorithm may rethrow it without wrapping inexception_list. It is unspecified how much work the algorithm will perform before returning after the first exception was encountered.
      • ifpolicy is some other type, the behavior is implementation-defined.
      • If the algorithm fails to allocate memory (either for itself or to construct anexception_list when handling a user exception),std::bad_alloc is thrown.

      [edit]Notes

      If the range is empty,init is returned, unmodified.

      • Ifpolicy is an instance ofsequential_execution_policy, all operations are performed in the calling thread.
      • Ifpolicy is an instance ofparallel_execution_policy, operations may be performed in unspecified number of threads, indeterminately sequenced with each other.
      • Ifpolicy is an instance ofparallel_vector_execution_policy, execution may be both parallelized and vectorized: function body boundaries are not respected and user code may be overlapped and combined in arbitrary manner (in particular, this implies that a user-provided Callable must not acquire a mutex to access a shared resource).

      [edit]Example

      reduce is the out-of-order version ofstd::accumulate:

      Run this code
      #include <chrono>#include <experimental/execution_policy>#include <experimental/numeric>#include <iostream>#include <numeric>#include <vector> int main(){std::vector<double> v(10'000'007,0.5); {auto t1=std::chrono::high_resolution_clock::now();double result=std::accumulate(v.begin(), v.end(),0.0);auto t2=std::chrono::high_resolution_clock::now();std::chrono::duration<double,std::milli> ms= t2- t1;std::cout<<std::fixed<<"std::accumulate result "<< result<<" took "<< ms.count()<<" ms\n";} {auto t1=std::chrono::high_resolution_clock::now();double result= std::experimental::parallel::reduce(std::experimental::parallel::par,                            v.begin(), v.end());auto t2=std::chrono::high_resolution_clock::now();std::chrono::duration<double,std::milli> ms= t2- t1;std::cout<<"parallel::reduce result "<< result<<" took "<< ms.count()<<" ms\n";}}

      Possible output:

      std::accumulate result 5000003.50000 took 12.7365 msparallel::reduce result 5000003.50000 took 5.06423 ms

      [edit]See also

      sums up or folds a range of elements
      (function template)[edit]
      applies a function to a range of elements, storing results in a destination range
      (function template)[edit]
      (parallelism TS)
      		 applies a functor, then reduces out of order
      (function template)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/experimental/reduce&oldid=155635"
      [8]ページ先頭
      ©2009-2025 Movatter.jp