TP4: Résolution des systèmes linéaires

Abdelkader FASSI FIHRI

November 21, 2022

1 Introduction aux méthodes numériques

1.1 travaux dirigés N° 1
1.1.1 Corrigé
1.2 TD11 : Codage des nombres
1) Calculer la représentation en base 10 du nombre binaire suivant : (101000.10110000)2
(101000.10110000)2 = 25 + 23 + 2−1 + 2−3 + 2−4 = 40.6875

17
2) Calculer la représentation binaire des nombres suivants : a = 20 , b = 4.125 et c = −28.8625.
17
a= = 0.850.85∗2 = 1.7 → 10.7∗2 = 1.4 → 10.4∗2 = 0.8 → 00.8∗2 = 1.6 → 10.6∗2 = 1.2 → 10.2∗2 = 0.4 →
20

b = 4.1254 = 2 ∗ 2 + 02 = 2 ∗ 1 + 01 = 2 ∗ 0 + 1
donc 4 = (100)2 .

0.125 ∗ 2 = 0.250 → 00.250 ∗ 2 = 0.5 → 00.5 ∗ 2 = 1.0 → 10. ∗ 2 = 0 → 0 . . . 0.125 = (0, 001)2

par suite b = 4.125 = (100.001)2

c = −28.862528 = 2 ∗ 14 + 014 = 2 ∗ 7 + 07 = 2 ∗ 3 + 13 = 2 ∗ 1 + 11 = 2 ∗ 0 + 128 = (11100)2

0.8625∗2 = 1.725 → 10.725∗2 = 1.45 → 10.45∗2 = 0.9 → 00.9∗2 = 1.8 → 10.8∗2 = 1.6 → 10.6∗2 = 1.2 → 10.2∗2 =
z}|{ z}|{
et par suite c = −28.8625 = (−11100.1101 1100 1100 . . .)2
3) Déterminer la représentation en virgule flottante normalisée en base 10 et en base 2 des
nombres a, b et c
en base 10
17
a= = 0.85 = (−1)0 ×0.85×(10)0 b = 4.125 = (−1)0 ×0.4125×(10)1 c = c = −28.8625 = (−1)1 ×0.288625×(
20

1
en base 2

z}|{ z}|{ z}|{ z}|{ z}|{ z}|{

a = (0.11 0110 0110 0110 . . .)2 = (−1)0 ×0.11 0110 0110 0110 . . .×20 b = (100.001)2 = (−1)0 ×0.100001×23=(11)2 c = (−

4) Déterminer la représentation au format simple précision suivant la norme IEEE 754 des nom-
bres a, b et c.
z}|{ z}|{ z}|{
a=(−1)0 × 1.1 0110 0110 0110 . . . × 2−1
z}|{ z}|{ z}|{
s = 0 et exposant=-1+127=(01111110)2 et m = 1 0110 0110 0110
donc a=0 01111110 1 0110 0110 0110 0110 0110 10
b = (−1)0 × 1.00001 × 22=(10)2
s = 0 et exposant=2+127=129= (10000001)2 et m = 00001 donc
b=0 10000001 00001000000000000000000
z}|{
c = (−1)1 × 1.11001101 1100 . . . × 24=(100)2
z}|{
s = 1 et exposant=4+127=131=(10000011)2 et m = 11001101 1100 . . . donc
c=1 10000011 11001101 1100 1100 1100 110
5) Soit les nombres flottants au format simple précision selon la norme IEEE 754 :
a=10111101010000000000000000000000
b=01010101011000000000000000000000
c=00111101110011001100110011001100
Trouver la représentation en virgule flottante normalisée en base 10 de ces nombres.
a=1 01111010 10000000000000000000000 s=1 c’est un nombre négatif
e=(01111010)2 − 127 = −5
m=(1.1)2 = 1.5
par suite a = (−1)1 × 1.5 × 2−5 = (−1)1 × 0.046875 = (−1)1 × 0.46875 × 10−1
b=0 10101010 11000000000000000000000
s=0 c’est un nombre positif
e=(10101010)2 − 127 = 43
m=(1.11)2 = 1, 75
par suite b = (−1)0 × 1.75 × 243 =15 393 162 788 864=(−1)0 × 0.15393162788864 × (10)14
c=0 01111011 100 1100 1100 1100 1100 1100 s=0 c’est un nombre positif
e=(01111011)2 − 127 = −4
m=(1.10011001100110011001100)2 = 1, 5999999046
par suite c = (−1)0 × 1.5999999046 × 2−4 = 0.099999994 = (−1)0 × 0.99999994 × (10)−1 ≃ 0.1
Remarque: Le nombre 0.1 est approché par 0.099999994 en représentation binaire simple précision.

1.3 TD12 : Observer la différence entre le calcul algébrique et le calcul

numérique.
1) Déterminer le nombre de valeurs normalisées qui peuvent être représentées par un système de
représentation flottant avec base β, mantisse m places, exposant e avec L ≤ e ≤ M .

2
 card(F) = 2 × card([β m−1 , β m − 1]) × card([L, U ]) (1)
m m−1
= 2 × (β −β ) × (U − L + 1) (2)
2) Calculer le nombre de valeurs normalisées dans le cas où β = 10, m = 3, L = −15 et U = 16.

card(F) = 2 × card([β m−1 , β m − 1]) × card([L, U ]) (3)

m m−1
= 2 × (β −β ) × (U − L + 1) (4)
3 2
= 2 × (10 − 10 ) × (16 − (−15) + 1) (5)
= 2 × 900 × 32 (6)
= 57600 (7)
3) Déterminer l’ensemble F(2, 3, −1, 3)

[48]: import numpy as np

import matplotlib.pyplot as plt
from matplotlib.pyplot import figure

# fonction pour construire les flottants normalisés

def floating_numbers(beta,t,L,U):
# calculer le cardinal
cardinal=2*(beta**t-beta**(t-1))*(U-L+1)

F=np.zeros(cardinal//2)

#remplir la partie positive

i=0 #indice de sauvegarde
for e in range(L,U+1):
for m in range(beta**(t-1),beta**t):
F[i]=m*beta**(e-t)
i=i+1

#ajouter la partie négative

F=np.concatenate((-F[-1::-1],F),axis = 0)
return F

# Script pour visualiser la distribution des nombres flottants

#choix des paramètres

beta=2 #base
t=3 #nombre de chiffres significatifs
L=-1 #exposant minimum
U=3 #exposant maximum

F=floating_numbers(beta,t,L,U)

3
 n = len(F)
print(n)
Y = np.zeros(n)
figure(figsize=(16, 6), dpi=80)
plt.plot(F,Y,"m:*",label ='Floating numbers')

40

[48]: [<matplotlib.lines.Line2D at 0x7f8ee7718550>]

4) Soient trois réels x = 0.125106, z = 0.4371012, w = 0.2151010. En utilisant le système de

numération de la question 2 pour le stockage de ces nombres, calculer :

a) La somme x + z et commenter le résultat

x = 0.125106 est représenté par 0.125 × 100 .
z = 0.4371012 est représenté par 0.437 × 100 .
pour calculer la somme x + z on doit s’aligner sur le plus grand exposant.
x + z = 0.5622072 est donc représenté par 0.562 × 100 .
b) Le produit xz et commenter le résultat
x = 0.125106 est représenté par 0.125 × 100 .
z = 0.4371012 est représenté par 0.437 × 100 .
x ∗ z = 0.0546839827 est représenté par 0.547 × 10−1 .
c) La division w/x
x = 0.125106 est représenté par 0.125 × 100 . w = 0.2151010 est représenté par 0.215 × 100 .
w/x = 1.7193499912 est représenté par 0.172 × 101
5) Soient trois réels x = y = 0.400×100 et z = 0.100×103 . En utilisant le système de numération
de l’exercice précédent pour le stockage de ces nombres, calculer les deux sommes (x + y) + z
et x + (y + z).
x + y = 0.400 × 100 + 0.400 × 100 = 0.800 × 100 est représenté par 0.800 × 100 .
(x + y) + z est sdonc représenté par 0.000800 × 103 + 0.100 × 103 = 0.101 × 103 .

4
 y + z = 0.000400 × 103 + 0.100 × 103 = 0.100400 × 103 est représenté par 0.100 × 103 .
x + (y + z) est donc représenté par 0.000400 × 103 + 0.100 × 103 = 0.100 × 103 .
6) Considérons une machine décimale avec mantisse à 4 chiffres. Calculer l’erreur de représen-
tation et l’erreur relative de représentation pour les nombres : a = 9.023506, b = 158.26 et
c = 0.00158894.
7) Dans le cadre du codage des nombres flottants en base 2. Déterminer

a) L’erreur d’affectation
b) L’erreur de l’opération d’addition
c) L’erreur de l’opération de soustraction
d) L’erreur de l’opération de mulitplication
e) L’erreur de l’opération de division

1.4 TD13 : Observer l’approximation numérique sous Matlab

√ √
1. Calculer algébriquement les expressions suivantes : x = 0.6 + 0.2 + 0.2 + 0.2, y = 2 ∗ 2 − 2,
z = 1 − 3 ∗ ( 43 − 1).
x = 1.2, y = 0, z = 0.
2. Calculer numériquement les expressions ci-dessus en utilisant le logiciel Matlab et les formats
short, long et rat pour afficher les résultats.

[49]: import numpy as np

x=0.6+0.2+0.2+0.2
print(format(x,'.17f'))
y=np.sqrt(2)*np.sqrt(2)-2
print(y)
z=1-3*(4/3-1)
print(z)

1.19999999999999996
4.440892098500626e-16
2.220446049250313e-16
√ 4
Pour y et z, la représentation sur ordinateur des nombres 2 et 3 entraine des erreurs d’arrondi
et par suite une erreur de calcul.
3. En utilisant le logiciel Matlab, calculer le plus grand nombre entier naturel n tel que le nombre
en est représenté en mémoire machine.

[50]: import numpy as np

n=1
while(np.isfinite(np.exp(n))): # on pourra remplacer cette ligne par␣
,→while(exp(n)~=Inf)

n=n+1

5
 n=n-1
print(np.exp(n))

8.218407461554972e+307
/var/folders/sz/pz2knvps6nn8p_1zvx21g3d80000gn/T/ipykernel_62818/4232687868.py:3
: RuntimeWarning: overflow encountered in exp
while(np.isfinite(np.exp(n))): # on pourra remplacer cette ligne par
while(exp(n)~=Inf)
(x+1)−1 x+(1−1)
4. Sous Matlab, calculer les expressions y = x et z = x pour x = 10−7 , 10−8 ,. . .,
10−16 , 10−17 . Que constatez-vous ?

[51]: for e in range(-7,-18,-1):

x = 10**e
y = ((x+1)-1)/x
z = (x+(1-1))/x
print("x=",x, " y = ",y," z = ", z)

x= 1e-07 y = 1.0000000005838672 z = 1.0

x= 1e-08 y = 0.999999993922529 z = 1.0
x= 1e-09 y = 1.000000082740371 z = 1.0
x= 1e-10 y = 1.000000082740371 z = 1.0
x= 1e-11 y = 1.000000082740371 z = 1.0
x= 1e-12 y = 1.000088900582341 z = 1.0
x= 1e-13 y = 0.9992007221626409 z = 1.0
x= 1e-14 y = 0.9992007221626409 z = 1.0
x= 1e-15 y = 1.1102230246251565 z = 1.0
x= 1e-16 y = 0.0 z = 1.0
x= 1e-17 y = 0.0 z = 1.0
5. Déterminer l’ensemble F(2, 3, −1, 3)
6. Représenter l’ensemble F(2, 3, −1, 3) en utilisant Matlab.

1.5 TD14 : Observer, à travers un exemple, la non fiabilité du calcul machine

On considère la suite (un ) définie par un = un−1 + un−2
4 avec u0 = 1 et u1 = a avec a ∈ R.
1. Ecrire
√ une fonction en langage Python qui représente graphiquement, pour a = −2 et a =
(1 − 2)/2, les m premiers (l’entier m est saisi par clavier) termes de la suite (un ).

[52]: import numpy as np

import matplotlib.pyplot as plt
def suite_rec(u0,u1,N):
Un = np.zeros(N)
Un[0] = u0;
Un[1] = u1
i = 2
while i < N:
Un[i] = Un[i-1]+1./4.*Un[i-2]

6
 i = i+1
return Un
u0=1
u1 = -2
m = input(" Donner m : ")
m = int(m)
Un = suite_rec(u0,u1,m)
plt.figure(figsize=(16, 6), dpi=80)
plt.plot(np.arange(0,m),Un,"m:*",label ='suite rec')

u0=1
u1 = (1-np.sqrt(2))/2
Un = suite_rec(u0,u1,m)
plt.figure(figsize=(16, 6), dpi=80)
plt.plot(np.arange(0,m),Un,"m:*",label ='suite rec')

Donner m : 100

[52]: [<matplotlib.lines.Line2D at 0x7f8eefa83ca0>]

7
 √
2. Pour le cas où a = (1 − 2)/2, représenter graphiquement
√ les m premiers termes de la suite
calculés au moyen de la formule: un = ((1 − 2/2)n . Que constatez-vous ?

[53]: u0=1; u1 = (1-np.sqrt(2))/2

m = input(" Donner m : ")

m = int(m)

Un = suite_rec(u0,u1,m)
Uex = np.zeros(m)
for n in range(m):
Uex[n] = ((1-np.sqrt(2))/2)**n

er = np.abs(Un-Uex)
plt.figure(figsize=(16, 6), dpi=80)
plt.plot(np.arange(0,m),Uex,"m:",label ='suite rec')

Donner m : 100

[53]: [<matplotlib.lines.Line2D at 0x7f8eefe36550>]

3. Notons par (un ) la suite calculée par la formule de récurrence ci-dessus. Afficher pour les m
premiers termes l’erreur commise |un − un |.

[54]: er = np.abs(Un-Uex)
print("Erreur=",er)

Erreur= [0.00000000e+00 0.00000000e+00 6.93889390e-17 5.37764278e-17

7.41594286e-17 8.71698547e-17 1.05845237e-16 1.27610596e-16
1.54078681e-16 1.85980589e-16 2.24500577e-16 2.70995678e-16
3.27120831e-16 3.94869749e-16 4.76649957e-16 5.75367394e-16
6.94529884e-16 8.38371732e-16 1.01200420e-15 1.22159714e-15

8
 1.47459819e-15 1.77999747e-15 2.14864702e-15 2.59364639e-15
3.13080814e-15 3.77921974e-15 4.56192177e-15 5.50672671e-15
6.64720715e-15 8.02388882e-15 9.68569061e-15 1.16916628e-14
1.41130855e-14 1.70360012e-14 2.05642725e-14 2.48232728e-14
2.99643410e-14 3.61701592e-14 4.36612444e-14 5.27037842e-14
6.36190953e-14 7.67950414e-14 9.26998152e-14 1.11898576e-13
1.35073529e-13 1.63048173e-13 1.96816556e-13 2.37578599e-13
2.86782738e-13 3.46177388e-13 4.17873072e-13 5.04417419e-13
6.08885687e-13 7.34990042e-13 8.87211463e-13 1.07095897e-12
1.29276184e-12 1.56050158e-12 1.88369204e-12 2.27381744e-12
2.74474045e-12 3.31319481e-12 3.99937992e-12 4.82767862e-12
5.82752360e-12 7.03444326e-12 8.49132416e-12 1.02499350e-11
1.23727660e-11 1.49352498e-11 1.80284413e-11 2.17622537e-11
2.62693640e-11 3.17099274e-11 3.82772685e-11 4.62047503e-11
5.57740674e-11 6.73252550e-11 8.12687719e-11 9.81000856e-11
1.18417279e-10 1.42942300e-10 1.72546620e-10 2.08282195e-10
2.51418850e-10 3.03489398e-10 3.66344111e-10 4.42216460e-10
5.33802488e-10 6.44356603e-10 7.77807225e-10 9.38896375e-10
1.13334818e-09 1.36807228e-09 1.65140932e-09 1.99342739e-09
2.40627972e-09 2.90463657e-09 3.50620650e-09 4.23236564e-09]
4. Représenter ces erreurs graphiquement.

[55]: plt.figure(figsize=(16, 6), dpi=80)

plt.plot(np.arange(0,m),er,"k:*",label ='suite rec')

[55]: [<matplotlib.lines.Line2D at 0x7f8eefea9580>]

5. Que constatez-vous ? Que s’est-il passé ?

Le polynôme caractéristique de la suite est r2 − r − √ 1/4 = 0 dont √le déscriminant ∆ = 1 + 1 = 2
ce qui entraine deux racines réelles distinctes r1 = 1−2 2 et r2 = 1+2 2 . Le terme général de la suite
est alors donné par un = λ1 r1n + λ2 r2n où λ1 et λ2 sont des constantes détérminées par u0 et u1 .

9
u0 = 1 entraine: λ1 + λ2 = 1
u1 = a entraine λ1 r1 + (1 − λ1 )r2 = a
On obtient ainsi λ1 = r2√−a
2
et λ2 = a−r
√ 1.
2
√ √
5+√ 2 −5+
√ 2
pour a = −2, on a λ1 = 2 2
et λ2 = 2 2
√
1− 2
pour a = 2 = r1 , on a λ1 = 1 et λ2 = 0
Concernant la suite dont le second terme est -2, on obtient pour 3ème terme la valeur -2+1/4=-7/4
un−2
négative et par la suite tous les termes suivants sont négatifs (un = un−1 + ) et la suite tend
n n
4 n
vers −∞ ce qui est en accord avec le résulat théorique un = λ1 r1 + λ2 r2 puisque r1 → 0 car |r1 | < 1
et |r2 | > 1 ce qui entraine que r2n → +∞ multiplié par λ2 < 0 entraine que un → −∞.
Pour la suite un avec u1 = r1 , on obtient λ1 = 1 et λ2 = 0 ce qui donne un = r1n avec |r1 | < 1 ce qui
donne théoriquement une suite convergente vers 0 en oscillant autour de 0. Mais numériquement
et à cause d’une erreur numérique on obtient une valeur négative au lieu d’une valeur positive et
un−2
encore une fois et à cause de la relation un = un−1 + la suite diverge vers −∞.
4

10