InterpolateArray1D.h

Classes

InterpolateArray1D -- Interpolate in one dimension (full description)

class InterpolateArray1D

Types

enum InterpolationMethod

nearestNeighbour
nearest neighbour
linear
linear
cubic
cubic
spline
cubic spline

Interface

Public Members
static void interpolate(Array<Range>& yout, const Vector<Domain>& xout, const Vector<Domain>& xin, const Array<Range>& yin, Int method)
static void interpolate(Array<Range>& yout, const Block<Domain>& xout, const Block<Domain>& xin, const Array<Range>& yin, Int method)
static void interpolate(Array<Range>& yout, Array<Bool>& youtFlags, const Vector<Domain>& xout, const Vector<Domain>& xin, const Array<Range>& yin, const Array<Bool>& yinFlags, Int method, Bool goodIsTrue=False, Bool extrapolate=False)
static void interpolate(Array<Range>& yout, Array<Bool>& youtFlags, const Block<Domain>& xout, const Block<Domain>& xin, const Array<Range>& yin, const Array<Bool>& yinFlags, Int method, Bool goodIsTrue=False, Bool extrapolate=False)
Private Members
static void interpolatePtr(PtrBlock<Range*>& yout, Int ny, const Vector<Domain>& xout, const Vector<Domain>& xin, const PtrBlock<const Range*>& yin, Int method)
static void interpolatePtr(PtrBlock<Range*>& yout, PtrBlock<Bool*>& youtFlags, Int ny, const Vector<Domain>& xout, const Vector<Domain>& xin, const PtrBlock<const Range*>& yin, const PtrBlock<const Bool*>& yinFlags, Int method, Bool goodIsTrue, Bool extrapolate)
static void polynomialInterpolation(PtrBlock<Range*>& yout, Int ny, const Vector<Domain>& xout, const Vector<Domain>& xin, const PtrBlock<const Range*>& yin, Int order)

Description

Prerequisite

Etymology

The InterpolateArray1D class does interpolation in one dimension of an Array only.

Synopsis

This class will, given the abscissa and ordinates of a set of one dimensional data, interpolate on this data set giving the value at any specified ordinate. It will extrapolate if necessary, but this is will usually give a poor result. There is no requirement for the ordinates to be regularly spaced, however they do need to be sorted and each abscissa should have a unique value.

Interpolation can be done using the following methods:

  • Nearest Neighbour
  • Linear (default unless there is only one data point)
  • Cubic Polynomial
  • Natural Cubic Spline

    The abscissa must be a simple type (scalar value) that can be ordered. ie. an uInt, Int, Float or Double (not Complex). The ordinate can be an Array of any data type that has addition, and subtraction defined as well as multiplication by a scalar of the abcissa type. So the ordinate can be complex numbers, where the interpolation is done separately on the real and imaginary components. Use of Arrays as the the Range type is discouraged, operations will be very slow, it would be better to construct a single higher dimensional array that contains all the data.

    Note: this class (and these docs) are heavily based on the Interpolate1D class in aips/Functionals. That class proved to be too slow for interpolation of large data volumes (i.e. spectral line visibility datasets) mainly due to the interface which forced the creation of large numbers of temporary Vectors and Arrays. This class is 5-10 times faster than Interpolate1D in cases where large amounts of data are to be interpolated.

    Example

    This code fragment does cubic interpolation on (xin,yin) pairs to produce (xout,yout) pairs.
      Vector<Float> xin(4); indgen(xin); 
      Vector<Double> yin(4); indgen(yin); yin = yin*yin*yin;
      Vector<Float> xout(20); 
      for (Int i=0; i<20; i++) xout(i) = 1 + i*0.1;
      Vector<Double> yout;
      InterpolateArray1D<Float, Double>::interpolate(yout, xout, xin, yin, 
                             InterpolateArray1D<Float,Double>::cubic);
    

    Motivation

    This class was motivated by the need to interpolate visibilities in frequency to allow selection and gridding in velocity space with on-the-fly doppler correction.

    Template Type Argument Requirements (Domain)

    Template Type Argument Requirements (Range)

    Thrown Exceptions

    To Do

    Member Description

    enum InterpolationMethod

    Interpolation methods

    static void interpolate(Array<Range>& yout, const Vector<Domain>& xout, const Vector<Domain>& xin, const Array<Range>& yin, Int method)

    Interpolate in the last dimension of array yin whose x coordinates along this dimension are given by xin. Output array yout has interpolated values for x coordinates xout. E.g., interpolate a Cube(pol,chan,time) in the time direction, all values in the pol-chan plane are interpolated to produce the output pol-chan plane.

    static void interpolate(Array<Range>& yout, const Block<Domain>& xout, const Block<Domain>& xin, const Array<Range>& yin, Int method)

    deprecated version of previous function using Blocks - no longer needed now that Vector has a fast index operator [].

    static void interpolate(Array<Range>& yout, Array<Bool>& youtFlags, const Vector<Domain>& xout, const Vector<Domain>& xin, const Array<Range>& yin, const Array<Bool>& yinFlags, Int method, Bool goodIsTrue=False, Bool extrapolate=False)

    Interpolate in the last dimension of array yin whose x coordinates along this dimension are given by xin. Output array yout has interpolated values for x coordinates xout. This version handles flagged data in a simple way: all outputs depending on a flagged input are flagged. If goodIsTrue==True, then that means a good data point has a flag value of True (usually for visibilities, good is False and for images good is True) If extrapolate==False, then xout points outside the range of xin will always be marked as flagged. TODO: implement flags for cubic and spline (presently input flags are copied to output).

    static void interpolate(Array<Range>& yout, Array<Bool>& youtFlags, const Block<Domain>& xout, const Block<Domain>& xin, const Array<Range>& yin, const Array<Bool>& yinFlags, Int method, Bool goodIsTrue=False, Bool extrapolate=False)

    deprecated version of previous function using Blocks - no longer needed now that Vector has a fast index operator [].

    static void interpolatePtr(PtrBlock<Range*>& yout, Int ny, const Vector<Domain>& xout, const Vector<Domain>& xin, const PtrBlock<const Range*>& yin, Int method)

    Interpolate the y-vectors of length ny from x values xin to xout.

    static void interpolatePtr(PtrBlock<Range*>& yout, PtrBlock<Bool*>& youtFlags, Int ny, const Vector<Domain>& xout, const Vector<Domain>& xin, const PtrBlock<const Range*>& yin, const PtrBlock<const Bool*>& yinFlags, Int method, Bool goodIsTrue, Bool extrapolate)

    Interpolate the y-vectors of length ny from x values xin to xout. Take flagging into account

    static void polynomialInterpolation(PtrBlock<Range*>& yout, Int ny, const Vector<Domain>& xout, const Vector<Domain>& xin, const PtrBlock<const Range*>& yin, Int order)

    Interpolate the y-vectors of length ny from x values xin to xout using polynomial interpolation with specified order.