C++ for Scientists - Technische Universität Dresden

4.8. FUNCTORS 117
};
const F& f;
T h;
This specialization is identical with the class derivative that we now could throw away. If we keep
it, we can at least reuse its functionality and variables to reduce redundancy. This is achieved
by derivation (more in Chapter 6).
template
class nth derivative
: public derivative
{
public:
nth derivative(const F& f, const T& h) : derivative(f, h) {}
};
With our recursive definition we can easily define the twenty-second derivative:
nth derivative spc 22(para sin plus cos(1.0), 0.00001);
The new object spc 22 is again a unary functor. Unfortunately, it approximates so badly that
we are too ashamed to present the results here. From Taylor series we know that the error of
the f ′′ approximation is reduced from O(h) to O(h 2 ) when a backward difference is applied
on the forward difference. This said, maybe we can improve our approximation if we alternate
between forward and backward differences:
template
class nth derivative
{
typedef nth derivative prec derivative;
public:
nth derivative(const F& f, const T& h) : h(h), fp(f, h) {}
T operator()(const T& x) const
{
return N & 1 ? ( fp(x+h) − fp(x) ) / h
: ( fp(x) − fp(x−h) ) / h ;
}
private:
T h;
prec derivative fp;
};
Sadly, our 22nd derivative is still as wrong as before, well slightly worse. Which is particularly
frustrating when we become aware that we evaluate f over four million times. 24 Decreasing h
does not help either: the tangent approaches better the derivative but on the other hand the
values of f(x) and f(x ± h) become quite close and their difference has only few meaningful
bits. At least the second derivative improved by our alternating difference scheme as the Taylor
series teach us. Another consolidating fact is that we probably did not pay for the alteration.
The template argument N is known at compile time and the condition N&1 whether the last
bit is on can be also evaluated during compilation. When N is odd than the operator reduces
effectively to:
24 TODO: Is there an efficient and well-approximating recursive scheme to compute higher order derivatives?