The restriction that each absicssa have a unique value can be lifted by setting the uniq=True option in the appropriate functions. This imposes the followig additional restrictions on interpolation.

The abscissa must be a SampledFunctional that returns a scalar value that can be ordered. ie. an uInt, Int, Float or Double (not Complex). The ordinate can be any data type that has addition, and subtraction defined as well as multiplication by a scalar. So the ordinate can be complex numbers, where the interpolation is done separately on the real and imaginary components, or an array, where the interpolation is done separately on an element by element basis.

This class will curently make an internal copy of the data supplied to it, and sort the data if it is not told it is already sorted, by using the sorted=True flag.

Example

  Vector<Float> x(4); indgen(x); 
  Vector<Double> y(4); indgen(y); y = y*y*y;
  ScalarSampledFunctional<Float> fx(x)
  ScalarSampledFunctional<Double> fy(y);
  Interpolate1D<Float, Double> gain(fx, fy);
  gain.setMethod(Interpolate1D<Float,Double>::cubic);
  for (Float xs = -1; xs < 5; xs += 0.1)
    cout << "gain(" << xs << "):" << gain(xs) << endl;

Motivation

Template Type Argument Requirements (Domain)

The Domain class must be a type that can be ordered in a mathemaitical sense. This includes uInt, Int, Float, Double, but not Complex.

Template Type Argument Requirements (Range)

The Range class must have addition and subtraction of Range objects with each other as well as multiplication by a scalar defined. Besides the scalar types listed above this includes Complex, DComplex, and Arrays of any of these types.

Thrown Exceptions

• AipsError

To Do

• avoid an internal copy of the data and have an index array as the only private data (plus the interpolation method and pointers to the actual data).
• Review the use of copy semantics in the copy constructor & assignment operator after making the above change.

Member Description

enum Method

Interpolate1D()

Interpolate1D(const SampledFunctional<Domain> &x, const SampledFunctional<Range> &y, const Bool sorted=False, const Bool uniq=False)

Construct an object with the specified data

void setData(const SampledFunctional<Domain> &x, const SampledFunctional<Range> &y, const Bool sorted=False, const Bool uniq=False)

Define a new data set for the class to operate on. Equivalent in many aspects to creating a new object.

Interpolate1D(const Interpolate1D<Domain, Range>& other)
Interpolate1D<Domain, Range> & operator=(const Interpolate1D<Domain, Range> & other)
~Interpolate1D()

The standard copy constructor, assignment operator and destructor. Internal data is copied in both cases (copy semantics)

virtual const String &name() const

Name of function

virtual Range eval(typename Function1D<Domain, Range>::FunctionArg x) const

uInt getMethod() const
void setMethod(uInt method)

inquire/set the current interpolation method. uInts are used as arguments instead of the Interpolate1D::Method enumerator due to compiler limitations. See the example above (or the demo code) for the recommended way to call these functions.

Vector<Domain> getX() const
Vector<Range> getY() const

Access the data set that interpolation is done over. This will usually be sorted.

virtual Function<Domain, Range> *clone() const

A function to copy the Interpolate1D object

Range polynomialInterpolation(const Domain x, uInt n, uInt offset) const