std::inner_product

Определено в заголовке `<numeric>`
	(1)
template< class InputIt1, class InputIt2, class T > T inner_product( InputIt1 first1, InputIt1 last1, InputIt2 first2, T init );		(до C++20)
template< class InputIt1, class InputIt2, class T > constexpr T inner_product( InputIt1 first1, InputIt1 last1, InputIt2 first2, T init );		(с C++20)
	(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 );		(до C++20)
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 );		(с C++20)

Вычисляет скалярное произведение (т.е. сумму произведений) или выполняет упорядоченную операцию map/reduce на диапазон [first1, last1) и диапазон, начинающийся с first2.

1) Инициализирует накопитель acc (типа T) начальным значением init и затем изменяет его с помощью выражения acc = acc + (*i1) * (*i2)(до C++11)acc = std::move(acc) + (*i1) * (*i2)(с C++11) для каждого итератора i1 в диапазоне [first1, last1) в порядке и соответствующего итератора i2 в диапазоне, начинающемся с first2. Для встроенного значения + и *, это вычисляет скалярное произведение двух диапазонов.

2) Инициализирует накопитель acc (типа T) начальным значением init и затем изменяет его с помощью выражения acc = op1(acc, op2(*i1, *i2))(до C++11)acc = op1(std::move(acc), op2(*i1, *i2))(с C++11) для каждого итератора i1 в диапазоне [first1, last1) в порядке и соответствующего итератора i2 в диапазоне, начинающемся с first2.

Если op1 или op2 делает какие-либо итераторы (включая конечные итераторы) недействительными или изменяет какие-либо элементы вовлечённого диапазона, поведение является неопределённым.

Параметры

first1, last1	-	первый диапазон элементов
first2	-	начало второго диапазона элементов
init	-	начальное значение суммы произведений
op1	-	бинарная операция-функция-объект, которая будет применена. Эта функция "суммы" принимает значение, возвращённое `op2`, и текущее значение накопителя и производит новое значение, которое будет сохранено в накопителе. Подпись функции должна быть эквивалентна следующей: `Ret fun(const Type1 &a, const Type2 &b);` Подпись не требует `const &`. Типы Type1 и Type2 должны быть такими, чтобы объекты типов T и Type3 могли быть неявно преобразованы в Type1 и Type2 соответственно. Тип `Ret` должен быть таким, чтобы объекту типа `T` можно было присвоить значение типа `Ret`.
op2	-	бинарная операция-функция-объект, которая будет применена. Эта функция "произведения" берёт одно значение из каждого диапазона и производит новое значение. Подпись функции должна быть эквивалентна следующей: `Ret fun(const Type1 &a, const Type2 &b);` Подпись не требует `const &`. Типы Type1 и Type2 должны быть такими, чтобы объекты типов InputIt1 и InputIt2 можно было дериференцировать и затем неявно преобразовать в Type1 и Type2 соответственно. Тип `Ret` должен быть таким, чтобы объекту типа `Type3` можно было присвоить значение типа `Ret`.
Требования к типам
-`InputIt1, InputIt2` должны удовлетворять требованиям LegacyInputIterator.
-`ForwardIt1, ForwardIt2` должны удовлетворять требованиям LegacyForwardIterator.
-`T` должны удовлетворять требованиям CopyAssignable и CopyConstructible.

Возвращаемое значение

acc после всех изменений.

Возможная реализация

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; }

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;
}

Примечания

Параллельная версия этого алгоритма, std::transform_reduce, требует, чтобы op1 и op2 были коммутативными и ассоциативными, но std::inner_product не делает таких требований и всегда выполняет операции в заданном порядке.

Пример

#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

Отчёты об ошибках

Следующие поправки, изменяющие поведение, были применены ретроактивно к ранее опубликованным стандартам C++.

DR	Применяется к	Поведение при публикации	Правильное поведение
LWG 242	C++98	`op1` и `op2` не могли иметь побочных эффектов	они не могут изменять участвующие диапазоны
LWG 2055 (P0616R0)	C++11	`acc` не перемещался во время накопления	он перемещается

См. также

transform_reduce (C++17)	применяет вызываемый объект, затем уменьшает вне порядка (функция-шаблон)
accumulate	суммирует или складывает диапазон элементов (функция-шаблон)
partial_sum	вычисляет частичную сумму диапазона элементов (функция-шаблон)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/algorithm/inner_product