**NB : Vous êtes appelés à utiliser :

1. une flèche −→ pour indiquer une indentation,

2. l’importation des modules “numpy“,“matplotlib.pyplot“ et “sympy“ en utilisant les alias
présentés ci-dessous :

[ ]: import numpy as np
import matplotlib.pyplot as plt
import sympy as sp

Exercice 1 : (8 points)

Dans cet exercice, on utilisera la classe Polynomial importée dans la cellule suivante :

[ ]: from numpy.polynomial import Polynomial

L’objectif de cet exercice est d’interpoler la fonction f définie par

1
f (x) =
1 + x2
par un polynôme de degré 2 en utilisant la méthode d’interpolation de Newton.

Soient trois points ( xi , yi )0≤i≤2 avec yi = f ( xi ), l’interpolation de ces points consiste à déterminer
le polynôme P ∈ R2 [ x ] dont la courbe représentative passe par ces points, autrement dit :

∀i ∈ {0, 1, 2} P ( xi ) = yi

1
On rappelle que l’expression du polynôme d’interpolation P se détermine en utilisant la méthode
de Newton comme suit :

2
P( x ) = ∑ β i ωi ( x )
i =0

où ω0 ( x ) = 1, ω1 ( x ) = x − x0 , ω2 ( x ) = ( x − x0 )( x − x1 ) et β 0 , β 1 et β 2 sont les coefficients de

Newton qui seront donnés dans la suite.
1. Compléter la fonction baseNewton(X) prenant en entrée une liste X qui contient les abscisses
des points ( xi )0≤i≤2 et retourne une liste qui contient les polynômes de la base de Newton
ω0 , ω1 et ω2 .(1,5 points)

[ ]:
def baseNewton(X):
w0=Polynomial([1])
w1=Polynomial([-X[0],1])
w2=Polynomial([X[0]*X[1],-(X[0]+X[1]),1])
# pour w2 on peut utiliser la multiplication de deux polynômes
w=[w0,w1,w2]
return w

2. a) Compléter la fonction polynomeNewton (X,Beta) prenant en entrée la liste X com-

posée par ( xi )0≤i≤2 , les abscisses des points et la liste Beta composée par ( β i )0≤i≤2 ,
les coefficients de Newton. Cette fonction retourne le polynôme d’interpolation P.(1,5
points)

2
[ ]:
def polynomeNewton(X,Beta):
p=Polynomial([0])
n=len(X)
N=baseNewton(X)
for i in np.arange(0,n):
produit=Beta[i]*N[i]
p+=produit

return p

b) Sachant que les coefficients de Newton sont égaux à β 0 = 0.2, β 1 = 0.3 et β 2 = 0.1,
déterminer l’expression du polynôme d’interpolation de Newton aux points d’abscisses
−2, −1 et 0.(2 points)
[ ]: X=[-2,-1,0]
Beta=[0.2,0.3,0.1]
p=polynomeNewton(X,Beta)
print(p) # p

L’expression du polynôme P est

P( x ) = 1 + 0.6x + 0.1x2

c) Donner l’instruction qui permet de calculer l’erreur d’interpolation E de la fonction f

par le polynôme P au point x = 12 .(1,5 points)

[ ]:
f= lambda x: 1/(1+x**2)
E=abs(p(0.5)-f(0.5))
E

1
L’erreur d’interpolation au point x = 2 vaut 0.5250
d) (1,5 points): En évaluant sur [-2,1] la fonction f et le polynôme P en 100 points, com-
pléter le script ci-dessous qui permet de tracer dans une même figure :
– La courbe de f en bleu.
– La courbe de P en rouge.
– Les points d’interpolation (−2, f (−2)), (−1, f (−1)) et (0, f (0)).

[ ]: Y=[f(-2),f(-1),f(0)]
t=np.linspace(-2,1,100)
plt.plot(t,f(t),'b',t,p(t),'r',X,Y,'*')
plt.xlabel('axe des abscisses')
plt.ylabel('axe des ordonnées')
plt.legend(('f','P','points d'interpolation'))

3
 plt.title('Interpolation de Newton')

Exercice 2 : (12 points)

Rb
Dans cet exercice, on s’intéresse à approcher l’intégrale I ( f ) = a
f ( x )dx, avec f une fonction de
classe C1 sur [ a, b], par une formule de quadrature définie par:
!
n −1 n −1
h
f 0 ( a) − f 0 (b) ∑ ∑



Qn ( f ) = 14 f ( a) + f (b) + h + 28 f ( xk ) + 32 f (mk ) ,
60 k =1 k =0

où
• n est le nombre de sous-intervalles de la subdivision uniforme de [ a, b],
b−a
• h= est le pas de la discrétisation de l’intervalle [ a, b],
n
• xk = a + kh , pour k ∈ {0, · · · , n}, désignent les points d’intégration,
• mk = a + (k + 21 )h , pour k ∈ {0, · · · , n − 1}, désignent les points milieux,
• f 0 ( a) et f 0 (b) sont les valeurs de la dérivée de la fonction f aux points x = a et x = b
respectivement.
1. Écrire une fonction nommée formulecomposite(f,df,a,b,n) prenant en entrée f une fonc-
tion de classe C1 sur l’intervalle [a,b], df la dérivée de f et n le nombre de sous-intervalles
à considérer, et qui retourne la valeur approchée Qn (f) de I (f).(2 points)

[ ]:
def formulecomposite(f,df,a,b,n):
h=(b-a)/n
Q= 14*(f(a)+f(b)) + h*(df(a)-df(b))
for k in range(1,n):
Q+= 28*f(a+k*h)
for k in range(0,n):
Q+= 32*f(a+(k+0.5)*h)
return (h/60)*Q

4
 On considère dans la suite la fonction f définie sur [−1, 0] par

f ( x ) = cos(2x )e− x .

2. a) En utilisant une fonction pré-définie dans le module sympy, donner les instructions per-
Z 0
mettant de calculer la valeur numérique de I ( f ) = f ( x )dx.(1,5 points)
−1

[ ]:
x=sp.symbols('x')
f=lambda x:sp.cos(2*x)*sp.exp(-x)
#ou f= sp.Lambda(x, sp.cos(2*x)*sp.exp(-x) )
a=-1
b=0
I=sp.integrate(f(x) ,(x,a,b) ).evalf()
print(I)

Résultat :

I ( f ) ' 0.56244 ( 5 chiffres après la virgule).

b) En utilisant une fonction pré-définie dans le module sympy, donner les instructions qui
permettent de déterminer l’expression de la dérivée de f et de calculer f 0 (−1) et f 0 (0).
(1,5 points)

[ ]:
df=sp.Lambda(x,sp.diff(f(x),x)) # expression symbolique de f'
a=-1
b=0
print(df)
print(df(a).evalf())
print(df(b).evalf())

Résultats :

df( x ) = f 0 ( x ) = −2exp(− x )sin(2x ) − exp(− x )cos(2x )

f 0 (−1) = 6.07465772776645 et f 0 (0) = −1.00000000000000

5
 c) Calculer l’erreur d’intégration EQ ( f ) de la formule composite Q30 ( f ) (n = 30).(1 point)

[ ]: # Donner les instructions nécessaires

EQ=np.abs(formulecomposite(f,df,a,b,30).evalf()-I)
print('E_Q(f)=',EQ)

Résultat : EQ ( f ) ' 1.48769885299771e − 14

3. a) Écrire une fonction nommée nombreintervalles(f,df,a,b,epsilon) prenant en en-

trée une fonction f de classe C1 sur [a,b], df la dérivée de f, et la tolérance epsilon et
qui retourne le nombre de sous intervalles nécessaire n associé à une tolérance epsilon
près.(1,5 points)

[ ]:
def nombreintervalles(f,df,a,b,epsilon):
n=1
E=np.abs(formulecomposite(f,df,a,b,n).evalf()-I)
while E > epsilon:
n+=1
E=np.abs(formulecomposite(f,df,a,b,n).evalf()-I)

return n

b) Compléter le code suivant qui permet de tracer le nombre de sous intervalles n en fonc-
tion de la tolérance epsilon, en considérant epsilon ∈ {10−3 , 10−5 , 10−7 , 10−9 }.(1,5
points)

6
 [ ]: NQ=[]
epsilon = (1/10)**np.arange(3,10,2)
for eps in epsilon:
NQ.append(nombreintervalles(f,df,a,b,eps))

plt.grid(True)
plt.plot(epsilon,NQ,'ro-')
plt.xlabel('epsilon ')
plt.xscale('log')
plt.ylabel('Nombre de sous intervalles')
plt.title('Nombre de sous intervalles en fonction de epsilon')

c) Déduire la valeur du pas de discrétisation maximal h∗ à considérer pour avoir une

erreur d’intégration de l’intégrale I ( f ) par la formule de quadrature Qn ( f ), inférieure
à 10−7 .(0,5 point)
Graphiquement : pour epsilon = 10−7 , on aura n = 3. Ceci donne

h∗ = (b − a)/n = 1/3

On s’intéresse dans la suite à étudier le degré de précision de la formule de quadrature

élémentaire Q1 ( f ), (pour n = 1).
Rappelons qu’une formule de quadrature est dite de degré de précision d, si elle est exacte
pour tout polynôme Pk ( x ) = x k , avec 0 ≤ k ≤ d, et non exacte pour Pd+1 ( x ) = x d+1 .
Autrement dit, elle est de degré de précision d si l’erreur de quadrature est nulle pour les
polynômes Pk avec 0 ≤ k ≤ d et elle est non nulle pour le polynôme Pd+1 .

4. a) Compléter les pointillés de la fonction nommée erreurquadrature(a,b,n,k) prenant

en entrée a et b les deux extrémités de l’intervalle [ a, b], n le nombre de sous-intervalles
de discrétisation, et k le degré du polynôme Pk ( x ) = x k , et qui retourne la valeur de
l’erreur de quadrature.(1 points)

[ ]: def erreurquadrature(a,b,n,k):
x=sp.symbols('x')
P=lambda x: x**k
dP=sp.Lambda(x,sp.diff(P(x),x))
I1=sp.integrate( P(x) ,(x,a,b) ).evalf()
I2=formulecomposite(P,dP,a,b,n).evalf()
Erreur=np.abs(I1-I2)
return Erreur

7
 b) Compléter les pointillés de la fonction nommée degréprécision(a,b,n) prenant en
entrée a et b les deux extrémités de l’intervalle [a,b] et n le nombre de sous-intervalles
de discrétisation, et qui retourne le degré de précision de Qn ( f ).(1 point)

[ ]: def degréprécision(a,b,n):
k=0
Erreur=erreurquadrature(a,b,n,k)
while Erreur ==0 :
k=k+1
Erreur=erreurquadrature(a,b,n,k)
return k-1 # c'est le degré de précision d

c) Déduire le degré de précision de la formule de quadrature élémentaire Q1 ( f ).(0,5

point)
Le degré de précision de la formule vaut 5.