Université Toulouse 3 Paul Sabatier 2018-2019

L2 Parcours Spécial

TP 1 - Calcul Scientifique
In [1]:

%pylab inline
# %pylab inline est un équivalent de l'importation* de numpy et de matplotlib.py
plot
#%matplotlib inline
#from matplotlib.pyplot import *
#from numpy import *
#from scipy import *

Populating the interactive namespace from numpy and matplotlib

Exercice 1 - Interpolation
1) On considère les abscisses et . Parmi les polynômes suivants, lequel est
le polynôme d'interpolation aux points (justifiez votre réponse) ?

Correction : On remarque que est de degré trop grand : le polynome recherché est de degré inférieur ou
égal à 3 (puisqu'il y a 4 points). Le polynome p_2 ne vaut pas 0 en 0. On vérifie que le polynome p3 convient
: il a bien un degré inférieur ou égal à 3 et .

2) Représentez sur une même figure les points d'interpolation, ainsi que les polynômes , et
respectivement en noir, vert et rouge, sur l'intervalle .
In [2]:

Xint=array([-2,0,1,2])
Yint=array([4,0,0,4])
x=linspace(-2.5,2.5,100)
p1=x**4-2.0/3*x**3-3*x**2+8.0/3*x
p2=4.0/3*x**2-4.0/3
p3=1.0/3*x**3+x**2-4.0/3*x
plot(x,p1,'black',x,p2,'g',x,p3,'r')
legend(['p1','p2','p3'])
plot(Xint,Yint,'o')
#on voit bien que p3 est le seul polynome dont le graphe passe par les 3 points

Out[2]:
[<matplotlib.lines.Line2D at 0x10daa8910>]
Exercice 2 - Calcul de polynômes d'interpolation
1) Calculez les polynômes d'interpolation aux points suivants :

a) et Correction : Méthode 1 : par une résolution de système : on cherche de

degré inférieur ou égal à 2 (car il y a 3 points), on cherche donc sous la forme . En
écrivant et on obtient le système suivant :

ce qui nous donne . Méthode 2 : par la base de Lagrange : On sait d'après le cours que
le polynome s'écrit simplement dans la base de Lagrange et l'on
calcule les polynômes . On obtient :

Alors . Il n'est pas utile de le développer

mais si on le faisait, on retrouverait bien sur celui de la méthode 1 (puisqu'il est unique d'après le cours).

d) et

Correction : Ici c'est plus simple puisqu'on voit à l'oeil que convient.

e) et

Correction : Ici c'est encore plus simple puisqu'on constate que convient.

2) Représentez graphiquement les polynômes des points a) et b), accompagnés des points d'interpolation
correspondants.
In [3]:

Xa=array([-1,2,3])
Ya=array([4,4,8])
Xd=array([-1,0,1])
Yd=array([1,0,1])
Xe=array([-3,-1,2,10])
Ye=Xe

x=linspace(-4,4,100)
P=2-x+x**2
Q=x**2
R=x

subplot(1,3,1)
plot(x,P,Xa,Ya,'o')
title('question a')
subplot(1,3,2)
plot(x,Q,Xd,Yd,'o')
title('question d')
subplot(1,3,3)
plot(x,R,Xe,Ye,'o')
title('question e')

Out[3]:
<matplotlib.text.Text at 0x10e065910>
Exercice 3 - Base de Lagrange
Soit (n+1) réels distincts deux à deux. Pour , on note

le -ième polynôme de Lagrange.

1) Montrez que est un polynôme de degré vérifiant pour tout .

Correction : voir cours

2) En déduire que la famille de polynôme forme une base de . Correction : voir cours

3) Écrire une fonction PolLagrange(Xint,x,k) qui calcule les valeurs prises par le -ième polynôme de
la base de Lagrange associé aux abscisses , en un point .

4) Ecrire une fonction ApproxLagrange(Xint,f,x) qui renvoie la valeur en du polynôme d'interpolation

de Lagrange de associé aux noeuds .
In [4]:

def PolLagrange(Xint, x, k):

P=ones(shape(x)) #on peut aussi mettre P=1
for i in range(len(Xint)):
if i!=k:
P=P*(x-Xint[i])/(Xint[k]-Xint[i])
return P

x=linspace(-2,4,100)
Xint=array([-1, 2, 3])
l0=PolLagrange(Xint,x,0)
l1=PolLagrange(Xint,x,1)
l2=PolLagrange(Xint,x,2)
Y0=array([1,0,0])
Y1=array([0,1,0])
Y2=array([0,0,1])
plot(x,l0,x,l1,x,l2)
legend(['$L_0$','$L_1$','$L_2$'])
plot(Xint,Y0,'o',Xint,Y1,'o',Xint,Y2,'o')

Out[4]:
[<matplotlib.lines.Line2D at 0x10e33d5d0>,
<matplotlib.lines.Line2D at 0x10e353d10>,
<matplotlib.lines.Line2D at 0x10e35f290>]
In [5]:

def ApproxLagrange(Xint,Yint,x):
P=0
for k in range(0,len(Xint)):
P=P+Yint[k]*PolLagrange(Xint,x,k)
return P

Xint=array([-1,2,3])
Yint=array([4,4,8])
x=linspace(-2,4,100)
y=ApproxLagrange(Xint,Yint,x)
z=2-x+x**2
subplot(1,2,1)
plot(x,y,'b',Xint,Yint,'o',x,z,'r') #on voit bien que les deux polynomes sont le
s memes !

#Si on veut passer une fonction en argument pour calculer le polynome de Lagrang
e d'une fonction :
def ApproxLagrangef(Xint,f,x):
P=0
for k in range(0,len(Xint)):
P=P+f(Xint[k])*PolLagrange(Xint,x,k)
return P
Xint=array([-pi,0,pi/2])
x=linspace(-2*pi, 2*pi, 100)
y=ApproxLagrangef(Xint,cos,x)
subplot(1,2,2)
plot(x,y,Xint,cos(Xint),'o')

Out[5]:
[<matplotlib.lines.Line2D at 0x10e580750>,
<matplotlib.lines.Line2D at 0x10e95d690>]
Exercice 4 - Méthode de Simpson pour le calcul approché d'intégrales
Soit une fonction continue . On cherche à approcher l'intégrale par la
formule d'intégration numérique suivante:

où les sont des réels.

1) Ecrire le système que doit vérifier pour que la méthode soit exacte pour les polynômes de
degré inférieur ou égal à 2.

Correction : La méthode est exacte pour les polynômes de degré inférieur ou égal à si et seulement si elle
est exacte pour les polynômes et , soit :

2) En déduire les valeurs de et .

Correction : On obtient après résolution .

3) Quel est le degré d'exactitude de la méthode ?

Correction : On sait déjà qu'elle est au moins de degré d'exactitude puisqu'elle a été construite poru être
exacte pour les polynômes de degré inférieur ou égal à . Mais elle peut etre de degré d'exactitude plus
grand, il faut tester sur , puis etc jusqu'à trouver un degré pour lequel .
Ici, on calcule Par contre on trouve par le calcul que .

4) Déduire de cette étude une valeur approchée de . Que peut-on faire pour avoir une approximation
aussi fine de que l'on souhaite ?

Correction : On utilise le fait que . Maintenant,

.
Exercice 5 - Méthode des rectangles en des trapèzes composite
1) Écrire une fonction RectComp(a,b,f,h), qui retourne une approximation numérique de l'intégrale de la
fonction f sur [a,b], en utilisant la méthode d'intégration de rectangle à gauche composite sur une
subdivision uniforme de pas h.

2) De même qu'à la question 1), écrire une fonction TrapComp(a,b,f,N), qui retourne une approximation
numérique de l'intégrale de la fonction f sur [a,b], en utilisant la méthode d'intégration de trapèze à
gauche composite sur une subdivision uniforme de pas h.

Correction : On rappelle la formule vue en cours pour les méthode des rectangles à gauche et des trapèzes
composites : si désigne une subdivision uniforme de pas de (c'est-à-dire que
), alors

3) Utiliser ces fonctions pour calculer une approximation de l'intégrale de la fonction sur
par les méthodes composites des rectangles et trapèzes, avec h = 0.1, puis h = 0.01 et enfin h =
0.001. Quelle erreur obtient-on dans chaque cas ? Cela est-il en accord avec les résultats théorique vus en
cours ?

In [6]:

def RectComp(a,b,f,h):
return(h*sum(f(arange(a,b,h))))

def TrapComp(a,b,f,h):
return(h/2*sum(f(arange(a,b,h)))+h/2*sum(f(arange(a+h,b+h,h))))

#affichage des erreurs pour h=0.1, h=01, h=0.001

print(RectComp(0,2,cos,0.1)-sin(2))
print(RectComp(0,2,cos,0.01)-sin(2))
print(RectComp(0,2,cos,0.001)-sin(2))
#Resultats théoriques pour la méthode des rectangles composite : erreur de l'ord
re de h

print(TrapComp(0,2,cos,0.1)-sin(2))
print(TrapComp(0,2,cos,0.01)-sin(2))
print(TrapComp(0,2,cos,0.001)-sin(2))
#Resultats théoriques pour la méthode des rectangles composite : erreur de l'ord
re de h^2

0.0700494676503
0.00707315669155
0.000707997643487
-0.000757874177074
-7.57749118596e-06
-7.57747867786e-08
Exercice 6 - Une nouvelle méthode d'intégration numérique
Soient , , et

On définit, pour une fonction continue sur , la méthode d'intégration numérique de la façon
suivante :

a) Montrer que est exacte pour les polynômes de degré inférieur ou égal à 1 sur si et seulement si
et .

Correction : Par définition, la méthode est exacte pour les polynômes de degré inférieur ou égal à 1 si et
seulement si elle est exacte pour et , c'est-à-dire:

Ce qui donne finalement et .

b) Pour quelles valeurs de , , et , est-elle exacte pour des polynômes de degré inférieur ou égal
à 3 ? Quel est alors le degré d'exactitude de la méthode ?

Correction : Pour que soit exacte pour les polynômes de degré inférieur ou égal à 3, il faut et il suffit
qu'elle soit exacte

(a) pour les polynômes de degré inférieur ou égal à 1

(b) pour
(c) pour .

Or, on a vu que (a) est vérifié si et seulement si et . De plus,

Enfin, (c) est vrai si et seulement si c'est-à-dire (car par hypothèse .

D'après (b), et sont de signe différents, ce qui donne au final : T est exacte pour les
polynômes de degré inférieur ou égal à 3 si et seulement si

c) Déduire des questions précédentes une méthode d'intégration de degré d'exactitude 3 sur un segment
quelconque.

Correction : On utilise le changement de variable expliqué en cours pour passer de notre méthode sur
à une méthode sur quelconque. On obtient

avec et

c) Programmer la méthode d'intégration obtenue, puis la méthode d'intégration composite correspondante.

Vérifiez l'ordre de la méthode en testant sur la fonction sur .
In [7]:

def MethIntExo6(a,b,f):
#On se contente de recopier la formule précédante
t1 = -((b-a)/2)*(sqrt(3)/3) + ((b+a)/2)
t2 = ((b-a)/2)*(sqrt(3)/3) + ((b+a)/2)
Jf = ((b-a)/2)*(f(t1) + f(t2))
return Jf

print("Méthode de l'exercice 6 pour cos entre 0 et 2")

print(MethIntExo6(0,2,cos),sin(2))

#La méthode composite peut s'obtenir avec en s'inspirant de l'exercice précédant

:

def MethCompExo6(a,b,f,h):
A=arange(a,b+h,h) #subdivision uniforme de [a,b] de pas h : a0...an
n=len(A)-1
J=0
for k in range(0,n):
J=J+MethIntExo6(A[k],A[k+1],f)
return J

print("Méthode composite de l'exercice 6 pour cos entre 0 et 2, pas 0.1")

print(MethCompExo6(0,2,cos,0.1),sin(2))
print("Méthode composite de l'exercice 6 pour cos entre 0 et 2, pas 0.01")
print(MethCompExo6(0,2,cos,0.01),sin(2))

Méthode de l'exercice 6 pour cos entre 0 et 2

(0.90545138523558433, 0.90929742682568171)
Méthode composite de l'exercice 6 pour cos entre 0 et 2, pas 0.1
(0.90929740577044627, 0.90929742682568171)
Méthode composite de l'exercice 6 pour cos entre 0 et 2, pas 0.01
(0.90929742682357673, 0.90929742682568171)

In [ ]: