我有

vector < vector < int > > data_mat ( 3, vector < int > (4) );
vector          < int >   data_vec ( 3                     ); 

哪里data_mat可以被认为是一个矩阵和data_vec作为列 vector ，我正在寻找一种方法来计算 data_mat 的每一列的内积与 data_vec , 并将其存储在另一个 vector < int > data_out (4) 中.

例子http://liveworkspace.org/code/2bW3X5%241使用 for_each和 transform , 可用于计算矩阵的列和:

sum=vector<int> (data_mat[0].size());
for_each(data_mat.begin(), data_mat.end(),
         [&](const std::vector<int>& c) {
            std::transform(c.begin(), c.end(), sum.begin(), sum.begin(),
                           [](int d1, double d2) 
                             { return d1 + d2; }
                          );
            }
        );

是否有可能以类似的方式(或使用 STL 函数的稍微不同的方式)计算矩阵列与 vector 的列点积？

问题是 'd2 = d1 + d2' 技巧在列内积的情况下不起作用——如果有办法包含 d3 也可以解决它 ( d3 = d3 + d1 * d2 ) 但三元函数似乎不存在于 transform 中.

最佳答案

事实上，您几乎可以一对一地使用现有的列求和方法。您不需要三元 std::transform 作为内部循环，因为在对矩阵行求和之前缩放矩阵行的因子对于每一行都是常数，因为它是列 vector 中的行值并且它与矩阵行一起迭代，因此与外部 std::for_each 一起迭代。

所以我们需要做的是遍历矩阵的行，将每个完整的行乘以列 vector 中的相应值，然后将缩放后的行添加到和 vector 中。但不幸的是，为此我们需要一个 std::for_each 函数，它同时迭代两个范围，即矩阵的行和列 vector 的行。为此，我们可以使用通常的一元 std::for_each 并使用额外的迭代器手动对列 vector 进行迭代:

std::vector<int> sum(data_mat[0].size());
auto vec_iter = data_vec.begin();
std::for_each(data_mat.begin(), data_mat.end(), 
              [&](const std::vector<int>& row) {
                 int vec_value = *vec_iter++;    //manually advance vector row
                 std::transform(row.begin(), row.end(), sum.begin(), sum.begin(),
                                [=](int a, int b) { return a*vec_value + b; });
              });

std::for_each 中额外的手动迭代并不是标准库算法的惯用用法，但不幸的是没有二进制 std::for_each我们可以使用。

另一种选择是使用 std::transform 作为外部循环(它可以迭代两个范围)，但我们并没有真正计算每个外部迭代中的单个值以返回，所以我们将不得不从外部 lambda 返回一些虚拟值，然后使用某种虚拟输出迭代器将其丢弃。这也不是最干净的解决方案:

//output iterator that just discards any output
struct discard_iterator : std::iterator<std::output_iterator_tag,
                                        void, void, void, void>
{
    discard_iterator& operator*() { return *this; }
    discard_iterator& operator++() { return *this; }
    discard_iterator& operator++(int) { return *this; }
    template<typename T> discard_iterator& operator=(T&&) { return *this; }
};

//iterate over rows of matrix and vector, misusing transform as binary for_each
std::vector<int> sum(data_mat[0].size());
std::transform(data_mat.begin(), data_mat.end(), 
               data_vec.begin(), discard_iterator(), 
               [&](const std::vector<int>& row, int vec_value) {
                   return std::transform(row.begin(), row.end(), 
                                         sum.begin(), sum.begin(),
                                         [=](int a, int b) { 
                                             return a*vec_value + b;
                                         });
               });

编辑:虽然这已经在评论中讨论过并且我理解(并理解)这个问题的理论性质，但我仍然会包括这样的建议，即在实践中动态数组的动态数组是一种像矩阵一样表示结构明确的二维数组的好方法。具有适当运算符的适当矩阵数据结构(连续存储其内容)几乎总是更好的选择。但是尽管如此，由于它们的通用性，您仍然可以使用标准库算法来处理此类自定义数据结构(甚至可以让矩阵类型提供自己的迭代器)。

关于c++ - vector < vector < int >> 在第一个维度上的点积，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/15212343/