Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::inner_product

      From cppreference.com
      <cpp‎ |algorithm
       
       
      Algorithm library
      Constrained algorithms and algorithms on ranges(C++20)
      Constrained algorithms, e.g.ranges::copy,ranges::sort, ...
      Execution policies(C++17)
      Sorting and related operations
      Partitioning operations
      Sorting operations
      Binary search operations
      (on partitioned ranges)
      Set operations (on sorted ranges)
      Merge operations (on sorted ranges)
      Heap operations
      Minimum/maximum operations
      (C++11)
      (C++17)
      Lexicographical comparison operations
      Permutation operations
      C library
      Numeric operations
      (C++11)
      inner_product
      Operations on uninitialized memory
       
       
      Defined in header<numeric>
      template<class InputIt1,class InputIt2,class T>

      T inner_product( InputIt1 first1, InputIt1 last1,

                       InputIt2 first2, T init);
      (1)(constexpr since C++20)
      template<class InputIt1,class InputIt2,class T,

               class BinaryOp1,class BinaryOp2>
      T inner_product( InputIt1 first1, InputIt1 last1,
                       InputIt2 first2, T init,

                       BinaryOp1 op1, BinaryOp2 op2);
      (2)(constexpr since C++20)

      Computes inner product (i.e. sum of products) or performs ordered map/reduce operation on the range[first1last1) and the range ofstd::distance(first1, last1) elements beginning atfirst2.

      1) Initializes the accumulatoracc (of typeT) with the initial valueinit and then modifies it with the expressionacc= acc+(*i1)*(*i2)(until C++20)acc= std::move(acc)+(*i1)*(*i2)(since C++20) for every iteratori1 in the range[first1last1) in order and its corresponding iteratori2 in the range beginning atfirst2. For built-in meaning of + and *, this computes inner product of the two ranges.
      2) Initializes the accumulatoracc (of typeT) with the initial valueinit and then modifies it with the expressionacc= op1(acc, op2(*i1,*i2))(until C++20)acc= op1(std::move(acc), op2(*i1,*i2))(since C++20) for every iteratori1 in the range[first1last1) in order and its corresponding iteratori2 in the range beginning atfirst2.

      Givenlast2 as thestd::distance(first1, last1)th next iterator offirst2, if any of the following conditions is satisfied, the behavior is undefined:

      • T is notCopyConstructible.
      • T is notCopyAssignable.
      • op1 orop2 modifies any element of[first1last1) or[first2last2).
      • op1 orop2 invalidates any iterator or subrange in[first1last1] or[first2last2].

      Contents

      [edit]Parameters

      first1, last1 - the pair of iterators defining therange of elements to
      first2 - the beginning of the second range of elements
      init - initial value of the sum of the products
      op1 - binary operation function object that will be applied. This "sum" function takes a value returned byop2 and the current value of the accumulator and produces a new value to be stored in the accumulator.

      The signature of the function should be equivalent to the following:

       Ret fun(const Type1&a,const Type2&b);

      The signature does not need to haveconst&.
      The types Type1 and Type2 must be such that objects of typesT andType3 can be implicitly converted to Type1 and Type2 respectively. The typeRet must be such that an object of typeT can be assigned a value of typeRet.​

      op2 - binary operation function object that will be applied. This "product" function takes one value from each range and produces a new value.

      The signature of the function should be equivalent to the following:

       Ret fun(const Type1&a,const Type2&b);

      The signature does not need to haveconst&.
      The types Type1 and Type2 must be such that objects of typesInputIt1 andInputIt2 can be dereferenced and then implicitly converted to Type1 and Type2 respectively. The typeRet must be such that an object of typeType3 can be assigned a value of typeRet.​

      Type requirements
      -
      InputIt1, InputIt2 must meet the requirements ofLegacyInputIterator.

      [edit]Return value

      acc after all modifications.

      [edit]Possible implementation

      inner_product (1)
      template<class InputIt1,class InputIt2,class T>constexpr// since C++20T inner_product(InputIt1 first1, InputIt1 last1, InputIt2 first2, T init){while(first1!= last1){        init= std::move(init)+(*first1)*(*first2);// std::move since C++20++first1;++first2;} return init;}
      inner_product (2)
      template<class InputIt1,class InputIt2,class T,class BinaryOp1,class BinaryOp2>constexpr// since C++20T inner_product(InputIt1 first1, InputIt1 last1, InputIt2 first2, T init,                BinaryOp1 op1, BinaryOp2 op2){while(first1!= last1){        init= op1(std::move(init), op2(*first1,*first2));// std::move since C++20++first1;++first2;} return init;}

      [edit]Notes

      The parallelizable version of this algorithm,std::transform_reduce, requiresop1 andop2 to be commutative and associative, butstd::inner_product makes no such requirement, and always performs the operations in the order given.

      [edit]Example

      Run this code
      #include <functional>#include <iostream>#include <numeric>#include <vector> int main(){std::vector<int> a{0,1,2,3,4};std::vector<int> b{5,4,2,3,1}; int r1= std::inner_product(a.begin(), a.end(), b.begin(),0);std::cout<<"Inner product of a and b: "<< r1<<'\n'; int r2= std::inner_product(a.begin(), a.end(), b.begin(),0,std::plus<>(),std::equal_to<>());std::cout<<"Number of pairwise matches between a and b: "<<  r2<<'\n';}

      Output:

      Inner product of a and b: 21Number of pairwise matches between a and b: 2

      [edit]Defect reports

      The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

      DRApplied toBehavior as publishedCorrect behavior
      LWG 242C++98op1 andop2 could not have side effectsthey cannot modify the ranges involved

      [edit]See also

      applies an invocable, then reduces out of order
      (function template)[edit]
      sums up or folds a range of elements
      (function template)[edit]
      computes the partial sum of a range of elements
      (function template)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/algorithm/inner_product&oldid=180324"

      [8]ページ先頭

      ©2009-2025 Movatter.jp