---

PsNumericTypeT.cxx

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 PsNumericTypeIMPLEMENTATION
#define PsNumericTypeIMPLEMENTATION
#include <PsNumericTypeT.h>
#include <math.h>
#include <PsNumericPolator.h>

//------------------------------------------------------------------------
//***********************************************************************
//** interpolation PsPolatorNT::Linear a partir d'un indice de la file et de la date
//** de son arrive pour compute une pente
//** calcul --> 
//                           t[indice-1]-t[indice] 
//                  pente  = ---------------------
//                         Temps[Indice-1] - Temps[Indice]
//
// on cherche a recuperer une valeur a la date tValeur
//
//               l 'ordonne a l'origine : t[indice-1] - pente*Temps[indice-1] 
//
//  ----->  valeur = pente*tValeur + ordonnee a l'origine
//
//
//        tIndice-1 < t < tIndice
//
//*********************************************************************** 

// v0 valeur a la date t0
// v1 valeur precedente v1 = file[t0-deltaTemps]
 

double PsNumericType::linearInterpolate(
                                        const long t,
                                        const long t1, 
                                        const double v1,
                                        const long t0,
                                        const double v0
                                        )
{
#ifdef _DEBUGPOLATION
   cerr<<"linearInterpolate("<<t<<" "<<t1<<" "<<v1<<" "<<t0<<" "<<v0<<") = "<<endl;
#endif
   long d0 = t1 - t0 ;
   assert ( d0 != 0) ;
#ifdef _DEBUGPOLATION
   cerr<< ( v1 * (t - t0 ) + v0 * ( t1 - t )) / d0 <<endl;
#endif
   return ( v1 * (t - t0 ) + v0 * ( t1 - t )) / d0 ;
}
//------------------------------------------------------------------------


double PsNumericType::quadraticInterpolate(const long t,
                                           const long t2, 
                                           const double v2,
                                           const long t1, 
                                           const double v1,
                                           const long t0,
                                           const double v0
                                           )
{
   return v0 + linearInterpolate(t-t0,t2-t0,v2-v0,t1-t0,v1-v0) ;
}


double PsNumericType::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 )
{
   return v0 + quadraticInterpolate(t - t0,
                                    t3 - t0,
                                    v3 - v0,
                                    t2 - t0,
                                    v2 - v0,
                                    t1 - t0,
                                    v1 - v0);
}
//------------------------------------------------------------------------

double PsNumericType::linearExtrapolate(const long t,
                                        const long t1, 
                                        const double v1,
                                        const long t0,
                                        const double v0
                                        )
{
#ifdef _DEBUGPOLATION
   cerr<<"linearExtrapolate ("<<t<<","<<t1<<","<<v1<<","<<t0<<","<<v0<<") = ";
#endif
  long d0 = (t1 - t0);
  //assert ( false ) ;
  assert(t1 != -1) ;
  assert(t != -1) ;
  assert ( t != t1 ) ;
  double resul =  ( (t - t1) * (v1 - v0) )/ d0 + v1; 
#ifdef _DEBUGPOLATION
  cerr<<resul<<endl;
#endif
  return ( (t - t1) * (v1 - v0) )/ d0 + v1 ;
}
//------------------------------------------------------------------------


double PsNumericType::quadraticExtrapolate(const long t3,
                                           const long t2,
                                           const double v2,
                                           const long t1,
                                           const double v1,
                                           const long t0,
                                           const double v0) 
{
#ifdef _DEBUGPOLATION
  cerr<<"quadraticExtrapolate ("<<t3<<","<<t2<<","<<v2<<","<<t1<<","<<v1<<","<<t0<<","<<v0<<") = ";
#endif
   //on utilise linearExtrapolate pour compute l'accroissement en t2 et t3
   double deltaValeur = linearExtrapolate(t3-t0,
                                               t2-t0,
                                               v2-v0,
                                               t1-t0,
                                               v1-v0);
#ifdef _DEBUGPOLATION
   cerr<<v2+deltaValeur<<endl;
#endif
   return v0+deltaValeur ;
}

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

double PsNumericType::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
                                       )
{
   double deltaValeur = quadraticExtrapolate(t4 - t0,
                                                  t3 - t0,
                                                  v3 - v0,
                                                  t2 - t0,
                                                  v2 - v0,
                                                  t1 - t0,
                                                  v1 - v0);
   return v0 + deltaValeur ;
}
//------------------------------------------------------------------------

#endif

---