std::inner_product() algorithm
- since C++20
- until C++20
// (1)
template< class InputIt1, class InputIt2, class T >
constexpr T inner_product( InputIt1 first1, InputIt1 last1, InputIt2 first2, T init );
// (2)
template< class InputIt1, class InputIt2, class T, class BinaryOperation1, class BinaryOperation2 >
constexpr T inner_product( InputIt1 first1, InputIt1 last1, InputIt2 first2,
T init, BinaryOperation1 op1, BinaryOperation2 op2 );
// (1)
template< class InputIt1, class InputIt2, class T >
T inner_product( InputIt1 first1, InputIt1 last1, InputIt2 first2, T init );
// (2)
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 );
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
.
Initializes the accumulator acc
(of type T
) with the initial value init
and then modifies it with the expression =
- (1)
acc = acc + (*i1) * (*i2)
(until C++11)acc = std::move(acc) + (*i1) * (*i2)
(since C++11) - (2)
acc = op1(acc, op2(*i1, *i2))
(until C++11)acc = op1(std::move(acc), op2(*i1, *i2))
(since C++11)
for every iterator i1
in the range [first1
; last1
) in order and its corresponding iterator i2
in the range beginning at first2
.
For built-in meaning of +
and *
, this computes inner product of the two ranges.
If op1
or op2
invalidates any iterators (including the end iterators) or modifies any elements of the range involved, the behavior is undefined
Parameters
first1 last1 | The firstrange of elements. |
first2 | The beginning of the second range of elements. |
init | Initial value of the products. |
op1 | Binary operation function object that will be applied.
This "sum" function takes a value returned by The signature of the function should be equivalent to the following:
|
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:
|
Type requirements
InputIt1 InputIt2 | LegacyInputIterator |
ForwardIt1 ForwardIt2 | LegacyForwardIterator |
T | CopyAssignable CopyConstructible |
Return value
acc
after all modifications.
Complexity
Exactly last - first
increments, assignments and applications of both op1
and op2
.
Exceptions
(none)
Possible implementation
inner_product(1)
template<class InputIt1, class InputIt2, class T>
constexpr // since C++20
T inner_product(InputIt1 first1, InputIt1 last1, InputIt2 first2, T init)
{
while (first1 != last1)
{
init = std::move(init) + (*first1) * (*first2); // std::move since C++11
++first1;
++first2;
}
return init;
}
inner_product(2)
template<class InputIt1, class InputIt2, class T,
class BinaryOperation1, class BinaryOperation2>
constexpr // since C++20
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++11
++first1;
++first2;
}
return init;
}
Notes
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.
Examples
#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';
}
Inner product of a and b: 21
Number of pairwise matches between a and b: 2
Hover to see the original license.