TabulatedFunction.h

Go to the documentation of this file.

#ifndef _utl_TabulatedFunction_h_
#define _utl_TabulatedFunction_h_

#include <utl/TabulatedFunctionIterators.h>
#include <utl/IteratorRange.h>
#include <vector>
#include <algorithm>
#include <numeric>
#include <string>
#include <functional>


namespace utl {

  class TabulatedFunction {

  public:
    typedef std::vector<double> Array;
    typedef Array::iterator ArrayIterator;
    typedef Array::const_iterator ArrayConstIterator;
    typedef Array::reverse_iterator ArrayReverseIterator;
    typedef Array::const_reverse_iterator ArrayConstReverseIterator;
    typedef Array::const_reference ArrayConstReference;
    typedef TabulatedFunctionIterator Iterator;
    typedef ConstTabulatedFunctionIterator ConstIterator;

    TabulatedFunction(const unsigned int interpolationOrder = 1,
                      const double boundaryTolerance = 1e-3) :
      fInterpolationOrder(interpolationOrder),
      fBoundaryTolerance(boundaryTolerance)
    { }

    TabulatedFunction(const std::vector<double>& xValues,
                      const std::vector<double>& yValues,
                      const unsigned int interpolationOrder = 1,
                      const double boundaryTolerance = 1e-3) :
      fInterpolationOrder(interpolationOrder),
      fBoundaryTolerance(boundaryTolerance)
    {
      FillTable(xValues, yValues);
    }

    unsigned int GetNPoints() const { return fX.size(); }

    Pair operator[](const int idx) const { return Pair(fX[idx], fY[idx]); }

    void Clear() { fX.clear(); fY.clear(); }

    void PushBack(const double x, const double y);

    Iterator Begin()
    { return Iterator(fX.begin(), fY.begin()); }

    Iterator End()
    { return Iterator(fX.end(), fY.end()); }

    ConstIterator Begin() const
    { return ConstIterator(fX.begin(), fY.begin()); }

    ConstIterator End() const
    { return ConstIterator(fX.end(), fY.end()); }

    OFFLINE_MAKE_BOTH_FRIEND_RANGES(Iterator, ConstIterator, TabulatedFunction)

    
    ArrayIterator XBegin() { return fX.begin(); }

    ArrayConstIterator XBegin() const { return fX.begin(); }

    ArrayReverseIterator XRBegin() { return fX.rbegin(); }

    ArrayConstReverseIterator XRBegin() const { return fX.rbegin(); }

    ArrayIterator YBegin() { return fY.begin(); }

    ArrayConstIterator YBegin() const { return fY.begin(); }

    ArrayReverseIterator YRBegin() { return fY.rbegin(); }

    ArrayConstReverseIterator YRBegin() const { return fY.rbegin(); }

    ArrayIterator XEnd() { return fX.end(); }

    ArrayConstIterator XEnd() const { return fX.end(); }

    ArrayReverseIterator XREnd() { return fX.rend(); }

    // end reverse iterator for X
    ArrayConstReverseIterator XREnd() const { return fX.rend(); }

    ArrayIterator YEnd() { return fY.end(); }

    ArrayConstIterator YEnd() const { return fY.end(); }

    ArrayReverseIterator YREnd() { return fY.rend(); }

    ArrayConstReverseIterator YREnd() const { return fY.rend(); }

    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(ArrayIterator, ArrayConstIterator, X)
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(ArrayReverseIterator, ArrayConstReverseIterator, XR)
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(ArrayIterator, ArrayConstIterator, Y)
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(ArrayReverseIterator, ArrayConstReverseIterator, YR)

    ArrayConstReference XFront() const { return fX.front(); }

    ArrayConstReference YFront() const { return fY.front(); }

    ArrayConstReference XBack() const { return fX.back(); }

    ArrayConstReference YBack() const { return fY.back(); }

    Iterator Insert(const double x, const double y);

    //ConstIterator Find(const double x, const double y) const;

    ConstIterator FindX(const double x) const;

    ConstIterator FindY(const double y) const;

    double Y(const double x) const
    { return InterpolateY(x, fInterpolationOrder); }

    double InterpolateY(const double x, const unsigned int polyDegree) const;

    // Interpolate the Y value with the polynomial degree given in the constructor
    double operator()(const double x) const { return Y(x); }

    // get/set the \p idx-th value of the Ys
    const double& GetY(const unsigned int idx) const { return fY[idx]; }

    // get/set the \p idx-th value of the Xs
    const double& GetX(const unsigned int idx) const { return fX[idx]; }

    double& GetX(const unsigned int idx) { return fX[idx]; }
    double& GetY(const unsigned int idx) { return fY[idx]; }

    double SumX() const { return std::accumulate(fX.begin(), fX.end(), 0.); }

    double SumY() const { return std::accumulate(fY.begin(), fY.end(), 0.); }

    bool IsInValidRange(const double x) const
    { return fX.front() <= x && x <= fX.back(); }

    bool operator==(const TabulatedFunction& t) const
    { return fX == t.fX && fY == t.fY; }

    bool operator!=(const TabulatedFunction& t) const
    { return !operator==(t); }

    unsigned int GetInterpolationOrder() const { return fInterpolationOrder; }

    void SetInterpolationOrder(const unsigned int interpolationOrder)
    { fInterpolationOrder = interpolationOrder; }

    double GetBoundaryTolerance() const { return fBoundaryTolerance; }

    void SetBoundaryTolerance(const double tolerance) { fBoundaryTolerance = tolerance; }

    void
    ScaleX(const double s)
    {
      std::transform(
        XBegin(), XEnd(), XBegin(),
        [&s](auto const& elem) { return elem * s; }
      );
    }

    void
    ScaleY(const double s)
    {
      std::transform(
        YBegin(), YEnd(), YBegin(),
        [&s](auto const& elem) { return elem * s; }
      );
    }

    void
    Swap(TabulatedFunction& tf)
    {
      using std::swap;
      swap(fX, tf.fX);
      swap(fY, tf.fY);
      swap(fInterpolationOrder, tf.fInterpolationOrder);
      swap(fBoundaryTolerance, tf.fBoundaryTolerance);
    }

  protected:
    void FillTable(const std::vector<double>& xValues,
                   const std::vector<double>& yValues);

    Array fX;
    Array fY;

  private:
    double LinearInterpolateY(const double x) const;

    unsigned int fInterpolationOrder;
    double fBoundaryTolerance;
  };


  inline void swap(utl::TabulatedFunction& t1, utl::TabulatedFunction& t2)
  { t1.Swap(t2); }

}

#endif