Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      Parallelized version of existing algorithms(parallelism TS)

      From cppreference.com
      <cpp‎ |experimental‎ |parallelism
       
       
       
       
      Merged into ISO C++ The functionality described on this page was merged into the mainline ISO C++ standard as of 3/2016; seethe algorithm library(since C++17)

      The C++ Extensions for Parallelism TS provides parallelized versions of the following 69 existing algorithms. Each of the following parallelized algorithms

      • is declared in thestd::experimental::parallel namespace,
      • does not participate in overload resolution unlessis_execution_policy<std::decay_t<ExecutionPolicy>>::value istrue, and
      • has the same semantics as the corresponding existing algorithm in the C++ standard library, except as noted in the page onparallel algorithms.


      Contents

      Non-modifying sequence operations
      Parallelized algorithm Existing algorithm
      template<class ExecutionPolicy,class InputIt,class UnaryPred>

      bool all_of( ExecutionPolicy&& policy, InputIt first, InputIt last,
                   UnaryPred p);

      		std::all_of
      template<class ExecutionPolicy,class InputIt,class UnaryPred>

      bool any_of( ExecutionPolicy&& policy, InputIt first, InputIt last,
                   UnaryPred p);

      		std::any_of
      template<class ExecutionPolicy,class InputIt,class UnaryPred>

      bool none_of( ExecutionPolicy&& policy, InputIt first, InputIt last,
                    UnaryPred p);

      		std::none_of
      template<class ExecutionPolicy,class InputIt,class T>

      typename iterator_traits<InputIt>::difference_type
          count( ExecutionPolicy&& policy, InputIt first, InputIt last,
                 const T&value);

      		std::count
      template<class ExecutionPolicy,class InputIt,class UnaryPred>

      typename iterator_traits<InputIt>::difference_type
          count_if( ExecutionPolicy&& policy, InputIt first, InputIt last,
                    UnaryPred p);

      		std::count_if
      template<class ExecutionPolicy,class InputIt1,class InputIt2>

      std::pair<InputIt1,InputIt2>
          mismatch( ExecutionPolicy&& policy,
                    InputIt1 first1, InputIt1 last1,
                    InputIt2 first2);

      template<class ExecutionPolicy,class InputIt1,
               class InputIt2,class BinaryPred>
      std::pair<InputIt1,InputIt2>
          mismatch( ExecutionPolicy&& policy,
                    InputIt1 first1, InputIt1 last1,
                    InputIt2 first2, BinaryPred p);

      template<class ExecutionPolicy,class InputIt1,class InputIt2>
      std::pair<InputIt1,InputIt2>
          mismatch( ExecutionPolicy&& policy,
                    InputIt1 first1, InputIt1 last1,
                    InputIt2 first2, InputIt2 last2);

      template<class ExecutionPolicy,class InputIt1,
               class InputIt2,class BinaryPred>
      std::pair<InputIt1,InputIt2>
          mismatch( ExecutionPolicy&& policy,
                    InputIt1 first1, InputIt1 last1,
                    InputIt2 first2, InputIt2 last2, BinaryPred p);

      		std::mismatch
      template<class ExecutionPolicy,class InputIt1,class InputIt2>

      bool equal( ExecutionPolicy&& policy,
                  InputIt1 first1, InputIt1 last1,
                  InputIt2 first2);

      template<class ExecutionPolicy,class InputIt1,
               class InputIt2,class BinaryPred>
      bool equal( ExecutionPolicy&& policy,
                  InputIt1 first1, InputIt1 last1,
                  InputIt2 first2, BinaryPred p);

      template<class ExecutionPolicy,class InputIt1,class InputIt2>
      bool equal( ExecutionPolicy&& policy,
                  InputIt1 first1, InputIt1 last1,
                  InputIt2 first2, InputIt2 last2);

      template<class ExecutionPolicy,class InputIt1,
               class InputIt2,class BinaryPred>
      bool equal( ExecutionPolicy&& policy,
                  InputIt1 first1, InputIt1 last1,
                  InputIt2 first2, InputIt2 last2, BinaryPred p);

      		std::equal
      template<class ExecutionPolicy,class InputIt,class T>

      InputIt find( ExecutionPolicy&& policy, InputIt first, InputIt last,
                   const T& value);

      		std::find
      template<class ExecutionPolicy,class InputIt,class UnaryPred>

      InputIt find_if( ExecutionPolicy&& policy, InputIt first, InputIt last,
                       UnaryPred p);

      		std::find_if
      template<class ExecutionPolicy,class InputIt,class UnaryPred>

      InputIt find_if_not( ExecutionPolicy&& policy,
                           InputIt first, InputIt last,
                           UnaryPred p);

      		std::find_if_not
      template<class ExecutionPolicy,class ForwardIt1,class ForwardIt2>

      ForwardIt1 find_end( ExecutionPolicy&& policy,
                           ForwardIt1 first, ForwardIt1 last,
                           ForwardIt2 s_first, ForwardIt2 s_last);
             
      template<class ExecutionPolicy,class ForwardIt1,
               class ForwardIt2,class BinaryPred>
      ForwardIt1 find_end( ExecutionPolicy&& policy,
                           ForwardIt1 first, ForwardIt1 last,
                           ForwardIt2 s_first, ForwardIt2 s_last,
                           BinaryPred p);

      		std::find_end
      template<class ExecutionPolicy,class InputIt,class ForwardIt>

      InputIt find_first_of( ExecutionPolicy&& policy,
                             InputIt first, InputIt last,
                             ForwardIt s_first, ForwardIt s_last);

      template<class ExecutionPolicy,class InputIt,
               class ForwardIt,class BinaryPred>
      InputIt find_first_of( ExecutionPolicy&& policy,
                             InputIt first, InputIt last,
                             ForwardIt s_first, ForwardIt s_last,
                             BinaryPred p);

      		std::find_first_of
      template<class ExecutionPolicy,class ForwardIt>

      ForwardIt adjacent_find( ExecutionPolicy&& policy,
                               ForwardIt first, ForwardIt last);
             
      template<class ExecutionPolicy,class ForwardIt,class BinaryPred>
      ForwardIt adjacent_find( ExecutionPolicy&& policy,
                               ForwardIt first, ForwardIt last,
                               BinaryPred p);

      		std::adjacent_find
      template<class ExecutionPolicy,class ForwardIt1,class ForwardIt2>

      ForwardIt1 search( ExecutionPolicy&& policy,
                         ForwardIt1 first, ForwardIt1 last,
                         ForwardIt2 s_first, ForwardIt2 s_last);

      template<class ExecutionPolicy,class ForwardIt1,
               class ForwardIt2,class BinaryPred>
      ForwardIt1 search( ExecutionPolicy&& policy,
                         ForwardIt1 first, ForwardIt1 last,
                         ForwardIt2 s_first, ForwardIt2 s_last,
                         BinaryPred p);

      		std::search
      template<class ExecutionPolicy,class ForwardIt,class Size,class T>

      ForwardIt search_n( ExecutionPolicy&& policy,
                          ForwardIt first, ForwardIt last,
                          Size count,const T& value);
             
      template<class ExecutionPolicy,class ForwardIt,
               class Size,class T,class BinaryPred>
      ForwardIt search_n( ExecutionPolicy&& policy,
                          ForwardIt first, ForwardIt last,
                          Size count,const T& value,
                          BinaryPred p);

      		std::search_n
      Modifying sequence operations
      Parallelized algorithm Existing algorithm
      template<class ExecutionPolicy,class InputIt,class OutputIt>

      OutputIt copy( ExecutionPolicy&& policy, InputIt first, InputIt last,
                     OutputIt d_first);

      		std::copy
      template<class ExecutionPolicy,class InputIt,

               class OutputIt,class UnaryPred>
      OutputIt copy_if( ExecutionPolicy&& policy, InputIt first, InputIt last,
                        OutputIt d_first, UnaryPred pred);

      		std::copy_if
      template<class ExecutionPolicy,class InputIt,

               class Size,class OutputIt>
      OutputIt copy_n( ExecutionPolicy&& policy, InputIt first, Size count,
                       OutputIt result);

      		std::copy_n
      template<class ExecutionPolicy,class InputIt,class OutputIt>

      OutputIt move( ExecutionPolicy&& policy, InputIt first, InputIt last,
                     OutputIt d_first);

      		std::move
      template<class ExecutionPolicy,class ForwardIt,class T>

      void fill( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last,
                 const T& value);

      		std::fill
      template<class ExecutionPolicy,class OutputIt,class Size,class T>

      OutputIt fill_n( ExecutionPolicy&& policy, OutputIt first, Size count,
                       const T& value);

      		std::fill_n
      template<class ExecutionPolicy,class InputIt,

               class OutputIt,class UnaryOp>
      OutputIt transform( ExecutionPolicy&& policy,
                          InputIt first1, InputIt last1,
                          OutputIt d_first, UnaryOp unary_op);

      template<class ExecutionPolicy,class InputIt1,class InputIt2,
               class OutputIt,class BinaryOp>
      OutputIt transform( ExecutionPolicy&& policy,
                          InputIt1 first1, InputIt1 last1,
                          InputIt2 first2, OutputIt d_first,
                          BinaryOp binary_op);

      		std::transform
      template<class ExecutionPolicy,class ForwardIt,class Generator>

      void generate( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last,
                     Generator g);

      		std::generate
      template<class ExecutionPolicy,class OutputIt,

               class Size,class Generator>
      OutputIt generate_n( ExecutionPolicy&& policy, OutputIt first,
                           Size count, Generator g);

      		std::generate_n
      template<class ExecutionPolicy,class ForwardIt,class T>

      ForwardIt remove( ExecutionPolicy&& policy,
                        ForwardIt first, ForwardIt last,const T& value);

      		std::remove
      template<class ExecutionPolicy,class ForwardIt,class UnaryPred>

      ForwardIt remove_if( ExecutionPolicy&& policy,
                           ForwardIt first, ForwardIt last, UnaryPred p);

      		std::remove_if
      template<class ExecutionPolicy,class InputIt,class OutputIt,class T>

      OutputIt remove_copy( ExecutionPolicy&& policy,
                            InputIt first, InputIt last,
                            OutputIt d_first,const T& value);

      		std::remove_copy
      template<class ExecutionPolicy,class InputIt,

               class OutputIt,class UnaryPred>
      OutputIt remove_copy_if( ExecutionPolicy&& policy,
                               InputIt first, InputIt last,
                               OutputIt d_first, UnaryPred p);

      		std::remove_copy_if
      template<class ExecutionPolicy,class ForwardIt,class T>

      void replace( ExecutionPolicy&& policy,
                    ForwardIt first, ForwardIt last,
                   const T& old_value,const T& new_value);

      		std::replace
      template<class ExecutionPolicy,class ForwardIt,

               class UnaryPred,class T>
      void replace_if( ExecutionPolicy&& policy,
                       ForwardIt first, ForwardIt last,
                       UnaryPred p,const T& new_value);

      		std::replace_if
      template<class ExecutionPolicy,class InputIt,class OutputIt,class T>

      OutputIt replace_copy( ExecutionPolicy&& policy,
                             InputIt first, InputIt last, OutputIt d_first,
                             const T& old_value,const T& new_value);

      		std::replace_copy
      template<class ExecutionPolicy,class InputIt,class OutputIt,

               class UnaryPred,class T>
      OutputIt replace_copy_if( ExecutionPolicy&& policy,
                                InputIt first, InputIt last, OutputIt d_first,
                                UnaryPred p,const T& new_value);

      		std::replace_copy_if
      template<class ExecutionPolicy,class ForwardIt1,class ForwardIt2>

      ForwardIt2 swap_ranges( ExecutionPolicy&& policy,
                              ForwardIt1 first1, ForwardIt1 last1,
                              ForwardIt2 first2);

      		std::swap_ranges
      template<class ExecutionPolicy,class BidirIt>

      void reverse( ExecutionPolicy&& policy, BidirIt first, BidirIt last);

      		std::reverse
      template<class ExecutionPolicy,class BidirIt,class OutputIt>

      OutputIt reverse_copy( ExecutionPolicy&& policy,
                             BidirIt first, BidirIt last, OutputIt d_first);

      		std::reverse_copy
      template<class ExecutionPolicy,class ForwardIt>

      ForwardIt rotate( ExecutionPolicy&& policy,
                        ForwardIt first, ForwardIt n_first, ForwardIt last);

      		std::rotate
      template<class ExecutionPolicy,class ForwardIt,class OutputIt>

      OutputIt rotate_copy( ExecutionPolicy&& policy,
                            ForwardIt first, ForwardIt n_first, ForwardIt last,
                            OutputIt d_first);

      		std::rotate_copy
      template<class ExecutionPolicy,class ForwardIt>

      ForwardIt unique( ExecutionPolicy&& policy,
                        ForwardIt first, ForwardIt last);

      template<class ExecutionPolicy,class ForwardIt,class BinaryPred>
      ForwardIt unique( ExecutionPolicy&& policy,
                        ForwardIt first, ForwardIt last, BinaryPred p);

      		std::unique
      template<class ExecutionPolicy,class InputIt,class OutputIt>

      OutputIt unique_copy( ExecutionPolicy&& policy,
                            InputIt first, InputIt last,
                            OutputIt d_first);

      template<class ExecutionPolicy,class InputIt,
               class OutputIt,class BinaryPred>
      OutputIt unique_copy( ExecutionPolicy&& policy,
                            InputIt first, InputIt last,
                            OutputIt d_first, BinaryPred p);

      		std::unique_copy
      Partitioning operations
      Parallelized algorithm Existing algorithm
      template<class ExecutionPolicy,class InputIt,class UnaryPred>

      bool is_partitioned( ExecutionPolicy&& policy,
                           InputIt first, InputIt last, UnaryPred p);

      		std::is_partitioned
      template<class ExecutionPolicy,class ForwardIt,class UnaryPred>

      ForwardIt partition( ExecutionPolicy&& policy,
                           ForwardIt first, ForwardIt last, UnaryPred p);

      		std::partition
      template<class ExecutionPolicy,class InputIt,class OutputIt1,

               class OutputIt2,class UnaryPred>
      std::pair<OutputIt1, OutputIt2>
           partition_copy( ExecutionPolicy&& policy,
                           InputIt first, InputIt last,
                           OutputIt1 d_first_true, OutputIt2 d_first_false,
                           UnaryPred p);

      		std::partition_copy
      template<class ExecutionPolicy,class BidirIt,class UnaryPred>

      BidirIt stable_partition( ExecutionPolicy&& policy,
                                BidirIt first, BidirIt last, UnaryPred p);

      		std::stable_partition
      Sorting operations
      Parallelized algorithm Existing algorithm
      template<class ExecutionPolicy,class ForwardIt>

      bool is_sorted( ExecutionPolicy&& policy,
                      ForwardIt first, ForwardIt last);

      template<class ExecutionPolicy,class ForwardIt,class Compare>
      bool is_sorted( ExecutionPolicy&& policy,
                      ForwardIt first, ForwardIt last, Compare cmp);

      		std::is_sorted
      template<class ExecutionPolicy,class ForwardIt>

      ForwardIt is_sorted_until( ExecutionPolicy&& policy,
                                 ForwardIt first, ForwardIt last);

      template<class ExecutionPolicy,class ForwardIt,class Compare>
      ForwardIt is_sorted_until( ExecutionPolicy&& policy,
                                 ForwardIt first, ForwardIt last,
                                 Compare cmp);

      		std::is_sorted_until
      template<class ExecutionPolicy,class RandomIt>

      void sort( ExecutionPolicy&& policy, RandomIt first, RandomIt last);

      template<class ExecutionPolicy,class RandomIt,class Compare>
      void sort( ExecutionPolicy&& policy,
                 RandomIt first, RandomIt last, Compare cmp);

      		std::sort
      template<class ExecutionPolicy,class RandomIt>

      void partial_sort( ExecutionPolicy&& policy,
                         RandomIt first, RandomIt middle, RandomIt last);

      template<class ExecutionPolicy,class RandomIt,class Compare>
      void partial_sort( ExecutionPolicy&& policy,
                         RandomIt first, RandomIt middle, RandomIt last,
                         Compare cmp);

      		std::partial_sort
      template<class ExecutionPolicy,class InputIt,class RandomIt>

      RandomIt partial_sort_copy( ExecutionPolicy&& policy,
                                  InputIt first, InputIt last,
                                  RandomIt d_first, RandomIt d_last);

      template<class ExecutionPolicy,class InputIt,
               class RandomIt,class Compare>
      RandomIt partial_sort_copy( ExecutionPolicy&& policy,
                                  InputIt first, InputIt last,
                                  RandomIt d_first, RandomIt d_last,
                                  Compare cmp);

      		std::partial_sort_copy
      template<class ExecutionPolicy,class RandomIt>

      void stable_sort( ExecutionPolicy&& policy,
                        RandomIt first, RandomIt last);

      template<class ExecutionPolicy,class RandomIt,class Compare>
      void stable_sort( ExecutionPolicy&& policy,
                        RandomIt first, RandomIt last, Compare cmp);

      		std::stable_sort
      template<class ExecutionPolicy,class RandomIt>

      void nth_element( ExecutionPolicy&& policy,
                        RandomIt first, RandomIt nth, RandomIt last);

      template<class ExecutionPolicy,class RandomIt,class Compare>
      void nth_element( ExecutionPolicy&& policy,
                        RandomIt first, RandomIt nth, RandomIt last,
                        Compare cmp);

      		std::nth_element
      Set operations (on sorted ranges)
      Parallelized algorithm Existing algorithm
      template<class ExecutionPolicy,class InputIt1,

               class InputIt2,class OutputIt>
      OutputIt merge( ExecutionPolicy&& policy,
                      InputIt1 first1, InputIt1 last1,
                      InputIt2 first2, InputIt2 last2,
                      OutputIt d_first);

      template<class ExecutionPolicy,class InputIt1,class InputIt2,
               class OutputIt,class Compare>
      OutputIt merge( ExecutionPolicy&& policy,
                      InputIt1 first1, InputIt1 last1,
                      InputIt2 first2, InputIt2 last2,
                      OutputIt d_first, Compare cmp);

      		std::merge
      template<class ExecutionPolicy,class BidirIt>

      void inplace_merge( ExecutionPolicy&& policy,
                          BidirIt first, BidirIt middle, BidirIt last);

      template<class ExecutionPolicy,class BidirIt,class Compare>
      void inplace_merge( ExecutionPolicy&& policy,
                          BidirIt first, BidirIt middle, BidirIt last,
                          Compare cmp);

      		std::inplace_merge
      template<class ExecutionPolicy,class InputIt1,class InputIt2>

      bool includes( ExecutionPolicy&& policy,
                     InputIt1 first1, InputIt1 last1,
                     InputIt2 first2, InputIt2 last2);

      template<class ExecutionPolicy,class InputIt1,
               class InputIt2,class Compare>
      bool includes( ExecutionPolicy&& policy,
                     InputIt1 first1, InputIt1 last1,
                     InputIt2 first2, InputIt2 last2, Compare cmp);

      		std::includes
      template<class ExecutionPolicy,class InputIt1,

               class InputIt2,class OutputIt>
      OutputIt set_difference( ExecutionPolicy&& policy,
                               InputIt1 first1, InputIt1 last1,
                               InputIt2 first2, InputIt2 last2,
                               OutputIt d_first);

      template<class ExecutionPolicy,class InputIt1,class InputIt2,
               class OutputIt,class Compare>
      OutputIt set_difference( ExecutionPolicy&& policy,
                               InputIt1 first1, InputIt1 last1,
                               InputIt2 first2, InputIt2 last2,
                               OutputIt d_first, Compare cmp);

      		std::set_difference
      template<class ExecutionPolicy,class InputIt1,

               class InputIt2,class OutputIt>
      OutputIt set_intersection( ExecutionPolicy&& policy,
                                 InputIt1 first1, InputIt1 last1,
                                 InputIt2 first2, InputIt2 last2,
                                 OutputIt d_first);

      template<class ExecutionPolicy,class InputIt1,class InputIt2,
               class OutputIt,class Compare>
      OutputIt set_intersection( ExecutionPolicy&& policy,
                                 InputIt1 first1, InputIt1 last1,
                                 InputIt2 first2, InputIt2 last2,
                                 OutputIt d_first, Compare cmp);

      		std::set_intersection
      template<class ExecutionPolicy,class InputIt1,

               class InputIt2,class OutputIt>
      OutputIt set_symmetric_difference( ExecutionPolicy&& policy,
                                         InputIt1 first1, InputIt1 last1,
                                         InputIt2 first2, InputIt2 last2,
                                         OutputIt d_first);

      template<class ExecutionPolicy,class InputIt1,class InputIt2,
               class OutputIt,class Compare>
      OutputIt set_symmetric_difference( ExecutionPolicy&& policy,
                                         InputIt1 first1, InputIt1 last1,
                                         InputIt2 first2, InputIt2 last2,
                                         OutputIt d_first, Compare cmp);

      		std::set_symmetric_difference
      template<class ExecutionPolicy,class InputIt1,

               class InputIt2,class OutputIt>
      OutputIt set_union( ExecutionPolicy&& policy,
                          InputIt1 first1, InputIt1 last1,
                          InputIt2 first2, InputIt2 last2,
                          OutputIt d_first);

      template<class ExecutionPolicy,class InputIt1,class InputIt2,
               class OutputIt,class Compare>
      OutputIt set_union( ExecutionPolicy&& policy,
                          InputIt1 first1, InputIt1 last1,
                          InputIt2 first2, InputIt2 last2,
                          OutputIt d_first, Compare cmp);

      		std::set_union
      Heap operations
      Parallelized algorithm Existing algorithm
      template<class ExecutionPolicy,class RandomIt>

      bool is_heap( ExecutionPolicy&& policy,
                    RandomIt first, RandomIt last);

      template<class ExecutionPolicy,class RandomIt,class Compare>
      bool is_heap( ExecutionPolicy&& policy,
                    RandomIt first, RandomIt last, Compare cmp);

      		std::is_heap
      template<class ExecutionPolicy,class RandomIt>

      RandomIt is_heap_until( ExecutionPolicy&& policy,
                              RandomIt first, RandomIt last);

      template<class ExecutionPolicy,class RandomIt,class Compare>
      RandomIt is_heap_until( ExecutionPolicy&& policy,
                              RandomIt first, RandomIt last, Compare cmp);

      		std::is_heap_until
      Minimum/maximum operations
      Parallelized algorithm Existing algorithm
      template<class ExecutionPolicy,class ForwardIt>

      ForwardIt max_element( ExecutionPolicy&& policy,
                             ForwardIt first, ForwardIt last);

      template<class ExecutionPolicy,class ForwardIt,class Compare>
      ForwardIt max_element( ExecutionPolicy&& policy,
                             ForwardIt first, ForwardIt last, Compare cmp);

      		std::max_element
      template<class ExecutionPolicy,class ForwardIt>

      ForwardIt min_element( ExecutionPolicy&& policy,
                             ForwardIt first, ForwardIt last);

      template<class ExecutionPolicy,class ForwardIt,class Compare>
      ForwardIt min_element( ExecutionPolicy&& policy,
                             ForwardIt first, ForwardIt last, Compare cmp);

      		std::min_element
      template<class ExecutionPolicy,class ForwardIt>

      std::pair<ForwardIt,ForwardIt>
          minmax_element( ExecutionPolicy&& policy,
                          ForwardIt first, ForwardIt last);

      template<class ExecutionPolicy,class ForwardIt,class Compare>
      std::pair<ForwardIt,ForwardIt>
          minmax_element( ExecutionPolicy&& policy,
                          ForwardIt first, ForwardIt last, Compare cmp);

      		std::minmax_element
      template<class ExecutionPolicy,class InputIt1,class InputIt2>

      bool lexicographical_compare( ExecutionPolicy&& policy,
                                    InputIt1 first1, InputIt1 last1,
                                    InputIt2 first2, InputIt2 last2);

      template<class ExecutionPolicy,class InputIt1,
               class InputIt2,class Compare>
      bool lexicographical_compare( ExecutionPolicy&& policy,
                                    InputIt1 first1, InputIt1 last1,
                                    InputIt2 first2, InputIt2 last2,
                                    Compare cmp);

      		std::lexicographical_compare
      Numeric operations
      Parallelized algorithm Existing algorithm
      template<class ExecutionPolicy,class InputIt,class OutputIt>

      OutputIt adjacent_difference( ExecutionPolicy&& policy,
                                    InputIt first, InputIt last,
                                    OutputIt d_first);

      template<class ExecutionPolicy,class InputIt,
               class OutputIt,class BinaryOp>
      OutputIt adjacent_difference( ExecutionPolicy&& policy,
                                    InputIt first, InputIt last,
                                    OutputIt d_first, BinaryOp op);

      		std::adjacent_difference
      template<class ExecutionPolicy,class InputIt1,

               class InputIt2,class T>
      T inner_product( ExecutionPolicy&& policy,
                       InputIt1 first1, InputIt1 last1, InputIt2 first2,
                       T value);

      template<class ExecutionPolicy,class InputIt1,class InputIt2,
               class T,class BinaryOp1,class BinaryOp2>
      T inner_product( ExecutionPolicy&& policy,
                       InputIt1 first1, InputIt1 last1, InputIt2 first2,
                       T value, BinaryOp1 op1, BinaryOp2 op2);

      		std::inner_product
      Operations on uninitialized memory
      Parallelized algorithm Existing algorithm
      template<class ExecutionPolicy,class InputIt,class ForwardIt>

      ForwardIt uninitialized_copy( ExecutionPolicy&& policy,
                                    InputIt first, InputIt last,
                                    ForwardIt d_first);

      		std::uninitialized_copy
      template<class ExecutionPolicy,class InputIt,

               class Size,class ForwardIt>
      ForwardIt uninitialized_copy_n( ExecutionPolicy&& policy,
                                      InputIt first, Size count,
                                      ForwardIt d_first);

      		std::uninitialized_copy_n
      template<class ExecutionPolicy,class ForwardIt,class T>

      void uninitialized_fill( ExecutionPolicy&& policy,
                               ForwardIt first, ForwardIt last,
                               const T& value);

      		std::uninitialized_fill
      template<class ExecutionPolicy,class ForwardIt,class Size,class T>

      ForwardIt uninitialized_fill_n( ExecutionPolicy&& policy,
                                      ForwardIt first, Size count,
                                     const T& value);

      		std::uninitialized_fill_n
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/experimental/parallelism/existing&oldid=155053"
      [8]ページ先頭
      ©2009-2025 Movatter.jp