Université Claude Bernard - Lyon 1 Semestre d’automne 2022-2023

Analyse 3

TP : Méthodes d’intégration numérique

Pour commencer, télécharger le fichier

[Link]
puis le téléverser sur la plateforme Jupyter
[Link]
À l’exception des cadres à compléter, rédiger vos réponses sur une feuille indépendante en reportant
les numéros des questions.

0 Échelles logarithmiques - Régression linéaire

c
Soit c > 0 et α ∈ R. On considère la suite (vn )n≥1 définie pour n ≥ 1 par vn = .
nα
1) Expliciter la relation linéaire entre ln(n) et ln(vn ) pour tout n ≥ 1.
2) Observer le premier exemple fourni (voir [Link]) et expliquer l’intérêt des échelles logarithmiques dans cet exemple.
3) Que retourne le code suivant ?
from scipy import stats
res = [Link](log_n,log_vn)
print([Link], [Link])

4) Déterminer un équivalent simple de e2 /(n + ln n + 2)4 quand n tend vers l’infini.

5) Montrer qu’une suite (wn ) est équivalente à (vn ) quand n tend vers l’infini si et seulement ln wn + α ln n −−−−−→ ln c.
n→+∞
6) Observer le second exemple fourni et expliquer l’usage de droites de régression linéaire pour approximer les valeurs de
α et de ln c.

1 Méthode(s) des rectangles

Considérons une fonction réelle f : [a, b] → R de classe C 1 .

1.1 Formule de quadrature de la méthode des rectangles à gauche

Z b
Rappelons que la méthode des rectangles à gauche consiste à approcher l’intégrale I = f (x)dx par une somme
a
d’aires algébriques de rectangles : plus précisément, on considère une subdivision régulière de l’intervalle [a, b]
n o
a = x0 < x1 < · · · < xn = b où xk = pour k ∈ .

et on approxime I par la valeur Sn où

X
Sn = f (xk ).
≤k≤

1) À quelle notion vue en cours correspond cette formule par ailleurs ?

Une implémentation de cette méthode est donnée par le code suivant :
import numpy as np

def int_approchee_rect_gauche(f,a,b,n):
x,h=[Link](a,b,n+1,retstep=True)
Sn=h * [Link](f(x[0:n]))
return Sn
 Z π/2
2) Tester cette méthode sur la fonction sin sur [0, π/2] et comparer les résultats à la valeur exacte de sin(x)dx.
0
1
3) Tester également cette méthode sur la fonction f : [0, 1] → R, x 7→ et comparer à la valeur exacte de
Z 1 1 + x2
1
dx
0 1 + x2

Illustration graphique de cette méthode (avec une échelle logarithmique sur l’axe des abscisses) :
import [Link] as plt

def rep_int_approchee_rect_gauche(f,a,b,nMax):
S =[int_approchee_rect_gauche(f,a,b,n) for n in range(1,nMax+1)]
log_n = [Link]([Link](1,nMax+1))
[Link](log_n,S,’r+’)
[Link]("ln(n)")
[Link]("valeur approchée de l’intégrale")
[Link]("Méthode des rectangles àgauche")
[Link]()
return S

4) Tester ce code sur les deux fonctions précédentes avec nMax=50. Que représente-t-on ? (abscisses, ordonnées ...)

1.2 Erreur de l’estimation de l’intégrale

En fonction du nombre n de sous-intervalles de [a, b] considérés, notons En = |Sn − I| l’erreur commise lors de
l’estimation de l’intégrale (c.à.d. la valeur absolue de la différence de la valeur de l’intégrale avec l’estimation de celle-ci
par la formule de quadrature).
On rappelle que pour la méthode des rectangles à gauche, on a la majoration théorique suivante de cette erreur :

M1 (b − a)2
∀n ≥ 1, En ≤ avec M1 = .
2n

5) Déterminer M1 pour chacune des deux fonctions précédentes.

On souhaite maintenant tracer l’évolution de l’erreur, ainsi que sa majoration théorique en fonction de n :
def erreur_integration(f,a,b,I,M1,nMax):
S = [Link]([int_approchee_rect_gauche(f,a,b,n) for n in range(1,nMax+1)])
E = [Link](S-I)
majE = [Link]([M1*(b-a)**2/(2*n) for n in range(1,nMax+1)])
log_n = [Link]([Link](1,nMax+1))
[Link](log_n,[Link](E),’r+’)
[Link](log_n,[Link](majE),’b+’)
[Link]("ln(n)")
[Link]("ln(erreur)")
[Link](["erreur","majoration théorique"])
[Link]("Méthode des rectangles àgauche")
[Link]()

6) Tester ce code sur les deux fonctions précédentes avec nMax=50. Que représente-ton ? Pourquoi utilise-t-on des échelles
logarithmiques ? (L’argument d’entrée I de cette fonction Python correspond à la valeur exacte de l’intégrale calculée
par vos soins.)

2
 1.3 Comparaison avec les formules de quadrature des méthodes des rectangles à droite
et au milieu.
Rappeler les formules de quadrature de ces méthodes :

X X

Rectangles à droite : Sn = f (xk ) Rectangles au milieu : Sn = f .
≤k≤ ≤k≤

Implémenter ces deux formules avec deux fonctions Python

def int_approchee_rect_droite(f,a,b,n):
# compléter

def int_approchee_rect_milieu(f,a,b,n):
# compléter

Illustrer sur un même graphique ces trois méthodes des rectangles par une fonction Python
def rep_int_approchee_rect(f,a,b,nMax):
# compléter

À l’aide de la fonction Python suivante, comparer l’évolution des erreurs respectives des trois formules.
def erreur_integration(f,a,b,I,nMax):
SG = [Link]([int_approchee_rect_gauche(f,a,b,n) for n in range(1,nMax+1)])
SD = [Link]([int_approchee_rect_droite(f,a,b,n) for n in range(1,nMax+1)])
SM = [Link]([int_approchee_rect_milieu(f,a,b,n) for n in range(1,nMax+1)])
EG = [Link](SG-I)
ED = [Link](SD-I)
EM = [Link](SM-I)
log_n = [Link]([Link](1,nMax+1))
[Link](log_n,[Link](EG),’r+’)
[Link](log_n,[Link](ED),’b+’)
[Link](log_n,[Link](EM),’g+’)
[Link]("ln(erreur)")
[Link]("ln(n)")
[Link](["à gauche","à droite","au milieu"])
[Link]("Méthodes des rectangles")
[Link]()

7) Qu’observe-t-on ? (Remarque : faire le lien avec les majorations théoriques des erreurs vues en cours).
Compléter la fonction Python précédente avec les lignes de code
print([Link](log_n,[Link](EG)).slope)
print([Link](log_n,[Link](ED)).slope)
print([Link](log_n,[Link](EM)).slope)

8) Qu’affichent ces commandes ? Quelles valeurs retrouvez-vous ?

1.4 Régularité et vitesse de convergence

Z 2
9) Calculer la valeur exacte de x2 − 2 dx.
0
10) Tester les méthodes rep_int_approchee_rect(f,a,b,nMax) et erreur_integration(f,a,b,I,nMax) sur cet exemple.
11) Qu’observe-t-on ? Avez-vous une explication ?
12) Proposer une solution pour augmenter la vitesse de convergence sur cet exemple.

3
2 Méthode des trapèzes
On considère maintenant une fonction réelle f : [a, b] → R de classe C 2 et comme dans la partie précédente, une
subdivision régulière a = x0 < x1 < · · · < xn = b de l’intervalle [a, b].

2.1 Formule de quadrature

Rappelons que la méthode des trapèzes consiste à approximer l’intégrale de f sur chacun des sous-intervalles [xk , xk+1 ]
par l’intégrale de la fonction affine dont le graphe passe par les points (xk , f (xk )) et (xk+1 , f (xk+1 )).

Rappeler la formule de quadrature de la méthode des trapèzes : Sn =

Implémenter cette formule en Python (et la tester !) :

def int_approchee_trap(f,a,b,n):
# compléter

2.2 Erreur de l’estimation de l’intégrale

Compléter/modifier la fonction erreur_integration pour y inclure cette méthode.

Réponse :
Qu’observe-t-on sur l’ordre de grandeur de l’erreur ?

Pour cette méthode, on a la majoration théorique suivante de l’erreur

(b − a)3
En ≤ M2 avec M2 = .
12n2

Le but de l’exercice suivant est de démontrer cette majoration (une correction de cet exercice pourra être faite en
TD). Pour montrer ce résultat, on majore les erreurs commises sur chaque sous-intervalle [xk , xk+1 ] pour k parcourant
{0, . . . , n − 1}. Fixons k : l’erreur commise sur l’intervalle [xk , xk+1 ] s’écrit
Z xk+1
εk = (g(t) − f (t))dt
xk

où g est la fonction affine vérifiant g(xk ) = f (xk ) et g(xk+1 ) = f (xk+1 ).

1) Expliciter la formule définissant g.
2) Fixons un réel t ∈]xk , xk+1 [. Vérifier qu’il existe un réel K tel que la fonction
(x − xk )(x − xk+1 )
ht : [xk , xk+1 ] → R, x 7→ g(x) − f (x) + K
2
s’annule en t.
3) En utilisant le théorème de Rolle, montrer qu’il existe c1 ∈]xk , t[ et c2 ∈]t, xk+1 [ tel que h0t (c1 ) = h0t (c2 ) = 0.
00
4) En déduire qu’il existe c3 ∈]c1 , c2 [ tel que ht (c3 ) = 0.
00 00 (t − xk )(t − xk+1 )
5) Vérifier que K = f (c3 ) et en déduire que g(t) − f (t) = −f (c3 ) .
2
6) Vérifier alors l’inégalité
M2 xk+1
Z
εk ≤ (t − xk )(xk+1 − t)dt.
2 xk
7) Calculer le second membre de cette inégalité (on pourra faire une intégration par partie).
8) Conclure.

4
3 Interpolation de Lagrange [Facultatif]
3.1 Polynômes de Lagrange
Expliciter sous forme développée les 3 polynômes de Lagrange pour les nœuds 0, 1/2 et 1.

L0 = L1 = L2 =

Que retourne la fonction Python suivante ? (On pourra la tester avec le code L(2)[0], L(2)[1], L(2)[2].)
from [Link] import Polynomial
def L(d):
X = Polynomial([0,1])
L= [[Link]([(d*X-j)/(i-j) for j in list(range(i))+list(range(i+1,d+1))]) for i in range(d+1)]
return L

Réponse :

Fixons un entier d ≥ 1 et notons L0 , L1 , . . ., Ld , respectivement L̃0 , L̃1 , . . ., L̃d , les polynômes de Lagrange aux d + 1
nœuds équi-distribués dans l’intervalle [0, 1], respectivement dans l’intervalle [a, b].
1) Montrer que pour chaque i ∈ {0, . . . , d},
Z b Z 1
L̃i (x)dx = (b − a) Li (x)dx.
a 0

Z 1
Pour la suite, on posera pour i ∈ {0, . . . , d}, wi = Li (x)dx.
0

2) Calculer w0 , w1 et w2 pour d = 2 : w0 = w1 = w2 =

Compléter le code suivant pour calculer numériquement les valeurs des wk .

def w(d):
Lag=L(d)
coef=[list(Lag[i]) for i in range(d+1)] # tableau des coefficients des polynômes de Lagrange
# compléter
return w

3.2 Méthodes simples

On construit des formules de quadrature à partir des polynômes d’interpolation de Lagrange : considérons une fonction
f : [a, b] → R intégrable, on remplace le calcul de l’intégrale de f par celui de l’intégrale d’un polynôme interpolateur.
3) En utilisant la partie précédente, montrer que la formule de quadrature obtenue à l’aide du polynôme interpolateur de
Lagrange de f aux d + 1 nœuds équi-distribués dans l’intervalle [a, b] vaut

d
!
X (b − a)
(b − a) wi f a+i .
i=0
d

5
 Réponse :
Expliciter cette formule pour d = 2 :

Coder une fonction int_approchee_Lag_simple(f,a,b,d) qui retourne l’intégrale du polynôme interpolateur de

Lagrange en question.

3.3 Méthodes composites

On considère à nouveau une subdivision régulière a = x0 < x1 < · · · < xn = b de l’intervalle [a, b] et on approxime
l’intégrale de f sur chacun des sous-intervalles [xk , xk+1 ] par l’intégrale du polynôme interpolateur.

Réponse :
Que retrouve-t-on pour d = 1 ?

Méthode de Simpson
Le cas d = 2 est la méthode Simpson : on approxime sur chaque sous-intervalle [xk , xk+1 ] par l’intégrale du polynôme
interpolateur quadratique aux nœuds xk , (xk + xk+1 )/2, xk+1 .
Expliciter la formule de quadrature de la méthode Simpson.

Réponse :

Implémenter cette formule en Python et compléter la fonction erreur_integration.

Réponse :
Sur des fonctions suffisamment régulières, estimer l’ordre de grandeur de l’erreur.

Méthodes composites d’ordre supérieur

À l’aide des fonctions Python suivantes, estimer l’ordre de grandeur de l’erreur pour d = 3, 4, 5, 6 et des fonctions
suffisamment régulières. (N’hésitez pas à diminuer la valeur de la variable nMax.
def int_approchee_Lag_composite(f,a,b,d,n):
W=w(d)
x,h=[Link](a,b,n+1,retstep=True)
pas=h/d
Sn = h*[Link]([[Link]([W[i]*f(x[k]+i*pas) for i in range(d+1)]) for k in range(n)])
return Sn

def erreur_integration(f,a,b,I,d,nMax):
SC = [Link]([int_approchee_Lag_composite(f,a,b,d,n) for n in range(1,nMax+1)])
EC = [Link](SC-I)
log_n = [Link]([Link](1,nMax+1))
[Link](log_n,[Link](EC),’k+’)
[Link]("ln(erreur)")
[Link]("ln(n)")
[Link]("Méthode composite d’ordre supérieur")
[Link]()
print([Link](log_n,[Link](EC)).slope)