---

PsPolatorAndPsNumericType.h

Go to the documentation of this file.

/*
 * This file is part of openMask © 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 Université de Rennes 1 
 * for the software may use this file in accordance with that specific license
 *
 */
#ifndef PsPolatorAndPsNumericTypeHEADER
#define PsPolatorAndPsNumericTypeHEADER

#include <PsPolatorNT.h>
#include <iostream>
#include <PsFlowable.h>
#include <PsType.h>

#include "PsEmptyFifoException.h"

class PsNumericType : public PsType {

public :
   virtual ~PsNumericType (void) {} ;
   
   virtual double getValue (void) const = 0 ;


   static double linearInterpolate(const long t,
                                   const long t1, 
                                   const double v1,
                                   const long t0,
                                   const double v0
                                   );


   static double quadraticInterpolate(const long t,
                                      const long t2, 
                                      const double v2,
                                      const long t1, 
                                      const double v1,
                                      const long t0,
                                      const double v0
                                      );



   static double cubicInterpolate(const long t,
                                  const long t3, 
                                  const double v3,
                                  const long t2, 
                                  const double v2,
                                  const long t1, 
                                  const double v1,
                                  const long t0,
                                  const double v0
                                  );


   static double linearExtrapolate(const long t,
                                   const long t1, 
                                   const double v1,
                                   const long t0,
                                   const double v0
                                   );


   static double quadraticExtrapolate(const long t3,
                                      const long t2,
                                      const double v2,
                                      const long t1,
                                      const double v1,
                                      const long t0,
                                      const double v0);


   static double cubicExtrapolate(const long t4,
                                  const long t3,
                                  const double v3,
                                  const long t2,
                                  const double v2,
                                  const long t1,
                                  const double v1,
                                  const long t0,
                                  const double v0);
} ;



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

template <class Type>

class PsNumericTypeT : public PsNumericType {
  
public :
  
   PsNumericTypeT (void) ;
   
   PsNumericTypeT (const int) ;

   PsNumericTypeT (const long) ;

   PsNumericTypeT (const float) ;

   PsNumericTypeT (const double) ;
   
   PsNumericTypeT (const PsNumericTypeT<Type> &) ;
   
   virtual ~PsNumericTypeT (void) ;

  
   virtual PsNumericTypeT & operator ++ (void) ;

   virtual PsNumericTypeT operator ++ (int) ;

   virtual PsNumericTypeT & operator -- (void) ;

   virtual PsNumericTypeT operator -- (int) ;
  
   virtual PsNumericTypeT & operator = (const PsNumericTypeT <Type> &) ;

   virtual PsNumericTypeT & operator = (int) ;
   
   virtual PsNumericTypeT & operator = (long int) ;

   virtual PsNumericTypeT & operator = (float) ;
   
   virtual PsNumericTypeT & operator = (double) ;

   virtual operator Type () const;
   
   virtual double getValue (void) const ;


   virtual void insertInStream (ostream & = cout) const ;

   virtual void extract (istream & = cin) ;

   virtual void unpack (PsIncomingSynchronisationMessage &) ;
   
   virtual void pack (PsOutgoingSynchronisationMessage &) const ;

   virtual PsPolatorNT * createPolator(void)  ;
   
private :
  Type _data ;

} ;

typedef PsNumericTypeT <int> PsInt ;

typedef PsNumericTypeT <long int> PsLongInt ;

typedef PsNumericTypeT <float> PsFloat ;

typedef PsNumericTypeT <double> PsDouble ;

typedef PsInt PsFrequency ;

typedef PsLongInt PsDate ;


template <typename Type> class PsnAbstractFifo;

template <typename Type>
class PsPolator : public PsPolatorNT {
   
public:
   PsPolator(PsnAbstractFifo<Type> *);

   PsPolator(void) ;

   PsPolator(int numberOfValuesForMaxPrecision ) ;

   virtual ~PsPolator(void) ;

   const Type & polate(const int requestedPrecisionLevel,
                       const PsDate & t,
                       int & distance,
                       Type & resultPlaceHolder ) const ;

   virtual const Type & interpolate(Type & resultPlaceHolder,
                                    const int interpolateLevel,
                                    const PsDate & dateNeeded,
                                    const PsDate & dateAfter,
                                    const Type & valueAfter,
                                    const PsDate & dateBefore,
                                    int offsetToMostRecentOfDateBefore
                                    ) const ;
   virtual const Type & extrapolate(Type & resultPlaceHolder,
                                    const int requestedPrecisionLevel,
                                    const PsDate & t,
                                    const PsDate & tIndice
                                    ) const ;
   virtual const Type & antepolate(Type & resultPlaceHolder,
                                     const int requestedPrecisionLevel,
                                     const PsDate & t,
                                     const PsDate & tIndice,
                                     unsigned int indice 
                                     ) const ;
   void setFifo(PsnAbstractFifo<Type> * fifo) ; 
   
protected:
  // on delivre une valeur par rapport a une date
  // si la date est anterieure, c'est la valeur associe dans la file
  // si la date est dans le futur le resultat est la derniere valeur de la file
  //
    // ce sont des appels aux methode de la file
  // transparent a l'utilisateur
  //-----------------------------------------------
   int getNumberOfPresentValues (int maxNeeded = -1) const   ; // nbre de valeur dans la file
  
  const Type & get(const int indice) const  ;
   const PsDate & getDate(const int indice) const  ;
 
protected:
   PsnAbstractFifo<Type> * _fifo ; 

private:
   void intialisePolator() ;

} ;

#include <PsnAbstractFifo.h>
#include "PsIncomingSynchronisationMessage.h"
#include "PsOutgoingSynchronisationMessage.h"

template <typename Type>

PsNumericTypeT<Type>::PsNumericTypeT (void) {

_data = 0 ;
}

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

template <typename Type>

PsNumericTypeT<Type>::PsNumericTypeT (const int d) {
  _data = Type (d) ;
  //_data = (Type)d ;
}

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

template <typename Type>

PsNumericTypeT<Type>::PsNumericTypeT (const long d) {
  _data = Type (d) ;
  //_data = (Type)d ;
}

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

template <typename Type>

PsNumericTypeT<Type>::PsNumericTypeT (const float d) {
  _data = Type (d) ;
  //_data = (Type)d ;
}

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

template <typename Type>

PsNumericTypeT<Type>::PsNumericTypeT (const double d) {
  _data = Type (d) ;
  //_data = (Type)d ;
}

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

template <typename Type>

PsNumericTypeT<Type>::PsNumericTypeT (const PsNumericTypeT<Type> & t) {
  //_data = (Type)t.getValue () ;
  _data = t._data ;
}


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

template <typename Type>

PsNumericTypeT<Type>::~PsNumericTypeT (void) {

}

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

template <typename Type>
void PsNumericTypeT<Type>::pack (PsOutgoingSynchronisationMessage & out) const
{
  out<<_data ;
}

template <typename Type>
void PsNumericTypeT<Type>::unpack (PsIncomingSynchronisationMessage & in)
{
  in>>_data ;
}

template <typename Type>
void PsNumericTypeT<Type>::insertInStream (ostream & out) const {
   out << _data ;
}

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

template <typename Type>

 void PsNumericTypeT<Type>::extract (istream & in) {
  in >> _data ;
}



//------------------------------------------------------------------
#include <PsNumericPolator.h>

template <typename Type>

PsPolatorNT * PsNumericTypeT<Type>::createPolator(void)
{
  // C'est l'utilisateur qui doit desaloue l'interpolateur cree
   //DM : non c'est le destructeur de PsnTypeT qui s'en charge
  PsNumericPolatorT <Type> * interp ; 
  interp = new PsNumericPolatorT<Type>();
  return ((PsPolatorNT *)interp) ;
} 


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

template <typename Type>

PsNumericTypeT<Type> & PsNumericTypeT<Type>::operator ++ (void) {
  ++ _data ;
  return *this ;
}

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

template <typename Type>

PsNumericTypeT<Type> PsNumericTypeT<Type>::operator ++ (int) {
  PsNumericTypeT<Type> retour (*this) ;
  ++ (* this) ;
  return retour ;
}

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

template <typename Type>

PsNumericTypeT<Type> & PsNumericTypeT<Type>::operator -- (void) {
  -- _data ;
  return *this ;
}

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

template <typename Type>

PsNumericTypeT<Type> PsNumericTypeT<Type>::operator -- (int) {
  PsNumericTypeT<Type> retour (*this) ;
  -- (* this) ;
  return retour ;
}

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

template <typename Type>

PsNumericTypeT<Type> & PsNumericTypeT<Type>::operator = (const PsNumericTypeT<Type> & n) {
  //  cout << "**************NUMERIQUE****************" << endl ;
  // cout << " operateur = " << endl ;
  if (this != &n) {
    //    _data = n.getValue () ;
    _data = n._data ;
  }
  return *this ;
}

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

template <typename Type>

PsNumericTypeT<Type> & PsNumericTypeT<Type>::operator = (int n) {
  _data = Type (n) ;
  //_data = (Type)n ;
  return *this ;
}

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

template <typename Type>

PsNumericTypeT<Type> & PsNumericTypeT<Type>::operator = (long int n) {
  _data = Type (n) ;
  //_data = (Type)n ;
  return *this ;
}

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

template <typename Type>

PsNumericTypeT<Type> & PsNumericTypeT<Type>::operator = (float n) {
  _data = Type (n) ;
  //_data = (Type)n ;
  return *this ;
}

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

template <typename Type>

PsNumericTypeT<Type> & PsNumericTypeT<Type>::operator = (double n) {
  _data = Type (n) ;
  //_data = (Type)n ;
  return *this ;
}


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

template <typename Type>

double PsNumericTypeT<Type>:: getValue() const {
  return (double)_data ;
}

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

template <typename Type>

PsNumericTypeT<Type>::operator Type  () const {
  return _data ;
}

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

//  template <typename Type>

//  Type PsNumericTypeT<Type>::getData (void) const {
//    return _data ;
//  }

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

template <typename Type>

PsNumericTypeT<Type> operator - (const PsNumericTypeT<Type> & n) {
  return  (PsNumericTypeT<Type> (- n.getValue ())) ;
}

//---------------------------------------------------------------
template <typename Type>
inline PsPolator<Type>::PsPolator() : PsPolatorNT ( 0 )
{
#ifdef _DEBUGTYPEUTIL
  cout << "PsPolator constructeur sans file" << endl;
#endif
  intialisePolator();
}


//---------------------------------------------------------------
template <typename Type>
inline PsPolator<Type>::PsPolator(int numberOfValuesForMaxPrecision) : PsPolatorNT ( numberOfValuesForMaxPrecision )
{
#ifdef _DEBUGTYPEUTIL
  cout << "PsPolator constructeur avec paramètre et sans file" << endl;
#endif
  intialisePolator();
}

//---------------------------------------------------------------
template <typename Type>
inline PsPolator<Type>::PsPolator(PsnAbstractFifo<Type> * file2) : PsPolatorNT ( 0 )
{
#ifdef _DEBUGTYPEUTIL
  cout << "PsPolator constructeur avec file" << endl;
#endif
 
  intialisePolator();
  _fifo = file2 ; 
}

template  <typename Type>
inline void PsPolator<Type>::intialisePolator() {
  _fifo = NULL ;
}

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

//---------------------------------------------------------------
template <typename Type>
inline const PsDate & PsPolator<Type>::getDate(const int value) const
{
#ifdef _DEBUGTYPEUTIL
   cerr<<"PsPolator<Type>::"<<this<<"::getDate ("<<value<<") "<<endl;
#endif
  return _fifo->getPreceedingDate(value) ;
}


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

template <typename Type>
inline void PsPolator<Type>::setFifo(PsnAbstractFifo<Type> * fifo)
{
#ifdef _DEBUGTYPEUTIL
   cerr<<"PsPolator<Type>::setFifo "<<endl;
#endif
  _fifo = fifo ; 
}

//---------------------------------------------------------------
template <typename Type>
inline int PsPolator<Type>::getNumberOfPresentValues (int maxNeeded ) const 
{
#ifdef _DEBUGTYPEUTIL
   cerr<<"PsPolator<Type>::getNumberOfPresentValues"<<endl;
#endif
  return(_fifo->getNumberOfPresentValues(maxNeeded));
}
//---------------------------------------------------------------
template <typename Type>
const Type & PsPolator<Type>::polate(
                                     const int requestedPrecisionLevel,
                                     const PsDate & t,
                                     int & distanceTemporelle,
                                     Type & resultPlaceHolder
                                     ) const 
{
#ifdef _DEBUGTYPEUTIL
   cerr<<"PsPolator<Type>::"<<this<<"::polate ("<<requestedPrecisionLevel<<","<<t<<") "<<endl;
#endif


  int requestedPrecisionLevelPossible = requestedPrecisionLevel ;
  //_fifo->initialiseContext() ;
  int NumberOfPresentValues = getNumberOfPresentValues(requestedPrecisionLevel+1) ;
  
#ifdef _DEBUGTYPEUTIL
  cerr<<"PsPolator<Type>::"<<this<<"::polate : NumberOfPresentValues : "<<NumberOfPresentValues<<endl;
#endif

  if (NumberOfPresentValues==0) { 
     throw PsEmptyFifoException ("PsPolator::polate") ;
  }

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

     requestedPrecisionLevelPossible = NumberOfPresentValues-1;
     
  }

  const PsDate & dateDerniereValeur( getDate( 0 ) );
  
  assert(dateDerniereValeur != -1) ;

  if (dateDerniereValeur <t)
    {                         
#ifdef _DEBUGTYPEUTIL
       cerr<<"Cas de l'extrapolation"<<endl;
#endif
       
       distanceTemporelle = t - dateDerniereValeur ;
       
      
      // On est dans le cas d'une extrapolation
       assert (t != dateDerniereValeur) ;
       assert ((NumberOfPresentValues != 1)||(requestedPrecisionLevelPossible == 0)) ;
       return extrapolate(resultPlaceHolder, 
                          requestedPrecisionLevelPossible, 
                          t, 
                          dateDerniereValeur );
    }

  // On est dans la configuration suivante :
  // t <= DateDerniereValeurs 
  //               ***********
  // - Soit on recupere une date dans la file qui correspond a t
  // - Soit on interpole
  // - soit on antépole



  int indice = 0 ; // l'indice le plus proche dans la file correspondant a la date t

  unsigned int numberOfValuesInFifoNeededToContinueExamination = 2 ;

  PsDate const * examinedDate = & dateDerniereValeur ;
  PsDate const * dateExaminedBefore = NULL ;
  Type const * valueExaminedBefore = NULL ; 

  bool pasTrouve ;  // end of iteration
  bool exact ;    // interpolation needed
  
  if (*examinedDate == t) 
    {
      pasTrouve = false ;
      exact = true ;
    }
  else 
    {
      pasTrouve = true ;
      exact = false ;     
    }
#ifdef _DEBUGTYPEUTIL
  cerr <<"PsPolator<Type>::polate : Boucle de recherche de valeurs...."<<t<< endl ;
#endif

  while ( (pasTrouve) &&
          (_fifo->getNumberOfPresentValues(numberOfValuesInFifoNeededToContinueExamination) >= numberOfValuesInFifoNeededToContinueExamination  ) ) 
     {
        
#ifdef _DEBUGTYPEUTIL
        cerr<<"variables de boucles : "
            <<pasTrouve<<" "
            <<examinedDate<<" "
            <<exact<<" "
            <<t<<" "
            <<indice<<" "
            <<numberOfValuesInFifoNeededToContinueExamination<<endl;
#endif

        dateExaminedBefore = examinedDate ;
        valueExaminedBefore = & get (indice) ;
        indice ++ ;
        examinedDate = & getDate ( indice ) ;

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

        ++numberOfValuesInFifoNeededToContinueExamination ;

#ifdef _DEBUGATTRIBUTSMOME
        if (indice > 4) cerr<<"On demande loin "<<NumberOfPresentValues<<" "<<examinedDate<<" "<<t<<endl;
#endif
     }
  
  if (*examinedDate > t) {//because of relaxed coherance, this can sometimes happen
    return  antepolate(resultPlaceHolder, 
                       requestedPrecisionLevelPossible, 
                       t, 
                       *examinedDate, 
                       indice );
  }

  /* here, dateOfOldestValueAvailable <= examinedDate <= t <= oldExaminedDate <= dateDerniereValeur, with examinedDate == t if exact */

  distanceTemporelle = t - *examinedDate ;
  if ( ! exact) {
    assert ( dateExaminedBefore != NULL) ;
    assert ( valueExaminedBefore != NULL ) ;
     return  interpolate ( resultPlaceHolder,
                             requestedPrecisionLevelPossible, 
                             t, 
                             *dateExaminedBefore, 
                             *valueExaminedBefore,
                             *examinedDate, 
                             indice) ;
  }  
  else {
     return  get( indice ) ;
  }
}

//---------------------------------------------------------------
//   t -> date a laquelle on veut trouver un valeur
//   tIndice -> date de l'indice avec lequel on va pouvoir trouver
//              une nouvelle valeur
//
//   
//                       -tIndice selon lineaire , PsPolatorNT::Quadratic ,etc  
//           l   q  c
//       ------------- 
//       |t |tI|tI|tI|
//       -------------
//
//
//   t < tIndice
//
//--------------------------------------------------------------
template <typename Type>
inline const Type & PsPolator<Type>::interpolate (Type & resultPlaceHolder,
                                                  const int interprecisionLevel,
                                                  const PsDate & dateNeeded,
                                                  const PsDate & dateAfter,
                                                  const Type & valueAfter,
                                                  const PsDate & dateBefore,
                                                  int offsetToMostRecentOfDateBefore
                                                  ) const 
{
   
#ifdef _DEBUGTYPEUTIL
   cout << "*********************************************" << endl ;
   cout << "PsPolator::interpolation PAR DEFAUT" << endl;
   cout << "PsDate dateAfter <----- : " << dateAfter << endl ;
   cout << "PsDate dateNeeded <----- : " << dateNeeded << endl ;
   cout << "PsDate dateBefore <----- : " << dateBefore << endl ;
   cout << "Type : valueAfter " << valueAfter << endl ;
   cout << "int : offsetToMostRecentOfDateBefore " << offsetToMostRecentOfDateBefore << endl ;
#endif
   
  if ( (dateAfter - dateNeeded) <= (dateNeeded - dateBefore) ) 
     {
        resultPlaceHolder = valueAfter ;
     }
  else 
     {
        resultPlaceHolder = get (offsetToMostRecentOfDateBefore) ;
     }

  return resultPlaceHolder ; 

}

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


template <typename Type>
inline const Type & PsPolator<Type>::extrapolate(Type & resultPlaceHolder,
                                                 const int requestedPrecisionLevel,
                                                 const PsDate & t,
                                                 const PsDate & tIndice
                                                 ) const
                                        
{
#ifdef _DEBUGTYPEUTIL
  cout << "*********************************************" << endl ;
  cout << "PsPolator<Type>::extrapolate PAR DEFAUT" << endl;
  cout << "PsDate t <----- : " << t << endl ;
  cout << "PsDate tIndice <----- : " << tIndice << endl ;
  cout << "niveau interpolation : " << requestedPrecisionLevel << endl ;
  cout << "indice dernier: " << requestedPrecisionLevel << endl ;
  cout << "*********************************************" << endl ;
#endif
  
  return get(0); 
  
}
//---------------------------------------------------------------
template <typename Type>
inline const Type & PsPolator<Type>::antepolate(Type & resultPlaceHolder,
                                                const int requestedPrecisionLevel,
                                                const PsDate & t,
                                                const PsDate & tIndice,
                                                unsigned int indice
                                                ) const
   
{
#ifdef _DEBUGTYPEUTIL
  cout << "*********************************************" << endl ;
  cout << "PsPolator::antepolate" << endl;
  cout << "PsDate t <----- : " << t << endl ;
  cout << "PsDate tIndice <----- : " << tIndice << endl ;
  cout << "niveau interpolate : " << requestedPrecisionLevel << endl ;
  cout << "indice dernier: " << indice << endl ;
  cout << "*********************************************" << endl ;
#endif
  
  return get(indice); 
  
}

#endif

---