向量<向量<int>>在第一维上的点积

Question

我有

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

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

使用和的示例http://liveworkspace.org/code/2bW3X5%241可用于计算矩阵的列总和：for_eachtransform

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函数的方式略有不同）来计算矩阵列与矢量的列点积？

问题在于，“ d2 = d1 + d2”技巧在此列内积案例中不起作用-如果有一种方法也可以包含d3来解决它（d3 = d3 + d1 * d2），但是似乎不存在三元函数transform。

Answer 1

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

因此，我们需要对矩阵的行进行迭代，并将每个完整行乘以列向量中的相应值，然后将缩放后的行添加到总和向量中。但是不幸的是，我们需要一个std::for_each同时在两个范围内迭代的函数，矩阵的行和列向量的行。为此，我们可以使用通常的一元代码，std::for_each并使用附加的迭代器手动对列向量进行迭代：

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

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