Introduction to the valarray Class

Suppose you have a list of measurements and you want to scale every one of them, or combine two lists value by value. The first instinct in many programs is to write a loop, pick out each element, compute the result, and store it somewhere. The valarray class in C++ is built to make this kind of work read more directly. Its operations are written as though the whole collection were a single value, and the same operator that works on one number works on the whole collection.

This article looks at the two capabilities the course material highlights for valarray: the usual arithmetic operations, and the most common mathematical functions. Both are supported directly on valarray objects, so you can work with a whole array at once rather than handling every element by hand in your own code.

The usual arithmetic operations are supported for valarray objects. Addition, multiplication, and the other ordinary arithmetic operators can be applied to a valarray, and the result is again a valarray. The practical effect is that an expression such as a + b takes two arrays and produces a new array, without you writing the indexing loop yourself.

The easiest way to picture the result is position by position. If the two inputs each hold values at positions 0, 1, and 2, the sum holds the sum of the value at position 0 from each input, then the sum at position 1, and so on. Written as a rule for an element at index i, the result works like this:

Here a_{i} and b_{i} are the values at position i in the two arrays, and c_{i} is the value at the same position in the result. Every position is handled by the same rule, and the rule never names a particular position. That is the core idea: one expression describes the work for all positions at once.

The diagram shows the pairing. Position 0 of the result holds 11 because the 1 from a and the 10 from b were combined there, and the other positions follow the same rule. The arithmetic line in the program never names an individual position, which is the point of working on the whole array.

The same pattern holds for scalar operations, where a single number such as 2 is combined with every element of the array. The number is applied at each position, so the scalar behaves as though it were matched against every value in turn. The result is a new valarray, and the original array keeps its values.

Beyond the basic operators, the most common mathematical functions are supported for valarray objects. A function of this kind takes the whole array and returns an array of results, one for each element. This lets you write a single call in place of a loop that visits each value.

The square root case is an illustration of the idea rather than a complete catalogue. The source material does not list every supported function, so when you need a specific function, check that it is available for valarray before relying on it.

The vector container was designed to be a general mechanism for holding values. It is meant to be flexible and to fit into the architecture of containers, iterators, and algorithms. Because of this design, vector does not support mathematical vector operations. A natural question follows: if vector is so useful for holding values, why not simply add mathematical operations to it? The source answers that question directly. Adding mathematical operations to vector would be easy, but its generality and flexibility preclude optimizations often considered essential for serious numerical work.

The standard library provides valarray, in the header <valarray>, as a vector-like template for numerical computation. The word vector-like is important. valarray shares the basic idea of a template that holds a sequence of values, but its purpose is different. Where vector aims at generality, valarray aims at numerical work that benefits from optimization. valarray is less general than vector and is more amenable to optimization, and that trade-off is the reason it exists as a separate template.