>

Interpolation polynomiale

Dans ce TP, on se propose d'étudier et de programmer différentes méthodes d'interpolation polynomiale.

Bien entendu, Maple dispose déjà de fonction d'interpolation performantes. On commence par regarder certaines d'entre elles.

On suppose donné dans la suite des points sous la forme de deux suites d'abscisses et d'ordonnées.

> X:=[1,2,3,4,5]: Y:=[2,-2,0,4,5];

Y := [2, -2, 0, 4, 5]

La fonction "interp" calcule le polynome de degré n-1 passant par les n points. Notez l'utilisation de eval et unapply plus bas. Pourquoi ? (regarder l'aide)

> P:=interp(X,Y,t);

P := -1/24*t^4-1/4*t^3+133/24*t^2-73/4*t+15

> eval(P,t=1);

2

> P:=unapply(P,t);

P := proc (t) options operator, arrow; -1/24*t^4-1/4*t^3+133/24*t^2-73/4*t+15 end proc

> map(P,X);

[2, -2, 0, 4, 5]

> map(P,[1.5,2.5]);

[-.96093750, -1.52343750]

La fonction "plot" permet de tracer le graphe d'une fonction (ici en 2D). Regardez l'aide quant à ses multiples options. Faites des essais avec plusieurs fonctions.

> plot(P,-1..6);

[Plot]

> A:=zip((x,y)->[x,y],X,Y);

A := [[1, 2], [2, -2], [3, 0], [4, 4], [5, 5]]

> plot(A, style=point, symbol=circle);

[Plot]

On rassemble les deux  dessins (par la fonction plots)

> plots[display](plot(A, style=point, symbol=circle),plot(P,-1..6));

[Plot]

>

1) Automatiser le tout dans une procédure (qui prend deux vecteurs X et Y et trace leur polynôme d'interpolation ainsi que le nuage de points).

>

Interpolation d'une fonction.

On interpole une fonction f de la façon suivante. Soit [a,b] un  intervalle donné, on prend n points dans cet intervalle (ce nombre n fait partie des données), x1, ..., xn et on calcule f(x1), ..., f(xn). Puis, on calcule le polynome d'interpolation en ces points. Le mieux est de prendre les points équidistants dans l'intervalle de la façon suivante:

> Equidist:=(a,b,n)->[seq(a+k*(b-a)/(n-1),k=0..n-1)];

Equidist := proc (a, b, n) options operator, arrow; [seq(a+k*(b-a)/(n-1), k = (0 .. n-1))] end proc

> Equidist(0,2,5);

[0, 1/2, 1, 3/2, 2]

2) Donner une procédure qui interpole une fonction f donnée en utilisant la fonction "interp" (regarder l'aide de la fonction "map" de Maple). Tracer les courbes pour comparer la fonction et son interpolante. Essayer avec plusieurs fonctions, augmenter le nombre de points pour regarder comment évolue la précision.

3) Essayer avec la fonction f:=t->1/(1+8*t^2) dans [-1,1]. Augmentez le nombre de points. Que remarquez-vous ?

>

Interpolation de lagrange.

4) Ecrire une procédure donnant le polynome d'interpolation de Lagrange de n points donnés (au besoin, regardez l'aide de la fonction "product"). Testez sur des valeurs et tracez les courbes.

5) Sur le modèle déjà vu plus haut, créez une procédure permettant d'interpoler une fonction par la méthode de Lagrange que l'on vient de programmer puis comparez avec la fonction de Maple..

>

Interpolation : méthode de Newton

6) Donnez une procédure calculant le polynome de Newton interpolant n points donnés. La transformer, là encore, en une procédure permettant d'interpoler une fonction f quelconque. On commencera par implémenter l'opérateur de différences divisées.

Testez sur plusieurs fonctions (notamment la fonction f:=t->1/(1+8*t^2)), comparez les méthodes entre-elles.

>