Functional.h
Classes
- Functional -- Map a domain object into a range object via operator(). (full description)
template<class Domain, class Range> class Functional
Interface
- Public Members
- virtual ~Functional()
- virtual Range operator()(const Domain &x) const = 0
Review Status
- Reviewed By:
- UNKNOWN
- Date Reviewed:
- before2004/08/25
Etymology
The term ``Functional'' was chosen to follow the usage
in Barton and Nackman's ``Scientific and Engineering C++.''
Synopsis
A Functional<Domain,Range> is an abstract base class which
encapsulates the mapping of an object of type Domain into an
object of type Range.
This operation is invoked via operator() to make it look like
a function call.
While these functions are function-like, there is no guarantee
that evaluations of the same parameter will yield the same result
(the implementor of a particular class could, for example, merely choose
to emit a random number).
However implementors of Functional classes are strongly
encouraged to implement (visible) side-effect free semantics in their
classes.
A Functional object is used in circumstances similar to those
in which a function pointer could be used. An advantage of the
Functional objects is that it is possible to have more than
one of them at the same time.
Another potential advantage (not yet
implemented) is that it will be possible to perform functional
composition at run time, e.g. a=b+c where a,b, and c are
Functionals.
Another advantage is that since the Functional implementations
will in general be templated, the same source code would yield
instantiations for all the numeric types and for specializations like
automatic derivatives.
To be of greatest utility, a library of functions that do mathematics,
plotting, etc. on Functional objects needs to be developed.
Example
The following simple example shows how you can write a function that uses a
Functional object.
Double integrate1D(const Functional<Float,Float> &f,
Double x1, Double x2, Double dx) {
uInt n = (xend - xstart) / dx;
Double sum = 0.0;
for (uInt i=0; i < n; i++) sum += f(x1 + i*dx) * dx;
return sum;
}
Obviously this isn't a very serious algorithm!
Motivation
The specific application that caused the implementation of these
Functional
classes was the creation of the Fitting
module, which needed classes to represent the fitting functions.
Template Type Argument Requirements (Domain)
- Accessible default and copy constructors, assignment operators,
and destructors will almost always also be required.
Template Type Argument Requirements (Range)
- A copy constructor is absolutely required for Range objects because
operator() returns Range objects by value.
- Accessible default constructors, assignment operators,
and destructors will almost always also be required.
To Do
- For polymorphic access it could be that a clone() function
is needed at this level.
Member Description
Destructor
virtual Range operator()(const Domain &x) const = 0
Map a Domain x into a Range y value.