STL way to add a constant value to a std::vector

38
votes

Is there an algorithm in the standard library that can add a value to each element of a std::vector? Something like

std::vector<double> myvec(5,0.);
std::add_constant(myvec.begin(), myvec.end(), 1.);

that adds the value 1.0 to each element?

If there isn't a nice (e.g. short, beautiful, easy to read) way to do this in STL, how about boost?

6
c++stl
Thanks for the quick answers - I edited the question to represent what I am actually looking for better - an easy-to-read portable way to achieve this - Hans
either answer you have so far will work on any C++03-conforming compiler. I think the reason std::add_constant doesn't exist is because it's pretty easy to write your own. C++ isn't a functional language, so doing stuff like this is a little clunky. - Michael Kristofik
@Kristo, true, its easy to write it yourself, but the one you write yourself isn't going to be fast. I am looking for something that is similar to BLAS functionality: An easy-to-read interface hiding a complex algorithm which might for example use multithreading or other features. - Hans
it's likely to be faster than a hand-rolled for loop for large vectors, thanks to compiler inlining. To parallelize the "add 1 to every element" operation you're going to need a separate library or custom solution tuned to your hardware. Remember: make sure you profile it before you decide it's too slow. - Michael Kristofik
you should look at the uBlas library in boost, boost.org/doc/libs/1_45_0/libs/numeric/ublas/doc/index.htm, maybe you'll find something useful there... - Nim

6 Answers

36
votes

Take a look at std::for_each and std::transform. The latter accepts three iterators (the begin and end of a sequence, and the start of the output sequence) and a function object. There are a couple of ways to write this. One way, using nothing but standard stuff, is:

transform(myvec.begin(), myvec.end(), myvec.begin(),
          bind2nd(std::plus<double>(), 1.0));

You can do it with for_each as well, but the default behavior of std::plus won't write the answer back to the original vector. In that case you have to write your own functor. Simple example follows:

struct AddVal
{
    double val;
    AddVal(double v) : val(v);

    void operator()(double &elem) const
    {
        elem += v;
    }
};

std::for_each(myvec.begin(), myvec.end(), AddVal(1.0));
59
votes

Even shorter using lambda functions, if you use C++0x:

std::for_each(myvec.begin(), myvec.end(), [](double& d) { d+=1.0;});
14
votes

The shortest way in plain C++0X is :

for(double& d : myvec)
  d += 1.0;

and with boost :

for_each(myvec, _1 += 1.0); // boost.range + boost.lambda
9
votes
std::transform( myvec.begin(), myvec.end(), 
                myvec.begin(), std::bind2nd( std::plus<double>(), 1.0 ) );
5
votes

If you're interested in performing lots of math on vectors, you might want to look into the <valarray> part of the standard library. It's basically a std::vector<> designed for vectorial numerical computations (slices, math functions, point-wise operators, etc.).

The only part that really sucks is it doesn't have easy conversions to and from std::vector<>.

2
votes

The best way is to add std::transform() and lambda expression.

#include <vector>
#include <algorithm>    
std::vector<double> myVector;
double constantElement;
std::transform(myVector.begin(), myVector.end(), myVector.begin(), [&](auto& value){ return value+constantElement; });