TabulatedFunctionErrors.h

Go to the documentation of this file.

#ifndef _utl_TabulatedFunctionErrors_h_
#define _utl_TabulatedFunctionErrors_h_

#include <vector>
#include <utl/Pair.h>
#include <utl/TabulatedFunction.h>


namespace utl {

  /*
    \class TabulatedFunctionErrors TabulatedFunctionErrors.h "utl/TabulatedFunctionErrors.h"
  */

  class TabulatedFunctionErrors : public TabulatedFunction {

  public:
    typedef TabulatedFunctionErrIterator IteratorErr;
    typedef ConstTabulatedFunctionErrIterator ConstIteratorErr;

    TabulatedFunctionErrors(const unsigned int interpolationOrder = 1,
                            const double borderTolerance = 1e-3)
      : TabulatedFunction(interpolationOrder, borderTolerance) { }

    TabulatedFunctionErrors(const std::vector<double>& xValues,
                            const std::vector<double>& xValuesErr,
                            const std::vector<double>& yValues,
                            const std::vector<double>& yValuesErr,
                            const unsigned int interpolationOrder = 1,
                            const double borderTolerance = 1e-3) :
      TabulatedFunction(interpolationOrder, borderTolerance)
    { FillTable(xValues, xValuesErr,yValues, yValuesErr); }

    PairErr operator[](const int idx) const
    { return PairErr(fX[idx], fXErr[idx], fY[idx], fYErr[idx]); }

    void Clear();

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

    IteratorErr Begin()
    { return IteratorErr(fX.begin(), fXErr.begin(), fY.begin(), fYErr.begin()); }

    IteratorErr End()
    { return IteratorErr(fX.end(), fXErr.end(), fY.end(), fYErr.end()); }

    ConstIteratorErr Begin() const
    { return ConstIteratorErr(fX.begin(), fXErr.begin(), fY.begin(), fYErr.begin()); }

    ConstIteratorErr End() const
    { return ConstIteratorErr(fX.end(), fXErr.end(), fY.end(), fYErr.end()); }

    OFFLINE_MAKE_BOTH_FRIEND_RANGES(IteratorErr, ConstIteratorErr, TabulatedFunctionErrors)

    
    ArrayIterator XErrBegin() { return fXErr.begin(); }

    ArrayConstIterator XErrBegin() const { return fXErr.begin(); }

    ArrayIterator YErrBegin() { return fYErr.begin(); }

    ArrayConstIterator YErrBegin() const { return fYErr.begin(); }

    ArrayIterator XErrEnd() { return fXErr.end(); }

    ArrayConstIterator XErrEnd() const { return fXErr.end(); }

    ArrayIterator YErrEnd() { return fYErr.end(); }

    ArrayConstIterator YErrEnd() const { return fYErr.end(); }

    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(ArrayIterator, ArrayConstIterator, XErr)
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(ArrayIterator, ArrayConstIterator, YErr)

    const double& GetXErr(const unsigned int idx) const { return fXErr[idx]; }
    const double& GetYErr(const unsigned int idx) const { return fYErr[idx]; }

    double& GetXErr(const unsigned int idx) { return fXErr[idx]; }
    double& GetYErr(const unsigned int idx) { return fYErr[idx]; }

    IteratorErr Insert(const IteratorErr& pos,
                       const double x, const double xErr,
                       const double y, const double yErr);

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

    ConstIteratorErr FindX(const double x) const;

    ConstIteratorErr FindY(const double y) const;

    void
    Swap(TabulatedFunctionErrors& tf)
    {
      TabulatedFunction::Swap(tf);
      std::swap(fXErr, tf.fXErr);
      std::swap(fYErr, tf.fYErr);
    }

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

  private:
    Array fXErr;
    Array fYErr;

    friend void swap(utl::TabulatedFunctionErrors& t1, utl::TabulatedFunctionErrors& t2) { t1.Swap(t2); }

  };

}


#endif