Introduction aux méthodes numériques

Travaux Dirigés/Travaux Pratiques N° 1

2023‑2024
Corrigé
TD11 ꞉ Codage des nombres
1) Calculer la représentation en base 10 du nombre binaire suivant ꞉ (101000.10110000)2
5 3 −1 −3 −4
(101000.10110000)2 = 2 + 2 + 2 + 2 + 2 = 40.6875

2) Calculer la représentation binaire des nombres suivants ꞉ a =

17

20
, b = 4.125 et c = −28.8625 .
17
a = = 0.85
20

0.85 ∗ 2 = 1.7 → 1

0.7 ∗ 2 = 1.4 → 1

0.4 ∗ 2 = 0.8 → 0

0.8 ∗ 2 = 1.6 → 1

0.6 ∗ 2 = 1.2 → 1

0.2 ∗ 2 = 0.4 → 0

…
  
17
a = = 0.85 = (0.11 0110 0110 0110 …)2
20

b = 4.125

4 = 2 ∗ 2 + 0

2 = 2 ∗ 1 + 0

1 = 2 ∗ 0 + 1

donc 4 = (100)2 .
0.125 ∗ 2 = 0.250 → 0

0.250 ∗ 2 = 0.5 → 0

0.5 ∗ 2 = 1.0 → 1

0. ∗ 2 = 0 → 0

0.125 = (0, 001)2

par suite b = 4.125 = (100.001)2

 c = −28.8625

28 = 2 ∗ 14 + 0

14 = 2 ∗ 7 + 0

7 = 2 ∗ 3 + 1

3 = 2 ∗ 1 + 1

1 = 2 ∗ 0 + 1

28 = (11100)2

0.8625 ∗ 2 = 1.725 → 1

0.725 ∗ 2 = 1.45 → 1

0.45 ∗ 2 = 0.9 → 0

0.9 ∗ 2 = 1.8 → 1

0.8 ∗ 2 = 1.6 → 1

0.6 ∗ 2 = 1.2 → 1

0.2 ∗ 2 = 0.4 → 0

0.4 ∗ 2 = 0.8 → 0

…
 
0.8625 = (0.1101 1100 1100 …)2

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 0 0
a = = 0.85 = (−1) × 0.85 × (10)
20
0 1
b = 4.125 = (−1) × 0.4125 × (10)

1 2
c = c = −28.8625 = (−1) × 0.288625 × (10)

en base 2
     
0 0
a = (0.11 0110 0110 0110 …)2 = (−1) × 0.11 0110 0110 0110 … × 2

0 3=(11)2
b = (100.001)2 = (−1) × 0.100001 × 2

   

1 5=(101)2
c = (−11100.1101 1100 1100 …)2 = (−1) × 0.111001101 1100 1100 … × 2

4) Déterminer la représentation au format simple précision suivant la norme IEEE 754 des nombres , a b

et . c

a=
  
0 −1
(−1) × 1.1 0110 0110 0110 … × 2

et exposant=‑1+127= et
  
s = 0 (01111110)2 m = 1 0110 0110 0110

donc =0 01111110 1 0110 0110 0110 0110 0110 10

a

0 2=(10)2
b = (−1) × 1.00001 × 2

s = 0 et exposant=2+127=129= et (10000001)2 m = 00001 donc

b =0 10000001 00001000000000000000000 
1 4=(100)2
c = (−1) × 1.11001101 1100 … × 2
 et exposant=4+127=131= et donc

s = 1 (10000011)2 m = 11001101 1100 …

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 suitea = (−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 suiteb = (−1)

0
=15 393 162 788 864=
× 1.75 × 2
43
(−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 suitec = (−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.

TD12 ꞉ Observer
calcul numérique.la différence entre le calcul algébrique et le
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 places, exposant avec
β m . e L ≤ e ≤ M

m−1 m
card(F) = 2 × card([β ,β − 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 .
m−1 m
card(F) = 2 × card([β ,β − 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)

In [1]: 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)
n = len(F)
print(n)
Y = np.zeros(n)
figure(figsize=(16, 6), dpi=80)
plt.plot(F,Y,"m꞉*",label ='Floating numbers')

40
[<matplotlib.lines.Line2D at 0x7f9ad3514220>]
Out[1]:

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 × 10
0
.
z = 0.4371012 est représenté par 0.437 × 10 .
0

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 × 10
0
.
b) Le produit et commenter le résultat
xz

x = 0.125106 est représenté par 0.125 × 10

0
.
z = 0.4371012 est représenté par 0.437 × 10 .
0

x ∗ z = 0.0546839827 est représenté par0.547 × 10

−1
.
c) La division w/x

x = 0.125106 est représenté par .

0.125 × 10
0
est représenté par
w = 0.2151010 . 0.215 × 10
0

w/x = 1.7193499912 est représenté par 0.172 × 10

1

5) Soient trois réels x = y = 0.400 × 10 et 0

. En utilisant le système de numération de
z = 0.100 × 10
3

l’exercice précédent pour le stockage de ces nombres, calculer les deux sommes et (x + y) + z

x + (y + z) .
x + y = 0.400 × 10
0
+ 0.400 × 10
0
est représenté par
= 0.800 × 10
0
. 0.800 × 10
0

(x + y) + z est sdonc représenté par 0.000800 × 10

3
.
+ 0.100 × 10
3
= 0.101 × 10
3

y + z = 0.000400 × 10
3
+ 0.100 × 10
3
est représenté par
= 0.100400 × 10
3
. 0.100 × 10
3

x + (y + z) est donc représenté par 0.000400 × 10

3
+ 0.100 × 10. 3
= 0.100 × 10
3

6) Considérons une machine décimale avec mantisse à 4 chiffres. Calculer l’erreur de représentation et
l’erreur relative de représentation pour les nombres ꞉ , et
a = 9.023506 b = 158.26 . c = 0.00158894

7) Dans le cadre du codage des nombres flottants en base 2. Déterminer

a) L’erreur d’affectation
Procédure pour tronquer à chiffres꞉ s

Si X=∓0.d1 d2 … ds ds+1 b alors tron( )=

e
X ∓0.d1 d2 … ds b
e

Procédure pour arrondir à chiffres꞉ s

Si X=∓0.d1 d2 … ds ds+1 b alorse

X
∗
= ∓0.d1 d2 … ds ds+1 b avec
e
alors
∓ 0.00 … 0αs+1 b
e
αs+1 = b/2

arrondi(X)=tron( )X
∗

b) L’erreur de l’opération d’addition

x + y ⟶ Φ(Φ(x) + Φ(y))

c) L’erreur de l’opération de soustraction

x − y ⟶ Φ(Φ(x) − Φ(y))

d) L’erreur de l’opération de mulitplication

x ∗ y ⟶ Φ(Φ(x) ∗ Φ(y))

e) L’erreur de l’opération de division

x/y ⟶ Φ(Φ(x)/Φ(y))

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 ∗ (
4

3
. − 1)

, , .
x = 1.2 y = 0 z = 0

1. Calculer numériquement les expressions ci‑dessus en utilisant le logiciel Matlab et les formats
 short, long et rat pour afficher les résultats.
In [2]: 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

Pour et , la représentation sur ordinateur des nombres

y z √2 et entraine des erreurs d'arrondi et
4

par suite une erreur de calcul.

3

1. En utilisant le logiciel Matlab, calculer le plus grand nombre entier naturel tel que le nombre
n e
n

est représenté en mémoire machine.

In [3]: 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
n=n‑1
print(n)
print(np.exp(n))

709
8.218407461554972e+307
/var/folders/sz/pz2knvps6nn8p_1zvx21g3d80000gn/T/ipykernel_2144/897311188.py꞉3꞉ RuntimeW
arning꞉ overflow encountered in exp
while(np.isfinite(np.exp(n)))꞉ # on pourra remplacer cette ligne par while(exp(n)~=In
f)

1. Sous Matlab, calculer les expressions y =

(x+1)−1
et z =
x+(1−1)
pour x = 10
−7
, 10
−8
, ,
… 10
−16
,
. Que constatez‑vous ?
x x
−17
10

In [4]: 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

1. Déterminer l’ensemble F(2, 3, −1, 3)

 1. Représenter l’ensemble F(2, 3, −1, 3) en utilisant Matlab.

TD14 ꞉
machineObserver, à travers un exemple, la non fiabilité du calcul
On considère la suite définie par
(un ) un = un−1 + avec
un−2

4
et
u0 = 1 avec
u1 = a . a ∈ R

1. Ecrire une fonction en langage Python qui représente graphiquement, pour et

a = −2

a = (1 − √2)/2 , les premiers (l’entier est saisi par clavier) termes de la suite .
m m (un )

In [5]: 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]
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
[<matplotlib.lines.Line2D at 0x7f9ad3c490a0>]
Out[5]:
 1. Pour le cas où
a = (1 − √2)/2 , représenter graphiquement les premiers termes de la suite
m

calculés au moyen de la formule꞉

un = ((1 − √2/2)
n
. Que constatez‑vous ?
In [6]: 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
[<matplotlib.lines.Line2D at 0x7f9ad43bc940>]
Out[6]:

1. Notons par la suite calculée par la formule de récurrence ci‑dessus. Afficher pour les
(un ) m

premiers termes l’erreur commise .

|un − un |

In [7]: 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
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]

1. Représenter ces erreurs graphiquement.

In [8]: plt.figure(figsize=(16, 6), dpi=80)
plt.plot(np.arange(0,m),er,"k꞉*",label ='suite rec')

[<matplotlib.lines.Line2D at 0x7f9ad43e3a00>]
Out[8]:

1. Que constatez‑vous ? Que s’est‑il passé ?

Le polynôme caractéristique de la suite est r dont le déscriminant
2
− r − 1/4 = 0 ce
Δ = 1 + 1 = 2

qui entraine deux racines réelles distinctes et r1 = . Le terme général de la suite est
1−√2
r2 =
1+√2

alors donné par où et sont des constantes détérminées par et .

2 2
n n
u n = λ1 r + λ2 r λ1 λ2 u0 u1

entraine꞉
1 2

u0 = 1 λ1 + λ2 = 1

u1 = a entraine
λ1 r1 + (1 − λ1 )r2 = a

On obtient ainsi
λ1 =
r2 −a

√2
et λ2 = . a−r1

√2
pour a = −2 , on a λ1 = et
5+√2

2√ 2
λ2 =
−5+√2

2√ 2

pour a =
1−√2

2
= r1, on a λ1 = 1et λ2 = 0

Concernant la suite dont le second terme est ‑2, on obtient pour 3ème terme la valeur ‑2+1/4=‑7/4
négative et par la suite tous les termes suivants sont négatifs ( ) et la suite tend vers
un = un−1 +
un−2

ce qui est en accord avec le résulat théorique puisque car et

4
n n n
−∞ u n = λ1 r + λ2 r r → 0 |r1 | < 1

ce qui entraine que multiplié par entraine que .

1 2 1

n
|r2 | > 1 r → +∞ λ2 < 0 un → −∞
2

Pour la suite avec

un , on obtient
u 1 = r1 et
λ1 = 1 ce qui donne
λ2 = 0 avec un = r ce qui
n
|r1 | < 1

donne théoriquement une suite convergente vers 0 en oscillant autour de 0. Mais numériquement et à
1

cause d'une erreur numérique on obtient une valeur négative au lieu d'une valeur positive et encore une
fois et à cause de la relation un = un−1 + la suite diverge vers .
un−2

4
−∞