**NB : Vous êtes appelés :

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

2. à importer “numpy“ et “matplotlib.pyplot“ en utilisant les alias présentés ci-dessous:

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

3. à écrire que deux chiffres après la virgule pour tous résultats numériques trouvés.
Exercice 1 (9 points)
Soient n un entier strictement supérieur à 1 et F = {( xi , yi ) ∈ R2 , i ∈ [1, ..., n]} , un ensemble de n
observations. On souhaite chercher la droite qui ajuste au mieux les observations trouvées avec la
méthode algébrique. Cette droite prend la forme suivante

P(t) = a + bt

où a et b sont des constantes à déterminer et t ∈ R.

On rappelle que

XY − X Y
b= 2
X2 − X
et
a = Y − bX
n n n n
∑ xi ∑ yi ∑ xi yi ∑ xi2
i =1 i =1 i =1 i =1
avec X = , Y= , XY = et X2 = .
n n n n

1
Partie 1 : Codage
1. Construire une fonction somme(x,y) prenant en entrée une liste x=[ x1 , ..., xn ] et une liste
y=[y1 , ..., yn ] , et qui renvoie les valeurs de X, Y, XY et X 2 notées respectivement sous python
xbar, ybar , xybar et x2bar. (2,5 points)
[ ]: def somme(x,y):
xbar=np.sum(x)/len(x) #len(x)=len(y) ou autre..........
ybar=np.sum(y)/len(y)
prod=0
x2=0
for k in np.arange(0,len(x)):
prod+=x[k]*y[k]
x2+=x[k]**2
xybar=prod/len(x)
x2bar=x2/len(x)
return xbar,ybar,xybar,x2bar

2. Programmer une fonction coefficient(xbar,ybar,xybar,x2bar) prenant en entrée les re-

tours de la fonction somme ci-dessus. Cette fonction doit retourner les coefficients a et b du
polynôme P.(1,5 points)

2
[ ]: def coefficient(xbar,ybar,xybar,x2bar):
b=(xybar-xbar*ybar)/(x2bar-xbar**2)
a=ybar-b*xbar
return a,b

Partie 2 : Application
Pour étudier les problèmes de malnutrition dans un pays pauvre, on a calculé le poids moyen par
âge d’un échantillon de 2400 enfants repartis uniformément en 12 classes d’âge. On a obtenu les
données suivantes :
âge (mois) 1 2 3 4 5 6 7 8 9 10 11 12
poids (Kg) 4,3 5,1 5,7 6,3 6,8 7,1 7,2 7,2 7,2 7,2 7,5 7,8

1. Un statisticien veut calculer par sa machine la droite au sens des moindres carrés pour ces
données qui représente le poids en fonction de l’âge.
a) Déclarer les variables de la fonction somme de ce problème de malnutrition.(1 point)

[ ]: # Instructions Python

x=np.arange(1,13)
y=[4.3,5.1,5.7,6.3,6.8,7.1,7.2,7.2,7.2,7.2,7.5,7.8]

b) En utilisant la fonction somme, donner les valeurs de xbar, ybar , xybar et x2bar.(1
point)
xbar =6.5
ybar =6.61
xybar=46.19
x2bar=54.16
c) Déduire l’équation de la droite au sens des moindres carrés du poids en fonction de
l’âge.(1,5 points)

[ ]: # Instruction(s) Python
# Méthode 1
coefficient(somme(x,y)[0],somme(x,y)[1],somme(x,y)[2],somme(x,y)[3])
# Méthode 2
xbar=somme(x,y)[0]
ybar=somme(x,y)[1]
xybar=somme(x,y)[2]
x2bar=somme(x,y)[3] # ou [-1]
coefficient(xbar,ybar,xybar,x2bar)

L’équation de la droite est P(t) = 4.88 + 0.26t.

3
 2. Donner une approximation du poids lorsque l’âge d’un enfant est 17.(1 point)
poids ≃ 9.42
3. Estimer l’âge de l’enfant lorsque son poids est 10,23.(0.5 point)
age=20,.. ≃ 20.

Exercice 2 ( 11 points)
L’évolution d’une population bactérienne dans un milieu de culture est décrite par le modèle
suivant 
 ′ x (t)
( PC ) x ( t ) = r x ( t ) (1 − ), t ≥ 0
K
x (0) = x0 ,


avec
• t désigne le temps exprimé en heures,
• x (t) est l’effectif de la population bactérienne au temps t, donné en mg,
• r est le taux de croissance de la population (r > 0), donné en mg/h,
• K est le nombre de bactéries maximal que le milieu peut supporter, donné en mg,
• x0 est l’effectif initial (x0 >0), donné en mg.
La population étudiée a les caractéristiques suivantes

r=0.2 mg/h et K=100 mg.

L’observation de l’évolution de l’effectif x (t) à chaque instant, nous amène à résoudre numérique-
ment le problème de cauchy ( PC ) par une méthode itérative décrite par le schéma ( MN ) suivant


 p = x k + h f ( t k , x k ),
h


( MN ) x k +1 = x k + f (tk , xk ) + f (tk+1 , p) , ∀k ∈ {0, 1, ..., N − 1},

 2
x (0) = x0 donnée


où
• N est le nombre de sous-intervalles de la subdivision uniforme de [t0 , t0 + T ] avec t0 est
l’instant initial et T > 0,
T
• h= est le pas de la discrétisation de l’intervalle [t0 , t0 + T ],
N
• tk = t0 + k h, pour k ∈ {0, 1, ..., N }, désigne les points de la discrétisation.
• f (t, x ) est le second membre du problème ( PC ),
• xk est la solution approchée de la solution exacte évaluée au point tk ( xk ≃ x (tk )).

4
1. a) Écrire une fonction nommée schema(f,x0,t0,T,N) qui prend en paramètres une fonc-
tion f, une valeur initiale x0, l’instant initial t0, T la longueur de l’intervalle [t0,
t0 + T], et N le nombre de sous-intervalles de [t0, t0 + T]. Cette fonction doit retourner
la liste des valeurs X= [ x0 , x1 , ..., x N ]. (2,5 points)

[ ]: def schema(f,x0,t0,T,N):
h=T/N
X=[x0]
for k in np.arange(0, N):
p=X[k]+h*f(t0+k*h,X[k])
X.append(X[k]+0.5*h*(f(t0+k*h,X[k])+f(t0+(k+1)*h,p)))
return X

b) On se place sur l’intervalle [0, 72]. Pour N = 180 et x0 = 40, déclarer la fonction f (t, x )
puis donner la valeur approchée de l’effectif de la population bactérienne à l’instant
t = 72.(1,5 points)

[ ]: # Instructions Python

r=0.2
K=100
t0=0
T=72
N=180
x0=40
f=lambda t, x: r*x*(1-x/K)
X=schema(f,x0,t0,T,N)
print('L'effectif de la population bactérienne à l'instant t=72 vaut
,→',X[-1])

L’effectif de la population bactérienne à l’instant t = 72 vaut 99.99

c) Sachant que la solution exacte du problème ( PC ) est donnée par

x0 K
xex (t) = t ≥ 0.
x0 + (K − x0 )e−rt

Déduire l’erreur commise par la méthode numérique ( MN ) à l’instant t = 72. (1,5

points)

5
 [ ]: #Instructions Python
r=0.2
K=100
x0=40
xex = lambda t,x0 :(x0*K)/(x0+(K-x0)*np.exp(-r*t)) #0.75
t=72
print("L'erreur commise est ",abs(xex(t,x0)-X[-1])) #0.75

# Pour la déclaration de xex, comme x0 est déclarée alors on pourra

,→écrire xex = lambda t :(x0*K)/(x0+(K-x0)*np.exp(-r*t))

L’erreur à l’instant t = 72 vaut 1.1988313275423934e-06

NB: Dans la suite, pour tous les tests, veuillez utiliser la fonction f déclarée dans la ques-
tion 1-b), r=0.2 et K=100.
2. Maintenant, on veut déterminer au bout de combien d’heures, tk , la suite ( xk ), définie dans
le schéma ( MN ), s’est stabilisée à une tolérance de 10−3 . Autrement dit, on cherche l’instant
tk qui vérifie le critère d’arrêt

| xk+1 − xk |≤ 10−3 ∀ k ∈ {0, 1, ..., N − 1}.

a) Ecrire une fonction limite(X,t0,T,N) qui prend en paramètres la liste X calculée par
le schéma ( MN ), l’instant initial t0, T la longueur de l’intervalle [t0, t0 + T] et N le
nombre de sous-intervalles de la subdivision uniforme de [t0, t0 + T].
Cette fonction limite retourne le nombre d’heures tk .(1,5 points)

[ ]: def limite(X,t0,T,N):
k=0
h=T/N
while (k <N) and (np.abs(X[k+1]-X[k])>10**-3):
k=k+1
return t0+k*h

b) Pour t0=0, T=72, N=180 et x0=40, déterminer l’instant de stabilisation du schéma ( MN )

.(1 point)
l’instant de stabilisation est 47.2

6
3. a) En utilisant la fonction schema(f,x0,t0,T,N), tracer sur un même graphe, les courbes
représentant l’évolution de la population bactérienne sur l’intervalle [0, 72] avec N=180
pour différentes valeurs de conditions initiales x0∈ {60, 80, 100, 120, 140}.(1,5 points)

[ ]: # Instructions Python
t0=0
T=72
N=180
# on pourra mettre t = np.linspace(t0, t0+T, N+1) ailleurs de la boucle
,→for

plt.figure(figsize=(20, 10))
M = [60,80,100,120,140]
plt.figure(figsize=(20,10))
for x0 in M:
X= schema(f,x0,t0,T,N)
t = np.linspace(t0, t0+T, N+1)
plt.plot(t, X, '*', label='Solution approchée (x0='+str(x0)+')')
plt.legend()

b) Observez les courbes tracées et interpréter graphiquement l’évolution de la population

bactérienne.(1,5 points)
Si x0 ∈]0, K [ alors la suite ( xk ) est croissante et converge vers K lorsque k tend vers
l’infini.
Si x0 > K alors la suite ( xk ) est décroissante et converge vers K lorsque k tend vers
l’infini.
Si x0 = K alors la suite ( xk ) est constante et égale à K.
On peut accepter aussi cette réponse : ∀ x0 > 0, la suite ( xk ) converge vers K lorsque k
tend vers l’infini.
Voici les différentes courbes obtenues.