OMKPolator.h

Go to the documentation of this file.

/************************************************************************/
/* This file is part of openMask(c) INRIA, CNRS, Universite de Rennes 1 */
/* 1993-2002, thereinafter the Software                                 */
/*                                                                      */
/* The Software has been developped within the Siames Project.          */
/* INRIA, the University of Rennes 1 and CNRS jointly hold intellectual */
/* property rights                                                      */
/*                                                                      */
/* The Software has been registered with the Agence pour la Protection  */
/* des Programmes (APP) under registration number                       */
/* IDDN.FR.001.510008.00.S.P.2001.000.41200                             */
/*                                                                      */
/* This file may be distributed under the terms of the Q Public License */
/* version 1.0 as defined by Trolltech AS of Norway and appearing in    */
/* the file LICENSE.QPL included in the packaging of this file.         */
/*                                                                      */
/* Licensees holding valid specific licenses issued by INRIA, CNRS or   */
/* Universite Rennes 1 for the software may use this file in            */
/* acordance with that specific license                                 */
/************************************************************************/
#ifndef OMKPolatorHEADER
#define OMKPolatorHEADER

#include "OMKTracer.h" 
#include <OMKPolatorNT.h>

namespace OMK 
{
template <typename T> class AbstractFifo ;
namespace Type
{

template <typename T>
class Polator : public PolatorNT 
{
public:
   Polator( AbstractFifo<T> * );

   Polator() ;

   Polator( int numberOfValuesForMaxPrecision ) ;

   virtual ~Polator() ;

   const T & polate( const int requestedPrecisionLevel,
                     const Date & t,
                     int & timeDistance,
                     T & resultPlaceHolder ) const ;

   virtual const T & interpolate( T & resultPlaceHolder,
                                  const int interpolateLevel,
                                  const Date & dateNeeded,
                                  const Date & dateAfter,
                                  const T & valueAfter,
                                  const Date & dateBefore,
                                  int offsetToMostRecentOfDateBefore ) const ;

   virtual const T & extrapolate( T & resultPlaceHolder,
                                  const int requestedPrecisionLevel,
                                  const Date & t,
                                  const Date & tIndex ) const ;

   virtual const T & antepolate( T & resultPlaceHolder,
                                 const int requestedPrecisionLevel,
                                 const Date & t,
                                 const Date & tIndex,
                                 unsigned int index ) const ;

   void setFifo( AbstractFifo<T> * fifo ) ;

protected:
   // We get a value based on a given date :
   // if date is in the past, we get value in the fifo
   // if date is in future, we get last fifo value.
   //
   // These function calls to fifo are transparents for user.

   //\brief Returns number of values in the fifo.
   int getNumberOfPresentValues( int maxNeeded = -1 ) const ;

   const T & get( const int index ) const ;

   const Date & getDate( const int index ) const  ;
 
protected:
   AbstractFifo<T> * _fifo ; 

private:
   void initialisePolator() ;

} ;

} // namespace Type
} // namespace OMK


//------------------------------------------------------------------------------


#include "OMKTracer.h"
#include <OMKAbstractFifo.h>
#include "OMKEmptyFifoException.h"

namespace OMK 
{
namespace Type
{

//------------------------------------------------------------------------------
template <typename T>
inline Polator<T>::Polator() 
: PolatorNT( 0 )
{
  OMTRACEID( OMK_DEBUG_OMK_POL, "Polator default constructor without fifo" ) ;
  initialisePolator();
}

//------------------------------------------------------------------------------
template <typename T>
inline Polator<T>::Polator( int numberOfValuesForMaxPrecision ) 
: PolatorNT( numberOfValuesForMaxPrecision )
{
  OMTRACEID( OMK_DEBUG_OMK_POL,
             "Polator constructor with one parameter and without fifo" ) ;
  initialisePolator();
}

//------------------------------------------------------------------------------
template <typename T>
inline Polator<T>::Polator( AbstractFifo<T> * fifo ) 
: PolatorNT( 0 )
{
  OMTRACEID( OMK_DEBUG_OMK_POL, "Polator constructor with fifo" ) ;
  initialisePolator();
  _fifo = fifo ; 
}

//------------------------------------------------------------------------------
template  <typename T>
inline void Polator<T>::initialisePolator() 
{
  _fifo = NULL ;
}

//------------------------------------------------------------------------------
template <typename T>
inline Polator<T>::~Polator()
{
}

//------------------------------------------------------------------------------
template <typename T>
inline const T & Polator<T>::get( const int value ) const
{
  return _fifo->getPreceedingValue( value ) ;
}

//------------------------------------------------------------------------------
template <typename T>
inline const Date & Polator<T>::getDate( const int value ) const
{
  OMTRACEID( OMK_DEBUG_OMK_POL,
             "Polator<" << typeid( T ).name()
             << ">::" << this << "::getDate( " << value << " )");
  return _fifo->getPreceedingDate( value ) ;
}

//------------------------------------------------------------------------------
template <typename T>
inline void Polator<T>::setFifo( AbstractFifo<T> * fifo )
{
  OMTRACEID( OMK_DEBUG_OMK_POL, "Polator<" << typeid( T ).name()
             << ">::setFifo" ) ;
  _fifo = fifo ;
}

//------------------------------------------------------------------------------
template <typename T>
inline int Polator<T>::getNumberOfPresentValues( int maxNeeded ) const
{
  OMTRACEID( OMK_DEBUG_OMK_POL, "Polator<" << typeid( T ).name()
             << ">::getNumberOfPresentValues" ) ;
  return _fifo->getNumberOfPresentValues( maxNeeded ) ;
}

//------------------------------------------------------------------------------
template <typename T>
const T & Polator<T>::polate( const int requestedPrecisionLevel,
                              const Date & t,
                              int & timeDistance,
                              T & resultPlaceHolder ) const 
{
  OMTRACEID( OMK_DEBUG_OMK_POL,
             "Polator<"  << typeid( T ).name()
             << ">::" << this << "::polate ("
             << requestedPrecisionLevel << "," << t << ") " ) ;

  int requestedPrecisionLevelPossible = requestedPrecisionLevel ;
  //_fifo->initialiseContext() ;
  int NumberOfPresentValues = getNumberOfPresentValues(
    requestedPrecisionLevel + 1 ) ;
  
  OMTRACEID( OMK_DEBUG_OMK_POL,
             "Polator<" << typeid( T ).name()
             << ">::" << this << "::polate : NumberOfPresentValues : "
             << NumberOfPresentValues ) ;

  if( NumberOfPresentValues == 0 )
  {
    throw EmptyFifoException( "Polator fifo is empty" ) ;
  }

  // Same test for antepolate and extrapolate
  // ------------------------------------------------
  if( NumberOfPresentValues <= requestedPrecisionLevel )
  {
    requestedPrecisionLevelPossible = NumberOfPresentValues - 1 ;
  }

  const Date & dateOfLastValue( getDate( 0 ) );

  OMASSERTM( dateOfLastValue != -1, "Date of last value not initialised" ) ;

  if( dateOfLastValue < t ||
      ( dateOfLastValue == t
        && PolatorNT::ConstantContinuous <= requestedPrecisionLevel ) )
  {
    OMTRACEID( OMK_DEBUG_OMK_POL, "Extrapolation case" ) ;
    timeDistance = t - dateOfLastValue ;
    
    // here, we have to do an extrapolation
    // OMASSERT( t != dateOfLastValue ) ;
    OMASSERT( NumberOfPresentValues != 1 ||
              requestedPrecisionLevelPossible == 0 ) ;
    return extrapolate( resultPlaceHolder,
                        requestedPrecisionLevelPossible,
                        t,
                        dateOfLastValue );
  }

  // Here, current state is : t <= dateOfLastValues
  // So, we have 3 cases :
  // - we get a value corresponding to t
  // - we interpolate
  // - we antepolate
  int index = 0 ; // nearest index in the fifo corresponding to date t
  unsigned int numberOfValuesInFifoNeededToContinueExamination = 2 ;

  Date const * examinedDate = & dateOfLastValue ;
  Date const * dateExaminedBefore = NULL ;
  T const * valueExaminedBefore = NULL ;

  bool notFound = true ;  // end of iteration
  bool exact = false ;    // interpolation needed
  if( *examinedDate == t )
  {
    notFound = false ;
    exact = true ;
  }

  OMTRACEID( OMK_DEBUG_OMK_POL,
             "Polator<" << typeid( T ).name() 
             << ">::polate : finding values loop..." << t ) ;

  while( notFound &&
         ( numberOfValuesInFifoNeededToContinueExamination <=
           _fifo->getNumberOfPresentValues(
             numberOfValuesInFifoNeededToContinueExamination ) ) )
  {
    OMTRACEID( OMK_DEBUG_OMK_POL, "loop status variables : "
               << notFound <<" "
               << examinedDate <<" "
               << exact <<" "
               << t <<" "
               << index <<" "
               << numberOfValuesInFifoNeededToContinueExamination ) ;
    dateExaminedBefore = examinedDate ;
    valueExaminedBefore = & get( index ) ;
    index++ ;
    examinedDate = & getDate( index ) ;

    if( *examinedDate == t )
    {
      notFound = false ;
      exact = true ;
    }
    else if( *examinedDate < t )
    {
      notFound = false ;
      exact = false ;
    }

    ++numberOfValuesInFifoNeededToContinueExamination ;
#ifdef _DEBUGATTRIBUTSMOME
    if( 4 < index )
      std::cerr << "checking a value further " << NumberOfPresentValues
                << " " << examinedDate << " " << t << std::endl ;
#endif
  }

  if( t < *examinedDate )
  { //because of relaxed coherance, this can sometimes happen
    return antepolate( resultPlaceHolder,
                       requestedPrecisionLevelPossible,
                       t,
                       *examinedDate,
                       index );
  }

  // Here,
  //   dateOfOldestValueAvailable <= examinedDate <= t <= oldExaminedDate <= dateOfLastValue,
  // with examinedDate == t if exact

  timeDistance = t - *examinedDate ;
  if( !exact )
  {
    OMASSERTM( dateExaminedBefore != NULL,
               "Pointer dateExaminedBefore must be valid" ) ;
    OMASSERTM( valueExaminedBefore != NULL,
               "Pointer valueExaminedBefore must be valid" ) ;
    return interpolate( resultPlaceHolder,
                        requestedPrecisionLevelPossible, 
                        t, 
                        *dateExaminedBefore, 
                        *valueExaminedBefore,
                        *examinedDate, 
                        index ) ;
  }
  else
  {
    return get( index ) ;
  }
}

//------------------------------------------------------------------------------
//   t -> date where we are looking for a value
//   tIndex -> date of index that we will use to find a new value
//   
//                       -tIndex depends on linear, PolatorNT::Quadratic ,etc.
//
//           l   q  c
//       ------------- 
//       |t |tI|tI|tI|
//       -------------
//
//
//   t < tIndex
//

//------------------------------------------------------------------------------
template <typename T>
inline 
const T & Polator<T>::interpolate( T & resultPlaceHolder,
                                   const int interprecisionLevel,
                                   const Date& dateNeeded,
                                   const Date& dateAfter,
                                   const T& valueAfter,
                                   const Date& dateBefore,
                                   int offsetToMostRecentOfDateBefore ) const 
{
  OMTRACEID( OMK_DEBUG_OMK_POL,
             "*********************************************" << std::endl 
             << "Polator<" << typeid( T ).name()
             << ">::interpolate (Default)" << std::endl
             << "Date dateAfter <----- : " << dateAfter << std::endl
             << "Date dateNeeded <----- : " << dateNeeded << std::endl
             << "Date dateBefore <----- : " << dateBefore << std::endl
             << "T : valueAfter " << valueAfter << std::endl
             << "int : offsetToMostRecentOfDateBefore "
             << offsetToMostRecentOfDateBefore ) ;
  resultPlaceHolder =
    ( ( dateAfter - dateNeeded ) <= ( dateNeeded - dateBefore ) ) ?
    valueAfter : get( offsetToMostRecentOfDateBefore ) ;
  return resultPlaceHolder ; 
}

//------------------------------------------------------------------------------
template <typename T>
inline 
const T & Polator<T>::extrapolate( T & resultPlaceHolder,
                                   const int requestedPrecisionLevel,
                                   const Date& t,
                                   const Date& tIndex ) const
{
  OMTRACEID( OMK_DEBUG_OMK_POL,
             "*********************************************" << std::endl
             << "Polator<" << typeid( T ).name()
             << ">::extrapolate (Default)" << std::endl
             << "Date t <----- : " << t << std::endl 
             << "Date tIndex <----- : " << tIndex << std::endl
             << "Interpolation level : "
             << requestedPrecisionLevel << std::endl
             << "*********************************************" ) ;
  return get( 0 ); 
}

//------------------------------------------------------------------------------
template <typename T>
inline 
const T & Polator<T>::antepolate( T& resultPlaceHolder,
                                  const int requestedPrecisionLevel,
                                  const Date& t,
                                  const Date& tIndex,
                                  unsigned int index ) const
{
  OMTRACEID( OMK_DEBUG_OMK_POL,
             "*********************************************" << std::endl 
             << "Polator<" << typeid( T ).name() << ">::antepolate" << std::endl
             << "Date t <----- : " << t << std::endl
             << "Date tIndex <----- : " << tIndex << std::endl 
             << "Interpolation level : " << requestedPrecisionLevel
             << std::endl 
             << "index of last element : " << index << std::endl 
             << "*********************************************" ) ;
  return get( index );
}

//------------------------------------------------------------------------------
} // namespace Type
} // namespace OMK

#endif

---