casacore::SampledFunctional< Range > Class Template Reference

More...

#include <SampledFunctional.h>

Public Member Functions
virtual Range	operator() (const uInt &index) const =0
	Access the specified element of the data. More...
virtual uInt	nelements () const =0
	Return the total size of the data set. More...
virtual	~SampledFunctional ()
	The virtual destructor does nothing. More...
Public Member Functions inherited from casacore::Functional< uInt, Range >
virtual	~Functional ()
	Destructor. More...

Detailed Description

template<class Range>
class casacore::SampledFunctional< Range >

A base class for indexing into arbitrary data types

Intended use:

Public interface

Review Status

Reviewed By:

wyoung

Date Reviewed:

1996/10/10

Test programs:

tSampledFunctional

Prerequisite

• Functional

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<Float>, 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

Definition at line 101 of file SampledFunctional.h.

Constructor & Destructor Documentation

~SampledFunctional()

template<class Range >

virtual casacore::SampledFunctional< Range >::~SampledFunctional ( )

inlinevirtual

The virtual destructor does nothing.

Definition at line 110 of file SampledFunctional.h.

Member Function Documentation

nelements()

template<class Range >

virtual uInt casacore::SampledFunctional< Range >::nelements ( ) const

pure virtual

Return the total size of the data set.

Implemented in casacore::ScalarSampledFunctional< T >, and casacore::ArraySampledFunctional< T >.

operator()()

template<class Range >

virtual Range casacore::SampledFunctional< Range >::operator() ( const uInt &  index ) const

pure virtual

Access the specified element of the data.

Implements casacore::Functional< uInt, Range >.

Implemented in casacore::ScalarSampledFunctional< T >, and casacore::ArraySampledFunctional< T >.

---

The documentation for this class was generated from the following files:

• scimath/Functionals/Interpolate1D.h
• scimath/Functionals/SampledFunctional.h