Pass function as parameter to integrate object using lambda - c++

Question

For educational purposes
I have a function integrate which takes in a std::function as a parameter.
double calculus::integralSimple(std::function<double(double)> fn, double begin, double end)
{
double integral = 0;
for (long double i = begin; i < end; i += _step)
{
integral += fn(i) * _step; // _step defined in class
}
return integral;
}
Currently I am calling this function from main.cpp using
calculus cl;
std::cout << cl.integralSimple(calculus::identity,0,1);
std::cout << cl.integralSimple([](double x) { return x*x; }, 0, 1);
where identity is a static function defined in calculus.h and the other uses a lambda function.
I was wondering whether I could make the syntax easier for the user and closer to a mathematics way.
So what I would prefer is that the user just have to type:
std::cout << cl.integralSimple( x*x ,0,1); // Always take a function of this form
std::cout << cl.integralSimple( x*sin(x) - x*x ,0,1);
Is there any way to achieve this in C++?

Answer 1

That is exactly what Boost.Lambda was designed for. The syntax would look like this:
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
const double PI =3.141592653589793238463;
double func(double v) { return std::sin(v); } // to avoid having to
// cast std::sin
int main()
{
using namespace boost::lambda;
std::vector<double> v = {0, PI / 4, PI / 2, PI};
std::for_each(v.begin(), v.end(),
std::cout << _1 * bind(func, _1) - _1 * _1 << '\n'
// ↑↑↑↑↑↑↑↑↑↑↑↑↑↑
// to delay invocation of func
);
}
Whether that's better than the C++11 lambda syntax or not is entirely up to you.
Note that thanks to C++14 and some abuse of features, we can actually write exactly the expression you want too:
auto x = _1;
auto sin(decltype(_1) ) {
return bind(static_cast<double(*)(double)>(std::sin), _1);
}
With that, we can do:
std::for_each(v.begin(), v.end(),
std::cout << x * sin(x) - x * x << '\n');
Which will print exactly the same thing the original example did. Just... more cryptically.