ipolin.cc

Go to the documentation of this file.

#define TF_IPOLIN_CC_VERSION \
  "TF_IPOLIN_CC   V1.1"

#include<iostream>
#include <tsxx/ipolin.h>
#include <tsxx/debug.h>

namespace ts {

  namespace ipo {

    LinearInterpolator::LinearInterpolator(const Tconst_timeseries& ts,
                                           const bool& debug): 
      Tbase(ts, debug), 
      Mlast(sff::wid2lastsample(Mts.header)),
      Mdt(libtime::double2time(Mts.header.dt)),
      Madjustedfirst(Mts.header.date+(Mdt/2)),
      Minputwindow(Mts.header.date,Mlast)
      { 
        TSXX_debug(this->debug(), 
                   "LinearInterpolator::LinearInterpolatorperator(...):",
                   TSXX_value(ts.first()) << " " <<
                   TSXX_value(ts.last()) << " " 
                   << std::endl <<
                   "         " << TSXX_value(Mts.header.date.timestring())
                   << std::endl <<
                   "                   " << TSXX_value(Mlast.timestring())
                   << std::endl <<
                   "                     " << TSXX_value(Mdt.timestring())
                   << std::endl <<
                   "          " << TSXX_value(Madjustedfirst.timestring())
                  );
      } // LinearInterpolator::LinearInterpolator(...)

    /*----------------------------------------------------------------------*/

    LinearInterpolator::Tvalue 
      LinearInterpolator::operator()(const libtime::TAbsoluteTime& t) const
    {
      using libtime::TAbsoluteTime;
      using libtime::TRelativeTime;
      const Tconst_series& s=this->Mts;
      const Theader& hd=this->Mts.header;
      //aff::Tsubscript ileft=s.f()+int(libtime::time2double(t-first)/hd.dt);
      /*
       * Notice that the division in libtime is defined to return the number
       * of samples that will come closest to the time interval. That means
       * that the operator round to the nearest integer and not to the lower
       * integer. For this reason we use the adjusted time of first sample.
       */
      aff::Tsubscript ileft=s.first()+(t-Madjustedfirst)/Mdt;
      TSXX_assert((Minputwindow.includes(t) && (ileft<=s.last())),
                  "requested sample lies outside time series");
      aff::Tsubscript iright= (ileft < s.last()) ? ileft+1 : ileft;
      double f=libtime::time2double(t-sff::wid2isample(hd, ileft-s.f()))/hd.dt;
      TSXX_debug(this->debug(), "LinearInterpolator::operator():",
           TSXX_value(ileft) << " " <<
           TSXX_value(iright) << " " <<
           TSXX_value(s.f()) << " " <<
           TSXX_value(f) << " " <<
           TSXX_value(hd.dt) << std::endl <<
           "                                " << TSXX_value(Mdt.timestring())
           << std::endl <<
           "                     " << TSXX_value(Madjustedfirst.timestring())
           << std::endl <<
           "  " << TSXX_value(sff::wid2isample(hd, ileft-s.f()).timestring())
           << std::endl <<
           "                                  " << TSXX_value(t.timestring())
           << std::endl <<
           " " << TSXX_value(sff::wid2isample(hd, iright-s.f()).timestring())
           << std::endl <<
           "                 " << TSXX_value((t-Madjustedfirst).timestring())
           << std::endl <<
           "                 " << TSXX_value((t-Madjustedfirst)/Mdt)
                );
      Tvalue retval=((1.-f)*s(ileft)+f*s(iright));
      return(retval);
    }

  } // namespace ipo

} // namespace ts

/* ----- END OF ipolin.cc ----- */