Accumulate absolute values of a vector

Question

If I like to accumulate the absolute values of a std::vector, I can use a lambda to calculate the absolute value and add it to the sum of std::accumulate (live demo).

#include <numeric>
#include <vector>

int main (){
    std::vector<int> vec {1,2,3,-4};
    auto abs_val =[](auto val, auto sum){return sum + std::fabs(val);};
    return std::accumulate(vec.begin(), vec.end(), 0, abs_val);
}

I would like to write

    return std::accumulate(vec.begin(), vec.end(), 0, std::fabs());

but this does not compile, since a function with the two arguments sum and value is expected.

Is there a more elegant way to write this? Do I need the lambda? Can I get rid of it?

You might want to have a look at [`transform_reduce`](https://en.cppreference.com/w/cpp/algorithm/transform_reduce) There is an overload (number 3 on that page) that takes a unary operator that could be useful. Requires C++17. Cannot check this myself because my compiler is too old for that. — RHertel, Oct 07 '19 at 09:34
fabs is defined in cmath header file https://en.cppreference.com/w/cpp/numeric/math/fabs — Hariom Singh, Oct 07 '19 at 09:42
@Adrian I like to use this for double and int values. This is why I have used `std::fabs`. — schorsch312, Oct 07 '19 at 09:51

463035818_is_not_an_ai · Accepted Answer · 2019-10-07T09:52:41.117

Before C++17

You basically want to do two things: Transform the elements and then sum them. For std::accumulate you have to tell the algorithm how you want to sum the elements up, but if you want to transform the elements, you need to do something extra.

The line you want to write only tells how to transform the elements (and it doesnt compile, because accumulate expects a functor that adds elements not one that transforms them).

TL;DR: No. If you want to transform and add elements, you have to do both. There is no algorithm called transform_and_accumulate, so you have to combine something yourself.

C++17

The above is true only till C++17, which has transform_reduce and that basically does what you are looking for.

@RHertel just saw your comment (the link is broken) – 463035818_is_not_an_ai Oct 07 '19 at 09:35 — 463035818_is_not_an_ai, Oct 07 '19 at 09:35

Philipp Lenk · Answer 2 · 2019-10-07T09:48:09.527

There are two issues with the way you would like to pass fabs. The first is trivial, the other one somewhat more involved. The code you showed cannot work, as you are trying to call fabs and pass the result to std::accumulate(a float or double):

std::accumulate(vec.begin(), vec.end(), 0, std::fabs()); //note the parens ()

So, if std::fabs were simply one function and used the correct signature this would work:

std::accumulate(vec.begin(), vec.end(), 0, std::fabs);

Yet, as can be seen here, fabs is overloaded on float, double and long double, meaning std::fabs is an overload set, not one single function and as such it's not clear which versions address you would like to pass. That part of the question has an answer here: How do I specify a pointer to an overloaded function?

Furthermore, as stated in the comments and other answer, accumulates last parameter expects a binary operation combining two values, whereas fabs only takes the absolute value of one. The correct algorithm to use is C++17's transform_reduce:

std::transform_reduce(vec.begin(), vec.end(),0,std::plus<>{}, static_cast<double (*)(double)>(std::fabs));

Accumulate absolute values of a vector

2 Answers2