C++ valarray vs. vector
valarray is kind of an orphan that was born in the wrong place at the wrong time. It's an attempt at optimization, fairly specifically for the machines that were used for heavy-duty math when it was written -- specifically, vector processors like the Crays.
For a vector processor, what you generally wanted to do was apply a single operation to an entire array, then apply the next operation to the entire array, and so on until you'd done everything you needed to do.
Unless you're dealing with fairly small arrays, however, that tends to work poorly with caching. On most modern machines, what you'd generally prefer (to the extent possible) would be to load part of the array, do all the operations on it you're going to, then move on to the next part of the array.
valarray is also supposed to eliminate any possibility of aliasing, which (at least theoretically) lets the compiler improve speed because it's more free to store values in registers. In reality, however, I'm not at all sure that any real implementation takes advantage of this to any significant degree. I suspect it's rather a chicken-and-egg sort of problem -- without compiler support it didn't become popular, and as long as it's not popular, nobody's going to go to the trouble of working on their compiler to support it.
There's also a bewildering (literally) array of ancillary classes to use with valarray. You get slice, slice_array, gslice and gslice_array to play with pieces of a valarray, and make it act like a multi-dimensional array. You also get mask_array to "mask" an operation (e.g. add items in x to y, but only at the positions where z is non-zero). To make more than trivial use of valarray, you have to learn a lot about these ancillary classes, some of which are pretty complex and none of which seems (at least to me) very well documented.
Bottom line: while it has moments of brilliance, and can do some things pretty neatly, there are also some very good reasons that it is (and will almost certainly remain) obscure.
Edit (eight years later, in 2017): Some of the preceding has become obsolete to at least some degree. For one example, Intel has implemented an optimized version of valarray for their compiler. It uses the Intel Integrated Performance Primitives (Intel IPP) to improve performance. Although the exact performance improvement undoubtedly varies, a quick test with simple code shows around a 2:1 improvement in speed, compared to identical code compiled with the "standard" implementation of
So, while I'm not entirely convinced that C++ programmers will be starting to use
valarray in huge numbers, there are least some circumstances in which it can provide a speed improvement.
I like vectors a lot. They're nifty and fast. But I know this thing called a valarray exists. Why would I use a valarray instead of a vector? I know valarrays have some syntactic sugar, but other than that, when are they useful?
The C++11 standard says:
The valarray array classes are defined to be free of certain forms of aliasing, thus allowing operations on these classes to be optimized.
See C++11 26.6.1-2.
I know valarrays have some syntactic sugar
I have to say that I don't think
std::valarrays have much in way of syntactic sugar. The syntax is different, but I wouldn't call the difference "sugar." The API is weird. The section on
std::valarrays in The C++ Programming Language mentions this unusual API and the fact that, since
std::valarrays are expected to be highly optimized, any error messages you get while using them will probably be non-intuitive.
Out of curiosity, about a year ago I pitted
std::vector. I no longer have the code or the precise results (although it shouldn't be hard to write your own). Using GCC I did get a little performance benefit when using
std::valarray for simple math, but not for my implementations to calculate standard deviation (and, of course, standard deviation isn't that complex, as far as math goes).
I suspect that operations on each item in a large (NOTE, following advice from musiphil, I've managed to get almost identical performance from
std::vector play better with caches than operations on
In the end, I decided to use
std::vector while paying close attention to things like memory allocation and temporary object creation.
std::valarray store the data in a contiguous block. However, they access that data using different patterns, and more importantly, the API for
std::valarray encourages different access patterns than the API for
For the standard deviation example, at a particular step I needed to find the collection's mean and the difference between each element's value and the mean.
std::valarray, I did something like:
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;
I may have been more clever with
std::gslice. It's been over five years now.
std::vector, I did something along the lines of:
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));
Today I would certainly write that differently. If nothing else, I would take advantage of C++11 lambdas.
It's obvious that these two snippets of code do different things. For one, the
std::vector example doesn't make an intermediate collection like the
std::valarray example does. However, I think it's fair to compare them because the differences are tied to the differences between
When I wrote this answer, I suspected that subtracting the value of elements from two
std::valarrays (last line in the
std::valarray example) would be less cache-friendly than the corresponding line in the
std::vector example (which happens to also be the last line).
It turns out, however, that
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;
Does the same thing as the
std::vector example, and has almost identical performance. In the end, the question is which API you prefer.