TabulatedFunctionErrors.cc

Go to the documentation of this file.

#include <sstream>
#if !defined(__clang_major__) || __clang_major__ < 5
#  include <ext/algorithm>
#endif
#include <utl/AugerException.h>
#include <utl/TabulatedFunctionIterators.h>
#include <utl/TabulatedFunctionErrors.h>
#include <utl/ErrorLogger.h>

using namespace std;
using namespace utl;


void TabulatedFunctionErrors::FillTable(const std::vector<double>& xValues,
                                        const std::vector<double>& xErrValues,
                                        const std::vector<double>& yValues,
                                        const std::vector<double>& yErrValues)

{
  const unsigned int xSize = xValues.size();

  if (xSize != yValues.size() || xSize != xErrValues.size() ||
      xSize != yErrValues.size()) {
    ostringstream err;
    err << "size of x, xErr, y, yErr arrays are different";
    ERROR(err);
    throw OutOfBoundException(err.str());
  }

  fX = xValues;
  fY = yValues;
  fXErr = xErrValues;
  fYErr = yErrValues;

  if (is_sorted(fX.begin(), fX.end()))
    return;

  // insertion sort
  for (unsigned int i = 0; i < xSize; ++i) {
    unsigned int mini = i;
    double minx = fX[i];
    for (unsigned int j = i+1; j < xSize; ++j) {
      const double x = fX[j];
      if (x < minx) {
        minx = x;
        mini = j;
      }
    }
    if (mini != i) {
      using std::swap;
      swap(fX[i], fX[mini]);
      swap(fY[i], fY[mini]);
      swap(fXErr[i], fXErr[mini]);
      swap(fYErr[i], fYErr[mini]);
    }
  }
}


void
TabulatedFunctionErrors::PushBack(const double x, const double xErr,
                                  const double y, const double yErr)
{
  fX.push_back(x);
  fY.push_back(y);
  fXErr.push_back(xErr);
  fYErr.push_back(yErr);
}


/*ConstTabulatedFunctionErrIterator
TabulatedFunctionErrors::Find(const double x,const double y)const{

  Array::const_iterator  itx = find(fX.begin(),fX.end(),x);
  Array::const_iterator  ity = find(fY.begin(),fY.end(),y);

  if (itx == fX.end() || ity ==fY.end() )
    return ConstTabulatedFunctionErrIterator(fX.end(),fXErr.end(),
                                             fY.end(),fYErr.end());
    else {
      unsigned int pos = ity - fY.begin();
      Array::const_iterator  itxerr= fXErr.begin() + pos;
      Array::const_iterator  ityerr= fYErr.begin() + pos;
      return ConstTabulatedFunctionErrIterator(itx,itxerr,ity,ityerr);
    }
}*/


ConstTabulatedFunctionErrIterator
TabulatedFunctionErrors::FindX(const double x)
  const
{
  const Array::const_iterator xBegin = fX.begin();
  const Array::const_iterator xEnd = fX.end();
  const Array::const_iterator xIt = lower_bound(xBegin, xEnd, x);
  if (xIt == xEnd || x != *xIt)
    return End();
  else {
    const int off = xIt - xBegin;
    const Array::const_iterator yIt = fY.begin() + off;
    const Array::const_iterator xErrIt = fXErr.begin() + off;
    const Array::const_iterator yErrIt = fYErr.begin() + off;
    return ConstTabulatedFunctionErrIterator(xIt, xErrIt, yIt, yErrIt);
  }
}


ConstTabulatedFunctionErrIterator
TabulatedFunctionErrors::FindY(const double y)
  const
{
  const Array::const_iterator yIt = find(fY.begin(), fY.end(), y);
  if (yIt == fY.end())
    return End();
  else {
    const int off = yIt - fY.begin();
    const Array::const_iterator xIt = fX.begin() + off;
    const Array::const_iterator xErrIt = fXErr.begin() + off;
    const Array::const_iterator yErrIt = fYErr.begin() + off;
    return ConstTabulatedFunctionErrIterator(xIt, xErrIt, yIt, yErrIt);
  }
}


TabulatedFunctionErrIterator
TabulatedFunctionErrors::Insert(const TabulatedFunctionErrIterator& pos,
  const double x, const double xErr, const double y, const double yErr)
{
  TabulatedFunctionErrIterator it = Begin();
  while (it != pos && it != End())
    ++it;

  Array::iterator xIt = it.fXIterator;
  Array::iterator xErrIt = it.fXErrIterator;
  Array::iterator yIt = it.fYIterator;
  Array::iterator yErrIt = it.fYErrIterator;

  xIt = fX.insert(xIt, x);
  xErrIt = fXErr.insert(xErrIt, xErr);
  yIt = fY.insert(yIt, y);
  yErrIt = fYErr.insert(yErrIt, yErr);

  return TabulatedFunctionErrIterator(xIt, xErrIt, yIt, yErrIt);
}


void
TabulatedFunctionErrors::Clear()
{
  TabulatedFunction::Clear();
  fXErr.clear();
  fYErr.clear();
}