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)。

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

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数组。适当的矩阵数据结构（将其内容有条理地存储）与适当的运算符几乎总是更好的选择。但是由于它们的通用性，您仍然可以使用标准库算法来处理这样的自定义数据结构（甚至可以通过让矩阵类型提供自己的迭代器）。

矢量的点积＆lt;矢量＆lt; int＆gt; ＆GT;在第一个维度

1 个答案: