obliczanie sum kolumn wektora macierzy <Wektor <double>> z iteratorami?

Question

W poprzednim poście column vector with row means -- with std::accumulate? Zapytałem, czy to było możliwe, wykorzystując funkcjonalność STL, aby obliczyć środki rzędem macierzy

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

Górny odpowiedź przez @benjaminlindley jest nie tylko to, czego szukałem, to rzecz piękna. Zawsze nadzieję, że myślałem, że będzie tak łatwo obliczyć kolumna oznacza, więc równoważny STL z

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

gdzie średnia nie jest wyliczana wewnątrz każdej vector<double>, ale po drugiej stronie tego samego indeksu we wszystkich wektorów:

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 

Okazuje się, że jest zupełnie inaczej - kumulacja nie chce pracować na wektorach wektorów. Czy w jakiś sposób można użyć akumulacji z operatorem []? Nie mogę nawet wymyślić pośredniej formy (aby pozbyć się pętli for i lub for j), która nie wydaje się odpowiednia.

Coś z operatorem accumulate i operatorem []? Lub bind?

Answer 1

Oto coś wymyśliłem, używając for_each i 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 Demo

Answer 2

pierwsze chciałbym stwierdzić, że naprawdę nie powinno gniazdo std :: wektory. Poza tym mam pewne rozwiązanie, które jest oczywiście dłuższa niż początkowego kodu, ale że może uratować w dłuższej perspektywie:

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

ten może być wykorzystywany w skrócie:

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

I zatrudniony niektóre zwiększyć funkcjonalność, aby ją skrócić, ale można to zrobić bez większego wysiłku (choć znacznie dłużej).

Ideą było stworzenie iterator nad wszystkimi kolumnami (zwanych Columns tylko dla krótkości) oraz iterator że iteracje nad wszystkimi elementami jednej kolumnie (ColumnElement również skrócona, powinna być lepiej nazwie ColumnElementIterator) i Column który reprezentuje zakres wszystkich elementów jednej kolumny.