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

Description

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

virtual ~Functional()

Destructor

virtual Range operator()(const Domain &x) const = 0

Map a Domain x into a Range y value.