TabulatedFunctionComplexLgAmpPhase.h

Go to the documentation of this file.

#ifndef _utl_TabulatedFunctionComplexLgAmpPhase_h_
#define _utl_TabulatedFunctionComplexLgAmpPhase_h_

#include <vector>
#include <algorithm>
#include <numeric>
#include <utl/ComplexLgAmpPhase.h>
#include <utl/TabulatedFunctionComplexLgAmpPhaseIterators.h>

namespace utl {

  class TabulatedFunctionComplexLgAmpPhase {

  public:
    typedef std::vector<double> Array;
    typedef std::vector<utl::ComplexLgAmpPhase> ArrayComplex;
    typedef TabulatedFunctionComplexLgAmpPhaseIterator Iterator;
    typedef ConstTabulatedFunctionComplexLgAmpPhaseIterator ConstIterator;

    TabulatedFunctionComplexLgAmpPhase(const double boundaryTolerance = 1e-3)
      : fBoundaryTolerance(boundaryTolerance) { }

    TabulatedFunctionComplexLgAmpPhase(const std::vector<double>& xValues,
                             const std::vector<utl::ComplexLgAmpPhase>& yValues,
                             const double boundaryTolerance = 1e-3) :
      fBoundaryTolerance(boundaryTolerance)
    {
      FillTable(xValues, yValues);
    }

    virtual ~TabulatedFunctionComplexLgAmpPhase() { }

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

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

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

    void PushBack(const double x, const utl::ComplexLgAmpPhase& 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()); }

    Array::iterator XBegin() { return fX.begin(); }

    Array::const_iterator XBegin() const { return fX.begin(); }

    ArrayComplex::iterator YBegin() { return fY.begin(); }

    ArrayComplex::const_iterator YBegin() const { return fY.begin(); }

    Array::iterator XEnd() { return fX.end(); }

    Array::const_iterator XEnd() const { return fX.end(); }

    ArrayComplex::iterator YEnd() { return fY.end(); }

    ArrayComplex::const_iterator YEnd() const { return fY.end(); }

    Array::const_reference XFront() const { return fX.front(); }

    ArrayComplex::const_reference YFront() const { return fY.front(); }

    Array::const_reference XBack() const { return fX.back(); }

    ArrayComplex::const_reference YBack() const { return fY.back(); }

    Iterator Insert(const double x, const utl::ComplexLgAmpPhase& y);

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

    ConstIterator FindX(const double x) const;

    ConstIterator FindY(const utl::ComplexLgAmpPhase& y) const;

    utl::ComplexLgAmpPhase Y(const double x) const;

    //utl::ComplexLgAmpPhase InterpolateY(const double x, const int polyDegree) const;

    // get/set the \p idx-th value of the Ys
    const utl::ComplexLgAmpPhase& 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]; }
    utl::ComplexLgAmpPhase& GetY(const unsigned int idx) { return fY[idx]; }

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

    bool IsInValidRange(const double x) const;

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

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

    double GetBoundaryTolerance() const { return fBoundaryTolerance; }

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

    //TabulatedFunctionComplexLgAmpPhase operator*(const TabulatedFunctionComplexLgAmpPhase& rhs) const;

    TabulatedFunctionComplexLgAmpPhase& operator*=(const TabulatedFunctionComplexLgAmpPhase& rhs);

    void Pow(const double power);

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

    double fBoundaryTolerance;
    Array fX;
    ArrayComplex fY;

  };

}


#endif

// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// compile-command: "make -C .. -k"
// End: