Come riscrivere un ciclo annidato usando gli algoritmi C++ STL?

Question

Il ciclo è abbastanza semplice, ma non riesco a spiegarmi come usare gli algoritmi STL per fornire lo stesso ciclo annidato in basso.

const int a_size = 5; // input 
const int c_size = 2; // output 
const int b_size = a_size * c_size; // multipliers 

std::vector<float> a(a_size); 
std::vector<float> b(b_size); 
std::vector<float> c(c_size); 

// fill a and b with data 

// this nested loop 
for(int i = 0; i<c_size; i++) { 
    c[i] = 0.0; 
    for(int k = 0; k<a_size; k++) { 
     c[i] += (a[k] * b[i*a_size+k]); 
    } 
    c[i] = sigmoid(c[i]); 
} 

Il motivo per cui mi piacerebbe fare questo, è per la biblioteca Boost.Compute, che avrebbe fatto i calcoli sulla GPU utilizzando algoritmi STL-simile (std :: trasformare, std :: for_each, ecc .).

Answer 1

mi è venuta with:

auto i = 0; 
generate(begin(c), end(c), [&i, &a, &b] 
{ 
    return sigmoid(inner_product 
    (
     begin(a), end(a), 
     begin(b) + distance(begin(a), end(a)) * i++, 0.f 
    )); 
}); 

Ma non sembra abbastanza bene - probabilmente in questo caso preferirei di scrivere il mio algoritmo.

Oppure utilizzare la matrice. Con la libreria Eigen diventerà:

MatrixXd b; 
VectorXd a, c; 
// ... 
c = (b*a).unaryExpr(sigmoid); 

Answer 2

infatti il ​​ciclo annidato è algoritmo std :: inner_product.

auto first = std::begin(b); 
auto increment = std::distance(std::begin(a), std::end(a)); 
//,, 

c[i] = std::inner_product(std::begin(a), std::end(a), first, 0); 
std::advance(first, increment); 

Invece del ciclo esterno è possibile utilizzare l'algoritmo std :: generate.