TD 2 : Recherche de racines

Transcription

TD 2 :
Recherche de racines
PC/PC* - Lycée Thiers
Exercice 1 : Extraction de racine n-ième par la méthode de Newton
Exercice 2 : Fonction définie de manière récursive
Exercice 3 : D’après Mines-Ponts 2016
Exercice 4 : Fractale de Newton
Exercice supplémentaire : Fractale de Mandelbrot
Enoncé
Corrigé
Enoncé
Corrigé
Enoncé
Corrigé
Enoncé
Correction
Enoncé
Corrigé
Enoncé
Corrigé
Exercice 1
Exercice 1. Ecrire une fonction racine(a,n,e) prenant en paramètre un
nombre a > 0 et un entier n et qui applique √
la méthode de Newton pour
retourner une valeur approchée à e près de n a (on prendra pour point initial
u0 = a). Quel critère d’arrêt peut-on considérer ici ?
Enoncé
Corrigé
Exercice 1
1) On cherche une racine de f (x) = x n − a.
On a f ′ (x) = nx n−1 , donc la méthode de Newton produit une suite vérifiant :
uk+1 = uk −
f (uk )
un − a
= uk − k n−1
′
f (uk )
nuk
Une étude mathématique
montrerait que quelque soit u0 > 0, la suite un est
√
convergente vers n a (la suite est décroissante à partir du rang 1, et minorée).
def racine(a,n,e):
f = lambda x: x**n-a
u = a
while f(max(0,u-e)) * f(u+e) > 0:
u = u-f(u)/(n*u**(n-1))
return u
Ici la fonction considérée f n’étant strictement monotone que sur R∗+ (sur R
lorsque n est impair) on peut prendre comme critère d’arrêt que
f (max(0, u − e)) et f (u + e) soient de signes opposés.
Enoncé
Corrigé
Exercice 2
Exercice 2. (Sujet 0 Banque PT) Etude d’une fonction définie de manière
récursive
Enoncé
Corrigé
1)
def g(x):
assert 0 <= x < 2
if x<1:
return x
else:
return 1
● La fonction étant définie par disjonction de cas, il est utile de la ”vectoriser” (à l’aide de
np.vectorize() afin de pouvoir l’appliquer à un tableau numpy en vue du tracé.
g v = np.vectorize(g)
X = np.arange(0,2,0.01)
plt.figure("Exercice 4.1 : Courbe de $g$")
plt.clf()
Y = g v(X)
plt.plot(X,Y)
plt.axis([0,2,0,1.5])
plt.title(’Courbe représentative de $g$’)
plt.show()
● Aussi le graphe de la fonction étant ”par pallier”, mieux vaut définir la fenêtre à afficher à l’aide
de plt.axis() pour une bonne lisibilité.
Enoncé
Corrigé
Ce qui produit :
Enoncé
Corrigé
2) Définition de f de manière récursive :
def f(x):
assert x >= 0
if x < 2:
return g(x)
return x**0.5 * f(x-2)
3) Ici encore pour faciliter l’obtention de l’échantillonnage de l’image de f on ”vectorise” la
fonction :
f v = np.vectorize(f)
X = np.linspace(0,6,1000)
Y = f v(X)
plt.figure("Exercice 4.2 : Courbe de $f$")
plt.title(’Courbe représentative de $f$ sur $[0,6]$’)
plt.plot(X,Y)
plt.show()
Enoncé
Corrigé
Ce qui produit :
Enoncé
Corrigé
On remarque que la fonction f est continue et croissante sur [4.5; 5.5] avec f (4.5) < 4 et
f (5.5) > 4. On applique donc une recherche par dichotomie à f − 4 et l’on retournera un
encadrement à 10−2 près d’une racine. Le majorant dans l’encadrement nous donnera donc une
valeur approchée à 10−2 près (par excès) du plus entier réel x pour lequel f (x) > 4.
def dichotomie(f,a,b,e):
assert f(a)*f(b) <=0
while (b-a) > e:
m = (a+b)/2
if f(a)*f(m) <= 0:
a, b = a, m
else:
a, b = m, b
return a,b
a,b = dichotomie(lambda x:f(x)-4, 4.5, 5.5, 0.01)
In[1] : print(b)
Out[1] : 5.125
In[3] : f(5.125)
Out[3] : 4.001952648395531
In[4] : f(5.12)
Out[4] : 3.9967987189749747
Enoncé
Corrigé
Exercice 3 : D’après Écrit Mines-Ponts 2016
Dans la simulation numérique de la propagation d’une pandémie on a tracé
pour plusieurs valeurs de :
p2, probabilité qu’une personne saine en contact avec la maladie soit infectée,
La proportion x atteinte de la population atteinte par l’épidémie au cours de
la simulation.
Enoncé
Corrigé
On appelle seuil critique de pandémie la valeur de p2 à partir de laquelle plus de
la moitié de la population a été atteinte par la maladie durant la simulation.
On suppose que les valeurs de p2 et x atteinte utilisées pour tracer la courbe
de la figure 3 ont été stockées dans deux listes de même longueur Lp2 et Lxa.
Écrire en Python une fonction seuil(Lp2, Lxa) qui détermine par dichotomie
un encadrement [p2cmin, p2cmax] du seuil critique de pandémie avec la plus
grande précision possible. On supposera que la liste Lp2 est croissante de 0 à 1
et que la liste Lxa des valeurs correspondantes est croissante.
Enoncé
Corrigé
def seuil(Lp2,Lxa):
a, b = 0, len(Lp2)-1
while b-a>1:
m = (a+b)//2
if (Lxa[a]-0.5)*(Lxa[m]-0.5) <= 0:
b = m
else:
a = m
return [Lp2[a], Lp2[b]]
Enoncé
Correction
Exercice 4. Fractale de Newton
La convergence d’une suite définie par la méthode Newton est un problème très difficile.
L’ensemble des points u0 pour laquelle la suite (un ) converge est un ensemble très complexe.
On peut s’en convaincre en étendant la suite au plan complexe (c’est possible notamment lorsque
f est un polynôme et f ′ son polynôme dérivée) :
⎧
u ∈C
⎪
⎪
⎪ 0
f (un )
(un ) ∶ ⎨
un+1 = un − ′
⎪
⎪
⎪
f (un )
⎩
Illustrons le phénomène en prenant pour f le polynôme z ↦ z 3 − 1 (et donc f ′ ∶ z ↦ 3z 2 ) :
u0 ∈ C
∀n ∈ N
un+1 = un −
2un3 + 1
un3 − 1
=
= un+1
3un2
3un2
La fonction f a 3 racines dans C : 1, j = exp(2iπ/3), j = exp(4iπ/3). Nous allons représenter dans
un domaine carré du plan complexe l’ensemble des points initiaux u0 ∈ C pour lesquels cette suite
converge :
D = {u0 ∈ C ∣ (un )converge}
La méthode de Newton se généralise très bien au plan complexe, et si (un ) converge, alors
nécessairement c’est vers l’une des 3 racines de f : 1, j, j.
Enoncé
Correction
Il faut choisir un critère approximatif de convergence. Prenons par exemple :
Donné u0 ∈ C, u30 est à distance < tol = 0.01 de l’une des
3 racines.
√
3
, z2 = j :
C’est à dire, en notant les racines z0 = 1, z1 = j = −1+i.
2
min(∣u30 − z0 ∣, ∣u30 − z1 ∣, ∣u30 − z2 ∣) < 0.01
1. Importer les modules numpy et matplotlib.pyplot. Définir les constantes z0 , z1 , z2 et la
2z 3 + 1
fonction F (z) =
.
3z 2
2. Définir deux variables globales N = 30 et tol = 0.01. Ecrire une fonction g prenant en
paramètre un complexe z et qui retourne :
– S’il existe, le plus petit rang k ∈ [[1, N − 1]] tel que, si (un ) désigne la suite obtenue
par la méthode de Newton avec u0 = z :
min(∣uk − z0 ∣, ∣uk − z1 ∣, ∣uk − z2 ∣) < tol
– Sinon, retourne N.
3. Définir une variable globale K=500. Créer un tableau T d’un maillage de K × K points du plan
complexe régulièrement espacés dans le domaine carré {z ∈ C ∣∣Re(z)∣ ⩽ 2, ∣Im(z)∣ ⩽ 2}.
4. Créer le tableau des images des éléments de T par la fonction g . Puis le représenter
graphiquement à l’aide de la fonction imshow de matplotlib.pyplot. Interpréter le
graphique obtenu.
Enoncé
Correction
Indications. Le nombre complexe i s’obtient par l’expression 1j, le module par la fonction
abs.
3) On conseille d’utiliser les fonctions linspace et meshgrid du module numpy. Exemple
d’utilisation de meshgrid :
>>> x = [-1,-2] ; y = [1,2,3]
>>> X, Y = np.meshgrid(x,y)
>>> X, Y
array([[-1,-2],
[-1,-2],
[-1,-2]])
array([[1, 1],
[2, 2],
[3, 3]]
4) : on conseille de vectoriser la fonction g : gv = np.vectorize(g) pour l’appliquer à T.
# Création de la grille
x = np.linspace(-2,2,K)
y = np.linspace(2,-2,K)
X,Y = np.meshgrid(x,y)
T = X + Y * 1j
# Vectorisation de g pour l’appliquer à un tableau et tracé :
gv = np.vectorize(g)
Tab = gv(T)
plt.imshow(Tab, extent=[-2,2,-2,2])
plt.show()
Enoncé
Correction
1) Code :
# Importation des modules nécessaires :
import numpy as np
import matplotlib.pyplot as plt
# Les 3 racines complexes de f :
z0 = 1
z1 = -0.5+((3**0.5) / 2)*1j
z2 = -0.5-((3**0.5) / 2)*1j
# Fonction F de récurrence : u(n+1) = F(u(n)) :
F = lambda z: (2*z**3 +1)/(3*z**2)
Enoncé
Correction
2) Définition des variables globales N et tol et de la fonction g :
N = 30 # Profondeur d’itération
tol = 0.01 # Tolérance
# Fonction estimant la convergence de (un) et sa rapidité pour u0
= z :
def g(z):
for i in range(N):
z = F(z)
m = min(abs(z-z0),abs(z-z1),abs(z-z2))
if m < tol:
return i
return N
Enoncé
Correction
3) Création du tableau T du maillage :
# Constante pour la précision du tracé
K = 500
# Création du maillage pour le tracé :
x = np.linspace(-2,2,K)
y = np.linspace(2,-2,K)
X,Y = np.meshgrid(x,y)
T = X + Y * 1j
4) Tracé de la fractale de Newton :
# Vectorisation de g pour l’appliquer à un tableau :
gv = np.vectorize(g)
# Tableau à convertir en image :
Tab = gv(T)
# Tracé :
plt.clf() # Effacement de la fen^
etre graphique (optionnel)
plt.imshow(Tab, extent=[-2,2,-2,2]) # Création de l’image
# l’option extent définit les plages de valeurs des 2 axes
Enoncé
Correction
Les points ”de divergence” sont en rouge foncé. Tous les autres points
convergent vers l’une des 3 racines (en bleu foncé), à une vitesse d’autant plus
grande qu’il apparaı̂t plus bleuté. En fait les frontières des bassins d’attraction
(en bleu) sont des points divergents.
Enoncé
Corrigé
Exercice 5 : Fractale de Mandelbrot
Exercice 3. (Sujet 0 - Banque PT) Fractale de Mandelbrot
Enoncé
Corrigé
(1)
def f(c):
u = 0
result = m
for k in range(m+1):
u = u**2 + c
if abs(u) > M:
result = k
break
return result
Enoncé
Corrigé
(2)
import numpy as np
import matplotlib.pyplot as plt
LX = np.linspace(-2,2,401)
f v = np.vectorize(f)
LY = f v(LX)
# ou LY = [f(x) for x in LX]
plt.plot(LX,LY)
plt.grid()
plt.xlabel(’c’)
plt.ylabel(’f (c)’)
plt.title(’graphe de f’)
plt.axis([0,2,0,50])
plt.show()
Enoncé
Corrigé
Enoncé
Corrigé
(3) et (4) (pour un tracé précis on a pris M = 70, m = 50 et K = 500).
M=70
m=50
K=500
x = np.linspace(-2,0.5,K)
y = np.linspace(-1.1,1.1,K)
X, Y = np.meshgrid(x,y)
Tab = f v(X+1j*Y)
plt.imshow(Tab, extent = [-2,0.5,-1,1])
plt.show()
Enoncé
Corrigé

TD 2 : Recherche de racines

Transcription

Documents pareils

it`s magicit`s magic

Une brève explication de la géométrie fractale

Loi de la gravitation universelle - club d`astronomie Io de Val

La nature de la lumière - Institut Don Bosco Tournai

La Gravitation Universelle

Contrôle du flux de commandes

Nom: Prénom: TP 1 : Décomposition d`une lumière. Nom2: Prénom2

Formalisme Multifractal fondé sur les Ondelettes

Chapitre 7 – Actions, couples de forces et mouvement

5. 3 La troisième loi de Newton