TP2:Interpolation polynomiale

Ahmed hadrouchi

1)
Méthode de Lagrange :
La méthode de Lagrange consiste à construire le polynôme de degré N − 1 d'un
ensemble de N points par l'expression (1). Le coût d'écriture de la forme de
Lagrange est de
2N(N + 1) opérations auxquelles il faut ajouter N(2N + 3) opérations pour
l'évaluation. le
schéma de Hörner utilisé dans la méthode suivante donne une évaluation moins
coûteuse.

Méthode de Newton :
Le polynôme d'interpolation peut s'écrire :
P(N−1)(x) = b0+b1(x−x1)+b2(x−x1)(x−x2)+· · ·+b(N−1)(x−x1)(x−x2). . .(x−x(N−1))
On recherche les coefficients b0, b1, . . . tels que P(N−1)(xi) = yi, ∀i = 1, . . .
, N
Si on remplace x par xi, on obtient le système linéaire suivant :
y1 = P(N−1)(x1) = b0
y2 = P(N−1)(x2) = b0 + (x2 − x1)b1
. . . . . . . . .
yN = P(N−1)(xN ) = b0 + (xN − x1)b1 + · · · + (xN − x1)(xN − x2). . .(xN −
x(N−1))b(N−1)

On peut remarquer que la matrice du système est triangulaire inférieure et qu'il

peut être résolu par substitution connaissant les N points (xi, yi). Cependant la
résolution par
l'utilisation des différences divisées est plus rapide.
Le coût de l'évaluation de newton est de 3N << N(2N + 3) coût de Lagrange

2)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

/** Il s’agit là de commencer par le calcul des différences divisées afin de

pouvoir réaliser l’interpolation de Newton **/
void diffDiv(double x[],double y[],int taille,double coef[][20] )
{
int i,j;
for(j=0;j<taille;j++){//on met le tableau a zero
for(i=0;i<taille;i++){
coef[j][i]=0.00;
}
}
for(i=0;i<taille;i++){//on rempli la première colonne comme dans la formule
coef[i][0]=y[i];
}
for(j=1;j<taille;j++){
for(i=0;i<taille-j;i++){//on effectue la formule colonne par colonne car la
formule est faite par récurrence pour obtenir le triangle inférieur de la matrice
coef[i][j]=(coef[i+1][j-1]-coef[i][j-1])/(x[i+j]-x[i]);
}
}
for(j=0;j<taille;j++){//on affiche le tableau des différence divisées
printf("\n");
for(i=0;i<taille;i++){
printf("%f " , coef[j][i]);
}
}

return ;
}
/** La méthode de Newton : elle utilise deux tableaux X et Y qui sont données dans
les jeux essais et la valeur que l'on cherche,
mais aussi un tableau de données contenant les différences divisées.
**/
void methodeNewton(double A[],int N,double x[],int taille,double y[],double coef[]
[20] )
{//taille= nombre de valeurs de A
double p;
int i,j;
diffDiv(x,y,20,coef);//calcul des différences divise
p=coef[0][N-1];//on initialise avec b N-1 comme dans la formule
printf("%f" ,p);
for(j=0;j<taille;j++){
for(i=1;i<N;i++){
p=coef[i][N-i-1]+(A[j]-x[i])*p;//on effectue le calcul avec chaque
valeur rechercher
}
printf("\n A[%d]=%f" ,j,p);//on affiche chaque valeur
p=coef[0][N-1];
}
return ;
}

/**
La méthode de Lagrange : elle utilise deux tableaux X et Y qui sont données dans
les jeux essais et la valeur que l'on cherche
(par exemple X=6 avec le premier jeu d'essai on a Y=6.13 et n, la taille). Enfin,
on retourne la somme, qui est le résultat.
**/

void methodeLagrange(double X[],double Y[], double valeur, int n)

{
int i,j;
double somme=0;
double p;
for(i=0;i<n;i++)
{
p=1; // Important : remettre les compteurs du produit à 1.
for(j=0;j<n;j++)
{
if(j!=i)
{
p = p*(valeur -X[j])/(X[i] - X[j]); // Prise du cours, on a une
version différente sinon avec p1 et p2 pour décomposer, mais ça coûte plus de
mémoire.
}
}
somme = somme + Y[i]*p; // Permet d'avoir le résultat
}
printf("%f \n",somme); // Affiche le résultat à la fin.
//Au début j'ai fais une fonction double mais je me suis rendu compte qu'on
utilise pas le retour, puisqu'il est déjà affiché, donc autant faire une fonction
void.
}

int main()
{
int taille1 = 20, taille2 = 11, taille3 = 10, choix = 1, taille4 = 21;
// Les noms donnés aux tableaux sont créés à partir du texte (S = série)
double XD[20] = {0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38};
double YT[20] =
{0.9987,0.99997,1.00000,0.99997,0.99988,0.99973,0.99953,0.99927,0.99897,0.99846,0.9
9805, 0.999751, 0.99705, 0.99650, 0.99664, 0.99533, 0.99472, 0.99472, 0.99333,
0.99326};
double XSun[11] = {4,5,6,7,8,9,10,11,12,13,14};
double YSun[11] = {3.1,4.74,6.13,7.26,8.14,8.77,9.14,9.26,9.13,8.74,8.1};
double XSdeux[11] = {4,5,6,7,8,9,10,11,12,13,14};
double YSdeux[11] = {5.39,5.73,6.08,6.42,6.77,7.11,7.46,7.81,8.15,12.74,8.84};
double XStrois[11] = {8,8,8,8,8,8,8,8,8,8,19};
double YStrois[11] = {5.25,5.56,5.76,6.58,6.89,7.04,7.71,7.91,8.47,8.84,12.5};
double RevenusUn[11] = {462,492,569,582,610,734,752,855,871,907,921};
double DepensesUn[11] = {80,81,81,83,81,79,85,83,162,243,281};
double RevenusDeux[10] = {524,643,679,809,828,862,875,894,902,918};
double DepensesDeux[10] = {82,84,80,77,82,84,186,223,226,260};
printf("Quel intervalle entre 2 valeurs voulez-vous ? (conseil : 0.25 et 0.5) \n
Votre choix : ");
AfficheLagrange(XSun,YSun,11,choix); // 11 = taille XSun
return 0;