Manipulation des entiers signés : signe et valeur absolue

Manipulation des entiers signés : signe et valeur absolue
Système non redondant de base r ;
chiffres ∈ {0, 1, . . . , r − 1} → on représente tous les entiers
positifs.
Comment représenter les entiers relatifs (i.e. signés) ?
Première solution : signe et valeur absolue
conceptuellement simple ;
calcul de l’opposé trivial ;
deux représentations du zéro : +0 et −0 ;
algorithme (et donc circuit) différent pour addition et
soustraction
Manipulation des entiers signés : complément à la base (r
pair)
on dispose de n positions (on représente r n nombres
différents), on choisit de représenter tous les nombres compris
entre −r n /2 et r n /2 − 1 modulo r n
un nombre positif (entre 0 et r n /2 − 1) est représenté par son
écriture usuelle ;
un nombre x entre −r n /2 et −1 est représenté par l’écriture
usuelle de x + r n ;
signe : x ≥ 0 ⇔ son chiffre de poids fort xn−1 est < r /2 ;
Exemple : r = 10, n = 4, 3265 s’écrit 3265, et −3265 s’écrit
6735 ;
en base 2 (complément à 2), xn−1 xn−2 · · · x0 représente
n−1
−xn−1 2
+
n−2
X
i=0
xi 2i .
L’addition en complément à la base
l’addition se fait modulo r n → addition usuelle en ignorant la
retenue sortante ;
+
6 7 3 5
4 2 6 6
61 1 0 0 1
→ −3265 + 4266 = 1001.
dépassement de capacité lors du calcul de x + y :
s’ils sont de signes opposés, aucun dépassement possible ;
sinon : dépassement ssi la somme obtenue est de signe différent
Soustraction ?
ici : base 2 ;
calculer x − y c’est calculer x + (−y ) ;
si y = (yn−1 . . . y0 ) en complément à 2, définissons
ȳ = (yn−1 . . . y0 ) ;
y + ȳ = (1111 · · · 1) = −1, donc −y = ȳ + 1
→ soustraire un nombre = ajouter son complément, avec une
retenue entrante égale à 1 dans l’additionneur.
Multiplication
Multiplier : au moins aussi difficile qu’additionner (on s’en doutait !)
x
000 · · ·
001
X = 2n x + 1
y
000 · · ·
001
Y = 2n y + 1
2n
le produit XY donne :
xy
x +y
000 · · ·
01
4n
XY = 22n xy + 2n (x + y ) + 1.
→ Si on savait calculer XY en temps meilleur que O(log(4n))
= O(log(n)), on aurait x + y en temps meilleur que O(log(n)).
Théorème de Brent et Kung
Multiplieur n bits : circuit avec portes logiques à 2 entrées.
Hypothèses :
1
entrées et sorties en base 2 non redondante ;
2
circuit : surface plane et convexe d’aire A(n) ;
3
les connexions ont une largeur minimale λ > 0 ;
4
au plus ν ≥ 2 connexions peuvent se croiser en un point ;
5
un plot d’entrée/sortie contient un carré de côté λ ;
6
un bit met un temps ≥ τ pour se propager dans une connexion
ou pour être transmis par un plot d’entrée/sortie.
La surface A(n) du multiplieur et son temps de calcul T (n) vérifient
1
A(n) [T (n)] ≥
128
2
λτ
ν
2
· (n + 2)2
Multiplieurs cellulaires
pour simplifier : base 2 (non redondante), nombres positifs
uniquement ;
Algorithme “à la main” :
×
p5
a2 b1
a2 b2 a1 b2
p4
p3
a2
b2
a2 b0
a1 b1
a0 b2
p2
a1
a0
b1
b0
a1 b0 a0 b0
a0 b1
p1
p0
deux idées : addition carry-save, et dans une même colonne on
peut intervertir les bits comme ça nous arrange.
Petit retour sur l’addition carry-save
xy z
u =x ⊕y ⊕z
t = xy + xz + yz
FA
tu
a3 b 3
a2 b 2
a1 b1
FA
FA
FA
s4 s3
a0 b 0 0
FA
s1
s2
s0
a3 a3 b 3
(2) (1)
a2 a2 b2
(2) (1)
a1 a1 b 1
(2) (1)
a0 a0 b 0
(2) (1)
FA
FA
FA
FA
0
(1) (2)
s4 s4
0
(1) (2)
s3 s3
(1) (2)
s2 s2
(1) (2)
s1 s1
(1) (2)
s0 s0
Multiplieurs cellulaires
a4 b0
a 3 b4
a2 b0
0
a 1 b0
0
a2 b1
a1 b 1
a 3 b2
a2 b2
a1 b2
a0 b2
a3 b3
a 2 b3
a1 b3
a 0 b3
a2 b4
a 1 b4
a0 b4
a4 b2
a4 b4
a 3 b0
a3 b1
a 4 b1
a 4 b3
0
0
a0 b0
a0 b1
0
p9
p8
p7
p6
p5
p4
p3
p2
p1
p0
Multiplieurs cellulaires
temps : celui du plus long chemin dans ce graphe → 2n − 2
cellules FA pour un multiplieur n bits ;
n − 1 lignes identiques, et une seule est active à la fois, donne
2 idées
une seule ligne “rebouclée” sur elle-même (multiplieurs
“parallèle-série”) ;
pipe-line (en traitant à part la dernière ligne)
Faire mieux (mais plus gros !) : multiplieurs en temps logarithmique.
Décomposition récursive de la multiplication
Base r , nombres positifs (pour simplifier). On veut multiplier
A = A1 r n + A0 par B = B1 r n + B0 , où A0 , A1 , B0 , B1 s’écrivent sur
n chiffres.
Décomposition naïve (ou 4M)
AB = r 2n A1 B1 + r n (A1 B0 + A0 B1 ) + A0 B0
en séquentiel (logiciel), donne un temps en O(n2 ) pour
multiplier des nombres de n bits.
Décomposition de Karatsuba (ou 3M)
On calcule d’abord U = A1 B1 , V = A0 B0 ,
W = (A1 − A0 )(B1 − B0 ), et on obtient par la suite
AB = r 2n U + r n (U + V − W ) + V
en séquentiel (logiciel), chaque fois qu’on double n, on
log 3 multiplie (en gros. . . ) par 3 le temps → temps en O n log 2 .
Multiplieur “récursif” (4M) de Luk et Vuillemin
Circuit d’acheminement des opérandes
4M
n
2
4M
n
2
4M
n
2
4M
n
2
addition (en redondant) des résultats partiels
Temps de calcul en O(log(n)). . . mais circuit purement académique
Multiplieurs en temps logarithmique
appelés “arbres de Wallace”. . . mais c’est un peu injuste
multiplication (surtout en binaire) addition de n nombres
un additionneur “carry save” : peut se voir comme un
“compresseur” qui prend 3 entrées (non redondantes) et qui
exprime leur somme comme somme de ses 2 sorties (non
redondantes) ;
arbre d’addition : on fait des réductions partielles 3 → 2 :
l’ingénieur qui conçoit le circuit en bave (placement), mais
aucune difficulté conceptuelle
temps logarithmique
Arithmétique virgule flottante
s’est peu à peu imposée pour représenter les réels (en précision
finie) en machine ;
au début : pagaille totale :
avec certains Crays, multiplication par 1 → overflow ;
IBM 360 + Fortran : I = 14.0 / 2.0 donnait le résultat 1.0
1985 Norme IEEE 754-1985 : standardisation des formats et
√
du comportement des opérations (+,−,×,÷, )
prédictabilité
possibilité de construire des algorithmes et des preuves
pas de fonctions élémentaires (sin, cos, exp. . . les constructeurs
en profitent pour faire n’importe quoi)
2008 Nouvelle norme IEEE 754-2008
Les constructeurs en profitaient pour faire n’importe quoi
Computing System
Exact result
Vax VMS (g or h format)
HP 48 GX
HP 700
HP 375, 425t (4.3 BSD)
matlab V.4.2 c.1 for Macintosh
matlab V.4.2 c.1 for SPARC
Silicon Graphics Indy
SPARC
IBM RS/6000 AIX 3005
IBM 3090/600S-VF AIX 370
PC : Borland TurboC 2.0
Sharp EL5806
DECstation 3100
Casio fx-8100, fx180p, fx 6910 G
TI 89
sin x
−0.8522008497671888017727 · · ·
−0.852200849 · · ·
−0.852200849762
0.0
−0.65365288 · · ·
0.8740
−0.8522
0.87402806 · · ·
−0.85220084976718879
−0.852200849 · · ·
0.0
4.67734e − 240
−0.090748172
NaN
Error
Trig. arg. too large
Système virgule flottante

β≥2
 base
précision
p≥1
Paramètres :

exposants extrèmes emin , emax
Un nombre VF fini x est représenté par 2 entiers :
mantisse entière : M, |M| ≤ β p − 1 ;
exposant e, emin ≤ e ≤ emax .
tels que
x = M × β e+1−p
On appelle mantisse réelle, ou mantisse de x le nombre
m = M × β 1−p ,
ce qui donne x = m × β e , avec |m| < β.
Système virgule flottante
Ceci peut définir plusieurs représentations pour un même
nombre (7 × 101 = 70 × 100 ). L’ensemble des représentations
d’un même nombre est appelé une cohorte.
représentation normale : celle pour laquelle l’exposant est
minimum ;
une représentation normale vérifie :
soit |M| ≥ β p−1 (nombres normaux, de v.a. ≥ β emin )
soit |M| < β p−1 et e = emin (nombres sous-normaux, de v.a.
< β emin )
normal : ±m0 .m1 m2 · · · mp−1 × 2e , m0 6= 0, e ≥ emin ;
sous-normal : ±0.m1 m2 · · · mp−1 × 2emin .
En base 2 le premier chiffre de mantisse d’un nombre normal est un
“1” → pas besoin de le mémoriser.
Les sous-normaux compliquent les algorithmes, mais. . .
a−b a
0
β emin β emin +1 β emin +2
a−b a
0
b
b
β emin β emin +1 β emin +2
Figure: En haut : nombres VF normaux. Dans cet ensemble, a − b n’est
pas représentable → le calcul a − b donnera 0 en arrondi au plus près. En
bas : on ajoute les sous-normaux.
Système
DEC VAX
( D format )
HP 28, 48G
IBM 370
et 3090
IEEE-754
IEEE-754-R
“binary 128”
IEEE-754-R
“decimal 64”
β
2
2
10
16
16
2
2
p
24
56
12
6 (24 bits)
14 (56 bits)
23+1
52+1
emin
-128
-128
-500
-65
-65
-126
-1022
emax
126
126
498
62
62
127
1023
+ grand représ.
1.7 · · · × 1038
1.7 · · · × 1038
9.9 · · · × 10498
7.2 · · · × 1075
7.2 · · · × 1075
3.4 · · · × 1038
1.8 · · · × 10308
2
112+1
-16382
16383
1.2 · · · × 104932
10
16
-383
384
9.999 · · · 9 × 10384
Norme IEEE 754 (1985 et 2008)
la norme IEEE 754-1985 a mis fin à une pagaille (très
mauvaise portabilité des algorithmes numériques) ;
leader : W. Kahan (père de l’arithmétique des HP35 et Intel
8087) ;
formats ;
spécification des opérations, des conversions, etc. ;
√
gestion des exceptions (max+1, 1/0, −2, 0/0, etc.) ;
nouvelle révision adoptée en juin 2008, promulguée en août.
Formats (norme 754-1985)
Format
Single precision
Double precision
Single-extended
Double-extended
Double-extended (IA32)
Hidden bit ?
yes
yes
optional
optional
no
p
24
53
≥ 32
≥ 64
64
emin
−126
−1022
≤ −1022
≤ −16382
−16382
emax
127
1023
≥ 1023
≥ 16383
16383
Formats “basiques” binaires (norme 754-2008)
Name
p
emax
emin
binary16
11
+15
−14
binary32
(basic)
24
+127
−126
binary64
(basic)
53
+1023
−1022
binary128
(basic)
113
+16383
−16382
Formats “basiques” décimaux (norme 754-2008)
Name
p
emax
emin
decimal32
7
+96
−95
decimal64
(basic)
16
+384
−383
decimal128
(basic)
34
+6144
−6143
Arrondi correct
Definition 1 (Arrondi correct)
Mode d’arrondi actif parmi :
au plus près (défaut) s’il y en a deux :
round ties to even : celui dont la mantisse entière est paire ;
round ties to away : (2008 – recomm. en base 10 seulement)
celui de plus grande valeur absolue.
vers +∞.
vers −∞.
vers zéro.
Une opération dont les entrées sont des nombres VF doit retourner
ce qu’on obtiendrait en arrondissant le résultat exact.
Arrondi correct
IEEE-754-1985 : Arrondi correct pour +, −, ×, ÷,
conversions. Avantages :
√
et certaines
si le résultat d’une opération est exactement représentable, on
l’obtient ;
√
si on n’utilise que +, −, ×, ÷ et , l’arithmétique est
déterministe : on peut élaborer des algorithmes et des preuves
qui utilisent ces spécifications ;
précision et portabilité améliorées ;
en jouant avec les arrondis vers +∞ et −∞ → bornes
certaines sur le résultat d’un calcul.
L’arithmétique VF devient une structure mathématique en elle
même, que l’on peut étudier.
IEEE-754-2008 : l’arrondi correct est recommandé (mais pas exigé)
pour les principales fonctions mathématiques (cos, exp, log, . . . )
Premier exemple : lemme de Strebenz
Lemme 1 (Sterbenz)
Base β, avec nombres sous-normaux disponibles. Soient a et b deux
nombres VF positifs. Si
a
≤ b ≤ 2a
2
alors a − b est un nombre VF (→ il est calculé exactement dans
n’importe lequel des 4 modes d’arrondi).
Apparente contradiction avec ce qu’on entend parfois dire sur la
soustraction de nombres proches.
Erreur de l’addition VF
Premier résultat : représentabilité. RN (x) = x arrondi au plus près.
Lemme 2
Soient a et b deux nombres VF. Soient
s = RN (a + b)
et
r = (a + b) − s.
s’il n’y a pas de dépassement de capacité en calculant s, alors r est
un nombre VF.
Erreur de l’addition VF
Démonstration : Supposons |a| ≥ |b|,
1
2
s est “le” nombre VF le plus proche de a + b → il est plus près
de a + b que a ne l’est. Donc |(a + b) − s| ≤ |(a + b) − a|, par
conséquent
|r | ≤ |b|.
posons a = Ma × β ea −p+1 et b = Mb × β eb −p+1 , avec
|Ma |, |Mb | ≤ β p − 1, et ea ≥ eb .
a + b est multiple de β eb −p+1 ⇒ s et r sont multiples de
β eb −p+1 également ⇒ ∃R ∈ Z t.q.
r = R × β eb −p+1
mais |r | ≤ |b| ⇒ |R| ≤ |Mb | ≤ β p − 1 ⇒ r est un nombre VF.
Obtenir r : l’algorithme fast2sum (Dekker)
Théorème 1 (Fast2Sum (Dekker))
β ≤ 3. Soient a et b des nombres VF dont les exposants vérifient
ea ≥ eb (si |a| ≥ |b|,OK). Algorithme suivant : s et r t.q.
s + r = a + b exactement ;
s est “le” nombre VF le plus proche de a + b.
Algorithme 1 (FastTwoSum)
Programme C 1
s ← RN (a + b)
z ← RN (s − a)
r ← RN (b − z)
Se méfier des compilateurs “optimisants”.
s = a+b;
z = s-a;
r = b-z;
Algorithme TwoSum (Møller-Knuth)
pas besoin de comparer a et b ;
6 opérations au lieu de 3 → moins cher qu’une mauvaise
prédiction de branchement en comparant a et b.
Algorithme 2 (TwoSum)
s ← RN (a + b)
a0 ← RN (s − b)
b0 ← RN (s − a0 )
δa ← RN (a − a0 )
δb ← RN (b − b0 )
r ← RN (δa + δb )
Knuth : ∀β, en absence d’underflow et
d’overflow a + b = s + r , et s est le
nombre VF le plus proche de a + b.
Boldo et al : (preuve formelle) en base
2, marche même si underflow.
Preuves formelles (en Coq) d’algorithmes similaires très pratiques :
http://lipforge.ens-lyon.fr/www/pff/Fast2Sum.html.
Optimalité de l’algorithme TwoSum
Definition 2
Par la suite, on appelle Algorithme sans branchements à base de
RN-additions un algorithme
sans comparaisons, expressions conditionnelles, ou instructions
min/max ;
n’utilisant que des additions/soustractions en arrondi au plus
près : à l’étape i l’algorithme calcule RN (a + b) ou
RN (a − b) où a et b sont soit des variables d’entrée, soit des
valeurs calculées auparavant.
Graphe de dépendance d’un tel algorithme : DAG (Graphe orienté
acyclique). Profondeur de l’algorithme = profondeur du DAG.
Optimalité de l’algorithme TwoSum
Théorème 2
Dans tous les formats de la norme IEEE 754-2008, un algorithme
sans branchements à base de RN-additions qui calcule les mêmes
résultats que 2Sum demande au moins 6 opérations arithmétiques
(i.e., autant que 2Sum).
Théorème 3
Dans tous les formats de la norme IEEE 754-2008, un algorithme
sans branchements à base de RN-additions qui calcule les mêmes
résultats que 2Sum est de profondeur ≥ 5 (i.e., la même que
2Sum).
démonstrations : grand prix de l’inélégance mathématique ;
480756 algorithmes à 5 opérations (après suppression des
symétries les plus immédiates) ;
chacun d’eux essayé avec 2 couples d’entrées bien choisis.