notation en virgule flottante - démystificationvnozick/teaching/slides/imac2_math/01_virgule... ·...

Rappels sur les entiers Virgule Flottante C et C++ Arrondi Operations Erreur numerique En pratique

Notation en virgule flottantedemystification

Vincent Nozick

Vincent Nozick Notation en virgule flottante 1 / 48


Introduction

En programmation, on utilise :

• des int

• des unsigned int

• des float

• des double

• ...

→ Comment sont-ils codes dans la machine?→ Quelles precautions a prendre pour les utiliser?



Rappels sur les entiers

Ecriture binaire (base 2):

1 0 1 1 (base 2)1× 23 + 0× 22 + 1× 21 + 1× 20 (base 10)1× 8 + 0× 4 + 1× 2 + 1× 1 (base 10)8 + 0 + 2 + 1 (base 10)

→ 11 (base 10)




En base 2 :

x = am . . . a2a1a0

avec ai = 0 ou 1

Conversion en base 10 :

x = am2m + . . .+ a222 + a12

1 + a020

x =m∑i=0

ai2i (avec ai = 0 ou 1)




En base b :x = am . . . a2a1a0︸︷︷︸

en base b

Conversion en base 10 :

x =

m∑i=0

aibi

︸︷︷︸ai et bi exprimes en base 10




Addition binaire :

1 0 1 1+ 0 0 1 0

= 1 1 0 1




Operations binaires :

• Addition

• Soustraction (different du ’−’ unaire)

• Multiplication

• Division entiere

• Modulo (reste de la division entiere)

• <, ≤, ≥, >, == et 6=• <<, >>, & et |• && et ||• . . .



Les entiers en C/C++

Les unsigned int :

4 octets = 32 bitsde 00000000 · · · 00000000 a 11111111 · · · 11111111→ de 0 a 232 − 1 = 4, 294, 967, 295




Les int :

4 octets = 32 bits1 bit de signe pour les nombres negatifs : x = s.m

• s = 0/1 : bit de signe

• m : nombre binaire code sur 31 bits (magnitude)




Les int :

En pratique :x = m− s× 231

• si s = 0 0 ≤ x ≤ 231 − 1

• si s = 1 −231 ≤ m− s× 231 ≤ −1

→ evite de coder 0 deux fois (+0 et −0)

⇒ −2147483648 ≤ x ≤ 2147483647

soit environ 4 milliards d’entiers



Nombre a Virgule Flottante

Introduction :

(1, 25)10 = 1× 100 + 2× 10−1 + 5× 10−2

= 1× 20 + 0× 2−1︸︷︷︸12

+1× 2−2︸︷︷︸14

= (1, 01)2




Definition :Le reel x est ecrit en virgule flottante de base b a m chiffres si :

• b ≥ 2

• on peut ecrire x sous la forme :

x = ±0, a1a2 . . . am︸︷︷︸mantisse

bM → exposant

x = ±m∑i=1

aibM−i avec ai ∈ N et 0 ≤ ai < b

• a1 6= 0 pour une ecriture normalisee

• Mmin ≤M ≤Mmax




x = ±0, a1a2 . . . ambM

Exemple :

x = 0, 00064

b = 10

m = 3

Mmin = −5Mmax = 6

→ x = 0, 640.10−3




x = ±0, a1a2 . . . ambM

Exemple :

x = 0, 00064

b = 10

m = 3

Mmin = −5Mmax = 6

→ x = 0, 640.10−3




Limites de cette representation :

• nombres exprimables




Propriete : (version ideale en base b)Nombre de reels representables exactement en virgule flottante.

x = ±0, a1a2 . . . ambM

• ± → 2

• a1 → (b− 1) possibilites pour a1 6= 0

• a2 . . . am → bm−1 possibilites

• M → nombre d’exposants possibles =Mmax −Mmin + 1

• pour 0 → +1 (remarque : +2 si on differencie +0 de −0)

−→ en tout : 2(b− 1)bm−1(Mmax −Mmin + 1) + 1



Norme IEEE 754

En pratique : float norme IEEE 754 (C et C++)

• 4 octets (32 bits)

• b = 2

• m = 23 + 1 bit de signe

• M est code sur 8 bits sans bit de signe (256 valeurs),auquel on retire 127. →Mmax = 128 et Mmin = −127

• a1 fantome (pas code car suppose egal a 1)

x = ±(bM−127︸︷︷︸pour a1

+∑m

i=2 aibM−(i−1)−127

)Nombre de reels codable exactement en C/C++

' 2 milliards de reels differents



Norme IEEE 754

En pratique : norme IEEE 754 (C et C++)

On code aussi :

• +∞, −∞• NaN (Not a Number) exemple: float a = 8.0/0.0;

• zeros signes : +0 6= −0



Norme IEEE 754

En pratique : float norme IEEE 754 (C et C++)

signe s exposant M mantisse m valeur

0/1 1→ 254 any (−1)s × 2M−127 × 1m

0 0 0 +0

1 0 0 −00 255 0 + inf

1 255 0 − inf

0/1 255 6= 0 NaN

a1 = 1 est un bit fantome non codeen representation normalisee



Norme IEEE 754

x = (−1)s × 2M−127 × 1m

Exemples :

x = 0︸︷︷︸±

01111111︸︷︷︸127

00000000000000000000000

exposant associe au a1 fantome : 2127−127 = 20

20 2−1 2−2 2−3 · · ·x = + (1) 0 0 0 · · · = 1



Norme IEEE 754

x = (−1)s × 2M−127 × 1m

Exemples :

x = 0︸︷︷︸±

10000000︸︷︷︸128

11000000000000000000000

exposant associe au a1 fantome : 2128−127 = 21

21 20 2−1 2−2 · · ·x = + (1) 1 1 0 · · · = 3.5



Norme IEEE 754

Exemples : float en norme IEEE 754

signe (1) | exposant (8) | mantisse (23)0 00000000 00000000000000000000000→ +01 00000000 00000000000000000000000→ −00 01111111 00000000000000000000000→ 10 10000000 00000000000000000000000→ 20 10000001 00000000000000000000000→ 40 10000001 01000000000000000000000→ 50 10000000 11000000000000000000000→ 3, 50 10000001 11000000000000000000000→ 70 10000010 11000000000000000000000→ 140 11111111 10000000000000000000000→ NaN0 11111111 00000000000000000000000→ ∞



Arrondi et troncature

Valeur tronquee a p decimales :

x = ±0, a1a2 . . . ap | ap+1 . . . am.bM

Valeur arrondie (au plus pres) a p decimales :

x = ±0, a1a2 . . . ap−1ap . . . am.bM

x′ = ±0, a1a2 . . . ap−1rp.bM

avec : rp = ap + 1 si ap+1 ≥

b

2

rp = ap si ap+1 <b

2

en base 2 : rp = ap + ap+1




Exemple :representer x = 0, 306.102

b = 10

m = 2

Mmin = −5Mmax = 6

→ Troncature : x = 0, 30.102

→ Arrondi : x = 0, 31.102

Remarque : avec un arrondi, on perd 2 fois moins d’incertitude.




Exemple :representer x = 0, 306.102

b = 10

m = 2

Mmin = −5Mmax = 6

→ Troncature : x = 0, 30.102

→ Arrondi : x = 0, 31.102

Remarque : avec un arrondi, on perd 2 fois moins d’incertitude.



Operations sur les float

Operations standards :

• +, −, × et ÷• <, ≤, ≥, >, == et 6=• . . .

Operations plus evoluees :

• √ , exp, log, . . .

• cos, sin, . . .

• . . .




Addition et soustraction :

x = 0, x1x2 . . . xm.10Mx

y = 0, y1y2 . . . ym.10My

↪→ x+ y ou x− y

1 M = max(Mx,My)

2 on reecrit x et y en bM

3 on fait l’operation

4 on reajuste M si necessaire

5 on arrondit




Addition et soustraction : exemple

b = 10, m = 3, Mmin = −5 et Mmax = 6x = +0, 321.102

y = +0, 440.103

x+ y = 0, 321.102 + 0, 440.103

M = max(Mx,My) →M = 3on reecrit x et y en bM → x+ y = (0, 0321 + 0, 440).103

on fait l’operation → x+ y = 0, 4721.103

on reajuste M si necessaire → pas besoinon arrondit → x+ y = 0, 472.103




Addition et soustraction : exemple

b = 10, m = 3, Mmin = −5 et Mmax = 6x = +0, 321.102

y = +0, 440.10−3

x+ y = 0, 321.102 + 0, 440.10−3

M = max(Mx,My) →M = 2on reecrit x et y en bM → x+ y = (0, 321 + 0, 00000440).102

on fait l’operation → x+ y = 0, 3210044.102

on reajuste M si necessaire → pas besoinon arrondit → x+ y = 0, 321.102= x




Multiplication et division :

x = 0, x1x2 . . . xm.10Mx

y = 0, y1y2 . . . ym.10My

↪→ x× y ou x÷ y

• M = max(Mx,My)

• on reecrit x et y en bM

1 on fait l’operation

2 on reajuste M si necessaire

3 on arrondit




Multiplication et division : exemple

b = 10, m = 3, Mmin = −5 et Mmax = 6x = +0, 321.102

y = +0, 542.101

x× y = 0, 321.102 × 0, 542.101 = (0, 321× 0, 542).102+1

on fait l’operation → x× y = 0, 173982.103

on reajuste M si necessaire → pas besoinon arrondit → x× y = 0, 174.103




Multiplication et division : exemple

b = 10, m = 3, Mmin = −5 et Mmax = 6x = +0, 321.105

y = +0, 542.104

x× y = 0, 321.105 × 0, 542.104 = (0, 321× 0, 542).105+4

on fait l’operation → x× y = 0, 173982.109

on reajuste M si necessaire → pas besoinon arrondit → x× y = 0, 174.109 → depassement



Erreur numerique

Precision de la machine :La precision εm de la machine est le plus petit float (en magnitude)qui, additionne a 1.0 donne un float different de 1.0.

En norme IEEE 754 :std::numeric limits<float>::epsilon() 1, 19× 10−7

std::numeric limits<float>::min() 1, 18× 10−38

std::numeric limits<float>::max() 3, 40× 1038

std::numeric limits<double>::epsilon() 2, 22× 10−16

std::numeric limits<double>::min() 2, 23× 10−308

std::numeric limits<double>::max() 1, 80× 10308



Erreur numerique : 2 sources d’erreurs

Erreur de troncature :L’erreur generee par les arrondis s’appelle l’erreur de troncature. Ils’agit des erreurs dues a la precision de la machine, lors d’operationsbinaires.

Erreur de precision :Elle est due au fait qu’un float ne peut pas representer parfaitementcertain nombres reels.



Erreur numerique

Remarque :Il arrive qu’il y ait une perte de chiffres significatifs dans la soustrac-tion de deux nombres voisins du fait des arrondis.

La soustraction est une des operations les plus dangereuses encalcul numerique : elle peut amplifier l’erreur relative de facon catas-trophique.

Exemple :

• addition : (x+ ε1) + (x+ ε2) = 2x+ err(ε1 + ε2)↪→ l’erreur est petite par rapport a 2x

• soustraction : (x+ ε1)− (x+ ε2) = 0 + err(ε1 − ε2)↪→ l’erreur est grande par rapport a 0



Consequence des arrondis

Associativite : (x+ y) + z = x+ (y + z)

b = 10, m = 3, Mmin = −5 et Mmax = 6x = y = 0, 400.100

z = 0, 100.103

(x+ y) + z = (0, 400.100 + 0, 400.100) + 0, 100.103

= 0, 800.100 + 0, 100.103

= 0, 1008.103

= 0, 101.103





b = 10, m = 3, Mmin = −5 et Mmax = 6x = y = 0, 400.100

z = 0, 100.103

(x+ y) + z = 0, 101.103

x+ (y + z) = 0, 400.100 + (0, 400.100 + 0, 100.103)= 0, 400.100 + (0, 0004.103 + 0, 100.103)= 0, 400.100 + 0, 1004.103

= 0, 400.100 + 0, 100.103

= 0, 100.103 = z





Dans notre exemple, on a : (x+ y) + z 6= x+ (y + z)

Remarque :On a le meme probleme avec la distributivite de la multiplication.




Methode :

On calcule mieux les operations sur des valeurs du meme ordre degrandeur.

On ajoute d’abord les plus petits elements entre eux afin qu’ilsdeviennent suffisamment gros pour ne plus etre negligeables devantles autres.

Autrement dit, on fait les sommes du plus petit au plus grand.



En pratique

Precautions a prendre :

• etre attentif dans la formulation des equations.

• faire attention aux depassements.→ normer / conditionner les donnees

• bien ordonner les operations.



Et en C/C++ ?

Et en pratique ? : dans du code C/C++

float a = 0.0;

float b = -0.0;

cout << "a = " << a;

cout << "b = " << b;

→ a = 0 b = -0



Et en C/C++ ?


float a = 0.0;

float b = -0.0;

cout << "a = " << a;

cout << "b = " << b;

→ a = 0 b = -0



Et en C/C++ ?


float a = 0.0;

float b = -0.0;

if(a==b) cout << "a==b";

else cout << "a != b";

→ a == b



Et en C/C++ ?


float a = 0.0;

float b = -0.0;

if(a==b) cout << "a==b";

else cout << "a != b";

→ a == b



Et en C/C++ ?


float a = ...;

float b = ...;

...

if(a==b) ...

→ PAS OK !



Et en C/C++ ?


float a = ...;

float b = ...;

...

if(a==b) ...

→ PAS OK !



Et en C/C++ ?


float a = ...;

float b = ...;

...

if(a==b) ...

→ if( fabs(a-b) < epsilon) OK !



Et en C/C++ ?

Et en pratique ?

Temps d’execution d’operations standards :

+ 0.8 ns− 0.8 ns× 1,3 ns÷ 5,8 ns

PC Intel Core i7-2600, 3.40GHz

→ float a = x / 2.0; vs. float a = x * 0.5;



Et en C/C++ ?

Et en pratique ?

Quelques operations :

#include<limits>

float inf = std::numeric limits<float>::infinity();

std::cout << inf - inf; → -nanstd::cout << inf + 42; → infstd::cout << 1.0/inf; → 0std::cout << sqrt(inf); → infstd::cout << sqrt(-1.0); → -nan



Et en C/C++ ?

Et en mode warrior ?

Quake III Arena

float F a s t I n v S q r t ( float x ) {float x h a l f = 0 . 5 f ∗ x ;int i = ∗( int∗)&x ; // e v i l f l o a t i n g po i n t b i t l e v e l hacki = 0 x 5 f 3 7 5 9 d f − ( i >> 1 ) ; // what the fuck ?x = ∗( float∗)& i ;x = x ∗ ( 1 . 5 f−( x h a l f ∗x∗x ) ) ;return x ;

}

Pour calculer une excellente approximation de1√x

→ normer un vecteur par exemple



sinus et cosinus rapides

• on utilise 2 LUT : sin et cos avec n cases sur [0, 2π[

• θ = α+ β

• cosα et sinα sont donnes exactement par les LUT

• β petit ⇒ developpements limites :

sinβ = β − β3

3!+β5

5!cosβ = 1− β2

2!+β4

4!

sin θ = sin(α+ β) = sinα cosβ + cosα sinβ

cos θ = cos(α+ β) = cosα cosβ − sinα sinβ

→ legerement moins precis, mais meme temps de calcul que sin ou cos



Optimisation du compilateur

Code :

float v [ 1 ] = {4 9 8 . 2 5 5} ;float b = 4 9 8 . 2 5 5 ;

v [ 0 ] = v [ 0 ] / b ;

s t d : : cout<< s t d : : s e t p r e c i s i o n ( 2 0 ) << v [ 0 ] ;

Resultats :− avec g++ -O2 -ffast-math main.cpp → 0.99999994− avec g++ main.cpp → 1

-ffast-math inclue -freciprocal-math



Complexite

Complexite et temps d’execution :

The Algorithm Design manual, Steven Skiena


notation en virgule flottante - démystificationvnozick/teaching/slides/imac2_math/01_virgule... ·...

Documents