Defined in header <numeric>  

template< class InputIt1, class InputIt2, class T > T inner_product( InputIt1 first1, InputIt1 last1, InputIt2 first2, T init );  (1)  
template<class InputIt1, class InputIt2, class T, class BinaryOperation1, class BinaryOperation2> T inner_product( InputIt1 first1, InputIt1 last1, InputIt2 first2, T init, BinaryOperation1 op1, BinaryOperation2 op2 );  (2) 
Computes inner product (i.e. sum of products) or performs ordered map/reduce operation on the range [first1, last1)
and the range beginning at first2
.
acc
with the initial value init
and then modifies it with the expression  (until C++20) 
modifies it with the expression  (since C++20) 
last1
. For builtin meaning of + and *, this computes inner product of the two ranges.acc
with the initial value init
and then modifies it with the expression  (until C++20) 
modifies it with the expression  (since C++20) 
last1
.
 (until C++11) 
 (since C++11) 
first1, last1    the first range of elements 
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 by op2 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:
The signature does not need to have 
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:
The signature does not need to have 
Type requirements  
InputIt1, InputIt2 must meet the requirements of LegacyInputIterator. 

ForwardIt1, ForwardIt2 must meet the requirements of LegacyForwardIterator. 

T must meet the requirements of CopyAssignable and CopyConstructible. 
The final value of acc
as described above.
First version 

template<class InputIt1, class InputIt2, class T> T 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; } 
Second version 
template<class InputIt1, class InputIt2, class T, class BinaryOperation1, class BinaryOperation2> T inner_product(InputIt1 first1, InputIt1 last1, InputIt2 first2, T init, BinaryOperation1 op1 BinaryOperation2 op2) { while (first1 != last1) { init = op1(std::move(init), op2(*first1, *first2)); // std::move since C++20 ++first1; ++first2; } return init; } 
The parallelizable version of this algorithm, std::transform_reduce
, requires op1
and op2
to be commutative and associative, but std::inner_product
makes no such requirement, and always performs the operations in the order given.
#include <numeric> #include <iostream> #include <vector> #include <functional> 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: 21 Number of pairwise matches between a and b: 2
(C++17)  applies a functor, then reduces out of order (function template) 
sums up a range of elements (function template) 

computes the partial sum of a range of elements (function template) 
© cppreference.com
Licensed under the Creative Commons AttributionShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/algorithm/inner_product