C++ for Scientists - Technische Universität Dresden

4.8. FUNCTORS 115
Since we are using a template argument F we need to define the constraints that it has to satisfy.
For this function, we need F to be a functor with one argument. This is called a UnaryFunctor.
Formally, we can write this as follows:
• Let f be of type F.
• Let x be of type X, where X is the argument type of F.
• f(x) calls f with one argument, and returns an object of the result type.
In this example we also require that the argument type and result type of F are identical. We
can remove this restriction if we establish a unique way to deduce the return type. This can be
achieved by meta-programming or with the type deduction in the next C ++ standard.
So far so good. We complained before that we cannot apply the finite differences on themselves
to compute higher order derivatives. Actually, we still cannot. The problem is that the
finite difference expects (amongst others) a unary functor and is itself a ternary function. So it
cannot use itself as argument. The solution is to realize its functionality in a unary functor that
we call derivative:
template
class derivative
{
public:
derivative(const F& f, const T& h) : f(f), h(h) {}
T operator()(const T& x) const
{
return ( f(x+h) − f(x) ) / h ;
}
private:
const F& f;
T h;
};
Now we can create an object that approximates the derivative from f(x) = sin(1 · x) + cos x:
typedef derivative spc der 1;
spc der 1 spc(sin 1, 0.001);
The object spc can be used like a function and it approximates f ′ (x). In addition it is a unary
functor. That means we can compute its derivative:
typedef derivative spc der 2;
spc der 2 spc scd(spc, 0.001);
std::cout ≪ ”Second derivative of sin(0) + cos(0) is ” ≪ spc scd(0.0) ≪ ’\n’;
The object spc scd is again a unary functor and aproximates f ′′ (x). We could again construct
a functor for its derivative and continue this game eternally.
Assume that we need second derivatives from different functions. Then it becomes annoying to
define first the type of the first derivative constructing a functor from it for finally creating a
functor the second one. According to Greg Wilson’s [?] 23 maxim “Whatever you use twice,
automate!” we write a class that provides us the second derivative directly:
23 This online course contains a gigantic collection of tips how to develop software successfully and avoid
frustrating unproductivity. We highly recommend you reading this material.