Interpolation de Lagrange, avance dans le temps?

[inviteb565bafd]

Bonjour,

Pour un projet électronique/automatique j'ai mis en œuvre la méthode d'interpolation de Lagrange pour obtenir une courbe de 2000 points à partir d'une courbe de 500 points.

J'ai fait tourner mon algorithme mais je suis confronté au problème de la limite d'intervalle "nombre de poteaux et nombre de clôtures" :
- Les données connues s'étalent de 0 à 499 (500 points)
- Les données à calculer s'étalent de 0 à 1999 (2000 points)

Le problème que je constate et qui est tout à fait normal, c'est que mes données ne peuvent être calculées que dans les intervalles connus : ces 500 données constituent 499 intervalles, ce qui donne une interpolation sur 4 x 499=1996, au delà je me retrouve avec une inconnue et la valeur dérive énormément!

Ma question est, connaissant les points précédents (donc ligne directrice de la courbe), comment déterminer les 4 derniers points en admettant qu'ils suivent cette trajectoire (ce sera le cas, mon système est un système mécanique du premier ordre avec une certain temps de réponse, donc pas de discontinuité ou variation brusque).

voici mes différentes fonctions en langage C:

* Génération d'une courbe trapèze de 500 points :

void trapezeGenerator(UINT16 x0, UINT16 y0, UINT16 x1, UINT16 y1, UINT16 x2, UINT16 y2, UINT16 x3, UINT16 y3, UINT16 *outBuffer)
{
  UINT16 i = 0;
  for(i = 0; i < x0; i++)
    {
      outBuffer[i] = y0;
    }
  for(i = 0; i < (x1-x0); i++)
    {
      if(y1 >= y0)
        outBuffer[i+x0] = y0+((y1 - y0)*((double)i / (x1 - x0)));
      else
        outBuffer[i+x0] = y0-((y0 - y1)*((double)i / (x1 - x0)));
    }
  for(i = 0; i < (x2-x1); i++)
    {
      outBuffer[i+x1] = y1;
    }
  for(i = 0; i < (x3-x2); i++)
    {
      if(y2 >= y3)
        outBuffer[i+x2] = y2-((y2 - y3)*((double)i / (x3 - x2)));
      else
        outBuffer[i+x2] = y2+((y3 - y2)*((double)i / (x3 - x2)));
    }
  for(i = 0; i < (500-x3); i++)
    {
      outBuffer[i+x3] = y3;
    }
}

* Fonction de calcul interpolation :

INT32 LagrangeInterpolation(UINT16 y[4], UINT16 a, UINT16*value)
{
  double s = 0, t = 0, k = 0;
  UINT8 i = 0, j = 0;
  double x[4] = {0};
  for(i = 0; i < 4; i++)
    {
      x[i] = i << 2;
    }
  for(i = 0; i < 4; i++)
    {
      s = 1;
      t = 1;
      for(j = 0; j < 4; j++)
        {
          if(j != i)
            {
              s = s * ((double)a - x[j]);
              t = t * (x[i] - x[j]);
            }
        }
      k += (double)((s / t) * (double)y[i]);
    }
  *value = (UINT16) k;
  return 0;
}

* Fonction "main" : calcul des 2000 nouveaux points

       UINT16 inData[8]={0};
       UINT16 memoryBuffer[500]={500 points connus};
       UINT16 accelerationProfile1[2000]={0};
       UINT16 j=0;
       UINT16 k=0;
       // génération d'un trapèze de 500 points
       trapezeGenerator(100, 0, 150, 32767, 250, 32767, 300, 0, memoryBuffer);
       // Calcul des 2000 points
       for(j = 0; j < 500; j++)
          {
            for(k = 0; k < 8; k++)
              {
                inData[k] = memoryBuffer[k + j];
              }
            for(k = 0; k < 4; k++)
              {
                LagrangeInterpolation(inData, k, &accelerationProfile1[k+j*4]);
              }
          }

* Courbes récupéres sous Excel (pièce jointe) :
En rouge, ce que je voudrais obtenir, en bleu ce que j'obtiens avec la dérive sur les derniers points.

Merci beaucoup!
-----