Sé que los valarrays tienen algo de azúcar sintáctica
Tengo que decir que no creo que std::valarraystenga mucho azúcar sintáctico. La sintaxis es diferente, pero no llamaría a la diferencia "azúcar". La API es rara. La sección sobre std::valarrays en The C ++ Programming Language menciona esta API inusual y el hecho de que, dado que std::valarrayse espera que los s estén altamente optimizados, cualquier mensaje de error que reciba mientras los usa probablemente no sea intuitivo.
Por curiosidad, hace aproximadamente un año Entré en boxes std::valarrayen contra std::vector. Ya no tengo el código o los resultados precisos (aunque no debería ser difícil escribir el tuyo). El uso de GCC Me hice un poco beneficio en el rendimiento cuando se utilizan std::valarraypara operaciones matemáticas sencillas, pero no para mis implementaciones para calcular la desviación estándar (y, por supuesto, la desviación estándar no es tan compleja, en lo que va de matemáticas). Sospecho que las operaciones en cada elemento en un std::vectorjuego grande funcionan mejor con cachés que las operaciones en std::valarrays. ( NOTA , siguiendo los consejos de musiphil , he logrado obtener un rendimiento casi idéntico de vectory valarray).
Al final, decidí usarlo std::vectormientras prestaba mucha atención a cosas como la asignación de memoria y la creación de objetos temporales.
Ambos std::vectory std::valarrayalmacenan los datos en un bloque contiguo. Sin embargo, acceden a esos datos utilizando diferentes patrones y, lo que es más importante, la API std::valarrayfomenta diferentes patrones de acceso que la API std::vector.
Para el ejemplo de la desviación estándar, en un paso particular necesitaba encontrar la media de la colección y la diferencia entre el valor de cada elemento y la media.
Para el std::valarray, hice algo como:
std::valarray<double> original_values = ... // obviously I put something here
double mean = original_values.sum() / original_values.size();
std::valarray<double> temp(mean, original_values.size());
std::valarray<double> differences_from_mean = original_values - temp;
Puede que haya sido más inteligente con std::sliceo std::gslice. Han pasado más de cinco años.
Para std::vector, hice algo en la línea de:
std::vector<double> original_values = ... // obviously, I put something here
double mean = std::accumulate(original_values.begin(), original_values.end(), 0.0) / original_values.size();
std::vector<double> differences_from_mean;
differences_from_mean.reserve(original_values.size());
std::transform(original_values.begin(), original_values.end(), std::back_inserter(differences_from_mean), std::bind1st(std::minus<double>(), mean));
Hoy ciertamente escribiría eso de manera diferente. Si nada más, aprovecharía C ++ 11 lambdas.
Es obvio que estos dos fragmentos de código hacen cosas diferentes. Por un lado, el std::vectorejemplo no hace una colección intermedia como lo hace el std::valarrayejemplo. Sin embargo, creo que es justo compararlos porque las diferencias están vinculadas a las diferencias entre std::vectory std::valarray.
Cuando escribí esta respuesta, sospeché que restar el valor de los elementos de dos std::valarrays (última línea en el std::valarrayejemplo) sería menos amigable con el caché que la línea correspondiente en el std::vectorejemplo (que también es la última línea).
Resulta, sin embargo, que
std::valarray<double> original_values = ... // obviously I put something here
double mean = original_values.sum() / original_values.size();
std::valarray<double> differences_from_mean = original_values - mean;
Hace lo mismo que el std::vectorejemplo y tiene un rendimiento casi idéntico. Al final, la pregunta es qué API prefieres.
