C++ for Scientists - Technische Universität Dresden

118 CHAPTER 4. GENERIC PROGRAMMING
T operator()(const T& x) const
{
return ( fp(x+h) − fp(x) ) / h ;
}
Likewise for even N, only the backward difference is computed without testing.
If nothing else we learned something about C ++ and we are confirmed in the
Truism
Not even the coolest programming can substitute for solid mathematics.
In the end, this script is primarily about programming. To improve the expressiveness of our
software, functors are an extremely powerful approach. We have seen how to take an arbitrary
unary function and construct a unary function that approximates its derivative or a higher-order
derivative.
If we do not know the type of a function or we do not like to bother with it we can write a
convenience function that detects the type automatically:
template
nth derivative
inline make nth derivative(const F& f, const T& h)
{
return nth derivative(f, h);
}
Here F and T are types of function arguments and can be detected by the compiler. The only
template argument that the compiler does not detect is N. Note that such arguments must be
at the beginning of the template argument list and the compiler-detected at the end. Therefore
the following template function is wrong:
template // error
nth derivative
inline make nth derivative(const F& f, const T& h)
{
return nth derivative(f, h);
}
If you call this one, the compiler will complain that it cannot detect N. This leads us to the
question how we call this function. Of course, we can explicitly declare all argument types:
make nth derivative(sin 1, 0.00001);
But this is exactly what we wanted to avoid with implementing this function. As said, F and T
can be detected by the compiler and we only need to provide N:
make nth derivative(sin 1, 0.00001);
What is this expression good for? Written like this, not much. It creates a function that will
be immediately destroyed. If it is a function we should be able to call it with an argument: