6

在上一篇文章中，列向量带有行的意思——使用 std::accumulate? 我问是否可以使用 STL 功能来计算矩阵的行均值

vector< vector<double> > data ( rows, vector<double> ( columns ) );

@benjaminlindley 的最佳答案不仅是我在寻找的东西，而且是美丽的东西。永远充满希望，我认为计算列均值会很容易，所以 STL 相当于

vector<double> colmeans( data[0].size() );
    for ( int i=0; i<data.size(); i++ )
        for ( int j=0; j<data[i].size(); j++ )            
            colmeans[j] += data[i][j]/data.size();

其中平均值不是在 each 内部计算vector<double>，而是在所有向量中的相同索引上计算：

colmeans[0]       == ( data[0][0] + data[1][0] + ... data[rows][0] ) / rows
colmeans[1]       == ( data[0][1] + data[1][1] + ... data[rows][1] ) / rows
colmeans[2]       == ( data[0][2] + data[1][2] + ... data[rows][2] ) / rows
...
colmeans[columns] == ( data[0]   [columns] + 
                       data[1]   [columns] + 
                       ... 
                       data[rows][columns] ) / rows

事实证明这是完全不同的——accumulate 不想处理向量的向量。是否有可能与[]操作员一起使用累积？我什至无法想出一个看起来不正确的中间形式（摆脱for ior循环）。for j

accumulate和[]运营商有什么关系？或者bind？

4

2 回答 2

6

这是我想出的，使用for_eachand transform：

std::vector<std::vector<double>> data { {1,2,3}, {1,2,3}, {1,2,3} };

std::vector<double> colsums( data[0].size() ); // initialize the size
                                                // to number of columns

std::for_each(data.begin(), data.end(),

    [&](const std::vector<double>& row)
    {
        // Use transform overload that takes two input ranges.
        // Note that colsums is the second input range as well as the output range.
        // We take each element of the row and add it to the corresponding
        // element of colsums vector:
        std::transform(row.begin(), row.end(), colsums.begin(), colsums.begin(),
                       [](double d1, double d2) { return d1 + d2; });
    });

std::cout << "Column means: ";
std::transform(
    colsums.begin(), colsums.end(),
    std::ostream_iterator<double>(std::cout, " "),
    [&data](double d) { return d / data.size(); });

LWS 演示

于 2013-02-17T21:22:21.670 回答
2

首先让我声明你真的不应该嵌套 std::vectors。除此之外，我得到了一些解决方案，它当然比您的初始代码长，但从长远来看可以节省：

#include <vector>
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/iterator/counting_iterator.hpp>

typedef std::vector<std::vector<double> > Data;

struct ColumnElement : boost::iterator_adaptor<ColumnElement,
                                                Data::const_iterator,
                                                const double> {
        int col;

        ColumnElement(int col, const Data::const_iterator &iter)
        : iterator_adaptor(iter), col(col)
        {}
        const double& dereference()const { return (*base())[col]; }
};

struct Column {
        int col;
        const Data *data;

        Column(int col, const Data *data) : col(col), data(data) {}
        ColumnElement begin()const { return ColumnElement(col, data->begin()); }
        ColumnElement end()const { return ColumnElement(col, data->end()); }
        int size()const { return std::distance(begin(), end()); }
};

struct Columns : boost::iterator_adaptor<Columns, boost::counting_iterator<int>,
                                        Column, boost::use_default, Column> {
        const Data *data;

        Columns(int col, const Data *data): iterator_adaptor(col), data(data) {}

        Column dereference()const { return Column(*base(), data); }
};

Columns columnsBegin(const Data &data) { return Columns(0, &data); }
Columns columnsEnd(const Data &data) {
        return Columns(data.empty() ? 0 : data.front().size(), &data);
}

这可以简而言之：

double Mean(const Column &d) {
        return std::accumulate(d.begin(), d.end(), 0.0) / d.size();
}

int main() {
        Data data = {   {1, 2, 3},
                        {2, 2, 2},
                        {9, 8, 7}};
        std::vector<double> colMeans(data[0].size());
        std::transform(columnsBegin(data), columnsEnd(data), 
                       colMeans.begin(), Mean);
        std::copy(colMeans.begin(), colMeans.end(),
                  std::ostream_iterator<double>(std::cout, ","));
        std::cout << "\n";
}

我使用了一些增强功能来缩短它，但它可以在没有增强的情况下完成（但要长得多）。

这个想法是创建一个遍历所有列的迭代器（Columns只是为了简短而调用）和一个迭代一列的所有元素的迭代器（ColumnElement也缩短了，应该更好地命名ColumnElementIterator），Column它表示一列的所有元素的范围。

于 2013-02-17T22:16:23.153 回答