Calcul scientifique TP4 Integration Numerique-Corrige

November 5, 2019

1 TP4 : Intégration numérique

1.1 Objectif
L’objectif de ce TP 4 est de :
- Programmer certaines méthodes composites d’intégration numérique. - Comparer, visuellement
et via les claculs, les valeurs approchées de l’intégrale d’une fonction f continue sur [ a, b] ⊂ R
à celle exacte. - Etudier l’évolution de l’erreur d’intégration en fonction du nombre de points
d’intégration et/ou le nombre de sous intervalles de [ a, b] à considérer.

1.2 Rappel du Cours

Les méthodes numériques utilisées pour calculer la valeur exacte de l’integrale I d’une fonction
continue f sur un intervalle [ a, b] ne sont pas toujours efficaces et conduisent généralement à
d’avantages de calculs. En analyse numérique, il existe une vaste famille d’algorithmes dont le
but principal est d’estimer la valeur exacte de I.
Les méthodes qui seront étudiées dans ce TP sont : - la méthode composite des rectangles (à
gauche et à droite). - la méthode composite des trapèzes. - la méthode composite de Simpson.

1.2.1 Principe général

∫ b
Soit f : [ a, b] → R une fonction continue. Il s’agit d’approcher la valeur de I ( f ) = f (t) dt.
a
Pour ce faire, nous commençons par subdiviser l’intervalle [ a, b] en n sous-intervalles [ xk , xk+1 ],
b−a
0 ≤ k ≤ n − 1, de largeur uniforme h = , tels que xk = a + kh, ∀ 0 ≤ k ≤ n. Ainsi,
n
∫ b n1 ∫ x k +1
I( f ) =
a
f (t) dt = ∑ f (t) dt.
k =0 x k
∫ x k +1
Ensuite, en approchant f (t) dt, 0 ≤ k ≤ n − 1 par l’une des méthodes simples suivantes,
xk
appliquée sur [ xk , xk+1 ] : 1. Rectangle à droite simple : IRd s
( f ) = f ( xk )( xk+1 − xk )
2. Rectange à gauche simple : IRg s
( f ) = f ( xk+1 )( xk+1 − xk )
x + x k +1
3. Rectange du point milieu simple : IRm s
(f) = f( k )( xk+1 − xk )
2
f ( x k ) + f ( x k +1 )
4. Trapèze simple : ITs ( f ) = ( xk+1 − xk ) 5. Simpson simple : ISs ( f ) =
2
1 x k +1 − x k [ x + x k +1 ]
f ( xk ) + 4 f ( k ) + f ( x k +1 )
3 2 2

1
 Nous obtenons la formule composite associée pour approcher I ( f ).
Les abréviations Rg, Rd, Rm, T, S, s, et c désignent, respectivement, Rectangle à gauche, Rect-
angle à droite, Rectangle milieu, Trapèze, Simpson, simple et composite.
Dans tout ce qui suit, nous considérons une fonction f continue sur [ a, b] ⊂ R et xk = a + kh,
0 ≤ k ≤ n les points d’intégrations issus de la subdivision de [ a, b] en n sous intervalles avec un
b−a
pas fixe h = .
n

1.3 Méthodes composites des rectangles

1.3.1 Formule de la méthode composite des rectangles à gauche
n −1
I ( f ) ≈ IRg
c
(f) = h ∑ f ( x k ).
k =0
Ecrire une fonction rectangle_gauche_composite(f,a,b,n) prenant en entrée f , une fonc-
tion continue sur [ a, b], a, b, les bornes de [ a, b] et n, le nombre de sous intervalles à considérer et
retourne la valeur approchée IRg c ( f ).

[1]: import numpy as np

import matplotlib.pyplot as plt
[2]: def rectangle_gauche_composite(f,a,b,n):
h = (b-a)/n
s = 0
for k in np.arange(0,n):
s += f(a+k*h)
return h*s
Application 1 :
∫1
On considère la fonction f (t) = e−t , t ∈ [−1, 1]. 1. Pour n = 4, approcher I ( f ) = −1 f (t)dt par la
2

méthode composite des rectangles à gauche. 2. Sur un même graphe, représenter la valeur exacte
c ( f ) en rouge.
I ( f ) en bleu et la valeur approchée IRg
Indication : utiliser la fonction plt.fill_between. Consuter le help pour savoir comment
l’utiliser. 3. Retracer les figures pour n = 10. Observer les résultats et conclure.
Question 1 :
[3]: f=lambda t : np.exp(-t**2)
a=-1
b=1
n=4
I_Rg=rectangle_gauche_composite(f,a,b,n)
print(I_Rg)

1.4627405036571262

Question 2 :
[4]: plt.figure(figsize=(20,10))
t=np.linspace(-1,1,100)
x=np.linspace(-1,1,n+1)
plt.fill_between(t,f(t),color="blue",alpha=0.5)

2
 plt.fill_between(x,f(x),step="post",color="red",alpha=0.5)
plt.legend(('$I(f)$','$I_{Rg}^c(f)$'),loc=0,fontsize=30)
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)
plt.xlabel('t',fontsize=30)
plt.ylabel('f(t)',fontsize=30)
plt.title('Approximation de $\int_{-1}^1 e^{-t^2}dt$ par la méthode des␣
,→rectangles à gauche (n=4)', fontsize=30)

plt.show()

Question 3 :
[5]: n=10
I_Rg=rectangle_gauche_composite(f,a,b,n)
print(I_Rg)
plt.figure(figsize=(20,10))
t=np.linspace(-1,1,100)
x=np.linspace(-1,1,n+1)
plt.fill_between(t,f(t),color="blue",alpha=0.5)
plt.fill_between(x,f(x),step="post",color="red",alpha=0.5)
plt.legend(('$I(f)$','$I_{Rg}^c(f)$'),loc=0,fontsize=30)
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)
plt.xlabel('t',fontsize=30)
plt.ylabel('f(t)',fontsize=30)
plt.title('Approximation de $\int_{-1}^1 e^{-t^2}dt$ par la méthode des␣
,→rectangles à gauche (n=10)', fontsize=30)

plt.show()

3
 1.4887366795273342

1.3.2 Formule de la méthode composite des rectangles à droite

n
I ( f ) ≈ IRd
c
(f) = h ∑ f ( x k ).
k =1

Ecrire une fonction rectangle_droite_composite(f,a,b,n) prenant en entrée f , une fonc-

tion continue sur [ a, b], a, b, les bornes de [ a, b] et n, le nombre de sous intervalles à considérer et
retourne la valeur approchée IRd c ( f ).

[6]: def rectangle_droite_composite(f,a,b,n):

h= (b-a)/n
s = 0
for k in np.arange(1,n+1):
s+= f(a+k*h)
return h*s
Appliction 2 :
Refaire l’application 1 en utilisant la méthode des rectangles à droite.
Question 1:
[7]: n=4
I_Rd=rectangle_droite_composite(f,a,b,n)
print(I_Rd)

1.4627405036571262

Question 2:

4
[8]: plt.figure(figsize=(20,10))
t=np.linspace(-1,1,100)
x=np.linspace(-1,1,n+1)
plt.fill_between(t,f(t),color="blue",alpha=0.5)
plt.fill_between(x,f(x),step="pre",color="red",alpha=0.5)
plt.legend(('$I(f)$','$I_{Rd}^c(f)$'),loc=0,fontsize=30)
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)
plt.xlabel('t',fontsize=30)
plt.ylabel('f(t)',fontsize=30)
plt.title('Approximation de $\int_{-1}^1 e^{-t^2}dt$ par la méthode des␣
,→rectangles à droite (n=4)', fontsize=30)

plt.show()

Question 3:
[9]: n=10
I_Rd=rectangle_droite_composite(f,a,b,n)
print(I_Rd)
plt.figure(figsize=(20,10))
t=np.linspace(-1,1,100)
x=np.linspace(-1,1,n+1)
plt.fill_between(t,f(t),color="blue",alpha=0.5)
plt.fill_between(x,f(x),step="pre",color="red",alpha=0.5)
plt.legend(('$I(f)$','$I_{Rd}^c(f)$'),loc=0,fontsize=30)
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)
plt.xlabel('t',fontsize=30)

5
 plt.ylabel('f(t)',fontsize=30)
plt.title('Approximation de $\int_{-1}^1 e^{-t^2}dt$ par la méthode des␣
,→rectangles à droite (n=10)', fontsize=30)

plt.show()

1.4887366795273345

1.4 Méthode composite des trapèzes

h( n −1 )
I ( f ) ≈ ITc ( f ) = f ( x0 ) + 2 ∑ f ( x k ) + f ( x n ) .
2 k =1

Ecrire une fonction trapeze_composite(f,a,b,n) prenant en entrée f , une fonction continue

sur [ a, b], a, b, les bornes de [ a, b] et n, le nombre de sous intervalles à considérer et retourne la
valeur approchée ITc ( f ).
[10]: def trapeze_composite(f,a,b,n):
h= (b-a)/n
s = (f(a)+f(b))*0.5
for k in np.arange(1,n):
s+= f(a+k*h)
return h*s
Appliction 3 :
Refaire l’application 1 en utilisant la méthode des trapèzes.
Question 1:

6
[11]: n=4
I_T=trapeze_composite(f,a,b,n)
print(I_T)

1.4627405036571262

Question 2:
[12]: plt.figure(figsize=(20,10))
t=np.linspace(-1,1,100)
x=np.linspace(-1,1,n+1)
plt.fill_between(t,f(t),color="blue",alpha=0.5)
plt.fill_between(x,f(x),color="red",alpha=0.5)
plt.legend(('$I(f)$','$I_{T}^c(f)$'),loc=0,fontsize=30)
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)
plt.xlabel('t',fontsize=30)
plt.ylabel('f(t)',fontsize=30)
plt.title('Approximation de $\int_{-1}^1 e^{-t^2}dt$ par la méthode des␣
,→trapèzes (n=4)', fontsize=30)

plt.show()

Question 3:
[13]: n=10
I_T=trapeze_composite(f,a,b,n)
print(I_T)
plt.figure(figsize=(20,10))

7
 t=np.linspace(-1,1,100)
x=np.linspace(-1,1,n+1)
plt.fill_between(t,f(t),color="blue",alpha=0.5)
plt.fill_between(x,f(x),color="red",alpha=0.5)
plt.legend(('$I(f)$','$I_{T}^c(f)$'),loc=0,fontsize=30)
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)
plt.xlabel('t',fontsize=30)
plt.ylabel('f(t)',fontsize=30)
plt.title('Approximation de $\int_{-1}^1 e^{-t^2}dt$ par la méthode des␣
,→trapèzes (n=10)', fontsize=30)

plt.show()

1.4887366795273342

1.5 Méthode composite de Simpson

h( )
p −1 p −1
I ( f ) ≈ ISc ( f ) = f ( a) + 4 ∑ f ( x2k+1 ) + 2 ∑ f ( x2k ) + f (b) ,
3 k =0 k =1
avec n = 2p, p ∈ N∗ .
Ecrire une fonction simpson_composite(f,a,b,n) prenant en entrée f , une fonction continue
sur [ a, b], a, b, les bornes de [ a, b] et n, le nombre de sous intervalles à considérer et retourne la
valeur approchée ISc ( f ).
[14]: def simpson_composite(f,a,b,n) :
h=(b-a)/n

8
 z0=f(a)+f(b)
z_paire=0
z_impaire=0
p=n//2
for i in np.arange(1,p) :
z_paire+=f(a+2*i*h)
for i in np.arange(0,p) :
z_impaire+=f(a+(2*i+1)*h)
z=(z0+2*z_paire+4*z_impaire)/3
return h*z
Application 4:
EStimer la valeur de I ( f ) de l’application 1 par la méthode composite de Simpson pour n = 4.
[15]: n=4
I_S=simpson_composite(f,a,b,n)
print(I_S)

1.4943608578190206

1.6 Comparaison des méthodes composites sur un seul exemple

Exercice 1:
1
On considère la fonction f (t) = , t ∈ [1, 2].
t
∫ 2
1. Donner la valeur exacte de I ( f ) = f (t)dt.
1
Indication : Utiliser la fonction integrate du module sympy.

2. Pour n = 4, ensuite, pour n = 10, approcher I ( f ) par les méthodes composites déjà pro-
grammées.
3. Comparer les résultats.

Question 1:
[16]: import sympy as sp
[17]: x=sp.Symbol('x')
I=sp.integrate(1/x,(x,1,2)).evalf()
a=1
b=2
f=lambda x: 1/x
Question 2:
[18]: n=4
print('n=',4)
print ("Formule du rectangle a gauche composite : ",␣
,→rectangle_gauche_composite(f,a,b,n))

print ("Formule du rectangle a droite composite : ",␣

,→rectangle_droite_composite(f,a,b,n))

9
 print ("Formule des trapezes composite : ", trapeze_composite(f,a,b,n))
print ("Formule de Simpson composite : ", simpson_composite(f,a,b,n))

n=10
print('n=',10)
print ("Formule du rectangle a gauche composite : ",␣
,→rectangle_gauche_composite(f,a,b,n))

print ("Formule du rectangle a droite composite : ",␣

,→rectangle_droite_composite(f,a,b,n))

print ("Formule des trapezes composite : ", trapeze_composite(f,a,b,n))

print ("Formule de Simpson composite : ", simpson_composite(f,a,b,n))

n= 4
Formule du rectangle a gauche composite : 0.7595238095238095
Formule du rectangle a droite composite : 0.6345238095238095
Formule des trapezes composite : 0.6970238095238095
Formule de Simpson composite : 0.6932539682539683
n= 10
Formule du rectangle a gauche composite : 0.718771403175428
Formule du rectangle a droite composite : 0.6687714031754278
Formule des trapezes composite : 0.693771403175428
Formule de Simpson composite : 0.6931502306889303

Question 3:
[19]: n=4
print('n=',4)
print ("Erreur commise par la méthode composite des rectangles à gauche : ",␣
,→abs(rectangle_gauche_composite(f,a,b,n)-I))

print ("Erreur commise par la méthode composite des rectangles à droite : ",␣
,→abs(rectangle_droite_composite(f,a,b,n)-I))

print ("Erreur commise par la méthode composite des trapèzes : ",␣

,→abs(trapeze_composite(f,a,b,n)-I))

print ("Erreur commise par la méthode composite de Simpson : ",␣

,→abs(simpson_composite(f,a,b,n)-I))

n=10
print('n=',10)
print ("Erreur commise par la méthode composite des rectangles à gauche : ",␣
,→abs(rectangle_gauche_composite(f,a,b,n)-I))

print ("Erreur commise par la méthode composite des rectangles à droite : ",␣
,→abs(rectangle_droite_composite(f,a,b,n)-I))

print ("Erreur commise par la méthode composite des trapèzes : ",␣

,→abs(trapeze_composite(f,a,b,n)-I))

print ("Erreur commise par la méthode composite de Simpson : ",␣

,→abs(simpson_composite(f,a,b,n)-I))

n= 4

10
 Erreur commise par la méthode composite des rectangles à gauche :
0.0663766289638642
Erreur commise par la méthode composite des rectangles à droite :
0.0586233710361358
Erreur commise par la méthode composite des trapèzes : 0.00387662896386420
Erreur commise par la méthode composite de Simpson : 0.000106787694023058
n= 10
Erreur commise par la méthode composite des rectangles à gauche :
0.0256242226154827
Erreur commise par la méthode composite des rectangles à droite :
0.0243757773845175
Erreur commise par la méthode composite des trapèzes : 0.000624222615482672
Erreur commise par la méthode composite de Simpson : 3.05012898504931e-6

1.7 Erreurs d’intégration

Exercice :
π
On considère la fonction f (t) = te−t cos (2t), t ∈ [0, ].
∫ 2
1
1. Calculer la valeur exacte de I ( f ) = f (t)dt. 2. Représenter I ( f ) graphiquement. 3. Sur un
−1
même graphe, et pour n ∈ {10, 20, 30, · · · , 103 }, tracer l’évolution de l’erreur d’intégration pour
c , I c , I c ( f ) et I c ( f ) en fonction de n le nombre de sous-intervalles
l’approximation de I ( f ) par IRg Rd T S
π
de [0, 2 ].
Question 1:
[20]: f=lambda t: t*np.exp(-t)*np.cos(2*t)
x=sp.Symbol('x')
I=sp.integrate(x*sp.exp(-x)*sp.cos(2*x),(x,0,sp.pi/2)).evalf()
Question 2:
[21]: t=np.linspace(0,np.pi/2,100)
plt.figure(figsize=(20,10))
plt.fill_between(t,f(t))
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)
plt.xlabel('t',fontsize=30)
plt.ylabel('f(t)',fontsize=30)
plt.show()

11
 Question 3:
[22]: a=0
b=np.pi/2
N=np.arange(10,1010,10)
Err_rg=[]
Err_rd=[]
Err_t=[]
Err_s=[]
for n in N:
Err_rg.append(np.abs(I-rectangle_gauche_composite(f,a,b,n)))
Err_rd.append(np.abs(I-rectangle_droite_composite(f,a,b,n)))
Err_t.append(np.abs(I-trapeze_composite(f,a,b,n)))
Err_s.append(np.abs(I-simpson_composite(f,a,b,n)))
[23]: plt.figure(figsize=(20,10))
plt.plot(N,Err_rg,'r*--', N, Err_rd, 'b^--', N, Err_t ,'go--',N,␣
,→Err_s,'y>--',markersize=8,linewidth=3)

plt.legend(('Méthode composite des rectangles à gauche', 'Méthode composite des␣

,→rectangles à droite','Méthode composite des trapèzes', 'Méthode composite de␣

,→Simpson'),fontsize=20,loc=0)

plt.xscale('log')
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)
plt.xlabel('nombre de sous-intervalles', fontsize=30)
plt.ylabel('Erreur d\'intégration', fontsize=30)
plt.grid(True)

12
 1.8 Nombre d’itérations
L’Objectif de cette partie est de comparer les différentes méthodes d’intégration numérique, pro-
grammées dans ce TP, en terme de nombre d’itérations nécessaires pour approcher l’intégrale
∫ b
I= f (t)dt avec une précision ε donnée.
a
Ecrire une fonction integrale_precise(f, a, b, I, epsilon, methode='') qui permet de
déterminer le nombre nécessaire d’itérations en fonction de la précision epsilon, la valeur de I
et une méthode parmi les méthodes d’intégrations numériques définies ci-dessus.
[24]: def integrale_precise(f,a,b,I,epsilon, methode=''):
n=2
val =methode(f,a,b,n)
while (abs(val-I) >epsilon):
n+=1
val=methode(f,a,b,n)
n_necessaire=n
return n_necessaire
Exercice 2: ∫
1 1
On considère la fonction f (t) = 2
, t ∈ [0, 1]. 1. Donner la valeur de I = f (t)dt, en utilisant
1+t 0
la fonction integrate du module sympy.
2. Pour ε = 10−1 , ε = 10−2 et ε = 10−3 , estimer le nombre necessaire de sous-intervalles pour
approcher I à ε prés en utilisant:
a. La méthode du rectange à gauche
b. La méthode du rectangle à droite
c. La méthode du trapèze
d. La méthode de Simpson 3. Comparer la convergence des méthodes en terme du nombre
d’itérartion nécessaire.

13
 Question 1:
[25]: x=sp.Symbol('x')
I=sp.integrate(1/(1+x**2),(x,0,1)).evalf()
Question 2:
[26]: f=lambda x: 1/(1+x**2)
epsilon=1e-2

N_r_g=integrale_precise(f,0,1,I,epsilon,methode=rectangle_gauche_composite)
N_r_d=integrale_precise(f,0,1,I,epsilon,methode=rectangle_droite_composite)
N_t=integrale_precise(f,0,1,I,epsilon,methode=trapeze_composite)
N_s=integrale_precise(f,0,1,I,epsilon,methode=simpson_composite)
print('La valeur exacte de I est =', I)
print('le nombre necessaire de sous intervalles pour estimer I en utilisant la␣
,→methode de rectange à gauche à epsilon pres =', epsilon,' est :', N_r_g)

print('le nombre necessaire de sous intervalles pour estimer I en utilisant la␣

,→methode de rectange à droite à epsilon pres =', epsilon,' est :', N_r_d)

print('le nombre necessaire de sous intervalles pour estimer I en utilisant la␣

,→methode du trapeze à epsilon pres =', epsilon,' est :', N_t)

print('le nombre necessaire de sous intervalles pour estimer I en utilisant la␣

,→methode de simpson à epsilon pres =', epsilon,' est :', N_s)

La valeur exacte de I est = 0.785398163397448

le nombre necessaire de sous intervalles pour estimer I en utilisant la methode
de rectange à gauche à epsilon pres = 0.01 est : 25
le nombre necessaire de sous intervalles pour estimer I en utilisant la methode
de rectange à droite à epsilon pres = 0.01 est : 26
le nombre necessaire de sous intervalles pour estimer I en utilisant la methode
du trapeze à epsilon pres = 0.01 est : 3
le nombre necessaire de sous intervalles pour estimer I en utilisant la methode
de simpson à epsilon pres = 0.01 est : 2

1.9 Application
On lance une fusée verticalement du sol et on mesure son accélération γ durant les premières 80
secondes. √
Les mesures montrent que γ évolue en fonction de t selon la fonction γ(t) = 0.1t2 + 900. Soit
V la vitesse de la fusée à chaque instant t.

(a) Sachant qe V (0) = 0, déterminer l’expression de V en fonction de t.

(b) Calculer la vitesse V de la fusée à l’instant t = 80s, par la méhode composée des trapèzes
pour n ∈ {10, 100, 1000}.

(c) Calculer la vitesse V de la fusée à l’instant t = 80s, par la méthode composée de Simpson
pour n ∈ {10, 100, 1000}.

14
 1.9.1 Solution
(a) On sait que
∫ t
V ( t ) = V (0) + γ(s)ds.
0

Comme V (0) = 0, alors

∫ t
V (t) = γ(s)ds.
0

[27]: gamma=lambda t: np.sqrt(0.1*t**2+900)

(b) Méthode composée du trapèzes

[28]: trapeze_composite(gamma,0,80,100)
[28]: 2659.9095419301143

(c) Méthode composée de Simpson

[29]: simpson_composite(gamma,0,80,100)
[29]: 2659.898669390679

2 Références
[1] Kiusalaas, J. (2013). Numerical methods in engineering with Python 3. Cambridge university
press.
[2] Numpy Package
[3] Mathplotlib Package
[4] Jupyter markdowns
[5] Sympy Package

15