SampledFunctional.h
Classes
- SampledFunctional -- A base class for indexing into arbitrary data types (full description)
template <class Range> class SampledFunctional: public Functional<uInt, Range>
Interface
- Public Members
- virtual Range operator()(const uInt &index) const = 0
- virtual uInt nelements() const = 0
- virtual ~SampledFunctional()
- See Also
- ScalarSampledFunctional Access an Array or Block using a SampledFunctional interface
Review Status
- Reviewed By:
- wyoung
- Date Reviewed:
- 1996/10/10
- Programs:
- Tests:
Prerequisite
Etymology
A Functional is simply a mapping from a Domain type to a Range
type. Experimental data is usually sampled, and is can be represented as
a mapping from the unsigned integers to an arbitrary Domain.
Synopsis
This abstract class defines an interface for functions that map from the
unsigned integers to an arbitrary type. It defines two functions: the
operator() function which it inherits from the Functional class, and the
nelements function which is necessary to know how many data elements.
This class is useful for freeing the writer of other classes from having
to know how how a linear data set is stored or represented. For example,
four floating point numbers will probably be stored as a Vector,
and kept in memory for fast access. But 400 million floating point
numbers cannot usually be kept in memory, and may be stored on disk as a
Table. By using a SampledFunctional writers of other classes
(Interpolate1D is an example), can ignore these details if all they are
interested in is random access to individual elements of the data.
Example
Because this is an abstract class the example will be inside a function
T sum(SampledFunctional<T> data)
{
T result = 0;
for (uInt i = 0; i < data.nelements(); i++)
result += data(i);
return result;
}
Motivation
If all you need to do is random access indexing into arbitrary data sets
this class provides a suitable abstraction of that functionality.
Template Type Argument Requirements (Range)
Templating restrictions will depend on the actual derived class that is
used.
Thrown Exceptions
Exceptions will depend on derived classes and the templating
arguements. This abstract class only defines an interface and does not
throw any exceptions.
To Do
- I cannot think of anything
Member Description
virtual Range operator()(const uInt &index) const = 0
Access the specified element of the data
virtual uInt nelements() const = 0
Return the total size of the data set.
The virtual destructor does nothing