C++11标准模板（STL）- 算法 - 数值运算（std::inner_product）

繁星璀璨G

已于 2023-05-28 23:04:37 修改

阅读量1.4k

点赞数 2

分类专栏： # 数值运算文章标签： c++ 算法计算两个范围的元素的内积 inner_product

于 2022-12-26 08:30:00 首次发布

本文链接：https://blog.csdn.net/qq_40788199/article/details/128401646

版权

数值运算专栏收录该内容

5 篇文章 0 订阅

订阅专栏

定义于头文件 <algorithm>

算法库提供大量用途的函数（例如查找、排序、计数、操作），它们在元素范围上操作。注意范围定义为 [first, last) ，其中 last 指代要查询或修改的最后元素的后一个元素。

计算两个范围的元素的内积

std::inner_product

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)

计算内积（即积之和）或在范围 [first1, last1) 和始于 first2 的范围上进行有序映射/规约操作。

1) 以初值 init 初始化积累器 acc ，然后

以表达式 acc = acc + first1 first2 修改它，再以表达式 acc = acc + (first1+1) * *(first2+1) 修改它，以此类推	(C++20 前)
以表达式 acc = std::move(acc) + first1 first2 修改它，再以表达式 acc = std::move(acc) + (first1+1) * *(first2+1) 修改它，以此类推	(C++20 起)

直至抵达 last1 。对于 + 与 * 的内建含义，此算法计算二个范围的内积。2) 以初值 init 初始化积累器 acc ，然后

以表达式 acc = op1(acc, op2(first1, first2)) 修改它，再以表达式 acc = op1(acc, op2((first1+1), (first2+1))) 修改它，以此类推	(C++20 前)
以表达式 acc = op1(std::move(acc), op2(first1, first2)) 修改它，再以表达式 acc = op1(std::move(acc), op2((first1+1), (first2+1))) 修改它，以此类推	(C++20 起)

直至抵达 last1 。

`op1` 或 `op2` 必须无副效应。	(C++11 前)
`op1` 或 `op2` 必须不非法化所涉及范围的任何迭代器，含尾迭代器或修改该范围的任何元素。	(C++11 起)

参数

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 的最终值。

可能的实现

版本一

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; // C++20 起有 std::move
         ++first1;
         ++first2;
    }
    return init;
}

版本二

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)); // C++20 起有 std::move
         ++first1;
         ++first2;
    }
    return init;
}

注意

此算法的可并行版本 std::transform_reduce 要求 op1 与 op2 可交换并可结合，但 std::inner_product 不作这种要求，且始终以给定顺序进行操作。

调用示例

#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
#include <list>
#include <iterator>
#include <time.h>

using namespace std;

struct Cell
{
    int x;
    int y;

    Cell &operator +=(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator +(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator *(const Cell &cell)
    {
        x *= cell.x;
        y *= cell.y;
        return *this;
    }

    Cell &operator ++()
    {
        x += 1;
        y += 1;
        return *this;
    }

    bool operator <(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y < cell.y;
        }
        else
        {
            return x < cell.x;
        }
    }

    bool operator ==(const Cell &cell) const
    {
        return x == cell.x && y == cell.y;
    }
};

std::ostream &operator<<(std::ostream &os, const Cell &cell)
{
    os << "{" << cell.x << "," << cell.y << "}";
    return os;
}

int main()
{
    std::mt19937 g{std::random_device{}()};

    srand((unsigned)time(NULL));;

    std::cout << std::boolalpha;

    std::function<Cell()> generate = []()
    {
        int n = std::rand() % 10;
        Cell cell{n, n};
        return cell;
    };

    // 初始化lCells1
    std::list<vector<Cell>> lCells1(3, vector<Cell>(5));
    //用从起始值开始连续递增的值填充一个范围
    for (vector<Cell> &vCells : lCells1)
    {
        std::generate(vCells.begin(), vCells.end(), generate);
    }

    // 初始化lCells1
    std::list<vector<Cell>> lCells2(3, vector<Cell>(5));
    //用从起始值开始连续递增的值填充一个范围
    for (vector<Cell> &vCells : lCells2)
    {
        std::generate(vCells.begin(), vCells.end(), generate);
    }

    size_t index = 0;
    std::list<vector<Cell>>::iterator it1 = lCells1.begin();
    std::list<vector<Cell>>::iterator it2 = lCells2.begin();
    for (; it1 != lCells1.end() && it2 != lCells2.end(); it1++, it2++)
    {
        std::cout << "lCells1 " << index << " ";
        std::copy((*it1).begin(), (*it1).end(), std::ostream_iterator<Cell>(std::cout, " "));
        std::cout << std::endl;

        std::cout << "lCells1 " << index << " ";
        std::copy((*it2).begin(), (*it2).end(), std::ostream_iterator<Cell>(std::cout, " "));
        std::cout << std::endl;

        auto inner_product = std::inner_product((*it1).begin(), (*it1).end(), (*it2).begin(), Cell{0, 0});
        std::cout << "inner_product: " << inner_product << std::endl;
        std::cout << std::endl;
        index++;
    }

    std::cout << std::endl;
    std::cout << std::endl;
    std::cout << std::endl;

    auto opt1 = [](const Cell & a, const Cell & b)
    {
        Cell cell{a.x + b.x, a.y + b.y};
        return cell;
    };

    auto opt2 = [](const Cell & a, const Cell & b)
    {
        Cell cell{a.x * b.x, a.y * b.y};
        return cell;
    };

    // 初始化lCells3
    std::list<vector<Cell>> lCells3(3, vector<Cell>(5));
    //用从起始值开始连续递增的值填充一个范围
    for (vector<Cell> &vCells : lCells3)
    {
        std::generate(vCells.begin(), vCells.end(), generate);
    }

    // 初始化lCells4
    std::list<vector<Cell>> lCells4(3, vector<Cell>(5));
    //用从起始值开始连续递增的值填充一个范围
    for (vector<Cell> &vCells : lCells4)
    {
        std::generate(vCells.begin(), vCells.end(), generate);
    }

    index = 0;
    std::list<vector<Cell>>::iterator it3 = lCells3.begin();
    std::list<vector<Cell>>::iterator it4 = lCells4.begin();
    for (; it3 != lCells3.end() && it4 != lCells4.end(); it3++, it4++)
    {
        std::cout << "lCells1 " << index << " ";
        std::copy((*it3).begin(), (*it3).end(), std::ostream_iterator<Cell>(std::cout, " "));
        std::cout << std::endl;

        std::cout << "lCells1 " << index << " ";
        std::copy((*it4).begin(), (*it4).end(), std::ostream_iterator<Cell>(std::cout, " "));
        std::cout << std::endl;

        auto inner_product = std::inner_product((*it3).begin(), (*it3).end(), (*it4).begin(),
                                                Cell{0, 0}, opt1, opt2);
        std::cout << "inner_product: " << inner_product << std::endl;
        std::cout << std::endl;
        index++;
    }

    return 0;
}

输出

繁星璀璨G

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C++11标准模板（STL）- 算法 - 数值运算（std::inner_product）

计算两个范围的元素的内积。计算内积（即积之和）或在范围 [first1, last1) 和始于 first2 的范围上进行有序映射/规约操作。
复制链接

扫一扫