RR 5105

INSTITUT NATIONAL DE RECHERCHE EN INFORMATIQUE ET EN AUTOMATIQUE
Arithmtique ottante
Vincent Lefvre Paul Zimmermann
N 5105
Janvier 2004
THME 2
ISSN 0249-6399
ISRN INRIA/RR--5105--FR
apport de recherche
Arithmtique ottante e
Vincent Lef`vre , Paul Zimmermann e
Th`me 2 Gnie logiciel e e et calcul symbolique Projet Spaces Rapport de recherche n 5105 Janvier 2004 60 pages
Rsum : Ce document rassemble des notes dun cours donn en 2003 dans la li`re e e e e Algorithmique Numrique et Symbolique du DEA dInformatique de lUniversit Henri e e Poincar Nancy 1. Ces notes sont bases en grande partie sur le livre Elementary Functions. e e Algorithms and Implementation de Jean-Michel Muller. Mots-cls : nombre ottant, prcision xe, prcision arbitraire, arrondi correct, norme e e e IEEE 754
Unit de recherche INRIA Lorraine LORIA, Technople de Nancy-Brabois, Campus scientique, 615, rue du Jardin Botanique, BP 101, 54602 Villers-Ls-Nancy (France)
Tlphone : +33 3 83 59 30 00 Tlcopie : +33 3 83 27 83 19
Floating-point Arithmetic
Abstract: This document releases lecture notes given during 2003 at University Henri Poincar (Nancy, France). These notes are mainly based on the book Elementary Functions. e Algorithms and Implementation by Jean-Michel Muller. Key-words: oating-point number, xed precision, arbitrary precision, correct rounding, IEEE 754 standard
1. Introduction 1.1. Reprsentation. Les nombres a virgule ottante plus couramment appels nombres e ` e ottants sont de la forme : x = s m e
o` s est le signe de x (s = 1), est la base (usuellement 2 ou 10), m la mantisse, et e u lexposant de x. La mantisse m comprend en gnral au plus p chires en base ; on dit alors e e que p est la prcision de x. Lexposant e est compris entre deux bornes : emin e emax . e Cette reprsentation nest pas unique : par exemple, le ottant 3.1416 en base 10 et e prcision 5 peut scrire aussi .31416 101 , ou encore 31416. 104 . La notion dexposant e e nest donc pas intrins`que, et est relative a la convention choisie pour la mantisse. Une fois e ` choisie une telle convention (par exemple, virgule apr`s le premier chire non nul, ou devant e celui-ci, ou encore apr`s le pe chire de la mantisse, ce qui revient a une mantisse enti`re), e ` e on peut calculer lintervalle de nombres ottants correspondant a [emin , emax ]. ` Lorsquon convient dune mantisse enti`re, on a alors 0 e m < p , et on voit que les oprations sur les ottants se ram`nent a des calculs entiers sur les mantisses. Cependant du e e ` fait de la plage dexposants valides, ces entiers peuvent tre tr`s grands. Par exemple, que se e e passe-t-il quand on ajoute 1.0 et 1.0 2100 ? Si on se ram`ne a un calcul entier, il faut ajouter e ` 1 et 2100 . On constate dune part quil faut eectuer des calculs intermdiaires sur 100 bits, e alors que le rsultat nal nest voulu quavec 2 bits. De plus le rsultat exact 1 + 2 100 nest e e pas reprsentable exactement sur 2 bits. Il faudra donc larrondir. e Le programme ci-dessous permet de dterminer automatiquement la base de votre e ordinateur ou calculette (` condition quil ou elle ne simplie pas ((A + 1.0) - A) - 1.0 a en 0 comme le fait Maple, pour lequel il faut remplacer A + 1.0 par evalf(A + 1.0), et A + B par evalf(A + B)) [28] : A := 1.0; B := 1.0; while ((A + 1.0) - A) - 1.0 = 0.0 do A := 2 * A od; while ((A + B) - A) - B <> 0.0 do B := B + 1.0 od; B; ` 1.1.1. Virgule xe. A loppos, un nombre en virgule xe scrit x = dn1 ...d1 d0 .d1 ...dm e e o` m est x, et n n0 (ce qui revient a considrer n = n0 , en autorisant des chires initiaux u e ` e nuls), et 0 di < . On voit que cela revient plus ou moins a xer e = emin = emax = m ` avec une mantisse enti`re dn1 ...d1 d0 d1 ...dm , et donc une prcision de p = n + m chires e e en base . 1.1.2. Reprsentation redondante. Parfois, une reprsentation redondante est utilise pour e e e la mantisse pour acclrer les calculs. Chaque chire peut alors prendre plus de valeurs, ee par exemple, + 1 valeurs pour [0, ..., ], ou 2 1 valeurs pour [( 1), ..., 1]. Pour = 2, cette derni`re reprsentation est appele codage de Booth, avec des chires 1, 0, 1. e e e Lintrt dune reprsentation redondante est de pouvoir retarder les propagations de ee e retenue dans une addition ou une soustraction. Par exemple, avec les chires 0, 1, 2 en base
RR n 5105
Lef`vre & Zimmermann e
2, on peut calculer sans propagation la somme de deux nombres dont les chires sont 0 ou 1 : 1011 + 0111 = 1122. Laddition peut alors seectuer en parall`le, ou indiremment de e e la gauche vers la droite ou de la droite vers la gauche (calcul en ligne). 2. La norme IEEE 754 La norme IEEE 754 (1985) [22] dnit 4 formats de ottants en base 2 : simple prcision e e (correspondant gnralement au type float en C), simple prcision tendue (obsol`te), e e e e e double prcision (correspondant gnralement au type double en C), et double prcision e e e e tendue (extended en anglais). Les exposants ci-dessous sont relatifs a une mantisse 1 e ` m < 2. format taille prcision e emin emax valeur max. simple 32 23+1 bits -126 +127 3.403...1038 double 64 52+1 bits -1022 +1023 1.798...10308 extended 79 64 16382 16383 1.190...104932
Le format double prcision tendue (64 bits de mantisse sur un total dau moins 79 bits, ou e e 80 bits sans bit implicite cf. section 2.3) est utilis en interne dans les processeurs x86, et e la rvision en cours de la norme IEEE 754 (cf. http://www.validlab.com/754R/) dnit e e le format quadruple prcision (quad ), avec 113 bits de mantisse sur un total de 128 bits. e
2.1. Nombres spciaux et exceptions. En plus des nombres usuels vus ci-dessus, e la norme IEEE 754 dnit trois nombres spciaux : , + et NaN (Not-a-Number). De e e plus, le zro est sign (il y a un +0 et un 0, qui sont gaux). Ces nombres doivent tre e e e e traits aussi bien en entre quen sortie par les fonctions arithmtiques. Par exemple, 1/(0) e e e donne , 1/(+0) donne +, et (+) (+) ou 1 donne NaN. En plus de ces valeurs spciales, la norme IEEE 754 impose de positionner certains drae peaux (ags en anglais) dans les cas suivants : drapeau inexact (inexact) : lorsque le rsultat dune opration ne peut tre reprsent e e e e e exactement, et doit donc tre arrondi : e drapeau eration invalide (invalid ) : en cas dopration donnant comme rsultat NaN op e e comme 1 ou / ; drapeau division par zro : en cas de calcul de x/0 (x ntant ni NaN, ni un zro) ; e e e drapeau dbordement vers linni (overow ) : lorsque le rsultat dune opration est e e e trop grand en valeur absolue a cause de la borne suprieure de la plage des exposants ` e reprsentables ; e drapeau dbordement vers zro (underow ) : lorsque le rsultat dune opration trop e e e e petit en valeur absolue a cause de la borne infrieure de la plage des exposants repr` e e sentables ; Une fois ces drapeaux positionns, ils le restent jusqu` ce que lutilisateur les remette en e a position initiale (non levs). Lorsquun drapeau a t lev, il nest donc pas possible de e ee e savoir quelle instruction a provoqu lexception correspondante, sauf a tester le drapeau e ` apr`s chaque instruction. e
INRIA
Lutilisateur peut aussi demander a ce que chaque type dexception dclenche une erreur ` e a lexcution (trap en anglais). Cest le comportement par dfaut dans certains cas (certaines ` e e versions de FreeBSD par exemple). Limportance du traitement des exceptions est parfaitement illustr par le crash du vol e 501 dAriane en 1996 [2], qui a co t quelques 500 millions de dollars. Lorigine du probl`me ue e sest avre tre une erreur de programmation dans le syst`me de rfrence inertielle. Plus ee e e ee prcisment, un ottant 64 bits donnant la vitesse horizontale de la fuse tait converti en e e e e entier sign sur 16 bits. Or lentier obtenu tant plus grand que 32767, le plus grand entier e e reprsentable sur 16 bits, la conversion chouait, dclenchant une exception non traite. Le e e e e plus drle si lon peut dire dans cette histoire est que tous les tests logiciels avaient o t russis, mais ils avaient t eectus avec les donnes dAriane 4, fuse moins puissante ee e ee e e e et donc moins rapide quAriane 5, pour laquelle la vitesse horizontale restait infrieure au e maximum de 32767 ! 2.2. Notion darrondi. La norme IEEE 754 dnit 4 modes darrondi : vers , vers e +, vers 0, et au plus proche. Un autre mode intressant est larrondi a loppos de 0 e ` e (away en anglais), qui est le symtrique de larrondi vers 0, comme larrondi vers + est le e symtrique de celui vers . Les arrondis vers et vers 0 sont appels arrondis dirigs e e e car ils sont dirigs dans une direction donne. e e Soit x la valeur exacte (i.e. en prcision innie) dune opration, et x , x+ les deux e e nombres ottants entourant x (qui existent toujours, car x , mais on peut avoir x = x+ lorsque x est reprsentable exactement) : e x x x+ .
Larrondi vers de x est x , larrondi vers + est x+ , larrondi vers 0 est x si x 0, et x+ si x < 0. Larrondi au plus proche est quant a lui dni comme le nombre parmi x ` e et x+ qui est le plus proche de x ; en cas dgalit, ce qui arrive quand x est au milieu de e e deux nombres ottants, la norme IEEE impose de choisir celui dont la mantisse est paire, i.e. nit par un zro (en base dirente de 2, les deux dnitions ne sont pas identiques). e e e Par abus de langage, on appelle cette convention larrondi pair . 2.2.1. Arrondi correct. La consquence la plus importante est que, une fois un mode dare rondi choisi, le rsultat dune opration est parfaitement spci, en particulier il y a un seul e e e e rsultat possible. On parle alors d arrondi correct . e La norme IEEE 754 impose larrondi correct pour les 4 oprations de base (addition, e soustraction, multiplication, division) ainsi que pour la racine carre. Ainsi, un programme e utilisant ces 5 oprations se comporte de mani`re identique sur toute conguration (proe e cesseur, syst`me et compilateur) respectant la norme IEEE 754, sous rserve quil ny ait e e pas de prcision intermdiaire tendue (ou que celle-ci soit dsactive) et que le langage de e e e e e programmation ne permette pas au compilateur de changer lordre des oprations si cela e peut produire un rsultat dirent. e e
RR n 5105
La proprit darrondi correct permet de construire des algorithmes prouvs utilisant ces ee e 5 oprations de base (cf. TwoSum, FastTwoSum, Sterbenz, Dekker, sections 10.1, 10.4 et e 10.5). Larrondi correct vers et + permet deectuer de larithmtique dintervalles, i.e. de e calculer a chaque opration un encadrement du rsultat exact. On na pas vraiment besoin ` e e dun arrondi correct pour cela, le respect de la direction darrondi sut, mais larrondi correct donne le meilleur rsultat possible, et par consquent la portabilit en dcoule. e e e e Par contre, la norme IEEE 754 nimpose rien pour les autres oprations mathmatiques e e (puissance, exponentielle, logarithme, sinus, cosinus, etc.) pour lesquelles aucune exigence nest impose. e On parle quelquefois darrondi d`le (faithful en anglais) quand le rsultat dune opration e e e est lun des deux nombres x et x+ entourant la valeur exacte x. Lerreur est alors au plus dun ulp, comme pour les arrondis dirigs, mais on ne sait pas quelle est la direction de e lerreur. Limportance de larrondi est illustr par lchec du missile Patriot en 1991 [2]. Pendant e e la guerre du Golfe, un anti-missile Patriot tir de Dahran (Arabie Saoudite) ayant manqu e e linterception dun missile irakien Scud, ce dernier a tu 28 soldats et bless quelque 100 e e autres personnes. Lerreur tait a une imprcision dans le calcul de la date de lanti-missile e ` e Patriot. Celui-ci dispose en eet dun processeur interne, qui calcule lheure en multiples de dixi`mes de secondes. Le nombre de dixi`mes de secondes depuis le dmarrage du processeur e e e est stock dans un registre entier, puis multipli par une approximation sur 24 bits de 1/10 e e pour obtenir le temps en secondes. Lapproximation sur 24 bits eectivement stocke tait e e 209715 221 , soit une erreur denviron 107 . Le processeur du missile ayant t dmarr ee e e une centaine dheures auparavant, lerreur totale tait donc de 0, 34 seconde, temps pendant e lequel le missile Scud parcourt plus de 500 m`tres, do` lchec de linterception. e u e Si la valeur stocke avait t larrondi au plus proche de 1/10 sur 24 bits, soit 13421773 e ee 227 , alors lerreur totale naurait t que de 0, 005 seconde, temps pendant lequel le missile ee Scud parcourt moins de 10 m`tres, et il aurait donc t certainement dtruit. Mais avec des e ee e si... 2.2.2. Le probl`me du double arrondi. Soit x un nombre rel, y larrondi en prcision p de e e e x, et z larrondi en prcision q < p de y. Alors z nest pas toujours larrondi en prcision q e e de x. Par exemple, en arrondi au plus proche, x = 1.0110100000001 arrondi a 9 bits donne ` y = 1.01101000, qui arrondi a 5 bits donne z = 1.0110 par la r`gle de larrondi pair, alors ` e que larrondi direct de x a 5 bits donne z = 1.0111. On parle alors de probl`me de double ` e arrondi . On peut montrer que ce probl`me narrive que pour larrondi au plus proche : e Supposons larrondi vers zro. Alors z e y x, par consquent z est du e bon ct par rapport a x. Il sut donc de montrer quil ne peut pas exister oe ` dautre ottant z de mme prcision q que z qui soit strictement entre z e e et x. Si tel tait le cas, on aurait z e y x car z est aussi un nombre reprsentable dans la prcision p de y. Par consquent, z tant larrondi e e e e correct de y en prcision q, on ne peut pas avoir z < z . e
INRIA
Le probl`me du double arrondi survient sur les processeurs x86 : par dfaut, les calculs e e internes sont eectus en double prcision tendue, puis le rsultat nal est stock en double e e e e e prcision. Il est possible via une instruction spciale dimposer que les calculs internes soient e e faits en double prcision, pour un respect de la norme IEEE 754 (` condition de ne pas e a utiliser de variables en simple prcision). e 2.3. Nombres normaliss et dnormaliss. Mme en xant la place de la virgule dans e e e e la mantisse, le mme nombre peut avoir plusieurs reprsentations. Ainsi en base = 10, e e avec une prcision p = 4, les deux ottants 3.140 et 0.314 101 sont identiques. On parle de e nombre normalis lorsque le chire de poids fort de la mantisse est non nul, et pour tout e rel reprsentable non nul, la reprsentation devient alors unique. e e e Une consquence intressante en base = 2 est que pour un nombre normalis, le pree e e mier chire (bit) de la mantisse est toujours 1. On peut alors dcider de ne pas le stocker e physiquement en mmoire, et on parle alors de bit de poids fort implicite (implicit leading e bit en anglais). Ainsi en double prcision, le plus petit nombre normalis positif est x = 1.0 21022 e e 2.22510308 . Soit y le nombre normalis suivant x : y = (1+252 )21022 . Si on calcule yx, e la valeur exacte 21074 nest pas reprsentable par un ottant normalis, et est donc arrondie e e a zro (en mode darrondi au plus proche). Il sagit dun dbordement vers zro (underow ). ` e e e Le probl`me que cela pose est le suivant. Soit un programme contenant linstruction suivante : e if x <> y then z = 1.0 / (x - y); Le test x <> y est vri puisque x et y di`rent en eet de 21074 ; par contre le rsultat de e e e e x y en arrondi au plus proche est 0, donc la division 1/(x y) va soit chouer si lexception e division par zro dclenche une erreur, soit donner un rsultat inni. e e e Les nombres dnormaliss permettent de rgler ce probl`me. Lide est de rserver une vae e e e e e leur spciale de lexposant (celle qui correspondrait a emin 1) pour reprsenter ces nombres. e ` e Il ny a alors plus de 1 implicite en bit de poids fort, et la valeur stocke de la mantisse e correspond a 0.d1 d2 ...dp1 au lieu de 1.d1 d2 ...dp1 . En prenant d1 = ... = dp2 = 0 et ` dp1 = 1, cela permet de reprsenter des nombres aussi petits que 2emin (p1) , soit 21074 e en double prcision. On peut montrer alors que lorsque x = y, larrondi de x y ne peut e pas tre nul : e Si x = y, alors |x y| vaut au moins = 2emin (p1) . Or est exactement le plus petit nombre dnormalis. Par consquent on a soit x y , soit e e e x y, et larrondi de x y quel que soit le mode darrondi ne peut pas tre zro. e e 3. Calcul derreur Le probl`me majeur du calcul ottant est la propagation des erreurs darrondi. Du fait du e probl`me de cancellation (cf. section 3.4), le rsultat nal dun calcul comprenant plusieurs e e oprations peut tre loign de la valeur exacte, voire de signe contraire ! e e e e
RR n 5105
Un exemple classique est le polynme de Rump : o 1335y 6 11y 8 x + x2 (11x2 y 2 y 6 121y 4 2) + + . 4 2 2y Le probl`me est de dterminer le signe de R(77617, 33096). e e Comme il nest pas possible dviter la propagation des erreurs darrondi, le mieux que e lon puisse faire est de borner lerreur nale. Pour cela, plusieurs mthodes existent : on peut e soit borner lerreur absolue, ou bien lerreur relative, ou bien borner lerreur en ulps. R(x, y) = 3.1. Erreur absolue. On utilise gnralement lerreur absolue quand on conna une mae e t joration a priori des valeurs intermdiaires calcules. Par exemple, quand on calcule une e e somme s = t1 + t2 + + tn , et que lon sait que les sommes intermdiaires sont bornes en e e valeur absolue par T , alors on sait que chaque tape donne une erreur darrondi dau plus e 1 n1 2 ulp(T ) en arrondi au plus proche, et donc lerreur nale est dau plus 2 ulp(T ). 3.2. Erreur relative. On utilise a contrario lerreur relative quand on ne conna pas de t borne a priori sur les valeurs intermdiaires calcules. Soit une opration c = (a b), o` est e e e u une opration mathmatique, et (x) donne larrondi correct de x. On sait par la proprit e e ee darrondi correct que |c (a b)| ulp(c) (on consid`re un arrondi dirig ici, ajouter un e e facteur 1/2 pour larrondi au plus proche). Comme on peut borner ulp(c) par 21p |c| (cf. ci-dessous), on en dduit |c (a b)| 21p |c|, do` e u a b = (1 + )c, avec || 2 . En fait, on peut montrer quon a aussi |c (a b)|
1p 1p
ulp(a b), ce qui donne
c = (1 + )(a b),
avec | | 2 . Higham propose dcrire pour chaque opration c = (1 + )(a b). En supposant que e e a = (1 + a )n a o` a est la valeur exacte dont a est une approximation, et que b = (1 + b )m u b, on voit quon obtient une borne en (1+c )1+n+m pour la multiplication, et (1+c )1+max(n,m) pour laddition (` condition que a et b soient de mme signe). Il sut donc a chaque opration a e ` e de compter lexposant de 1 + , et on obtient une erreur relative nale en (1 + ) n 1. 3.3. Unit in last place (ulp). Un ulp (abrviation dunit in last place en anglais) est le e poids du plus petit bit signicatif de la mantisse dun ottant. Si x = 1.b1 ...b1p 2e , alors ulp(x) = 2e+1p . Si la dnition de lexposant nest pas intrins`que et dpend du choix de e e e position de la virgule, celle dulp est intrins`que. On peut tendre cette dnition a un rel e e e ` e x quelconque, en disant que ulp(x) est lulp du ottant le plus proche de x en direction de zro, ou encore ulp(x) = 2 log2 |x| +1p . e Parfois il est plus agrable de calculer en termes dulp. Il faut savoir en eet quon peut e perdre un facteur 2 en passant de lerreur en ulp a lerreur relative et rciproquement : en ` e eet, une erreur dun ulp peut tre aussi grande que 21p |x| (lorsque x est une puissance de e 2), et une erreur de 21p |x| peut tre presque aussi grande que 2 ulps (pour x juste en-dessous e dune puissance de 2).
INRIA
3.4. Cancellation. Il sagit ici du probl`me principal du calcul ottant. Lorsque deux e nombres sont tr`s proches, la partie signicative de leur dirence apr`s arrondi diminue e e e dautant. En dautres termes, la valeur du rsultat tant petite devant les oprandes, lere e e reur commise sur ceux-ci lors des oprations antrieures en est multiplie dautant. e e e Le polynme de Rump est un exemple agrant de ce probl`me, puisquil faut pas o e moins de 122 bits de prcision (mme avec arrondi correct) pour obtenir le signe du rsultat. e e e Pour sen prmunir, il faut soit rordonner les calculs pour viter les cancellations, soit e e e ma triser lerreur commise lors de ces cancellations.
4. Approximations polynomiales et rationnelles Pour approcher une fonction donne sur un intervalle donn (pas trop grand) et avec une e e prcision xe a priori (pas trop grande non plus), le plus simple est dutiliser une approxie e mation polynomiale ou rationnelle. Les polynmes sont en eet les objets les plus simples que o lon puisse calculer, puisquils requi`rent juste des additions et des multiplications. Quand e on autorise aussi des divisions, on obtient des fractions rationnelles. On distingue deux types dapproximation : celles qui minimisent lerreur moyenne (par exemple, approximations par moindres carrs) et celles qui minimisent lerreur maximale e (approximations minimax ). Pour xer les notations, on consid`re que la fonction est f , lintervalle [a, b], et quon e cherche un polynme p de degr infrieur ou gal a n. o e e e ` 4.1. Approximations par moindres carrs. On veut ici minimiser la distance e
b
||p f ||2 =
w(x)[p(x) f (x)]2 dx
o` w est une fonction de poids. u b Soit le produit scalaire dni par f, g := a w(x)f (x)g(x)dx, et une famille (Ti )i 0 de e polynmes orthogonaux pour ce produit scalaire, cest-`-dire Ti , Tj = 0 pour i = j. On o a peut obtenir un polynme optimal pour le poids w(x) en calculant les coecients o ai = et en prenant comme polynme o
n
f, Ti , T i , Ti
(1)
p =
i=0
a i Ti .
Pour certaines valeurs du poids w(x) et de lintervalle [a, b], des familles classiques de polynmes orthogonaux sont connues. o
RR n 5105
10
4.1.1. Polynmes de Legendre. Ils sont orthogonaux pour le poids uniforme w(x) = 1, sur o lintervalle [1, 1]. Ces polynmes sont dnis par T0 (x) = 1, T1 (x) = x, o e Tn (x) = 2n 1 n1 xTn1 (x) Tn2 (x). n n
Par exemple, pour f (x) = exp(x) et n = 2, on obtient : p (x) = = 3e1 + 33e1 15e1 105e1 2 + 3e1 x + x 4 4 0.996294019 + 1.103638324x + 0.536721528x2 ,
ce qui donne ||p exp ||2 0.0014, et le graphe suivant :

2.5
1.5
0.5 1 0.8 0.6 0.4 0.2 0 0.2 0.4 x 0.6 0.8 1
Le maximum de |p (x) exp(x)| est atteint en x = 1, avec une valeur de 0.082. 4.1.2. Polynmes de Chebyshev. Ils sont orthogonaux pour le poids w(x) = o lintervalle [1, 1]. Ces polynmes sont dnis par T0 (x) = 1, T1 (x) = x, o e Tn (x) = 2xTn1 (x) Tn2 (x), ou plus simplement par cos(nx) = Tn (cos x). Toujours pour f (x) = exp(x) et n = 2, on obtient : p (x) = 0.9945705384 + 1.130318208x + 0.5429906792x 2 , ce qui donne ||p exp ||2 0.0031, et le graphe suivant :
1 , 1x2
sur
INRIA
11
2.5
1.5
0.5 1 0.8 0.6 0.4 0.2 0 0.2 0.4 x 0.6 0.8 1
Le maximum de |p (x) exp(x)| est aussi atteint en x = 1, avec une valeur de 0.050. 4.2. Approximations minimax. On veut ici minimiser la distance Un polynme p de degr infrieur ou gal a n ralisant le minimum de cette distance o e e e ` e parmi tous les polynmes de degr n est appel polynme minimax de degr n de f sur o e e o e [a, b]. Weierstrass a montr le rsultat suivant en 1885 : e e Thor`me 1. Soit f une fonction continue sur [a, b]. Pour tout > 0, il existe un polynme e e o p tel que ||p f || . Un autre rsultat, d a Chebyshev, est le suivant : e u` Thor`me 2. Il existe un unique polynme p de degr infrieur ou gal a n sur [a, b] qui e e o e e e ` minimise ||p f || . Il est appel polynme minimax de degr n de f sur [a, b]. De plus, il e o e existe N n + 2 points a x0 < x1 < ... < xN 1 b tels que En dautres termes, p f atteint son maximum en valeur absolue n + 2 fois sur [a, b], alternativement positivement et ngativement. e Un algorithme d a Remez [34] permet de calculer le polynme minimax de degr n de u` o e f sur [a, b]. Voici un programme Maple simpli eectuant ce calcul : e remez := proc(f, x, n, a, b) local pts, i, sys, eps, p, c, q, oldq; p := add(c[i]*xî, i=0..n); pts := {seq(evalf((a+b)/2+(b-a)/2*cos(Pi*i/(n+1))), i=0..n+1)}; while q<>oldq do sys := {seq(evalf(subs(x=op(i+1,pts),p-f))=(-1)î*eps, i=0..n+1)}; sys := solve(sys, {seq(c[i], i=0..n), eps}); oldq := q; q := subs(sys, p); lprint(q); pts := sort([a, solve(diff(q-f,x), x), b]); p (xi ) f (xi ) = (1)i [p (x0 ) f (x0 )] = ||p f || .
||p f || = maxa
x b |f (x)
p(x)|.
RR n 5105
12
od; q end: > remez(exp(x), x, 2, -1, 1); .9891410756+1.130864333*x+.5539395590*x^2 .9890394441+1.130184090*x+.5540411905*x^2 .9890397287+1.130183805*x+.5540409059*x^2 .9890397284+1.130183805*x+.5540409062*x^2 .9890397284+1.130183805*x+.5540409062*x^2 2 .9890397284 + 1.130183805 x + .5540409062 x Cet algorithme est implant dans le module numapprox de Maple : e > p:=numapprox[minimax](exp(x), x=-1..1, [2,0], 1, err): > expand(p), err; 2 0.9890365552 + 1.130258690 x + 0.5540440796 x , 0.04505715466 Par exemple, pour exp(x) et n = 2, on obtient : p (x) = 0.9890365552 + 1.130258690x + 0.5540440796x 2 , avec une distance maximale |p f | de 0.045 environ, et le graphe suivant :
2.5
1.5
0.5 1 0.8 0.6 0.4 0.2 0 0.2 0.4 x 0.6 0.8 1
Remarque 1. En gnral, une approximation de Taylor est bien moins bonne que les ape e proximations en norme euclidienne ou minimax. Par exemple, pour exp(x) sur [1, 1], lapproximation de Taylor de degr 2 en x = 0, soit 1 + x + x2 /2, donne une erreur denviron e 0.218 en x = 1, contre 0.082 pour lapproximation via les polynmes de Legendre, 0.050 o pour ceux de Chebyshev, et 0.045 pour lapproximation minimax. Remarque 2. Lapproximation en norme euclidienne avec les polynmes de Chebyshev est o souvent proche de lapproximation minimax. Ceci peut sexpliquer de la faon suivante : les c
INRIA
13
f,T e coecients ai = Ti ,Tii dcroissant rapidement, an+1 Tn+1 est une bonne approximation de f pn . Or Tn+1 (x) = cos((n + 1) cos1 x) est une fonction qui prend n + 2 fois les valeurs 1 pour 1 x 1.
4.3. Erreur relative. En prenant comme poids w(x) = |f (x)|1 , le polynme minimax o optimise la distance relative avec f , au lieu de la distance absolue avec w = 1. On obtient alors pour la fonction exponentielle sur [1, 1] avec n = 2 : p (x) = 1.027030791 + 1.113889894x + 0.4693555168x 2 , avec une erreur relative dau plus 0.040 environ : > p:=numapprox[minimax](exp(x), x=-1..1, [2,0], 1/exp(x), err): > expand(p), err; 2 1.027030791 + 1.113889894 x + 0.4693555168 x , 0.03974574998 Cependant, pour certaines fonctions comme la racine carre, les approximations polynoe miales, mme minimax, sont de pi`tre qualit. Par exemple, sur [1/4, 1], lapproximation e e e minimax de degr 10 donne une erreur de 7.0 108 , alors quune approximation ratione nelle de numrateur et dnominateur de degr 5 donne une erreur de 5.2 1012 . On utilise e e e alors des approximations rationnelles, ou on rduit la largeur de lintervalle, en utilisant par e exemple des tables de polynmes (cf. section 5). o 4.4. Approximations rationnelles. On cherche ici une fraction rationnelle de la forme r = p/q, o` p est de degr n et q de degr m. Comme on peut xer le coecient constant de u e e q a 1 par exemple , on a donc n + m + 1 coecients a xer. Le cas m = 0 correspond ` ` a une approximation polynomiale. ` Il existe dans ce cas une variante de lalgorithme de Remez, et on peut dnir lapproxie mation rationnelle minimax, qui atteint le maximum de |f r| en n + m + 2 points, avec alternance des signes. > p:=numapprox[minimax](exp(x), x=-1..1, [1,1], 1, err): > expand(p), err; 1.017021247 0.5175411565 x ------------------ + ------------------, 0.02097256305 1 - 0.4397882839 x 1 - 0.4397882839 x Un inconvnient des approximations rationnelles est quelles ncessitent une division e e nale, opration qui est souvent plus lente sur les processeurs actuels. Cependant la meilleure e prcision de ces approximations peut compenser cet inconvnient : e e
foo := proc(n) numapprox[minimax](exp(x), x=-1..1, [2*n,0], 1, e1); numapprox[minimax](exp(x), x=-1..1, [n,n], 1, e2); e1, e2 end: > foo(1); 0.04505715466, 0.02097256305 > foo(2); 0.0005471825736, 0.00008692582114 > foo(3);
RR n 5105
14
0.3213305387 10 > Digits:=12: foo(4); 0.110714404311 10
-5 -6 , 0.1553032727 10 -7 -9 , 0.162192037578 10
4.5. Approximations avec coecients xs. Un probl`me pratique des approximations e e polynomiales ou rationnelles est que les coecients donns par lalgorithme de Remez ne e sont pas en gnral reprsentables exactement en machine. Par consquent, non seulement e e e e on eectue des erreurs darrondi en valuant p(x) ou r(x), mais en plus les valeurs utilises e e des coecients de ces polynmes sont fausses ! o Une solution pour parer a ce probl`me est de dterminer de proche en proche les coe` e e cients avec lalgorithme de Remez, en les arrondissant au plus proche a chaque fois. ` Supposons par exemple quon veuille calculer un polynme dapproximation de 2x de o degr 3 sur [0, 1/8], avec des coecients sur 24 bits : e > numapprox[minimax](2^x, x=0..1/8, [3,0], 1); 0.9999999806 + (0.6931520763 + (0.2400319493 + 0.05797081006 x) x) x On dtermine alors le ottant sur 24 bits le plus proche de 0.9999999806, soit a 0 = 1. On e cherche maintenant un polynme de la forme a0 + x(a1 + a2 x + a3 x2 ), donc a1 + a2 x + a3 x2 o 2x a0 doit approcher x avec comme poids w(x) = x : > numapprox[minimax]((2^x-1)/x, x=0..1/8, [2,0], x); 0.6931507544 + (0.2400538055 + 0.05786898601 x) x Le coecient sur 24 bits le plus proche de 0.6931507544 est a1 = 2907285/222 , et ainsi de suite. ` 5. Mthodes a base de tables e Evaluer une fonction sur un grand intervalle avec une erreur borne requiert un polynme e o de grand degr, ou une fraction rationnelle avec un numrateur et un dnominateur de e e e grands degrs. Par exemple, pour lexponentielle sur [0, log 2 ], en double prcision, il faudrait e e 2 un polynme de degr 9 au moins : o e
> numapprox[minimax](exp(x), x=0..log(2)/2, 9, 1/exp(x), err): > err; -16 0.13183037374386121299 10
Une technique classique consiste a dcouper lintervalle donn en plusieurs sous-intervalles, ` e e et a utiliser sur chacun de ces sous-intervalles un polynme dirent, stock dans une table. ` o e e Par exemple, pour la fonction exponentielle, en dcoupant lintervalle [0, log 2 ] en 8 souse 2 intervalles, des polynmes de degr 6 susent pour obtenir une erreur de lordre de celle o e ci-dessus :
> numapprox[minimax](exp(x), x=0..log(2)/16, 6, 1/exp(x), err): > err; -17 0.693605083458 10
INRIA
15
On constate sur cet exemple que dcouper en deux un intervalle permet de diminuer le degr e e dune unit. e Cette mthode est dautant plus intressante avec les processeurs actuels, que la mmoire e e e est de moins en moins onreuse. David Defour a montr dans sa th`se [15] que la taille e e e optimale dune telle table ne devait pas dpasser la taille dune voie du cache, soit 4 Ko sur e les processeurs actuels. Il nest pas toujours ncessaire de stocker tous les polynmes. Par exemple, pour la fonce o tion exp(x), si les sous-intervalles sont de la forme [kh, (k + 1)h], il sut de calculer le polynme pour lintervalle [0, h] soit k = 0 et pour kh x (k + 1)h, on approche o exp(x) par exp(kh) exp(x kh), o` seul exp(kh) est tabul pour lintervalle k, et exp(x kh) u e est obtenu en se ramenant a lintervalle [0, h], puisque 0 x kh h. ` On distingue trois types de tables : les tables classiques, avec des sous-intervalles de mme longueur, dont les bornes a k sont e rguli`rement espaces. Ces tables ncessitent une prcision interne plus grande que la e e e e e prcision nale voulue. En eet, en supposant quon tabule f (ak ) dans la prcision e e nale, lerreur peut aller jusqu` 1 ulp, ce qui laisse peu despoir dobtenir une erreur a 2 1 nale borne par 2 ulp. Ces tables conviennent par exemple aux processeurs x86, en e utilisant en interne la prcision tendue (64 bits de prcision) pour une prcision nale e e e e de 53 bits (double prcision). La mthode de Tang utilise de telles tables ; e e les tables prcises , qui utilisent des points irrguli`rement espacs, en lesquels la e e e e valeur de la fonction est tr`s proche dun nombre machine. Avec un peu de soin, elles e peuvent tre implantes en faisant tous les calculs avec la prcision nale. La mthode e e e e de Gal utilise de telles tables ; enn, dautres mthodes utilisent des tables en cascade, et des oprateurs hardware e e ddis. Les algorithmes de Wong et Goto en sont un exemple. e e 5.1. Mthode de Tang. La mthode de Tang comprend 3 tapes : e e e (1) rduction : a partir du point initial x, apr`s une ventuelle rduction dargument e ` e e e (cf. section 8), on dduit un point y tel que f (x) se dduit facilement de f (y), ou de e e g(y) pour une autre fonction g ; (2) approximation : f (y), ou g(y), est approch par un polynme de petit degr ; e o e (3) reconstruction : f (x) est dduit de f (y), ou de g(y). e Voici quelques exemples. 5.1.1. La fonction exponentielle. Rduction : Tang sugg`re de mettre largument x sous la e e forme log 2 x = (32m + j) + r, 32 log 2 avec |r| j < 32 ; puis dapprocher exp(r) 1 par un polynme p(r), et enn o 64 et 0 de reconstruire exp(x) par la formule exp(x) = 2m 2j/32 (1 + p(r)).
RR n 5105
16
Largument rduit r est mis sous la forme r = r1 + r2 , o` r1 et r2 sont deux nombres e u 1 ottants double prcision tels que |r2 | e ulp(r1 ), de telle sorte que r1 + r2 approche 2 e e x(32m+j) log 2 en double-double prcision (cf. section 10.6). Pour ce faire, Tang dtermine 32 32 lentier N le plus proche de x, o` est log 2 arrondi au plus proche. On a alors j = u N mod 32 et m = (N j)/32. Les valeurs r1 et r2 sont obtenues par o` Lhi + Llo approche u Lhi ayant quelques bits de poids faible nuls, de telle sorte que N Lhi est exact, et par consquent x N Lhi lest aussi.1 e Approximation : p(r) est calcul de la faon suivante. On calcule dabord e c Q = r 2 (a1 + r(a2 + r(a3 + r(a4 + ra5 )))), o` les ai sont les coecients dune approximation minimax, puis on en dduit u e p(r) = r1 + (r2 + Q). Reconstruction : les valeurs sj = 2j/32 sont tabules pour 0 j < 32 en double-double e prcision : sj sj + sj , de sorte que les 6 bits de poids faible de sj sont nuls ; sj + sj est e hi lo hi hi lo donc une approximation a environ 100 bits de sj . On calcule : ` exp x 2m (sj + (sj + (sj p(r) + sj p(r)))). hi lo hi lo 5.2. Mthode de Gal. Cette mthode utilise des points presque rguli`rement espacs, au e e e e e contraire de celle de Tang. Soit a approcher par exemple la fonction exp x sur [1/2, 1], avec ` des approximations de 4 chires dcimaux, et 5 intervalles. e La mthode classique consiste a dcouper [1/2, 1] en 5 intervalles de mme largeur, et e ` e e a prendre les approximations de exp x au milieu de ces intervalles : exp 0.55 1.733253, ` exp 0.65 1.915541, exp 0.75 2.117000, exp 0.85 2.339647, exp 0.95 2.585710. Lerreur maximale est de 0.46 ulp (pour 0.65) si on arrondit au plus proche. La mthode de Gal consiste a chercher des nombres reprsentables sur 4 chires dcimaux, e ` e e dont lexponentielle est proche dun nombre dcimal de 4 chires. On peut trouver de tels e nombres par recherche exhaustive : l:=NULL; for x from 5000 to 10^4 do a:=evalf(exp(x/10^4), 20); b:=evalf(a, 4); if abs(a-b)<2e-6 then l := l, [x/1e4, b] fi od: l; [0.5038, 1.655], [0.5487, 1.731], [0.5579, 1.747], [0.5619, 1.754], [0.5738, 1.775], [0.6065, 1.834], [0.6195, 1.858], [0.6408, 1.898],
1Comme exp x provoque un overow pour x > log(21024 ), on a N
log 2 , 32 32 (1024 log 2) log 2 = 215 , donc on
log 2 32 ,
r1 = x N Lhi ,
r2 = N Llo ,
et les 53 bits suivants dans Llo , soit une peut stocker dans Lhi les 53 15 = 38 bits de poids fort de approximation a 91 bits (voire 92 en arrondissant Lhi au plus proche). `
INRIA
17
[0.7500, 2.117], [0.7807, 2.183], [0.7948, 2.214], [0.8211, 2.273], [0.8612, 2.366], [0.8671, 2.380], [0.8738, 2.396], [0.8817, 2.415], [0.9582, 2.607], [0.9647, 2.624], [0.9704, 2.639] Si lon prend comme points 0.5487, 0.6408, 0.7500, 0.8612, 0.9582, lerreur maximale diminue a 1.8 106 , soit 0.0018 ulp. On a gagn un facteur denviron 250 sur lerreur maximale. ` e Par exemple, pour valuer sin x pour |x| /4, Gal et Bachelis proposent lalgorithme e suivant : pour x 83/512, ils utilisent une approximation polynomiale a laide de tables ` classiques ; sinon, ils utilisent des points Xi proches de i/256, pour i 201, tels que sin Xi et cos Xi contiennent simultanment 11 zros apr`s le 53e bit. Si x Xi + z, on obtient une e e e approximation de sin x via : sin(x) sin Xi cos z + cos Xi sin z, o` sin z et cos z sont approchs par des approximations polynomiales de petit degr (4 ou u e e 5). Ils obtiennent ainsi un arrondi exact dans 99.9% des cas. Cette mthode a cependant des limitations. Si lon veut trouver un point Xi o` k fonctions e u sont simultanment a distance < 2p ulp dun nombre machine, il faut essayer de lordre de e ` 2kp points. De plus si lon veut les Xi quasi-rguli`rement espacs, il faut que 2kp ne soit e e e pas trop grand, ce qui limite la prcision p que lon peut atteindre. e 5.3. Mthode de Wong et Goto. Les mthodes vues prcdemment simplantent aussi e e e e bien en software quen hardware. La mthode de Wong et Goto, quant a elle, utilise spcie ` e quement le hardware. En loccurrence, ils se servent dun multiplieur rectangulaire 16 56, qui tronque le rsultat a 56 bits, en un peu plus de la moiti du temps quil faut pour une e ` e multiplication 53 53. Pour approcher log x, on crit e x = m2E , avec E = 1, 1 m < 2 pour E = 0, et 1/2 m < 2 pour E = 0.2 On calcule log m, auquel on ajoute E log 2. Pour approcher log m, lide de base consiste a trouver un petit entier K1 tel que K1 m 1, e ` la multiplication K1 m pouvant se faire via un multiplieur rectangulaire : log m = log(K1 m) log K1 , o` log K1 est tabul. On continue, en cherchant un petit entier K2 tel que K1 K2 m est encore u e plus proche de 1 : log m = log(K1 K2 m) log K1 log K2 . On sarrte quand K1 ...Kk m est si proche de 1 quun dveloppement de Taylor de petit e e degr (ici 3) sut. e
2On vite ainsi une possible cancellation pour E = 1 et m proche de 2. e
RR n 5105
18
Pour log x, lalgorithme propos par Wong et Goto utilise trois multiplications rectane gulaires par K1 , K2 , K3 (apr`s recherche dans une table pour chaque), une multiplication e double prcision pour le terme dordre 2 de log(K1 K2 K3 m), et une recherche en table pour e celui dordre 3. Ils obtiennent ainsi une erreur dau plus 0.5 ulp sur le format interne (56 bits), soit au plus 1 ulp apr`s larrondi nal en 53 bits. e 5.4. Tables bipartites et multipartites. Les tables bipartites et multipartites sont utilises pour stocker les approximations dune fonction f avec n bits en entre et en sortie. e e Elles sont utilises en pratique pour stocker par e exemple une approximation initiale de f (x) pour litration de Newton (par exemple, 1/x, x, ...). Comme il y a 2n sorties possibles e sur n bits, une table classique aurait une taille de lordre de n2n bits. Lide des tables bipartites est de dcouper les bits de largument x en trois parties a peu e e ` pr`s gales x0 , x1 , x2 de n/3 bits chacune, et dutiliser deux tables, lune indexe par x0 et e e e x1 , lautre par x0 et x2 . On obtient alors lapproximation voulue par t1 [x0 , x1 ] + t2 [x0 , x2 ]. Ainsi, au lieu davoir une seule table de taille n2n , on a deux tables, chacune ayant une taille de lordre de n22n/3 bits. Si on crit x = x0 + x1 + x2 , la formule de MacLaurin a lordre 2 donne : e ` (2) f (x) = f (x0 + x1 ) + x2 f (x0 + x1 ) + x2 f (), 2 f (x) f (x0 + x1 ) + x2 f (x0 ), pour [x0 + x1 , x]. Une table bipartite revient a une approximation : ` et lerreur est de lordre de 2n . En eet, le dveloppement (2) donne f (x) = f (x0 + e x1 ) + x2 f (x0 + x1 ) + O(x2 ) ; or de mme f (x0 + x1 ) = f (x0 ) + O(x1 ), do` f (x) = e u 2 f (x0 + x1 ) + x2 f (x0 ) + O(x1 x2 + x2 ). 2 Les tables multipartites sont une gnralisation des tables bipartites : au lieu de dcouper e e e en 3 parties, avec 2 tables, on dcoupe en k + 1 parties, avec k tables, et une taille totale de e lordre de kn22n/(k+1) bits. On peut aussi avoir des dcoupages dirents pour les tables t1 e e et t2 . ` 6. Mthodes a base dadditions et de dcalages e e 6.1. Une petite histoire. Au dbut du 17e si`cle, il y eut une terrible pnurie de nourrie e e ture. Le roi dcida alors dimposer une taxe sur la consommation de pain, proportionnelle a e ` lexponentielle du poids du pain ! Comment calculer rapidement cette taxe ? Un vieux mathmaticien, Briggs, trouva une solution convenable. Il dit au roi : Pour calculer la taxe, e jai besoin dune balance a plateaux, des poids et dune lime. Surpris, le roi t apporter le ` matriel a Briggs. e ` Briggs commena par limer les poids, puis demanda au roi un morceau de pain. Il pesa c le pain et trouva un poids apparent (les poids ayant t lims) gal a 0,572 kg. Puis il dit : ee e e ` Jcris 0,572 ; je remplace le 0 par un 1 ; ceci donne 1,572. Maintenant je calcule le e produit des deux premi`res dcimales (5 7), que je divise par 1000 ; ceci donne 0,035. Je e e
INRIA
19
calcule le produit de la premi`re et de la troisi`me dcimale (5 2), que je divise par 10 000 ; e e e ceci donne 0,001. Jajoute 0,035 et 0,001 a 1,572, et jobtiens lexponentielle du poids : ` 1,608. Le roi tait plutt sceptique et demanda a ses serviteurs de peser le pain (0,475 kg) et aux e o ` mathmaticiens de calculer lexponentielle. Apr`s de longs calculs, il trouv`rent le rsultat : e e e e 1,608014... Lestimation de Briggs ntait pas si mauvaise ! e Expliquons maintenant la mthode de Briggs. Les poids taient lims de faon a ce quun e e e c ` poids de x kg pesait nalement log(1 + x) kg. Par consquent, si le poids apparent tait de e e 0,x1 x2 x3 kg, le poids rel tait, en kg, de e e log 1 + dont lexponentielle est : 1+ x1 10 1+ x2 100 1+ x3 1000 1+ x2 x3 x1 x2 x1 x3 x1 + + + + . 10 100 1000 1000 10 000 x1 x2 x3 + log 1 + + log 1 + , 10 100 1000
Bien que cette histoire soit de la pure ction (elle a t invente par Xavier Merrheim pour ee e sa soutenance de th`se), Henry Briggs (1561-1631) a rellement exist et a conu les premiers e e e c algorithmes pratiques pour calculer les logarithmes ; il a publi des tables de logarithmes avec e 15 chires de prcision. e 6.2. La forme gnrale de ces algorithmes. On se restreint a des oprations tr`s e e ` e e simples : ces algorithmes sont destins a tre implments en hardware, en utilisant tr`s e ` e e e e peu de ressources. En particulier : additions, soustractions, dcalages (i.e. multiplications e par une puissance de la base), multiplications par un seul chire (triviales si la base est 2), lectures dans de tr`s petites tables. e Dans la suite, nous supposons que la base est 2. 6.3. Un premier algorithme (calcul de lexponentielle). Exposons-en dabord le principe. Lalgorithme se basera sur la proprit suivante : eu+v = eu ev (et pourra tre gnralis ee e e e e pour calculer ax ). Algorithme itratif : calculer deux suites (xk ) et (yk ) telles que yk = exk e pour tout k et la suite (xk ) converge vers x, de faon a ce que la suite (yk ) converge vers c ` y = ex . Plus prcisment : e e xk+1 yk+1 = xk ou xk + tk = yk ou yk etk
e e o` les tk et etk sont xs et tabuls. u Rappelons que le but est de nutiliser que des oprations tr`s simples. Ici, le seul proe e bl`me concerne les multiplications. Mais nous pouvons choisir les tk de mani`re a ce que e e ` ces multiplications soient tr`s simples ! Si nous choisissons etk = 1 + 2k , une multiplication e correspondra (apr`s dveloppement) a un dcalage et une addition. e e ` e
RR n 5105
20
Algorithme (tr`s proche de celui de Briggs) : calculer les suites suivantes dnies par : e e x0 y0 xk+1 yk+1 dk = = = = = 0 1 xk + log(1 + dk 2k ) = xk + dk log(1 + 2k ) yk (1 + dk 2k ) = yk + dk yk 2k 1 si xk + log(1 + 2k ) x 0 sinon.
Si (xk ) converge vers x, alors (yk ) converge vers y = ex . Mais quelles sont les valeurs de x pour lesquelles la suite (xk ) converge vers x ? Thor`me 3 (algorithme de dcomposition restaurant). Soit (wk ) une suite de rels positifs e e e e dcroissante telle que la srie k=0 wk converge vers un rel w et pour tout n, e e e wn
k=n+1
wk
(une telle suite est appele base discr`te). Alors pour tout x [0, w], les suites (x k ) et (dk ) e e dnies par e x0 = 0 xk+1 = xk + dk wk 1 si xk + wk x dk = 0 sinon vrient e x=
k=0
dk wk = lim xk .
n
Preuve : montrer par rcurrence sur n que e 0 x xn

k=n
wk
en distinguant les cas dn = 0 et dn = 1. Consquence : en admettant que la suite des log(1 + 2k ) soit une base discr`te, lalgoe e rithme calculant lexponentielle est applicable pour tout x compris entre 0 et k=0 log(1 + 2k ) 1,562. En pratique, les calculs ne sont pas faits exactement ; dautre part, on doit sarrter a une e ` certaine itration et renvoyer une valeur yn . Il y aura donc deux types derreur : des erreurs e darrondi, qui peuvent tre values de mani`re classique (il faudrait galement tenir compte e e e e e du fait quune mauvaise valeur de dk peut tre choisie), et lerreur due au reste. Cette erreur e correspond a une erreur sur x infrieure a : ` e `
k=n
log(1 + 2k )
k=n
2k = 2n+1 ,
INRIA
21
qui donne lerreur relative sur ex : ex y n = 1 exn x ex 1 e2

n+1
2n+1 ,
i.e. on obtient environ n 1 bits signicatifs, sans tenir compte des erreurs darrondi. 6.4. Calcul du logarithme. Il sut de reprendre le mme algorithme, mais en changeant e la condition sur x (dont la valeur est maintenant inconnue) en une condition sur y (dont la valeur est maintenant connue) : dk = 1 si yk (1 + 2k ) 0 sinon. y
k=0 (1
Cet algorithme permet alors de calculer x = log y pour tout y compris entre 1 et 2k ) 4,768.
6.5. CORDIC. Algorithme introduit par Volder en 1959 pour calculer des sinus, cosinus et arctangente (ainsi que des produits et des quotients), et gnralis par Walther en 1971 pour e e e calculer des logarithmes, exponentielles et racines carres. Cet algorithme a t implment e ee e e dans de nombreuses calculatrices, pour sa simplicit. e Lide de dpart, pour calculer un sinus et un cosinus (coordonnes dun point sur un e e e cercle unit), est de se rapprocher du point voulu en eectuant des rotations successives : e xk+1 yk+1 qui peut se simplier en : xk+1 yk+1 = cos(dk wk ) 1 tan(dk wk ) tan(dk wk ) 1 xk yk . = cos(dk wk ) sin(dk wk ) sin(dk wk ) cos(dk wk ) xk yk
Probl`me : on ne peut plus choisir dk = 0 ou 1 a cause du facteur cos(dk wk ). Mais si on se e ` restreint a dk valant 1 ou +1 (algorithme de dcomposition non restaurant), le probl`me ` e e est quasiment rsolu : cos(dk wk ) = cos(wk ), et on peut mettre en facteur le produit de ces e cos(wk ), qui est une constante (i.e. qui ne dpend pas des valeurs des dk , et donc de la valeur e dentre). e De mani`re a simplier le produit par les tan(wk ), nous choisissons wk = arctan 2k , ce e ` qui donne comme itration (similitude et non plus une rotation) : e xk+1 yk+1 = 1 dk 2k dk 2k 1 xk yk .
Choix de dk pour eectuer une rotation dangle : z0 zk+1 dk = = z k d k wk 1 si zk 0 = 1 sinon.
RR n 5105
22
o` les termes arctan 2k sont prcalculs et tabuls, et o` les dk sont gaux a +1 ou 1. Le u e e e u e ` rapport K de la similitude est gal a : e ` K=
k=0
En rsum, lalgorithme CORDIC e e xk+1 yk+1 zk+1
est bas sur litration e e = xk dk yk 2k = yk + dk xk 2k = zk dk arctan 2k
1 = cos(arctan 2k )
k=0
1 + 22k = 1,646760258...
Comme avec une itration, on pouvait calculer soit une exponentielle, soit un logarithme, e on a ici aussi deux modes possibles. 6.5.1. Rotation mode. Pour un angle prenons x0 = y0 = z0 = tel que || 1/K 0 =
k=0
arctan 2k = 1,743..., si nous
0,607252935...
les suites (xk ) et (yk ) convergent respectivement vers cos et sin .
6.5.3. Gnralisation par Walther. Puisque les fonctions trigonomtriques et les fonctions e e e hyperboliques sont assez semblables, il nest pas tonnant de pouvoir modier cet algorithme e pour calculer les fonctions hyperboliques. Cest ce qua fait John Walther en 1971 : xk+1 = xk m dk yk 2(k) y = yk + dk xk 2(k) k+1 zk+1 = zk dk w(k) avec :
Cependant nest pas connu initialement. Notons que zk nest utilis que pour dterminer e e dk . Mais comme le but est de ramener le point sur laxe des x par similitudes successives, nous pouvons donc remplacer la condition sur zk par : yk 0, (i.e. dk = 1 si yk 0, 1 sinon). Nous obtenons alors, en partant de z0 = 0 : 2 xk K x 2 + y 0 0 y 0 k zk arctan(y0 /x0 ).
6.5.2. Vectoring mode. Ce mode est utilis pour calculer des arctangentes, plus prcisment e e e = arctan(y0 /x0 ). Si on part de (x0 , y0 ) quelconque et que lon fait la similitude dangle z0 = (i.e. lopration inverse, en quelque sorte) et de rapport K en itrant, on obtient : e e 2 xk K x 2 + y 0 0 y 0 k zk 0.
INRIA
23
Circulaire : m = 1, wk = arctan 2k , (k) = k. xk yk zk Rotation mode K(x0 cos z0 y0 sin z0 ) K(y0 cos z0 + x0 sin z0 ) 0 Rotation mode xk x 0 yk y 0 + x 0 z0 zk 0 xk yk zk Vectoring mode 2 K x2 + y 0 0 0 z0 + arctan(y0 /x0 )
Linaire : m = 0, wk = 2k , (k) = k. e Vectoring mode xk x 0 yk 0 zk z0 y0 /x0 est le plus grand entier
Hyperbolique : m = 1, wk = tanh1 2k , (k) = k , o` u tel que 3 +1 + 2 1 2k. xk yk zk o` K = u Rotation mode K (x1 cosh z1 + y1 sinh z1 ) K (y1 cosh z1 + x1 sinh z1 ) 0 2(k) = 0,828159... k=1 1 2 xk yk zk
Vectoring mode 2 K x2 y 1 1 0 z1 tanh1 (y1 /x1 )
` A partir de ces fonctions de base, on peut calculer : ex = cosh x + sinh x log x = 2 tanh1 1 4K
2 2
x1 x+1 x 1 4K
2 2
x=K
x+
` 7. Algorithmes a convergence quadratique (Newton, Goldschmidt) 7.1. Itration de Newton. Soit f C 1 , ayant une racine simple non nulle. Considrons e e litration xn+1 = xn f (xn )/f (xn ). Si x0 est susamment proche de , alors (xn ) converge e vers , et la convergence est quadratique (la prcision double a chaque itration). e ` e 7.1.1. Application a la division. Pour calculer a/b, il sut de calculer 1/b par la mthode ` e de Newton et de multiplier le rsultat par a. On pose f (x) = 1/x b. Litration de Newton e e scrit : xn+1 = xn (2bxn ), qui converge si et seulement si x0 ]0, 2/b[. Une valeur approche e e de 1/b pour x0 peut tre obtenue en lisant dans une table a partir des premiers bits de la e ` mantisse de b.
RR n 5105
24
7.1.2. Choix des valeurs initiales pour litration de Newton. Supposons quon veuille approe cher une fonction f (x) pour x [a, b] par un nombre x a lavance ditrations de Newton. e` e Quel est le meilleur point de dpart, si lon veut minimiser lerreur maximale sur [a, b] ? Peter e Kornerup et Jean-Michel Muller [25] ont montr que pour linverse, la racine carre ou la e e racine carre inverse, on pouvait gagner jusqu` un facteur 400 avec un choix judicieux de e a valeur initiale. Par exemple, pour linverse, la meilleure valeur initiale i pour i itrations est 0 = e 1 1 2 ( a + 1 ), 1 = (ab)1/2 , = a+b . 2 b Pour la racine carre avec litration directe xn+1 = 1 (xn + y/xn ) on trouve e e 2 1 a1/4 +b1/4 0 = 2 ( a + b), et a1/4 +b1/4 . 7.2. Algorithme de Goldschmidt. Cet algorithme est implant dans lIBM 360. e On cherche a calculer a/b, avec 1/2 ` b < 1. But : chercher une suite (rn ) telle que b r0 r1 ... rn converge vers 1 le plus rapidement possible. Ainsi, a r0 r1 ... rn convergera vers a/b a la mme vitesse. ` e Le choix des rn se fait a partir de lidentit : (1 x)(1 + x) = 1 x2 . Soit = 1 b. ` e Ainsi, on part de b = 1 . On va alors prendre r0 = 1 + pour obtenir b r0 = 1 2 , n puis r1 = 1 + 2 pour obtenir b r0 r1 = 1 4 , et ainsi de suite, rn = 1 + 2 pour obtenir n+1 b r0 r1 ... rn = 1 2 . On calcule donc : = a q0 0 = 1b qn+1 = qn (1 + n ) n+1 = 2 . n Note : si dans litration de Newton, on pose n = 1 bxn , alors on a xn+1 = xn (1 + n ) e et n+1 = 1 bxn+1 = 1 bxn (2 bxn ) = 2 . n Remarque : lalgorithme de Goldschmidt converge de faon quadratique comme litration c e de Newton : chaque tape double le nombre de bits corrects. Par contre lalgorithme de e Goldschmidt nest pas auto-correcteur comme litration de Newton, cest-`-dire que pour e a obtenir n bits corrects, il faut eectuer toutes les itrations avec n bits. Cela provient du fait e que lentre b nest utilise quau dpart dans le schma de Goldschmidt, alors quelle est e e e e rintroduite a chaque itration de Newton. Pour des calculs de complexit polynomiale, la e ` e e complexit asymptotique de lalgorithme de Goldschmidt est donc plus leve dun facteur e e e log n que celle de litration de Newton. e 8. Rduction dargument e Les algorithmes vus jusqu` prsent supposent que lon cherche a valuer une fonction f a e è sur un petit intervalle. Quand largument x est dans un grand intervalle comme [1.798...10308 , 1.798...10308 ] pour les ottants double prcision il faut trouver une transe formation simple qui permette de dduire f (x) dune valeur g(x ), o` x est lui-mme dans e u e un petit intervalle (on peut avoir g = f ) ; x est appel largument rduit. Ltape de reconse e e truction consiste ensuite a retrouver f (x) en fonction de g(x ). `
INRIA
25
On distingue deux grandes classes de rduction dargument (k dsigne un entier et C une e e constante) : la rduction additive, o` x = x kC, par exemple C = /4 pour les fonctions trigoe u nomtriques, C = log 2 pour la fonction exponentielle, C = 1 pour la fonction 2x ; e la rduction multiplicative, o` x = x/C k , par exemple C = 2 ou C = e pour le e u logarithme. Exemple 1. [Rduction additive] On suppose quon sait calculer le sinus et le cosinus pour e x [/4, /4]. Pour calculer cos x pour x quelconque, on commence par dterminer k tel e que x = x k/2 [/4, /4], puis on a cos x = cos x ou sin x suivant la valeur de k mod 4. Ici la reconstruction est triviale, et nintroduit pas derreur. Exemple 2. [Rduction multiplicative] On suppose quon sait calculer le logarithme pour e x [1, e]. On commence par dterminer k tel que x = x/ek [1, e], on value log x , et e e on reconstruit log x via la formule log x = k + log x . Ici la reconstruction nest pas triviale, et peut mme engendrer un phnom`ne de cancellation pour k = 1 et x proche de e, e e e cest-`-dire x proche de 1 (cf. mthode de Wong et Goto, section 5.3). a e Pour une fonction donne, plusieurs mthodes de rduction dargument peuvent exister. e e e Par exemple, pour le logarithme, on peut aussi utiliser x = x/2k , ce qui donne log x = log x + k log 2. La rduction est plus facile (en base 2) puisquon na pas besoin de stocker e la constante e, par contre la reconstruction ncessite la constante log 2. e Il faut aussi garder a lesprit que lintervalle rel pour lequel on a besoin de rduire ` e e largument nest pas forcment tout lintervalle des nombres ottants possibles. Par exemple, e pour lexponentielle en double prcision, il y a dbordement (overow ) pour x > log(2 1024 ) e e 709.8. En pratique, la rduction multiplicative se produit uniquement pour les fonctions de type e logarithme et les racines (carre et cubique). Dans tous ces cas, on peut prendre pour C une e puissance de la base interne ( = 2 dans notre cas), et par consquent le calcul x/C k peut e se faire sans erreur. On sintresse donc dans la suite uniquement au cas de la rduction e e additive. Remarque. En gnral, largument rduit x nest pas reprsent dans le mme format que e e e e e e largument initial x. En eet, pour obtenir un arrondi correct sur f (x), en tenant compte des erreurs lors de la rduction et de la reconstruction, il faut calculer g(x ) avec une plus e grande prcision. On peut par exemple reprsenter x par deux ottants de mme prcision e e e e que x (expansion ottante) : x = hi + lo (voir section 10.6). Exemple. Un exemple classique [30] est le calcul de sin 1022 : 1022 est la plus grande puissance de 10 exactement reprsentable en double prcision, car 522 < 253 < 523 . On e e obtient sur Athlon XP avec gcc 3.2 sous Mandrake 9.0 :
#include <stdio.h> #include <stdlib.h> #include <math.h> int main (int argc, char *argv[]) {
RR n 5105
26
double x = atof (argv[1]); printf ("sin(%1.20e)=%1.20e\n", x, sin (x)); return 0; } % gcc e.c -lm ; ./a.out 10000000000000000000000.0 sin(1.00000000000000000000e+22)=4.62613040764601746169e-01
alors que la valeur exacte est :

> evalf(sin(10^22), 20); -.85220084976718880177
On peut dailleurs deviner lalgorithme utilis ci-dessus. La fonction sin de la biblioth`que e e mathmatique (plus prcisment, du processeur) a en mmoire une approximation sur 64 e e e e bits (format double prcision tendue) de , et la rduction dargument se fait par rapport e e e a cette valeur approche, et non par rapport a la valeur relle de : ` e ` e
> fpi:=approx(evalf(Pi), 64, 0); 14488038916154245685 fpi := -------------------4611686018427387904 > x:=10^22: k:=round(x/fpi); k := 3183098861837906715327 > evalf((-1)^k*sin(x-k*fpi)); .46261304076460176119008297523756774002009543800596
Le probl`me est ici une cancellation lors de la rduction dargument : 1022 contient 74 bits e e devant le point binaire, alors que x-k*fpi nen contient plus aucun. Exemple. [Cody, 1982] On peut obtenir de pires rsultats encore lorsque x k est tr`s e e petit. Au phnom`ne de cancellation sajoute le fait quon perd des bits signicatifs supple e e mentaires dans la valeur de x k. Il sut par exemple de prendre pour x le numrateur e dune rduite p/q du dveloppement en fraction continue de . On aura alors k = q, et on e e sait que |p/q | est de lordre de 1/q 2 . Par consquent |p q| est de lordre de 1/q, et e donc le nombre de bits perdus est environ log2 (pq). Le tableau ci-dessous indique pour direntes valeurs de x, lerreur en ulps eectue sur e e le calcul de sin x sur un Athlon XP, avec gcc 3.2, sous Mandrake 9.0. x 355 103993 104348 208341 312689 833719 1146408 erreur (ulps) 135 39516 79300 158330 950519 2534357 13939505 Le pire cas est obtenu pour la 29e rduite du dveloppement en fraction continue de , dont e e le numrateur est exactement reprsentable en double prcision : e e e
> Digits:=40: convert(evalf(Pi), confrac, l): l[29]; 6134899525417045 ---------------1952799169684491
et on obtient avec le mme programme C que ci-dessus : e

% ./a.out 6134899525417045.0 sin(6.13489952541704500000e+15)=-7.89815970288233026159e-06
INRIA
27
alors que le rsultat exact est 0.950 1016 ! e Nous allons voir une premi`re mthode de rduction additive due a Cody et Waite, peu e e e ` co teuse mais limite a de petits arguments, puis une mthode plus gnrale due a Payne u e ` e e e ` et Hanek. 8.1. Mthode de Cody et Waite. La mthode de Cody et Waite pour estimer x kC e e est la suivante : (1) on dcompose tout dabord C en C1 + C2 , o` C2 est petit devant C1 ; e u (2) on calcule x = x kC1 , qui est exact si le nombre de bits signicatifs de C1 plus celui de k est infrieur ou gal a la prcision courante ; e e ` e En fait, on simule ainsi le calcul de x kC avec la prcision de C1 + C2 . e Cette mthode simplante tr`s facilement, par exemple en prenant pour C1 lapproximae e tion au plus proche sur 27 bits de , et C2 lapproximation au plus proche sur 53 bits de C1 : (3) puis on calcule larrondi de x kC2 .
double cw_sin (double x) { double C1 = 3.1415926516056060791; double C2 = 0.19841871593610808504e-8; long k = rint (x / C1); double y = x - k * C1; y = y - k * C2; return (k % 2) ? -sin (y) : sin (y); }
Cela donne les rsultats suivants : e x 355 103993 104348 erreur (ulps) 0 1 1
208341 312689 833719 1146408 1 8 20 113
8.2. Calcul de pires cas avec fractions continues. Soit un nombre ottant x pour lequel on veut eectuer une rduction additive x = x kC. e Thor`me 4. Soit pi /qi une rduite du dveloppement en fraction continue dun nombre e e e e i+1 i irrationnel , pour i 2. Alors pour tout rationnel p = pi , tel que p = pi+1 , et q = qi+1 , q q q q on a : q p pi | | < | |. qi qi q Par consquent, pi /qi est la meilleure approximation de , parmi toutes les approximae tions rationnelles de dnominateur q qi . e Mettons x sous la forme x = M e avec M entier dau plus n chires en base : |M | < n . Un pire cas pour la rduction dargument est un x tel que x kC est tr`s petit, a savoir e e ` e M e proche de kC, ou encore proche du rationnel k/M . Le pire cas est donc obtenu en Ce e e ` prenant la derni`re rduite de dont le dnominateur est infrieur a n . Soit p/q cette e e C e e rduite : on a alors p/q C , soit pC q . e
RR n 5105
28
Lalgorithme ci-dessous (ici en Maple) dtermine le dnominateur q e e qmax donnant la meilleure approximation rationnelle du rel (il nest pas ncessaire de calculer le numrae e e e teur, qui se retrouve simplement par p = q avec ici = C ) :
find_worst_case := proc (alpha, qmax) local a, q, k; a := alpha; k := floor (a); q := [0, 1]; while q[2] <= qmax do a := 1 / (a - k); k := floor (a); q := [q[2], k*q[2]+q[1]]; od; q[1] end: > Digits:=20: find_worst_case (2^0/Pi, 2^10); 355 > Digits:=20: find_worst_case (2^0/Pi, 2^17); 104348
Il est facile den dduire un algorithme trouvant le ottant x = qr e le plus proche dun e multiple pC, pour une prcision n donne, et |x| < r emax (on a not ici r = ) : e e e
find_all := proc (r, n, C0, emax) local C, e, alpha, qmax, d, dmin, p, q, qmin; C := evalf (C0); qmax := r^n; alpha := 1/C/qmax; dmin := infinity; for e from -n+1 to emax-n do alpha:=alpha*r; q:=find_worst_case (alpha, qmax); p:=round(q * alpha); d:=abs(q*rê - p*C); if d < dmin then dmin := d; qmin:=q, e fi od; evalf(dmin, 3), qmin end: > Digits:=60: find_all (2, 24, Pi/2, 127); -8 .161 10 , 16367173, 72 > C:=Pi/2: x:=16367173*2^72: p:=round(x/C): evalf(x-p*C); -8 .16147697982476211883054 10
Thor`me 5. Les pires cas pour |q p| sont obtenus exactement pour les rduites p/q du e e e dveloppement en fractions continues de . Par contre une telle rduite donne un pire cas e e de | p/q|, mais pas rciproquement. e
> dmin := infinity: > for q to 1000 do p := round(q*Pi);
Par exemple, 13/4 est un pire cas pour la distance p/q, mais pas pour q p :
INRIA
29
d := abs(evalf(p-q*Pi)); if d<dmin then dmin:=d; lprint(p/q, d) fi od: 3, .141592654 22/7, .885142e-2 333/106, .88213e-2 355/113, .301e-4 > dmin := infinity: > for q to 1000 do p := round(q*Pi); d := abs(evalf(p/q-Pi)); if d<dmin then dmin:=d; lprint(p/q, d) fi od: 3, .141592654 13/4, .108407346 16/5, .58407346e-1 19/6, .25074013e-1 22/7, .1264489e-2 179/57, .1241777e-2 201/64, .967654e-3 223/71, .747584e-3 245/78, .567013e-3 267/85, .416183e-3 289/92, .288306e-3 311/99, .178513e-3 333/106, .83220e-4 355/113, .266e-6
avec X entier de n bits, 2n1 X < 2n . En supposant 1 C < 2, on a 1/2 < 1/C 1, et on veut les bits dexposant 1 a n de x/C, cest-`-dire les bits dexposant e 1 a e n ` a ` de X/C. Dcomposons 1/C de la faon suivante : e c 1/C = C0 2e + C1 2e2n + C2 2e2n ,
8.3. Mthode de Payne et Hanek. On suppose toujours quon veut eectuer une re e duction additive de la forme x = x kC. On a donc k = x/C , puis x = C(x/C k). Supposons maintenant que lon dispose dune fonction g(y) calculant f (Cy). Il sut donc de dterminer y = frac(x/C), puis dvaluer g(y ). A priori si x vaut de lordre de 2e , C e e est proche de 1, et que lon veut n bits signicatifs de y , il faut considrer e + n bits de x e et de 1/C. Lide de base est quon na pas besoin de calculer les bits de poids fort de x/C, puisquon e ne sintresse qu` la partie fractionnaire. e a Supposons x = X 2e
RR n 5105
30
avec C0 et C1 entiers, et |C2 | < 1. Alors XC0 2e est multiple entier de 2e , donc nintervient pas dans frac(x/C). De mme, XC2 2e2n est born par 2en , donc nintervient pas dans e e les bits dexposant e 1 a e n de X/C. Il reste donc a considrer seulement le produit ` ` e XC1 , o` X a n bits signicatifs, et C1 de lordre de 2n bits signicatifs. La partie intressante u e pour les bits dexposant 1 a n de x/C consiste en les n bits du milieu de ce produit ` n (2n), aussi appel produit mdian [20]. e e 9. Arrondi final 9.1. Arrondi dune valeur (exacte). Supposons que lon veuille arrondir une valeur y (non entache derreur), de mantisse 1.b1 b2 b3 ... (canonique, i.e. o` le nombre de bits nuls e u est inni) dans un syst`me a virgule ottante avec n bits de mantisse. Larrondi exact de e ` y peut se dnir comme suit, suivant le mode darrondi actif et les valeurs des bits r = bn e (appel round bit, ou bit darrondi ) et s = bn+1 bn+2 ... (appel sticky bit). e e r 0 0 1 1 / / / / / s 0 1 0 1 vers 0 vers + + + au plus pr`s e /+ +
Un dans le tableau ci-dessus signie que la mantisse de larrondi est 1.b1 b2 ...bn1 , et un + signie que lon doit ajouter 21n a cette mantisse (ce qui peut ncessiter un changement ` e dexposant, ou mme provoquer un overow si le nombre obtenu nest pas reprsentable). e e La case / + dans le cas r = 1, s = 0 pour larrondi au plus pr`s correspond a la r`gle de e ` e larrondi pair (section 2.2). 9.2. Le dilemme du fabricant de tables. Considrons maintenant le cas de lvaluation e e dune fonction mathmatique f quelconque (exp, log, sin, etc.) en un point x (nombre e machine). On cherche a arrondir exactement y = f (x) dans le mode darrondi actif. ` Si on se xe une erreur maximale > 0, on sait calculer y a pr`s. Notons y cette valeur ` e approche de y. On sait galement arrondir exactement y . Mais obtient-on ainsi toujours le e e mme rsultat que si on avait arrondi y ? e e Exemple dans le cas de larrondi au plus pr`s : e
valeur exacte y ?
arrondi x k+1 ou x k+2 ?
Ik xk
Ik+1 xk+1
valeur calcule
Ik+2
Ik+3 xk+3
xk+2
nombres machine
INRIA
31
Dans cet exemple, la valeur exacte y peut se situer dun ct ou de lautre de la fronti`re oe e entre les deux arrondis vers xk+1 (intervalle Ik+1 ) et vers xk+2 (intervalle Ik+2 ). On ne peut donc pas dcider de larrondi exact (qui est soit xk+1 , soit xk+2 ). e Reprenons le cas gnral... Notons la distance entre y et la plus proche fronti`re entre e e e deux arrondis (ces fronti`res sont les nombres machine dans le cas dun arrondi dirig, et e e les milieux de deux nombres machine conscutifs dans le cas de larrondi au plus pr`s). Si e e , il est impossible de garantir larrondi exact. Ce probl`me est connu sous le nom de e dilemme du fabricant de tables (en anglais, Table Makers Dilemma TMD), car il sest pos a lorigine (en base 10) aux diteurs de tables de valeurs numriques. e` e e En base 2, le probl`me sexprime de la faon suivante : si y est calcule avec une erreur de e c e 2m sur sa mantisse, alors larrondi exact ne pourra pas toujours tre garanti si la mantisse e de y est de la forme : en arrondi au plus pr`s, e
m bits m bits
1.xxxxx...xxx 100000...0000 xxx... ou

n bits
1.xxxxx...xxx 011111...1111 xxx...

n bits
avec les autres modes darrondi (arrondi dirig ), e

m bits m bits
1.xxxxx...xxx 000000...0000 xxx... ou

n bits
1.xxxxx...xxx 111111...1111 xxx...

n bits
Attention, il sagit ici dune condition sur la valeur exacte y (donc indpendante de lale gorithme de calcul) et non plus sur la valeur approche y ! e 9.3. Etude probabiliste. Nous pouvons faire les hypoth`ses probabilistes suivantes : e quand x est un nombre machine, les bits de f (x) apr`s la n-i`me position peuvent tre e e e vus comme des suites alatoires de 0 et de 1, 0 et 1 tant quiprobables ; e e e ces suites peuvent tre considres indpendantes pour deux nombres machine e ee e dirents. e Note : ces hypoth`ses probabilistes ne sont pas valables dans certains domaines, par e exemple pour sin x avec x susamment proche de 0. Mais ce sont aussi des cas o` la fonction u peut tre calcule simplement et le TMD peut tre facilement rsolu. e e e e Alors la probabilit pour que k bits donns soient identiques est de 21k . La probabilit e e e pour que le TMD se produise diminue donc rapidement avec la prcision. En particulier, e puisquil y a de lordre de 2n nombres machine (le nombre dexposants possibles de x tant e relativement faible, si on ignore les cas particuliers, comme pour exp x avec x susamment grand, qui donne un overow), pour un calcul intermdiaire avec un peu plus de 2n bits de e prcision, il y a de grandes chances pour que le TMD ne se produise jamais. e 9.4. La stratgie en peau doignon de Ziv. Evaluer directement f (x) a grande prcision e ` e (pour viter que le TMD ne se produise) prendrait beaucoup de temps. La mthode de e e Ziv permet dobtenir un temps de calcul moyen raisonnable, sensiblement suprieur a celui e ` ncessaire pour obtenir un rsultat a 1 ulp pr`s. Elle consiste a valuer f (x), a laide dune e e ` e è `
RR n 5105
32
mthode classique (cf. sections prcdentes), avec tout dabord une prcision intermdiaire e e e e e m un peu plus grande que n (prcision cible), et en cas dchec, prendre une valeur de m plus e e grande, et ainsi de suite. Par exemple, on peut commencer avec m = n + 20 ; la probabilit e pour que le TMD se produise et quon ne puisse pas garantir larrondi exact a cette tape ` e est tr`s faible : environ une chance sur 500 000. Dans ce cas, on peut alors rvaluer f (x) e ee avec m = n + 40. La probabilit dchec est encore tr`s faible : environ une chance sur un e e e million (une chance sur 500 milliards en cumulant). Et ainsi de suite... Cette stratgie est e illustre gure 1. e
m = n+20 chec succs m = n+40 m = 2n

rsultat arrondi
m=?
Fig. 1. La stratgie en peau doignon de Ziv. e Question : jusqu` quelle valeur de m peut-on aller ? Les hypoth`ses probabilistes suga e g`rent une valeur un peu suprieure a 2n. Mais peut-on le prouver ? e e ` 9.5. Etude mathmatique. Lindemann a montr en 1882 [4] que lexponentielle dun e e nombre algbrique non nul nest pas algbrique. Or les nombres machine sont algbriques e e e (car rationnels). Par consquent, exp x, sin x, cos x, arctan x pour x = 0, et log x pour x = 1 e ne peuvent pas avoir une innit de 0 ou 1 conscutifs dans leur criture binaire. e e e Donc pour tout x (hors cas particulier), il existe une valeur mx a partir de laquelle le ` TMD ne peut pas se produire. Comme les nombres machine de format x sont en nombre e ni, il existe une valeur de m a partir de laquelle pour tout x, le TMD ne peut pas se ` produire. Nous savons maintenant quil existe une borne nie sur m, mais nous ne savons toujours pas quelle est cette borne.
INRIA
33
Le meilleur rsultat actuellement connu en thorie des nombres est un thor`me de Nese e e e terenko et Waldschmidt [29], qui donne un minorant de la valeur de e + | |, o` u et sont des nombres algbriques, et un nombre complexe non nul arbitraire. e Ce thor`me permet dobtenir des bornes sur m pour exp et log, mais aussi pour les fonce e tions trigonomtriques et hyperboliques. Malheureusement, comme on pouvait sy attendre, e ces bornes sont tr`s grandes : de plusieurs millions a plusieurs milliards, suivant la fonction e ` et le domaine considrs. Mme si de tels calculs sont faisables sur les machines de bureau ee e daujourdhui, ils prendraient beaucoup de temps et beaucoup de mmoire. e La seule solution actuelle pour obtenir des bornes raisonnables, de lordre de celles pre vues par les hypoth`ses probabilistes (en fait, les vritables bornes) est deectuer des tests e e exhaustifs, une fois pour toutes. 9.6. Recherche exhaustive de pires cas. 9.6.1. Introduction. Nous ne sommes pas uniquement intresss par la plus grande valeur e e de m pour laquelle le TMD peut se produire. En eet, il est possible que pour certaines fonctions, cette valeur maximale m0 soit tr`s grande a cause dun certain argument x0 , e ` appel pire cas, mais qu` part cet argument, les valeurs de m pour lesquelles le TMD se e a produit sont beaucoup plus petites. Dans ce cas, il sera facile de traiter le pire cas lors de la conception de lalgorithme de calcul de la fonction f (avec arrondi exact), et les calculs pourront se faire a une prcision plus petite que m0 . De mme, il est intressant de trouver ` e e e tout un ensemble de pires cas (arguments x pour lesquels le TMD se produit, m tant x), e e qui pourront tre traits rapidement lors du calcul de f (x), a laide de tables construites lors e e ` de la conception de lalgorithme. Connaissant lordre de grandeur du nombre de pires cas que lon souhaite obtenir, la valeur de m peut tre xe a laide des hypoth`ses probabilistes. Par exemple, si on souhaite e e ` e tester 2r arguments et que lon veuille de lordre de 2p pires cas, on xera m = n + 2 + r p. Supposons que lon veuille tester tous les arguments ayant un signe et un exposant xs. e Il y a 2n1 mantisses possibles, donc 2n1 arguments a tester. Si on veut savoir si le TMD se ` produit pour m bits de prcision, il faudra calculer la mantisse du rsultat avec une erreur e e dau plus 2m . Evaluons le temps total des tests a laide des algorithmes classiques de calcul ` de fonctions, en supposant que n = 53 (double prcision), m 90, que les calculs se font sur e une machine a 3 GHz et demandent 200 cycles dhorloge par argument. Il faudra environ : ` 252 200 jours 3475 jours, 3 109 86400
soit 9 ans et demi ! Et ceci, a multiplier par le nombre dexposants (plusieurs dizaines ou ` centaines) et de fonctions a tester. ` La solution : concevoir des algorithmes tr`s rapides en tenant compte des spcicits du e e e probl`me (en particulier, les nombres machine sont espacs rguli`rement). Les tests sont e e e e eectus en deux tapes : e e (1) Filtre : algorithme tr`s rapide (basse prcision) qui slectionne un ensemble S contee e e nant tous les pires cas, mais bien plus petit que lensemble de dpart. e
RR n 5105
34
(2) On teste ensuite chaque nombre machine de S avec un algorithme plus prcis, mais e qui peut tre beaucoup plus lent. e Le tout peut tre paralllis. e e e Note : au lieu deectuer des tests a la fois sur la fonction f et la rciproque f 1 , on ` e peut obtenir les rsultats sur ces deux fonctions simultanment en nen testant quune seule e e en prcision n + 1 (et seulement en arrondi dirig, i.e. le bit darrondi doit tre le mme e e e e que les bits suivants) au lieu de n ; on pourrait penser que cela ne sert a rien, puisque le ` nombre darguments a tester double, mais en choisissant la fonction ayant la plus forte pente ` relative, ou en considrant des algorithmes de test a complexit sous-linaire, on y gagne. e ` e e 9.6.2. Calcul des valeurs successives dun polynme. On peut calculer les valeurs successives o dun polynme de degr d a laide de seulement d additions par valeur (gure 2). Avantages : o e ` cette mthode est rapide et on peut faire les calculs modulo 2n (seuls les bits situs apr`s e e e la mantisse nous intressent). e
0 1
1 7 6 6
8 19 12 6 0
27 37 18 6 0
64 61 24 6 0
125 91 30
216
Fig. 2. Table des dirences de P (X) = X 3 , permettant de calculer les e valeurs successives P (0), P (1), P (2), P (3), etc. 9.6.3. Approximations hirarchiques. Pour que la mthode dcrite prcdemment soit rae e e e e pide, il est prfrable que le degr d soit petit (ceci sera aussi ncessaire par la suite, pour ee e e dautres algorithmes, mentionns dans les sections suivantes) ; mais plus le degr est pee e tit, plus lintervalle dans lequel lapproximation a une erreur infrieure a une valeur xe e ` e est petit, ce qui signie quil faudra calculer beaucoup dapproximations. Pour gagner du temps sur ces approximations, une solution est de les faire hirarchiquement. Un exemple, e gnralisable, est donn gure 3. e e e 9.6.4. Minoration de la distance dun segment de droite a Z2 . On peut tenir compte du fait ` quen gnral, il ny a pas de pire cas dans un petit intervalle test : une minoration de la e e e distance entre les valeurs f (x) et les nombres machine sut alors. Lorsque le degr d du e polynme est gal a 1 (i.e. on passe dun point au suivant en ajoutant une constante), on o e `
INRIA
35
deg 2 deg 2 deg 2 deg 2 deg 2 deg 2 deg 2 deg 2
deg 1 deg 1 deg 1 deg 1 deg 1
Fig. 3. Approximations hirarchiques dune fonction f par des polynmes. e o peut trouver une telle minoration rapidement, avec la mme complexit que lalgorithme e e dEuclide. Ajouter une constante modulo 2n revient a faire une rotation dun angle constant ` sur un cercle. Si on construit ainsi des points x0 , x1 , x2 , ..., xk sur un cercle, alors a tout ` moment, langle entre deux points voisins sur le cercle peut prendre au plus 3 valeurs possibles (thor`me des trois distances). Ces valeurs dpendent de k et . De plus, il y a une innit de e e e e valeurs de k pour lesquelles langle ne prend que 2 valeurs possibles. Lalgorithme suivant [26] se base sur ces congurations pour calculer une minoration de {b ax}, o` x 0, N 1 . u
Initialisation : x = {a} ; y = 1 {a} ; d = {b} ; u = v = 1; Boucle innie : si (d < x) tant que (x < y) si (u + v N ) n y = y x; u = u + v; si (u + v N ) n x = x y; v = v + u; sinon d = d x; tant que (y < x) si (u + v N ) n x = x y; v = v + u; si (u + v N ) n y = y x; u = u + v; Valeur de retour : d Notez la ressemblance avec lalgorithme dEuclide... Une modication de cet algorithme permet galement de trouver les pires cas (et non plus e seulement une minoration).
RR n 5105
B A ! 9 7 C@#80 (65121) ('" $# % 4 " 0 3 0 % & % " !
polynme de degr 2
deg 1 deg 1
polynme de degr
(grand)
deg 2 deg 2
fonction
sur un intervalle
36
9.6.5. Algorithme SLZ. Et quen est-il des degrs suprieurs a 1 ? On a aussi un algorithme e e ` sous-linaire [36], en O(N (d+1)/(2d+1)+ ), bas sur les travaux de Coppersmith, utilisant e e lalgorithme LLL de rduction des rseaux. Note : le cas d = 1 correspond a lalgorithme de e e ` Lef`vre, mais lalgorithme donn ci-dessus est bien plus rapide que la forme gnrale de SLZ e e e e pour d = 1. Lide est la suivante. Coppersmith utilise lalgorithme LLL pour calculer rapidement e les petites racines dun polynme multivari modulo un entier A. Nous pouvons ici choisir o e Q(x, y) = P (x) + y. Dans notre probl`me, les valeurs de x et de y sont bornes par la taille e e de lintervalle et par le choix de m respectivement. 9.6.6. Rsultats apr`s plusieurs mois de calculs. Voici deux exemples de pires cas trouvs e e e par tests exhaustifs. Pour x = .011111111001110110011101110011100111010000111101101101, sin x vaut : .011110100110010101000001110011000011000100011010010101 1 1111...1111 00...
65 bits
ce qui donne m = 53 + 1 + 65 = 119 pour les modes darrondi dirig. e Pour x = 1.1110000100101101011001100111010001001111111110000001 2 429 , log10 x vaut : 10000001.011010100111101010011011100101001111001000100 1 0000...0000 10...
68 bits
ce qui donne m = 53 + 1 + 68 = 122 pour le mode darrondi au plus pr`s. e 10. Calcul exact avec des nombres flottants Larrondi exact permet de prouver des proprits lies au syst`me a virgule ottante et ee e e ` de concevoir des algorithmes permettant de faire du calcul exact en utilisant les ottants comme briques de base. On consid`re ici un syst`me en base 2, avec p bits de mantisse, en e e reprsentation signe-magnitude, avec arrondi exact au plus pr`s, mme si certains rsultats e e e e sont gnralisables dans toute base ou dans des syst`mes plus gnraux. e e e e e Note : certains calculs ne donnent pas le bon rsultat sous certaines conditions spciales e e (overow, underow, passage aux dnormaliss). Ces conditions ne seront pas toujours done e nes dans la suite, le but de ce document tant essentiellement la connaissance des diverses e e techniques utilises. e On note , et laddition, la soustraction et la multiplication dans le syst`me ottant e (i.e. avec un rsultat arrondi). e 10.1. Thor`me de Sterbenz. Ce thor`me est un exemple de nombreuses proprits e e e e ee lmentaires que lon peut prouver sur des syst`mes ottants. Ce thor`me est valable dans ee e e e nimporte quelle base , a condition que le syst`me supporte les dnormaliss (ou quil ne ` e e e se produise pas dunderow ). Thor`me 6 (Sterbenz). Si x et y sont deux ottants vriant y/2 e e e x mani`re quivalente x/2 y 2x), alors x y est exactement reprsentable. e e e 2y (ou de
INRIA
37
Preuve. Si x = 0 ou y = 0, alors x = y = 0 et x y = 0 est reprsentable. De mme si e e x = y. Supposons maintenant que x > y. Alors x y 2y y = y. Lexposant de x y est donc infrieur ou gal a celui de y (en particulier, il ne peut pas y avoir doverow ) ; donc si e e ` u dnote lexposant du bit de poids faible (ulp) dun ottant, alors u(x y) u(y). Dautre e part, lexposant du dernier bit 1 de x y est suprieur ou gal a u(y), donc suprieur ou e e ` e gal a u(x y). La borne u(y), resp. u(x y), assure que x y est reprsentable si cest un e ` e dnormalis, resp. normalis. Si x < y, la preuve reste la mme par symtrie. e e e e e Note : il existe des gnralisations de ce thor`me pour des syst`mes ottants exotiques e e e e e [5]. Consquence sur un syst`me avec arrondi exact : puisque larrondi dun ottant est ce e e ottant, la soustraction est exacte. 10.2. Dcoupage dun ottant en deux. Une des oprations lmentaires est le dcoue e ee e page dun ottant en deux : une partie haute et une partie basse (de mme taille ou non). e La mani`re de le faire prcisment dpend du contexte, mais lide gnrale est de gnrer, e e e e e e e e e a partir du ottant initial, un ottant ayant un plus gros exposant (de faon a perdre des ` c ` chires de poids faible), puis de faire lopration inverse exacte, qui donnerait 0 sil ny avait e pas darrondi ; mais a cause de larrondi de la premi`re opration, on obtient la partie de ` e e poids fort. La partie de poids faible sobtient en soustrayant cette partie du ottant initial. Deux exemples sont donns ci-dessous. e 10.2.1. Dcoupage sur une position absolue. Cette mthode est utilise quand on veut dcoue e e e per le ottant au niveau dun exposant x. Si s est un entier et x est un ottant normalis e e positif infrieur a 2s : e ` y = x 2s xh = y 2 s x = x xh Lexposant de y tant s, lulp de y a pour exposant s p + 1. La deuxi`me opration se e e e fait exactement et on obtient les bits de x de poids suprieur ou gal a 2sp+1 . La troisi`me e e ` e opration se fait aussi exactement, et on obtient les bits de x de poids infrieur ou gal a e e e ` 2sp . Cette mthode telle quelle ne fonctionne plus aussi bien si le signe de x nest pas connu, e car y aurait un exposant s pour x positif et un exposant infrieur a s pour x ngatif. Une e ` e solution : remplacer 2s par 3 2s1 par exemple... 10.2.2. Dcoupage sur une position relative. Cette mthode est utilise quand on na pas e e e de connaissance particuli`re sur les exposants : on veut simplement dcouper un ottant en e e deux parties de taille xe. Pour s entier positif : e x xh x = x (2s + 1) = (x x ) x = x xh
Ici, xh reoit les n s bits de poids fort de x, et xl les s bits de poids faible. c
RR n 5105
38
Justication rapide : supposons x entier pour simplier, cest-`-dire ulp(x) = a 1. Soit x = h2s + l, avec h, l entiers, |l| < 2s . Alors x(2s + 1) = (x + h)2s + l. Supposons que larrondi est x = (x + h)2s , alors x x = l x2s sarrondit en x2s , et apr`s ajout de x on obtient h2s . e 10.3. Application ` limplmentation de la fonction rint. La fonction rint arrondit a e un ottant x en un entier dans le mode darrondi courant. On suppose quon est en double prcision, et on dnit TWO52 comme tant 252 . e e e if (fabs (x) < TWO52) { if (x > 0.0) { x += TWO52; x -= TWO52; if (x == 0.0) x = 0.0; } else if (x < 0.0) { x -= TWO52; x += TWO52; if (x == 0.0) x = -0.0; } } return x; 10.4. Algorithmes TwoSum et FastTwoSum. Lalgorithme suivant [24] permet de calculer lerreur e2 sur une somme x + y arrondie (s). Algorithme TwoSum s = xy t = x s e1 = y t u = st v = x u e2 = e 1 + v Mais si |x| |y|, alors cette erreur est donne par e1 [17], ce qui fait gagner 3 oprations. e e En fait, il sut que lexposant de x soit suprieur ou gal a lexposant de y [14], ou bien que e e ` le poids du dernier bit 1 de x soit suprieur ou gal a lulp de y [11]. e e `
INRIA
39
Algorithme FastTwoSum s = xy t = x s e1 = y t Note : en base 10, FastTwoSum ne fonctionne pas toujours ; par exemple, avec une pre cision de p = 3 chires, pour x = 998 et y = 997 : s t e1 au lieu de 5. = 998 997 = (1995) = 2000 = 998 2000 = (1002) = 1000 = 997 1000 = (3) = 3
10.5. Algorithme de Dekker (multiplication exacte). Lalgorithme de Dekker permet de calculer xy exactement : il renvoie le rsultat arrondi rh = x y et le terme derreur e r = xy x y. Soit s = p/2 . Par exemple, pour la double prcision (p = 53), s = 27. e x xh x y yh y rh r = x (2s + 1) = (x x ) x = x xh = y (2s + 1) = (y y ) y = y yh = xy = (((xh yh rh ) xh y ) x yh ) x y
En rsum, cet algorithme fonctionne de la mani`re suivante : la premi`re tape consiste e e e e e a dcouper x et y en deux ottants de taille moiti (une partie de linformation se trouve ` e e dans le signe, grce a larrondi au plus pr`s). Ensuite, on part du rsultat arrondi r h , et on a ` e e enl`ve le rsultat exact, form a partir des 4 sous-produits (exacts), par une succession de e e e` soustractions (ou additions) exactes. 10.6. Expansions de nombres ottants. Une expansion de nombres ottants est une reprsentation dun ottant en multiprcision a laide dune somme de nombres ottants dun e e ` syst`me a prcision xe, avec quelques contraintes. Cette reprsentation a t introduite par e ` e e e ee T. J. Dekker [17], et tudie par [31], J. R. Shewchuk [35], M. Daumas et C. Finot-Moreau e e [12, 13] (cette partie est principalement base sur la th`se de cette derni`re [18]). e e e Plus prcisment, une expansion de nombres ottants est la reprsentation dun nombre e e e x par un n-uplet (x0 , x1 , ..., xn1 ) de nombres ottants tels que : (1) x est gal a la somme exacte des xi ; e ` (2) les composantes xi non nulles sont tries par ordre dcroissant de valeur absolue ; e e (3) les composantes xi non nulles ne se recouvrent pas : xi et xi+1 ne doivent pas avoir de bits signicatifs de mme poids. e
RR n 5105
40
Certaines contraintes peuvent tre relches. Par exemple, on peut autoriser deux come a e posantes conscutives a se recouvrir partiellement (mais pas xi et xi+2 ) ; on parle de pseudoe ` expansions. De telles reprsentations conviennent mieux pour le calcul en ligne. e 10.6.1. Addition dexpansions. Laddition dexpansions de nombres ottants peut se faire intuitivement a laide de FastTwoSum, en additionnant soit les deux composantes de poids ` fort, soit les deux composantes de poids faible, parmi celles des arguments et rsultats intere mdiaires. La version poids faible en tte produit bien une expansion, mais avec beaucoup e e de composantes : le rsultat aurait besoin dtre normalis. La version poids fort en tte ne e e e e produit pas une expansion, car certaines composantes du rsultat peuvent se recouvrir. e 10.6.2. Addition de pseudo-expansions. Ladditionneur se base sur un oprateur 3 prenant e trois ottants en entre et sortant une pseudo-expansion de taille au plus 3 (il sagit en e quelque sorte dune gnralisation de FastTwoSum a 3 entres et 3 sorties). Cet oprateur e e ` e e utilise un accumulateur contenant deux composantes. Les composantes des deux arguments sont tries poids fort en tte et fournies une par une a 3 (les deux autres entres provenant e e ` e de laccumulateur). La composante de poids fort produite par 3 sera la composante suivante du rsultat nal et les deux autres composantes forment laccumulateur. e 10.6.3. Oprateur 3 . Si a, b et c sont tris par exposant dcroissant, alors lalgorithme e e e suivant calcule une pseudo-expansion de longueur 3. (u, v) = FastTwoSum(b, c) (a , w) = FastTwoSum(a, u) (b , c ) = FastTwoSum(w, v) 10.6.4. Multiplication. Pour eectuer une multiplication de pseudo-expansions, lide est la e suivante : les produits partiels sont calculs comme dans lalgorithme de Dekker ; e ces produits partiels sont tris par ordre dcroissant dexposant (de mani`re similaire e e e a laddition) ; ` les produits partiels sont additionns par 3 (comme dans laddition de pseudo-expane sions) ou par un oprateur 5 . e 10.7. Multiplication en multiprcision base sur les ottants. Une autre faon de e e c faire de la multiprcision avec les ottants comme briques de base est dcrire les nombres e e dans une grande base, chaque ottant reprsentant un chire (entier). Par exemple, les e ottants en double prcision peuvent stocker des chires dans la base 250 , les trois bits e supplmentaires pouvant servir a accumuler des retenues (ainsi on a en quelque sorte une e ` reprsentation redondante). e Voici un exemple de code de multiplication (avec accumulation, i.e. calcul de xy, que lon ajoute a la valeur courante de z). Dans les commentaires, la notation [E:N1|N2|...|Nk] ` reprsente lensemble suivant : e
k
2EBQ
i=1
2Ni , 2Ni
INRIA
41
#define #define #define #define #define #define #define #define
BQ 25 SRB (1<<BQ) ROUND(x,c) ((x + c) - c) C0 6755399441055744.0 /* 3*2^51 */ C1 (C0 * SRB) C2 (C1 * SRB) CR (1.0 / SRB) CS (CR / SRB)
void mac(double *z, double *x, double *y, int n) { int i, j; double xx[2*MAXN]; assert(n <= MAXN); for (i = 0; i < n; i++) { double x0, x1; /* splits the digits of x */
x0 = x[i]; x1 = ROUND(x0,C1); x0 -= x1; xx[2*i] = x0; xx[2*i+1] = x1; } for (j = 0; j < n; j++) { double *p; double y0, y1, z1 = 0.0; p = z + j; y0 = y[j]; y1 = ROUND(y0,C1); y0 -= y1; for (i = 0; i < n; i++) { double x0, x1, z0, zr; x0 = xx[2*i]; x1 = xx[2*i+1]; z0 = x0*y1 + x1*y0; zr = ROUND(z0,C2); z0 = z1 + (z0-zr) + x0*y0 + *p; z1 = x1*y1 + zr; zr = ROUND(z0,C2);
/*
z1: [0:2BQ|BQ+2]
*/ */ */ */ */ */ */ */
/* x0,y0: [0:BQ] /* x1,y1: [1:BQ] /* z0: [1:2BQ+1] /* zr: [2:BQ+1] /* z0: [0:2BQ+3] /* z1: [2:2BQ|BQ+1] /* zr: [2:3]
RR n 5105
42
*p++ = z0-zr; z1 = (z1+zr) * CS; } while (z1 != 0) { double z0; z0 = z1 + *p; z1 = ROUND(z0,C2); *p++ = z0-z1; } } }
/* z0-zr: [0:2BQ] /* z1: [0:2BQ|BQ+2]
*/ */
/*
z1: [0:2BQ|BQ+2]
*/ */ */ */
/* z0: [0:2BQ+2] /* z1: [2:2] /* z0-z1: [0:2BQ]
11. Calcul en prcision arbitraire e Quand on travaille en prcision arbitraire, certains algorithmes vus en prcision xe ne e e sont plus adapts. Par exemple, les mthodes a base de tables ne sont plus utilisables, e e ` puisque ces tables dpendent de la prcision requise, et on ne peut pas calculer des tables e e de taille quelconque. Les approximations minimax ne sont plus utilisables non plus, car elles sont relativement co teuses : si on les calculait a la vole, le gain par rapport a un u ` e ` simple dveloppement de Taylor serait sans doute nul. Il faut donc repenser la plupart des e algorithmes. Cette section dcrit bri`vement les principaux algorithmes utiliss en prcision e e e e arbitraire. 11.1. Dveloppements de Taylor ou asymptotiques. Les dveloppements de Taylor ne e e sont pas les meilleures approximations a degr x (cf. approximations minimax), mais ils ` e e orent lavantage de la simplicit : seules des additions et des multiplications sont ncessaires. e e De plus pour la plupart des fonctions, les dveloppements de Taylor en 0 sont connus de e mani`re formelle [1]. e Prenons lexemple de la fonction derreur, dnie par e x 2 2 erf x = et dt. 0 Un dveloppement a lorigine de la fonction derreur est le suivant : e ` 2 erf x =
i=0
(1)i x2i+1 . i!(2i + 1)
Le principe gnral de lvaluation par srie formelle (de Taylor ou dveloppement asympe e e e e totique a linni) dune fonction f en un point x est le suivant : ` (1) pour k x, dterminer une borne Rk sur lerreur commise en sommant la srie e e e jusqu` lordre k ; a (2) en fonction de la prcision relative voulue n, et ventuellement du point x, dterminer e e e une bonne valeur de k ;
INRIA
43
(3) valuer une approximation Sk de la srie jusqu` lordre k, une borne k sur lerreur e e a darrondi sur Sk , et dterminer si Sk , en tenant compte des erreurs Rk et k , permet e de dterminer larrondi correct de f (x) ; e (4) sinon, augmenter k et la prcision, et retourner a ltape (3). e ` e Rk est lerreur mathmatique ; elle ne dpend pas de la mthode choisie pour sommer e e e la srie a ltape (3). k est lerreur darrondi ; elle dpend au contraire fortement de la e ` e e mthode choisie pour sommer la srie. e e Pour la fonction erf, la srie tant alterne et dcroissante en valeur absolue pour k x 2 , e e e e la somme de k + 1 a linni est borne valeur absolue par son premier terme, et on a ` e en donc, en utilisant le fait que k! (k/e)k 2k, et k x2 : Rk |x|2k+3 (k + 1)!(2k + 3) 1 5 x2 e k
k
Si on veut Rk 2n , on voit quil sut de prendre k lentier immdiatement suprieur a la e e ` solution de k log2 xke = n. 2 Remarque. Cette solution sexprime aussi symboliquement a laide de la fonction W de ` log 2 Lambert : on a en eet k = Wn n log 2 ) . Cependant on peut tout aussi bien dterminer une e (
n estimation ne de k en partant de k = n, et en itrant k log (kx2 e1 ) jusqu` ce que k e a 2 ne change plus. Par exemple, pour x = 1, n = 1000, on obtient successivement 117.3, 184.1, 164.4, 168.9, 167.8, 168.1, 168.0. (1) Il nous faut maintenant calculer une approximation de la srie tronque k i!(2i+1) x2i , e e i=0 2x quon multipliera ensuite par . Il faut pour cela expliciter la mthode de calcul : e
i x2 e
On suppose ici que toutes les variables ont la mme prcision de travail p, suprieure a e e e ` la prcision nale n a laquelle on veut valuer erf x. En utilisant la mthode de Higham, on e ` e e 2k i u peut crire quapr`s i itrations, on a t = xk! e e e j=1 (1 + j )(1 + y )(1 + j ), o` y est lerreur relative sur y, j celle sur larrondi de ty a ltape j, et j celle sur larrondi de t/k. Lerreur ` e relative sur t est donc borne par (1 + )3i 1 a ltape i. e ` e Une autre faon danalyser lerreur est dutiliser les ulps. Lerreur sur y est dau plus 1 c ulp, et si on arrondit vers linni, lerreur dune multiplication est borne par 1 ulp plus les e erreurs sur les oprandes, soit 3i ulps a ltape i (on suppose ici quil ny a pas derreur sur e ` e i dans la division t/i). Lerreur sur u est donc dau plus 3i + 1 ulps.
t1 s1 y (x2 ) for i from 1 to k do t (ty) t (t/i) u (t/(2i + 1)) s (s + (1)i u)
RR n 5105
44
Borner lerreur sur s nest pas aussi facile car il peut y avoir cancellation lors de la soustraction su pour i impair. Dautre part il faudrait exprimer lerreur de (3i+1) ulp(u) en fonction dulp(s). Une faon de contourner ce probl`me est de borner non pas lerreur relative c e sur s, mais lerreur absolue. Soit B une borne en valeur absolue sur u et s au cours du calcul. Lerreur absolue sur s due a ltape i est borne par ulp(s) + (3i + 1)ulp(u) (3i + 2)ulp(B). ` e e Lerreur nale sur s est donc au plus k (3i + 2) = 1 k(3k + 7) en termes dulp(B). Il sut i=1 2 2x ensuite dajouter lerreur darrondi commise lors de la multiplication par pour obtenir une approximation Sk de la srie tronque, avec une erreur borne par k . e e e Pour dcider si on peut calculer larrondi correct de erf x a partir de Sk , comme on sait e ` que Sk (Rk +k ) erf x Sk +(Rk +k ), il sut de sassurer que larrondi de Sk (Rk +k ) gale celui de Sk + (Rk + k ). Pour cela, une condition ncessaire est bien s r que Rk et k e e u soient infrieurs a ulpn (Sk ), o` n est la prcision nale voulue. e ` u e On a vu sur cet exemple quelques dicults que lon peut rencontrer pour dterminer e e larrondi correct de f (x) en prcision arbitraire. On peut aussi avoir une srie convergente e e mais non alterne, pour laquelle borner le reste nest pas si facile. On voit aussi sur cet e exemple que le calcul de f (x) peut faire intervenir des constantes comme ou log 2 : il est donc important de savoir calculer ces constantes de mani`re ecace, ventuellement en e e gardant en mmoire la valeur la plus prcise calcule. e e e 11.2. Dveloppement asymptotique. Pour x tendant vers linni, on a erf x = 1erfc x, e avec 1 (2k)! 2k1 erfc x = x2 x . (1)k k!22k e
k=0
2n , larrondi de erf x est donc soit 1, soit 1 (le nombre ottant 1 e x . Lorsque e x immdiatement infrieur a 1) suivant le mode darrondi. e e `
Attention, ce dveloppement asymptotique nest pas convergent ! En eet, le rapport de deux e termes conscutifs est de lordre de k/x2 , et tend vers linni avec k, x tant x. e e e Si on se contente du premier terme du dveloppement asymptotique, cela donne erf x e
x2 x2
11.3. Mthode de Brent et Kung. La mthode vue ci-dessus pour lvaluation de la srie e e e e de Taylor de erf x ncessite k itrations avec k = O(n), o` n est la prcision nale voulue. e e u e Chaque itration ncessite quant a elle une multiplication (ty) entre deux ottants de n bits, e e ` ce qui co te M (n). Le co t total est donc O(nM (n)), soit O(n3 ) avec une multiplication u u na ve. La mthode de Brent et Kung [9] permet dvaluer une telle srie en temps O(n1/2 M (n)). e e e Lide de base est de diviser les k = O(n) termes a sommer en k morceaux de k termes. e ` Reprenons lexemple de la fonction erf. On a en notant y = x2 : 2 1 1 1 4 1 5 1 6 1 1 erf x = 2 y + y 2 y 3 + y y + y y7 + y 8 + O(y 9 ), x 3 5 21 108 660 4680 37800 342720
INRIA
45
ce qui scrit aussi : e

x erf
3 + y3 y3 + 120
2 1 ( 7 1 ( 13
2 3y 1 + 38 y 1 105 y
1 + 5 y2 1 2 220 y 1 + 952 y 2 )).
Une fois calculs y 2 et y 3 , il sut de deux multiplications entre ottants de n bits pour valuer e e cette derni`re formule, soit en tout 4 telles multiplications ; toutes les autres oprations sont e e soit des multiplications ou divisions entre un ottant de n bits et un petit entier, soit des ` additions ou soustractions, oprations qui co tent O(n). A titre de comparaison, la premi`re e u e formule ncessite 7 multiplications entre ottants de n bits, pour calculer y 2 a y 8 . e ` La mthode de Brent et Kung consiste a rcrire la srie en termes de X = x l o` l k : e ` e e u
k l
a i xi =
i=0 j=0
bj (x)X j .
Chaque sous-srie bj (x) est de degr infrieur a l, et svalue uniquement via des oprations e e e ` e e l 2 l1 j en O(n), apr`s prcalcul de 1, x, x , ..., x . Quant a lvaluation de j=0 bj (x)X , elle se e e ` e fait via le schma de Horner, en O(l) multiplications. Cette mthode utilise donc en tout e e environ 2 k multiplications de ottants de n bits. 11.4. Approximation de Pad. Au lieu dutiliser un dveloppement de Taylor, on peut e e aussi utiliser une approximation rationnelle (Pad). En gnral, un dveloppement de Pad e e e e e de numrateur et dnominateur dordre k quivaut a un dveloppement de Taylor dordre e e e ` e 2k. On peut gagner ainsi a priori un facteur 2 sur le nombre de multiplications entre ottants de n bits, au prix dune division nale supplmentaire. Cependant les coecients lape de proximation de Pad peuvent savrer plus compliqus, par exemple toujours pour x erf x : e e e
2295626419 912396623 121749556141 2 + 2227367513 x2 + 32682547430 x4 + 524843261670 x6 + 1039189658106600 x8 9804764229 . 2921292333 5496758043 80154641 2491500345 1 + 6536509486 x2 + 65365094860 x4 + 9997014508 x6 + 7477766851984 x8
11.5. Fractions continues. Les fractions continues sont un autre moyen dvaluer une e fonction ayant un dveloppement de Taylor. On peut facilement calculer lun a partir de e ` lautre, par exemple en Maple :
> series(exp(x), x, 6); 2 1 + x + 1/2 x > convert(%, confrac); x 1 + ----------------------x 1 + ------------------x -2 + -------------x -3 + --------2 + 1/5 x + 1/6 x 3 + 1/24 x 4 + 1/120 x 5 6 + O(x )
RR n 5105
46
Par rapport au schma de Horner pour lvaluation dune srie de Taylor, o` lopration de e e e u e base est y xy + b, ici lopration de base est y x/y + b. Il est donc important davoir e une division ecace. 11.6. Mthode de Newton (rappel). Comme vu lors du paragraphe sur les algorithmes e a convergence quadratique (section 7), la mthode de Newton permet de trouver les racines ` e dune quation implicite f (x, y(x)) = 0. Elle consiste a itrer : e ` e yk+1 = yk f (x, yk ) . fy (x, yk )
Cette mthode comporte deux proprits importantes : e ee (1) la convergence est quadratique, cest-`-dire que le nombre de bits corrects de y k a double a chaque tape. Ainsi, pour obtenir n bits corrects, il sut de log 2 n tapes. ` e e (2) la mthode de Newton est auto-correctrice, cest-`-dire que pour obtenir n bits e a corrects a ltape k, il sut davoir n/2 bits corrects a ltape k 1. ` e ` e
Une consquence importante de ces deux proprits est que toute fonction algbrique se e ee e calcule en temps O(M (n)) via la mthode de Newton. En eet, une fonction algbrique est e e dnie par un polynme P (x, y) = 0 : P (x, y) et Py (x, y) svaluent en O(M (n)), ainsi que e o e leur quotient, donc le co t C(n) du calcul de y(x) vrie C(n) = O(M (n)) + C(n/2), soit u e C(n) = O(M (n)) pour M (n) n avec 1. Une application importante de la mthode de Newton est le calcul de fonction inverse. e Supposons quon sache calculer ecacement une fonction f (x). La mthode de Newton e permet alors de calculer la fonction inverse g(x) telle que f (g(x)) = x. En eet, la fonction g(x) est solution de f (y) x = 0. On en dduit litration de Newton : e e yk+1 = yk f (yk ) x . f (yk )
Si lon dispose dune mthode de calcul de f de complexit C(n), on en dduit une mthode e e e e de calcul de g de mme complexit, a une constante pr`s. Par exemple, pour f = log et e e ` e g = exp, on obtient [7] : yk+1 = yk yk (log yk x).
Ainsi, le logarithme se calculant en O(M (n) log n) via la moyenne arithmtico-gomtrique e e e (cf. ci-dessous), on en dduit un algorithme de mme complexit pour lexponentielle. e e e
11.7. Moyenne arithmtico-gomtrique. La moyenne arithmtico-gomtrique (AGM e e e e e e en anglais) de deux rels 0 < a b est la limite commune des deux suites adjacentes : e un + v n , v0 = b, vn+1 = un vn . u0 = a, un+1 = 2 Cette limite est note AGM(a, b). De nombreuses fonctions transcendantes peuvent se cale culer ecacement grce a la moyenne arithmtico-gomtrique, par exemple [7] : a ` e e e m log 2 + o(2n log x), log x = 4 2 AGM( 2m x , 1)
INRIA
47
o` n est la prcision nale voulue, et x2m > 2n/2 . u e 11.8. Le scindage binaire. Le scindage binaire (binary splitting en anglais) consiste a ` ramener le calcul dun ottant en grande prcision a une approximation rationnelle p/q, avec e ` p et q deux grands entiers, qui sont eux-mmes calculs par multiplications dentiers de taille e e moiti, et ainsi de suite. On utilise ainsi de mani`re optimale les algorithmes de multiplication e e rapide (Karatsuba, Toom-Cook, transforme de Fourier rapide). Les algorithmes obtenus e sont en gnral de complexit O(M (n) log n) ou O(M (n) log2 n). e e e Lexemple classique pour comprendre cette mthode est le calcul de n!. La mthode na e e ve consiste a calculer successivement 1!, 2!, 3!, ..., (n 1)!, n!, avec a chaque fois multiplication ` ` dun grand entier par un petit entier. Lide fondamentale du scindage binaire est dquilibrer e e les multiplications. Ainsi n! sera calcul par FastFactorial(0, n), o` FastFactorial(a, b) calcule e u (a + 1)(a + 2)...(b 1)b : Algorithme FastFactorial(a, b). if a + 1 = b then return b c a+b 2 f FastFactorial(a, c) g FastFactorial(c, b) Return f g.
Cette ide peut tre tendue au calcul de nombreuses fonctions, donnant des algorithmes e e e de calcul en O(M (n) log2 n) si une relation fonctionnelle simple existe entre f (x + y) et f (x), f (y) ; sinon, on obtient du O(M (n)log 3 n). Ces rsultats sont dus aux fr`res Borwein, e e a Haible et Papanikolaou, et aux fr`res Chudnovsky [6, 10, 19]. ` e Voici par exemple comment on peut calculer lexponentielle en temps O(M (n) log2 n). Cet algorithme est d a Brent [8]. On commence par supposer que |x| < 1/2, apr`s ventuelle u` e e rduction dargument multiplicative, utilisant exp x = (exp x )2 . On dcompose ensuite x de e e 2 la mani`re suivante : e x = 0.0 b2 b3 b4 b5 b6 b7 b8 ...,
x1 x2 x3
i1
ce qui revient a crire x = è
ri i 1 2 2i
, avec 0 exp x =
r i < 22 exp
i 1
. Par consquent on a : e
ri . 2 2i
se calcule par scindage binaire en temps O(M (n) log n). Lexponentielle de chaque Comme il y a O(log n) valeurs non nulles de ri , cela donne une complexit totale en e O(M (n) log2 n). 12. Hardware (et redondance) Nous nous intressons ici a limplmentation en matriel doprateurs, en mettant prine ` e e e cipalement laccent sur la complexit en temps, mais aussi en surface. e
ri 2 2i
RR n 5105
48
12.1. Le thor`me de Winograd. Une premi`re question qui se pose naturellement : e e e tant donne une fonction f sur des donnes de taille nie, combien de temps au moins e e e faut-il pour la calculer ? Si on consid`re une reprsentation binaire classique, le probl`me revient, du point de vue e e e de la complexit en temps, a calculer chaque bit du rsultat en parall`le en fonction dun e ` e e sous-ensemble des bits dentre : pour chaque bit de rang i, e fi : {0, 1}ni {0, 1}. On cherche a calculer fi par un circuit logique ayant des portes de fan-in r (i.e. avec au plus ` r entres par exemple r = 2 si on ne consid`re que les oprations logiques de base : NOT, e e e AND, OR, NAND, NOR) et de temps de rponse . On suppose de plus que ni est minimal, i.e. e que chaque bit dentre a une inuence sur le rsultat : pour tout 1 k ni , il existe une e e valeur des autres entres telle que fi (...0k ...) = fi (...1k ...). Le circuit devra alors avoir au e moins ni entres, et son temps de rponse sera suprieur ou gal a log r ni , car un circuit e e e e ` de h tages ne peut pas avoir plus de r h entres. e e Le temps ncessaire pour calculer la fonction f est donc dau moins maxi logr ni (haue teur de larbre associ au circuit). e 12.2. Additionneurs. Nous considrons ici laddition dentiers, a laquelle se ram`nent de e ` e nombreuses oprations. e 12.2.1. Additionneurs squentiels simples. Les entiers tant crits en binaire, la cellule de e e e base est le full adder (FA) ; elle additionne 3 bits (2 bits des 2 oprandes et un bit de retenue) e et renvoie un bit de rsultat et un bit de retenue : xi + yi + ci = 2ci+1 + si . e si ci+1 = xi y i c i = Maj(xi , yi , ci )
Probl`me : la propagation de la retenue donne un temps linaire. e e 12.2.2. Additionneurs parall`les. Si xi = yi , ladditionneur peut gnrer la bonne retenue e e e immdiatement, ce qui donne un temps moyen en log2 n, mais le temps de calcul au pire e reste linaire. e 12.2.3. Additionneurs a retenue conditionnelle. On reprend ici plus ou moins lide de lad` e ditionneur parall`le : si on ne peut pas deviner la retenue, on peut toujours eectuer en e parall`le le calcul avec une retenue a 0 et le calcul avec une retenue a 1 pour anticiper, et e ` ` garder le bon rsultat une fois la retenue rcupre. e e ee Ainsi, un additionneur de taille 2n sobtient avec 3 additionneurs de taille n. On crit : e x = xhi + xlo et y = yhi + ylo ; on calcule en parall`le : e (clo , slo ) = xlo + ylo shi,0 = xhi + yhi shi,1 = xhi + yhi + 1 et on multiplexe shi,0 et shi,1 avec la valeur de clo .
INRIA
49
En appliquant cette ide rcursivement, on obtient un temps en O(log n), mais cela occupe e e beaucoup de surface ! Cette mthode nest donc pas utilise en pratique. e e 12.2.4. Additionneurs carry look-ahead . On note le ou logique additivement et le et logique multiplicativement. On remarque que : si xi = yi , alors ci+1 = xi (= yi ) : gnration (ou non) de retenue ; e e si xi = yi , alors ci+1 = ci : propagation de retenue. pi = xi yi (aptitude a propager une retenue) ` On dnit alors : e gi = x i yi (aptitude a gnrer une retenue). ` e e Laddition pourra alors seectuer de la faon suivante : c (1) On construit en parall`le les pi et les gi . e (2) On calcule le plus vite possible les ci (Carry Look-ahead Unit). Carry Look-ahead Unit (CLU) : on a ci+1 = gi + pi ci (soit la retenue est gnre, soit elle e ee est propage), et en droulant : e e ci+1 = gi + pi gi1 + pi pi1 gi2 + ... + pi pi1 ...p1 g0 + pi ...p1 p0 c0 i.e. les ci se calculent a laide de deux portes logiques seulement, cest donc tr`s rapide, mais ` e le nombre dentres de ces portes (fan-in) augmente avec la taille des nombres a additionner. e ` Cette mthode est donc rserve a de petits additionneurs (jusqu` 8 bits). e e e ` a 12.2.5. Additionneurs carry look-ahead cascads. On peut mettre des CLU en cascade. e Si on utilise des CLU de 4 bits et on a des nombres de n = 4k bits, on pose : p g = p 3 p2 p1 p0 = g 3 + p 3 g2 + p 3 p2 g1 + p 3 p2 p1 g0 (3) On calcule en parall`le les si = pi ci . e
et on a toujours : c = gi + p c avec c = c4i . i+1 i i i 2 Une addition sur 4 = 16 bits consiste a : ` (1) calculer les p et gi ; i
(2) calculer les c ; i (3) calculer les ci . Pour une addition sur 4r bits, avec r tages de CLU, on obtient un temps de calcul e proportionnel au nombre dtages, donc logarithmique. e 12.2.6. Additionneurs carry skip (Babbage, 1840). Cette mthode consiste a faire un e ` dcoupage en blocs de m bits : n = km. Chaque bloc calcule le produit de ses pi . Deux cas e peuvent se produire : la retenue entrante cjm est propage si le produit des pi vaut 1 ; e la retenue sortante ne dpend pas de la retenue entrante dans le cas contraire, et son e temps de calcul est donc celui du bloc.
RR n 5105
50
Soient le temps de traverse dune cellule dun bloc et le temps pour sauter par e dessus un bloc. Le cas le pire est le suivant : une retenue appara dans le premier bloc, t saute les k 2 blocs suivants et dispara a la n du dernier bloc. Ceci donne un temps au t ` pire de 2n/k + (k 2), qui est minimal pour k = 2n/. Le temps au pire est alors de 2 2n 2, i.e. en O( n). Note : un bloc tant un additionneur, on peut aussi faire du carry-skip en cascades. e 12.2.7. Eviter les propagations de retenues : reprsentations redondantes. Peut-on aller plus e vite (au sens gagner un facteur non constant) ? Dapr`s le thor`me de Winograd (1965), e e e non : noter que pour calculer le bit de rang n du rsultat, on a besoin de tous les bits de e rang infrieur ou gal a n. e e ` Le probl`me essentiel concernant le temps de calcul de laddition est d aux propagations e u des retenues. Une solution pour les viter est dutiliser une reprsentation redondante pour e e les calculs intermdiaires. e 12.2.8. Syst`mes dAvizienis (1961). On consid`re une reprsentation en base B avec les e e e 2a + 1 chires signs allant de a a +a. Pour pouvoir reprsenter tous les entiers, il est e ` e ncessaire que 2a + 1 e B, et rciproquement. De plus, si 2a e B + 1 et a B 1, alors on peut additionner deux entiers x et y par lalgorithme parall`le suivant (algorithme e dAvizienis) : +1 si xi + yi a 0 si 1 a xi + yi a 1 ti+1 = 1 si xi + yi a si = xi + yi Bti+1 + ti Note : a cause des contraintes entre a et B, cet algorithme nexiste pas en base B = 2. ` 12.2.9. Reprsentation carry-save (CS). Un nombre x est reprsent par un couple (a, b) e e e de deux nombres crits en binaire, tels que x = a + b. Une addition dun nombre en carrye save et dun nombre en reprsentation non redondante se fait a laide dune cha de FA e ` ne (le temps de calcul est donc celui dun FA), qui rduit les 3 entres en 2 ; il y a un dcalage e e e sur la seconde sortie, mais cela ne co te rien en hardware. Et une addition de deux nombres u en carry-save se ram`ne a deux additions dun nombre en carry-save et dun nombre en e ` reprsentation binaire non redondante. e 12.2.10. Reprsentation borrow-save . Un nombre x est reprsent par un couple (x + , x ) e e e de deux nombres crits en binaire, tels que x = x+ x . La cellule de base nest plus le full e adder (FA), mais la cellule PPM : u = xyz t = Maj(x, y, z) qui calcule x + y z = 2t u. Les calculs sont tr`s similaires a ceux du carry-save. Cest e ` juste une histoire de complmentation. e 12.3. Multiplieurs.
INRIA
51
12.3.1. Gnralits concernant la complexit. La complexit est au moins en log n (Winoe e e e e grad, 1967). Si on pose X = 2n x + 1 et Y = 2n y + 1 avec x < 2n et y < 2n , on remarque que lcriture de XY fait intervenir une addition : XY = 22n xy + 2n (x + y) + 1. e Brent et Kung, 1981 : si A(n) et T (n) sont la surface et le temps de calcul dun multiplieur dentiers de n bits, alors il existe deux valeurs A0 et T0 qui ne dpendent que de la technologie, e telles que : 2 A(n) T (n) n2 A0 T0 et cette borne est atteinte. Des multiplieurs bass sur la FFT permettent davoir A(n).T (n)2 = O(n2 ) avec : e K. log2 n T (n) L n. Les multiplieurs rcursifs de Luk et Vuillemin permettent dobtenir un temps logarithe mique : dcoupage rcursif en 4 multiplications de taille n/2 en parall`le (3 avec la mthode e e e e de Karatsuba), et un additionneur en carry-save. 12.3.2. Mthode de Booth. Pour multiplier x par y, on rcrit y en chires signs 1, 0, 1, avec e e e un nombre minimal de chires non nuls, et la multiplication revient a faire une succession ` dadditions et de soustractions. 12.3.3. Multiplication par arbre binaire. On additionne les produits partiels xy i sous forme dun arbre binaire pour obtenir un temps de calcul logarithmique (sous rserve que laddition e se fasse en temps constant, donc en utilisant une reprsentation redondante). e 12.3.4. Multiplication par rseaux cellulaires (Braun, 1963). On a un rseau de n 2 cellules e e calculant les xi yi ( et logique associ a un full/half adder). Le rseau est bien rgulier, e` e e mais cest plutt lent et ca prend de la place ; cette solution est donc destine a dispara o e ` tre. Il en existe diverses variantes. 12.3.5. Multiplieur de Dadda. On reprendre lide prcdente, qui est de calculer les x i yi e e e et de tout additionner, mais on se dbrouille pour quilibrer les additions an dobtenir un e e temps logarithmique plus une addition nale : Tmult Tadd + (1, 709 log2 n 1, 193)TFA . 12.4. Retour sur les algorithmes ` base dadditions et de dcalages. a e 12.4.1. Lalgorithme SRT et le bug du Pentium [27]. Lalgorithme de division a base dad` ditions (soustractions) et de dcalages est celui que lon apprend a lcole : a partir du e ` e ` dividende x et du diviseur y, on dtermine le prochain chire du quotient qi et on calcule e x = Bx qi y (lorsque lon pose la division, la multiplication par la base B nappara pas t puisquil ne sagit que dun dcalage) ; puis on rit`re... e e e Lors de limplantation en matriel, on retrouve les mmes probl`mes : la dtermination e e e e de qi est complique (par rapport au cas moyen) lorsque lon est proche dun cas fronti`re e e (x proche dun multiple entier de y) ; idem pour la soustraction (propagation des retenues). La solution est donc dutiliser une reprsentation redondante. e
RR n 5105
52
Cest ce qui a t choisi pour le Pentium. Il sagit ici dune variante dun algorithme dcouee e vert indpendamment en 1958 par Sweeney, Robertson et Tocher, do` le nom dalgorithme e u SRT . Le Pentium utilise la base B = 4 avec les chires 2, 1, 0, 1 et 2. Les chires du quotient sont choisis de telle sorte que x(i) 2y/3. Ce choix se fait a laide dune table ` dont les entres sont les 5 bits de poids fort du diviseur y et 7 bits du dividende partiel e obtenus par une conversion approche de x(i) ; cf. gure 4.3 page 10 du rapport dIntel [23], e correspondant aux valeurs positives. Suivant les entres de la table, le chire q i du quotient e peut tre 0, 1 ou 2, ce qui dnit 3 zones se recouvrant partiellement (et une zone impossible, e e au-del` de 8y/3). Les rectangles sont identis par leur sommet infrieur gauche, mais tous a e e les points du plan hors zone impossible doivent tre pris en compte dans le choix de qi ; ceci e dnit un certain nombre de contraintes, les valeurs indcises ayant certainement t xes e e ee e lors de la construction/optimisation du PLA (Programmable Lookup Array). Les 5 rectangles griss correspondent aux valeurs errones de qi (0 au lieu de 2) ; lingnieur e e e ayant implment la table sest probablement dit que si le point identiant le rectangle tait e e e dans la zone impossible, alors il sagissait dun cas impossible... Note 1 : la probabilit derreur augmente lorsque y se rapproche de la partie droite dune e colonne contenant une valeur errone. Consquence : les valeurs du diviseur pouvant conduire e e a une erreur sont une puissance de 2 (ngative ou positive) multiplie par un nombre tr`s ` e e e lg`rement infrieur a 3 (cas 3), a 9 (cas 1), a 15 (cas 5), a 21 (cas 2) ou a 27 (cas 4). Exemple e e e ` ` ` ` ` de Thomas Nicely (octobre 1994) : 1.0/824633702441, o` le diviseur a pour criture binaire : u e 1011111111111111111111111011100000101001 (cas 3). Note 2 : lerreur est toujours assez faible. Ceci est d au prtraitement pour garantir que u e x(0) 2y/3 quel que soit y, si bien que 1/4 x(0) < 1/2, et que x(i) ne pourra pas tre e proche de 2y/3 avant quelques itrations. e 12.4.2. Lalgorithme BKM. En ce qui concerne les fonctions lmentaires, il existe des vaee riantes des algorithmes prsents prcdemment utilisant une reprsentation redondante, e e e e e avec souvent des inconvnients pour les variantes de CORDIC (facteur dchelle non e e constant, itrations supplmentaires...). Une mthode intressante est lalgorithme BKM e e e e [3]. Si En est un nombre complexe et que lon dnit En+1 = En (1 + idn 2n ), on obtient en e fait une itration tr`s proche de CORDIC, do` lide deectuer des multiplications par des e e u e termes de la forme 1+dn 2n , o` les dn sont des nombres complexes tels quune multiplication u par dn se rduise a quelques additions. On consid`re litration : e ` e e En+1 Ln+1 = En (1 + dn 2n ) = Ln log(1 + dn 2n )
avec dn {0, 1, 1 + i, i, i 1, 1, 1 i, i, i + 1}. Comme avec les autres algorithmes a base dadditions et de dcalages, il y a deux modes : ` e Mode E : si on trouve une suite (dn ) telle que Ln 0, alors En E1 eL1 . Mode L : si on trouve une suite (dn ) telle que En 1, alors Ln L1 + log(E1 ).
INRIA
53
dx , dy n n
En considrant linuence respective de dx et de dy dans ces deux expressions, on choisira e n n dx en fonction des premiers chires de Lx et dy en fonction des premiers chires de Ly . n n n n Dautre part, tout comme dans les autres algorithmes o` le domaine de convergence tait u e y x un segment, on va assurer ici la convergence dans un rectangle Rn = [sx , rn ] + i[sy , rn ], n n o` les bornes seront identies plus loin. u e x Choix de dx . La valeur de Lx n n+1 sexprime en fonction de la valeur de Ln par des segments de droite paramtrs par dx et dy (diagramme de Robertson). De plus, dx e e n n n e va tre choisi de mani`re a rendre Lx e e ` n+1 susamment petit (pas forcment le plus petit possible dans les zones o` cela a peu dimportance, notamment pour garder de u la redondance). Cependant, on ne contrle pas ici le choix de dy , ce qui signie que o n x x les suites (sx ) et (rn ) doivent tre tablies de mani`re a ce que Lx [sx , rn+1 ] e e e ` n n+1 n+1 y x x quelle que soit la valeur de dn . Pour la dnition de sn , on consid`re dn = 1 (pour e e minimiser) et dy = 1 (pour maximiser), ce qui donne : n sx = n
x rn ,
Considrons par exemple le mode E. On pose Ln = Lx + iLy et dn = dx + idy o` e n n n n u {1, 0, 1}. On a : x 1 x x n+1 + dx 2 + dy 2 22n Ln+1 = Ln 2 log 1 + dn 2 n n n 2 y y Ly . n+1 = Ln dn arctan 1 + dx 2n n
1 2
k=n
log(1 2k+1 + 22k+1 ).
Pour la dnition de e on consid`re dx = 1 (pour maximiser) et dy = 0 (pour e n n minimiser), ce qui donne :

x rn = k=n
log(1 + 2k ).
et on choisit dx de la faon suivante : c n Lx < A n si n si An Lx < Bn n si Bn Lx < Cn n si Cn Lx Dn n si Dn < L x n
On dnit ensuite : e An B n Cn Dn
= = = =
1 sx + 2 log(1 + 22n ) n+1 x rn+1 + log(1 2n ) sx + 1 log(1 + 2n+1 + 22n+1 ) n+1 2 x rn+1
alors alors alors alors alors
dx n dx n dx n dx n dx n
= 1 = 1 ou 0 =0 = 0 ou 1 = 1.
RR n 5105
54
Choix de dy . Avec des considrations similaires, on obtient : e n

y sy = r n = n k=n
arctan
2k 1 + 2k
On dnit : e
Le domaine de convergence de lalgorithme est :

y 0, 7497... = sy Ly r1 = 0, 7497... 1 1 Note : grce au recouvrement des domaines pour le choix de dx et dy , on peut simplier a n n les comparaisons et ne considrer que les premiers chires de Lx et Ly pour dterminer dx e e n n n et dy . n
y Bn = rn+1 et on choisit dy de la faon suivante : c n Ly < Bn si n si Bn Ly < An n si An Ly < An n si An Ly B n n si Bn < Ly n
An
y = rn+1 + arctan
2n 1 2n
alors alors alors alors alors
dy n dy n dy n dy n dy n
= 1 = 1 ou 0 =0 = 0 ou 1 = 1.
0, 8298... = sx 1
Lx 1
x r1 = 0, 8688...
13. Implmentation de la fonction exponentielle e Nous tudierons ici la mthode choisie par D. Defour pour sa th`se [15] et quil a imple e e e mente pour la biblioth`que crlibm [32], avec quelques corrections. Ce nest pas une tche e e a facile (pour information, cette implmentation, hors tests, reprsente 30 pages de description e e et preuves). Un autre exemple dimplmentation de fonctions transcendantes (sans arrondi exact) est e dcrit dans [21]. e 13.1. Introduction. Les objectifs sont les suivants : toujours fournir larrondi correct, pour chacun des quatre modes darrondi ; borner le temps dexcution dans le pire cas ; e avoir un temps dexcution en moyenne acceptable (au maximum deux fois le prix dune e valuation relativement prcise) ; e e avoir du code portable (en faisant tout de mme quelques suppositions raisonnables e sur limplmentation de C : par exemple, la norme IEEE 754 doit tre supporte a ce e e e ` niveau, le type double doit correspondre a la double prcision, le mode darrondi actif ` e doit tre le mode darrondi au plus pr`s) ; e e avoir un code simple (quitte a perdre sur le plan des performances) ; ` avoir des preuves des algorithmes et de limplmentation correspondante (dautant plus e simples que le code lest).
INRIA
55
La seule faon de satisfaire les premier (arrondi correct) et troisi`me (temps moyen accepc e table) points est dutiliser la stratgie de Ziv (cf. section 9 sur larrondi nal). Concernant e le deuxi`me point, il y aurait deux choix possibles : e utiliser des thor`mes de thorie des nombres (en particulier, celui de Nesterenko et e e e Waldschmidt), au prix dun certain nombre de probl`mes (implmentation, temps, me e e moire) ; utiliser les rsultats de tests exhaustifs, quand ils sont connus. e Pour lexponentielle, les pires cas sont connus (obtenus par V. Lef`vre en novembre 1999, e avec une seconde srie de tests en 2003), donc on peut choisir la deuxi`me mthode. e e e Le calcul de lexponentielle seectue de la faon suivante : c (1) Traitement des cas spciaux. e (2) Calcul rapide dune approximation a 68 bits pr`s. ` e (3) Calcul plus prcis (si le dilemme du fabricant de tables se produit). e 13.2. Remarque prliminaire. Lexponentielle tant une fonction positive, larrondi vers e e 0 se ram`ne au cas de larrondi vers . e 13.3. Cas spciaux. Les bornes lies a lunderow et a loverow sont dnies de la mani`re e e ` ` e e suivante : bu = (log(21075 )) = 745, 1332...
bo = (log((1 253 ).21024 )) = 709, 7827... Les dirents cas traits (regroups ici pour lensemble des modes darrondi) sont : e e e si x est NaN, alors exp(x) vaut NaN (x + x est renvoy pour gnrer une exception e e e opration invalide) ; e si x = , alors on renvoie + ou +0, sans gnrer dexception ; e e si x > bo , alors un overow est gnr (implment par un DBL_MAX * DBL_MAX en e ee e e arrondi au plus pr`s, et les autres exceptions le sont de mani`re similaire) ; e e si x < bu , alors un underow est gnr ; e ee en arrondi au plus pr`s, si |x| 254 , alors on renvoie 1, avec une exception inexact si e x = 0 (tests similaires dans les autres modes darrondi). Note 1 : les overow et underow des calculs intermdiaires devront tre vits par la e e e e suite. Note 2 : limplmentation crlibm eectue certains des tests sur la reprsentation en me e e moire des ottants en double prcision (type double), i.e. ce sont des tests sur des entiers. Ce e nest pas forcment un bon choix, que ce soit au niveau de la portabilit (la reprsentation e e e des ottants en mmoire nest pas normalise et la taille des types entiers peut varier dune e e implmentation a une autre) ou de la rapidit (cela demande un stockage du ottant en e ` e mmoire), surtout que la prcision tendue ne pose pas vraiment de probl`me a ce niveau. e e e e ` 13.4. Calcul rapide. Le calcul a 68 bits pr`s seectue en 4 tapes : ` e e (1) Premi`re rduction dargument : on calcule un entier k et une approximation r tels e e que x k. log(2) + r, avec r [ log(2)/2, + log(2)/2].
RR n 5105
56
(2) Seconde rduction dargument, par une table indexe par les premiers bits de r. e e (3) Evaluation polynomiale. (4) Reconstruction. 13.4.1. Premi`re rduction dargument. Il sagit dune rduction dargument de type additif : e e e on calcule un entier k et deux ottants rhi et rlo reprsentant un rel r = rhi + rlo tels que e e x = k. log(2) + r.(1 + ) avec |r| < log(2). Il y a donc une cancellation importante pour obtenir r. En plus de la cancellation normale (r tant gnralement de lordre de 0, 5), la vritable cancellation peut e e e e tre encore plus grande et donner une valeur de r tr`s petite par rapport a 0, 5. Mais seule e e ` lerreur absolue sur r est ici importante, puisque lon va valuer er , qui est de lordre de 1, e donc avec une erreur absolue xe. e Grce aux bornes de loverow et de lunderow, le calcul est assez simple... a /* log(2) = 1.62E42FEFA39EF35793C7673007... * 2^(-1) */ #define ln2_hi 1.62E42FEFA38P-1 /* 42 bits de poids fort de log(2) */ #define ln2_lo 1.EF35793C7673P-45 /* bits suivants de log(2) */ #define inv_ln2 1.715476533245FP0 /* approximation de 1/log(2) */ #define DOUBLE2INT(i, d) \ { double t = ((d) + 3.P51); i = LO(t); } /* o` LO() prend la partie basse dans la reprsentation en mmoire */ u e e double r_hi, r_lo, s_hi, s_lo; int k; DOUBLE2INT (k, x * inv_ln2); /* arrondi au plus pr`s */ e if (k != 0) { s_hi = x - ln2_hi * k; /* exact, cf. Sterbenz */ s_lo = - ln2_lo * k; Fast2SumCond (r_hi, r_lo, s_hi, s_lo); } else { r_hi = x; r_lo = 0; } On peut prouver les proprits suivantes (on note ici k une quantit borne en valeur ee e e absolue par 2k ) : ln2_hi + ln2_lo = log(2).(1 + 102 ) 1075 k 1025
1 2
et
si bien que k scrit sur au plus 11 bits et la multiplication ln2_hi * k seectue exactement. e On peut galement prouver que les conditions du thor`me de Sterbenz sappliquent pour e e e
INRIA
57
la soustraction, si bien que celle-ci seectue aussi exactement. On a galement : e La macro Fast2SumCond eectue lalgorithme FastTwoSum avec un test sur les exposants des deux entres (i.e. cest lquivalent de TwoSum, cf. section 10.4). On a donc : e e exp(x) = 2k exp(r_hi + r_lo + 91 ). 13.4.2. Seconde rduction dargument. Le nombre r = r_hi + r_lo est toujours trop grand e pour tre utilis dans une valuation polynomiale. Une seconde rduction dargument est e e e e donc ncessaire. e Cette rduction dargument seectue a laide dune table indexe par les premiers bits de e ` e r. Utiliser 8 bits (dont le signe) permet davoir une table de 28 log(2) 16 = 2848 octets. Si on note i le ottant form par les 8 premiers bits et on calcule s = r i, alors e exp(r) = exp(i). exp(s), o` lapproximation de exp(i) sur 105 bits (en fait, 70 bits suraient) u est lue dans la table et s, vriant |s| 29 , sera reprsent par s_hi + s_lo, obtenus par e e e FastTwoSum. On a alors : exp(x) = 2k .(ex_hi + ex_lo). exp(s_hi + s_lo + 91 ).(1 + 105 ). 13.4.3. Evaluation polynomiale. Lvaluation de exp(s), o` s = s_hi + s_lo, se fait comme e u suit : 1 1 + s + s2 + s3 .P 2 avec P = c0 + s_hi * (c1 + s_hi * (c2 + s_hi * c3)), correspondant a lvaluation ` e approche dun polynme de degr 3 en s_hi. e o e Exemple de majoration derreurs, en notant de P0 a P5 les rsultats intermdiaires de ` e e lvaluation de P (= P5 ) : e |P0 | 218 , donc P0 = (s_hi c3) + 71 . |P1 | 26 , donc P1 = (c2 + P0 ) + 59 . |P2 | 215 , donc P2 = (s_hi P1 ) + 68 . |P3 | 24 , donc P3 = (c1 + P2 ) + 57 . |P4 | 213 , donc P4 = (s_hi P3 ) + 66 . |P5 | 22 , donc P5 = (c0 + P4 ) + 55 . On en dduit lerreur sur P : e que lon peut majorer par 255 + 264 . 55 + 66 + 29 57 + 29 68 + 218 59 + 218 71 s_lo = ln2_lo k + 91 .
13.4.4. Reconstruction. En rsum, exp(x) est approch par 2k multipli par : e e e e 1 (ex_hi + ex_lo). 1 + s_hi + s_lo + (s_hi + s_lo)2 + (s_hi + s_lo)3 .P 2 avec une erreur relative 77 . Dans lexpression ci-dessus, on dveloppe et limine les termes non signicatifs par rapport e e a la prcision nale voulue (68 bits). Dans le calcul, il faudra utiliser lalgorithme de Dekker ` e
RR n 5105
58
(pour les multiplications) et lalgorithme FastTwoSum (pour les additions), sauf si on peut se permettre de perdre de la prcision. e ` 13.5. Test si larrondi est possible. A ce niveau, on a : exp(x) = 2k (y_hi + y_lo + 70 ) o` y_hi et y_lo ont t obtenus par un FastTwoSum. u ee La multiplication par 2k (avec k entier) est normalement exacte, mais si le rsultat nal e est un dnormalis, il est possible que cette multiplication fasse perdre de la prcision ! Ce e e e cas est trait a part. e` Le test de larrondi lui-mme peut se faire avant la multiplication par 2k puisque celle-ci e ne change pas la mantisse du rsultat. Une solution intuitive serait de considrer lerreur e e minimale (incluant y_lo) et de lajouter a y_hi pour voir si on obtient le mme rsultat, et ` e e faire de mme avec lerreur maximale. Cela demande beaucoup doprations. Un test plus e e simple consiste a faire : y_hi == y_hi + y_lo * errn avec errn = 1+2 15 , en remarquant ` que : on a y_hi 1/ 2 ; le TMD ne pourra se produire que si |y_lo| est susamment proche de ulp(y_hi)/2 ; ce qui permet de transformer lerreur absolue 70 en erreur relative a y_lo. En eet, le TMD ` ne peut se produire que lorsque |y_lo| 1 ulp(y_hi) 255 , donc 270 215 |y_lo|. 4 13.6. Calcul plus prcis. Il faut faire du calcul en multiprcision (les expansions de lone e gueur 2 ne sont pas susantes). 13.6.1. Prcision ncessaire. Les rsultats des tests exhaustifs donnent un pire cas a 158 e e e ` ` bits, tous modes darrondi confondus. A noter que les plus gros pires cas sont en fait tr`s e particuliers, lis a lapproximation exp(x) 1 + x + 1 x2 pour x susamment proche de 0 e ` 2 (en gros, |x| < 229 ). Une solution serait de tabuler ces pires cas ou de faire un traitement particulier, de faon a calculer a une prcision intermdiaire de 120 bits environ au lieu de c ` ` e e 160. Ce nest pas ce qui a t choisi ici. ee Les algorithmes seront essentiellement bass sur des additions et des multiplications. e Limplmentation utilisera la biblioth`que SCSLib (dveloppe par D. Defour, C. Daramy e e e e et F. de Dinechin, dans le projet Arnaire [33, 16]), qui satisfait les conditions requises e ultrieurement : e a + b = (a b).(1 + 210 ) et a b = (a b).(1 + 207 ). 13.6.2. Lalgorithme. (1) Pas de gestion des cas spciaux (ils ont dj` t traits). e eaee e (2) Rduction dargument : on calcule largument rduit r et lentier k tels que : e e r= x k. log(2) 512 avec log(2) 1024 r log(2) . 1024
INRIA
59
(3) Evaluation polynomiale : exp(r) = P (r).(1 + 179 ), o` P (r) = 1 + r + c2 r 2 + ... + c12 r 12 . u (4) Reconstruction : exp(x) = 2k . exp(r)512 .(1 + 170 ), o` llvation a la puissance 512 u ee ` se fait en levant 9 fois exp(r) au carr. e e Rfrences e e
[1] Abramowitz, M., and Stegun, I. A. Handbook of Mathematical Functions. Dover, 1973. [2] Arnold, D. N. Some disasters attributable to bad numerical computing. http://www.ima.umn.edu/ ~arnold/disasters/, 1998. [3] Bajard, J.-C., Kla, S., and Muller, J.-M. BKM : A new hardware algorithm for complex elementary functions. IEEE Trans. Comput. 43, 8 (1994), 955963. [4] Baker, A. Transcendental Number Theory. Cambridge University Press, 1975. [5] Boldo, S., and Daumas, M. Properties of the subtraction valid for any oating point system. In 7th International Workshop on Formal Methods for Industrial Critical Systems (Mlaga, Spain, 2002), a pp. 137149. http://www.inrialpes.fr/vasy/fmics/workshop-7/proceedings.pdf. [6] Borwein, J. M., and Borwein, P. B. The arithmetic-geometric mean and fast computation of elementary functions. SIAM Review 26, 3 (July 1984), 351366. [7] Brent, R. P. Multiple-precision zero-nding methods and the complexity of elementary function evaluation. In Analytic Computational Complexity (New York, 1975), J. F. Traub, Ed., Academic Press, pp. 151176. ftp://ftp.comlab.ox.ac.uk/pub/Documents/techpapers/Richard.Brent/rpb028.ps.gz. [8] Brent, R. P. The complexity of multiple-precision arithmetic. In The Complexity of Computational Problem Solving (1976), R. S. Anderssen and R. P. Brent, Eds., University of Queensland Press, pp. 126 165. ftp://ftp.comlab.ox.ac.uk/pub/Documents/techpapers/Richard.Brent/rpb032.ps.gz. [9] Brent, R. P., and Kung, H. T. Fast Algorithms for Manipulating Formal Power Series. J. ACM 25, 4 (1978), 581595. [10] Chudnovsky, D. V., and Chudnovsky, G. V. Computer algebra in the service of mathematical physics and number theory. In Computers in mathematics (Stanford, CA, 1986) (New York, 1990), D. V. Chudnovsky and R. D. Jenks, Eds., Marcel Dekker, pp. 109232. [11] Daumas, M. Multiplications of oating point expansions. In Proceedings of the 14th IEEE Symposium on Computer Arithmetic (Adelaide, Australia, 1999), I. Koren and P. Kornerup, Eds., IEEE Computer Society Press, Los Alamitos, CA, pp. 250257. ftp://ftp.ens-lyon.fr/pub/LIP/Rapports/RR/RR1998/ RR1998-39.ps.Z. [12] Daumas, M., and Finot, C. Algorithm, proof and performances of a new division of oating-point expansions. Rapport de recherche 3771, Institut National de Recherche en Informatique et en Automatique, 1999. [13] Daumas, M., and Finot, C. Division of oating point expansions with an application to the computation of a determinant. Journal of Universal Computer Science 5, 6 (1999), 323338. http: //www.jucs.org/jucs_5_6/division_of_floating_point. [14] Daumas, M., Rideau, L., and Thery, L. A Generic Library for Floating-Point Numbers and Its Application to Exact Computing. In Theorem Proving in Higher Order Logics : 14th International Conference (Sept. 2001), no. 2152 in LNCS, Springer-Verlag. [15] Defour, D. Fonctions lmentaires : algorithmes et implmentations ecaces pour larrondi correct ee e en double prcision. Th`se de doctorat, Ecole Normale Suprieure de Lyon, Sept. 2003. e e e [16] Defour, D., and de Dinechin, F. Software carry-save fast multiple-precision algorithms. Rapport de recherche RR2002-08, Laboratoire de lInformatique du Paralllisme, Lyon, Feb. 2002. e
RR n 5105
60
[17] Dekker, T. J. A oating-point technique for extending the available precision. Numerische Mathematik 18, 3 (1971), 224242. [18] Finot-Moreau, C. Preuves et algorithmes utilisant larithmtique ottante normalise IEEE. Th`se e e e de doctorat, Ecole Normale Suprieure de Lyon, July 2001. e [19] Haible, B., and Papanikolaou, T. Fast multiprecision evaluation of series of rational numbers. Technical Report TI-7/97, Darmstadt University of Technology, 1997. http://www.informatik.th-darmstadt. de/TI/Mitarbeiter/papanik/. [20] Hanrot, G., Quercia, M., and Zimmermann, P. Speeding up the division and square root of power series. Rapport de recherche 3973, Institut National de Recherche en Informatique et en Automatique, 2000. http://www.inria.fr/RRRT/RR-3973.html. [21] Harrison, J., Kubaska, T., Story, S., and Tang, P. T. P. The computation of transcendental functions on the IA-64 architecture. Intel Technology Journal 1999 Q4 (1999). http://www.intel.com/ technology/itj/q41999/articles/art_5.htm. [22] IEEE standard for binary oating-point arithmetic. Tech. Rep. ANSI-IEEE Standard 754-1985, New York, 1985. Approved March 21, 1985 : IEEE Standards Board, approved July 26, 1985 : American National Standards Institute, 18 pages. [23] Intel Corporation. Statistical analysis of oating point aw in the pentium processor, Nov. 1994. http://citeseer.nj.nec.com/366418.html. [24] Knuth, D. E. The Art of Computer Programming, vol. 2. Addison-Wesley, 1973. [25] Kornerup, P., and Muller, J.-M. Choosing starting values for Newton-Raphson computation of reciprocals, square-roots and square-root reciprocals. Research Report 4687, Institut National de Recherche en Informatique et en Automatique, Jan. 2003. ` [26] Lefevre, V. An algorithm that computes a lower bound on the distance between a segment and Z2 . Rapport de recherche RR1997-18, Laboratoire de lInformatique du Paralllisme, Lyon, 1997. e [27] Muller, J.-M. Algorithmes de division pour microprocesseurs : illustration a laide du bug du Pen` tium. Technique et Science Informatiques 14, 8 (1995). ftp://ftp.ens-lyon.fr/pub/LIP/Rapports/ RR/RR1995/RR1995-06.ps.Z. [28] Muller, J.-M. Elementary Functions. Algorithms and Implementation. Birkhauser, 1997. 232 pages. [29] Nesterenko, Y. V., and Waldschmidt, M. On the approximation of the values of exponential function and logarithm by algebraic numbers (in russian). Mat. Zapiski 2 (1996), 2342. [30] Ng, K. C. Argument reduction for huge arguments : Good to the last bits. Technical report, SunPro, 1992. Can be obtained by sending an e-mail to the author : kwok.ng@eng.sun.com. [31] Priest, D. M. Algorithms for arbitrary precision oating point arithmetic. In Proceedings of the 10th Symposium on Computer Arithmetic (Grenoble, France, 1991), P. Kornerup and D. Matula, Eds., IEEE Computer Society Press, pp. 132144. [32] Projet Arenaire. Biblioth`que crlibm. http://perso.ens-lyon.fr/catherine.daramy/crlibm.html. e [33] Projet Arnaire. The software carry-save multiple-precision library. http://www.ens-lyon.fr/LIP/ e Arenaire/News/SCSLib/. Version 1.4.1. [34] Remez, E. Sur un procd convergent dapproximations successives pour dterminer les polynmes e e e o dapproximation. Comptes-rendus de lAcadmie des Sciences, Paris, 198 (1934). e [35] Shewchuk, J. R. Adaptive precision oating-point arithmetic and fast robust geometric predicates. In Discrete and Computational Geometry (1997), vol. 18, pp. 305363. http://www.cs.cmu.edu/afs/cs/ project/quake/public/papers/robust-arithmetic.ps. [36] Stehl, D., Lef`vre, V., and Zimmermann, P. Worst cases and lattice reduction. In Proceedings of e e the 16th IEEE Symposium on Computer Arithmetic (Arith16) (2003), J.-C. Bajard and M. Schulte, Eds., pp. 142147.
INRIA
Unit de recherche INRIA Lorraine LORIA, Technople de Nancy-Brabois - Campus scientique 615, rue du Jardin Botanique - BP 101 - 54602 Villers-ls-Nancy Cedex (France)
Unit de recherche INRIA Futurs : Parc Club Orsay Universit - ZAC des Vignes 4, rue Jacques Monod - 91893 ORSAY Cedex (France) Unit de recherche INRIA Rennes : IRISA, Campus universitaire de Beaulieu - 35042 Rennes Cedex (France) Unit de recherche INRIA Rhne-Alpes : 655, avenue de lEurope - 38334 Montbonnot Saint-Ismier (France) Unit de recherche INRIA Rocquencourt : Domaine de Voluceau - Rocquencourt - BP 105 - 78153 Le Chesnay Cedex (France) Unit de recherche INRIA Sophia Antipolis : 2004, route des Lucioles - BP 93 - 06902 Sophia Antipolis Cedex (France)
diteur INRIA - Domaine de Voluceau - Rocquencourt, BP 105 - 78153 Le Chesnay Cedex (France)
http://www.inria.fr ISSN 0249-6399

RR 5105

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

RR 5105

Încărcat de

Drepturi de autor:

Formate disponibile

INSTITUT NATIONAL DE RECHERCHE EN INFORMATIQUE ET EN AUTOMATIQUE

Lef`vre & Zimmermann e

Lef`vre & Zimmermann e

Lef`vre & Zimmermann e

ulp(a b), ce qui donne

Lef`vre & Zimmermann e

ce qui donne ||p exp ||2 0.0014, et le graphe suivant :

0.5 1 0.8 0.6 0.4 0.2 0 0.2 0.4 x 0.6 0.8 1

0.5 1 0.8 0.6 0.4 0.2 0 0.2 0.4 x 0.6 0.8 1

Lef`vre & Zimmermann e

0.5 1 0.8 0.6 0.4 0.2 0 0.2 0.4 x 0.6 0.8 1

Lef`vre & Zimmermann e

0.3213305387 10 > Digits:=12: foo(4); 0.110714404311 10

Lef`vre & Zimmermann e

Lef`vre & Zimmermann e

Lef`vre & Zimmermann e

Preuve : montrer par rcurrence sur n que e 0 x xn

qui donne lerreur relative sur ex : ex y n = 1 exn x ex 1 e2

Choix de dk pour eectuer une rotation dangle : z0 zk+1 dk = = z k d k wk 1 si zk 0 = 1 sinon.

Lef`vre & Zimmermann e

En rsum, lalgorithme CORDIC e e xk+1 yk+1 zk+1

est bas sur litration e e = xk dk yk 2k = yk + dk xk 2k = zk dk arctan 2k

arctan 2k = 1,743..., si nous

les suites (xk ) et (yk ) convergent respectivement vers cos et sin .

Linaire : m = 0, wk = 2k , (k) = k. e Vectoring mode xk x 0 yk 0 zk z0 y0 /x0 est le plus grand entier

Vectoring mode 2 K x2 y 1 1 0 z1 tanh1 (y1 /x1 )

Lef`vre & Zimmermann e

Lef`vre & Zimmermann e

alors que la valeur exacte est :

et on obtient avec le mme programme C que ci-dessus : e

208341 312689 833719 1146408 1 8 20 113

Lef`vre & Zimmermann e

Lef`vre & Zimmermann e

arrondi x k+1 ou x k+2 ?

1.xxxxx...xxx 100000...0000 xxx... ou

1.xxxxx...xxx 011111...1111 xxx...

avec les autres modes darrondi (arrondi dirig ), e

1.xxxxx...xxx 000000...0000 xxx... ou

1.xxxxx...xxx 111111...1111 xxx...

Lef`vre & Zimmermann e

m = n+20 chec succs m = n+40 m = 2n

Lef`vre & Zimmermann e

deg 2 deg 2 deg 2 deg 2 deg 2 deg 2 deg 2 deg 2

deg 1 deg 1 deg 1 deg 1 deg 1

B A  ! 9 7 C@#80 (65121) ('" $#    % 4 " 0 3 0 % & % " !    

Lef`vre & Zimmermann e

Lef`vre & Zimmermann e

Lef`vre & Zimmermann e

#define #define #define #define #define #define #define #define

Lef`vre & Zimmermann e

/* z0-zr: [0:2BQ] /* z1: [0:2BQ|BQ+2]

/* z0: [0:2BQ+2] /* z1: [2:2] /* z0-z1: [0:2BQ]

(1)i x2i+1 . i!(2i + 1)

t1 s1 y (x2 ) for i from 1 to k do t (ty) t (t/i) u (t/(2i + 1)) s (s + (1)i u)

Lef`vre & Zimmermann e

ce qui scrit aussi : e

1 + 5 y2 1 2 220 y 1 + 952 y 2 )).

Lef`vre & Zimmermann e

ce qui revient a crire x = `e

Lef`vre & Zimmermann e

Lef`vre & Zimmermann e

Lef`vre & Zimmermann e

log(1 2k+1 + 22k+1 ).

B A ! 9 7 C@#80 (65121) ('" $# % 4 " 0 3 0 % & % " !