Résolution d`équations par méthode itérative Un corrigé 1 Un

Résolution d’équations par méthode itérative
Un corrigé
1
Un exemple
Q.1 On calcule xn avec n tel que 0.9n ≤ ε. On poursuit l’évolution tant que cette condition n’est pas
vérifiée. On gère deux variables : l’une r donnant les valeurs successives de la suite et l’autre p
donnant les puissances successives de 0.9. On teste ensuite.
from math import cos
def exemple(epsilon):
r,p=0,1
while p>epsilon:
r=cos(r)
p=p*0.9
return(r)
a=exemple(0.01)
print(a,cos(a)-a)
2
La dimension 2
Q.2 La situation est très proche de celle de la question précédente. On écrit une fonction F correspondant à celle de l’énoncé (elle prend en argument une liste de deux éléments et en renvoie
une autre). La fonction principale gère encore√deux variables : l pour les valeurs successives de
la suite et l’autre p pour les puissances de 1/ 2.
from math import sin
def F(l):
return([sin(l[0]+l[1])/2-1,cos(l[0]-l[1])/2+1/2])
def dimension2(epsilon):
l,p=[0,0],1
c=2**(-1/2)
while 2*p>epsilon:
l=F(l)
p=p*c
return(l)
l=dimension2(0.01)
print(l,F(l))
3
Systèmes linéaires
3.1
Un exemple simple
Q.3 C’est comme pour la question précédente mais en plus simple.
def F(l):
x,y=l[0],l[1]
return([(2+y)/3,-(5+x)/7])
1
Q.4 On sait combien de fois on itère et une boucle inconditionnelle s’impose.
def itereF(n):
l=[0,0]
for i in range(n):
l=F(l)
return(l)
Q.5 J’écris une fonction auxiliaire calculant la distance entre deux points de R2 . Le tracé est ensuite
classique.
from matplotlib import pyplot as plt
def dist(L,E):
return(((L[0]-E[0])**2+(L[1]-E[1])**2)**(1/2))
ln=[n for n in range(0,10)]
ly=[dist(itereF(n),[9/22,-17/22]) for n in ln]
plt.plot(ln,ly)
3.2
Quelques outils sur les matrices
Q.6 Une première fonction prend en argument une matrice A et un numéro de ligne i et renvoie
la somme des |A[i, j]| pour j 6= i. Elle utilise la fonction abs (valeur absolue). Il reste ensuite
à faire une simple recherche de maximum (la variable r correspondant à la plus grande valeur
trouvée, son initialisation à 0 étant cohérente puisque l’on cherche le maximum de quantités
positives).
import numpy as np
def somme(A,i):
s=0
for j in range(len(A)):
if j!=i:
s=s+abs(A[i,j])
return(s)
def R(A):
r=0
for i in range(len(A)):
c=somme(A,i)/abs(A[i,i])
if c>r:
2
r=c
return(r)
Q.7 Une variable s permet d’additionner les carrés des coefficients. On renvoie finalement la racine
carrée de la somme.
def norme(Y):
s=0
for i in range(len(Y)):
s=s+Y[i]**2
return(s**(1/2))
3.3
La méthode de Jacobi
Q.8 Une première fonction Ji permet de calculer ce qui est noté Y [i] dans l’énoncé. On peut alors
définir le tableau Y voulu en compréhension.
def Ji(A,B,X,i):
s=B[i]
for j in range(len(B)):
if j!=i:
s=s-A[i,j]*X[j]
return(s/A[i,i])
def J(A,B,X):
return(np.array([Ji(A,B,X,i) for i in range(len(B))]))
Q.9 On gère une variable X pour les termes successifs de la suite et une autre p pour gérer le test
d’arrêt comme dans les premières questions.
def Jacobi(A,B,epsilon):
X=J(A,B,np.array([0]*len(B)))
rA=R(A)
p=rA*norme(X)/(1-rA)
while p>epsilon:
X=J(A,B,X)
p=p*rA
return(X)
Q.10 Une fonction matA permet la création de An . On teste ensuite dans le cas n = 5 our obtenir
une solution approchée X pour laquelle on vérifie que J(X) est proche de X.
def matA(n):
A=np.zeros((n,n))
for i in range(n):
for j in range(n):
if i!=j:
A[i,j]=1/(i+j+1)
else:
A[i,i]=1+1/(i+j+1)
return(A)
B=[0,1,2,3,4]
A=matA(5)
X=Jacobi(A,B,0.001)
print(J(A,B,X)-X)
3
Q.11 La fonction matB permet la création de BnP
. On utilise la fonction
sum permettant de sommer
P
des éléments. Ici, c’est B[i] qui est égale à j A[i, j]E[j] = j A[i, j]j.
def matB(n):
A=matA(n)
B=[]
for i in range(n):
B.append(sum(A[i,j]*j for j in range(n)))
return(np.array(B))
On gère une variable X que l’on fait évoluer tant que kX − Ek n’est pas suffisamment petit.
def test(n,epsilon):
X=np.array([0]*n)
E=np.array([j for j in range(n)])
B=matB(n)
A=matA(n)
k=0
while norme(X-E)>epsilon:
k=k+1
X=J(A,B,X)
return(k)
Pour différentes valeurs de n et une précision de 0.001 (fixée), on regarde le nombre d’itérations
nécessaires.
ln=[n for n in range(2,11)]
ly=[test(n,0.001) for n in ln]
plt.plot(ln,ly)
Sans surprise, plus n est grand plus le nombre des itérations nécessaires est grand.
4