Racine Carrée Inverse Rapide
Total Page：16
File Type：pdf, Size：1020Kb
Racine carrée inverse rapide La racine carrée inverse rapide (en anglais fast inverse square root, parfois abrégé Fast InvSqrt() ou par la constante 0x5f3759df en hexadécimal) est une méthode pour calculer x−½, l'inverse de la racine carrée d'un nombre à virgule flottante à simple précision sur 32 bits. L'algorithme a probablement été développé chez Silicon Graphics au début des années 1990. Il a entre autres été 1 utilisé dans le code source de Quake III Arena, un jeu vidéo sorti en 1999 . À l'époque, le principal avantage de cet algorithme était d'éviter d'utiliser des coûteuses opérations à virgules flottantes en préférant des opérations sur entiers. Les racines carrées inverses sont utilisées pour calculer les angles d'incidence et la réflexion pour la lumière et l'ombre en imagerie numérique. L'algorithme prend en entrée des flottants de 32 bits non signés et stocke la moitié de cette valeur pour l'utiliser plus tard. Ensuite, il traite le nombre à virgule flottante comme un entier et lui applique un décalage logique (en) à droite d'un bit et le résultat est soustrait à la valeur « magique » 0x5f3759df. Il s'agit de la première approximation de la racine carrée inverse du nombre passé en entrée. En considérant de nouveau les bits comme un nombre à virgule flottante et en appliquant au nombre la méthode de Newton, on améliore Les calculs de lumière (ici cette approximation. Bien que n'assurant pas la précision la plus fine possible, le résultat final est une approximation de la racine dans OpenArena, un jeu de tir carrée inverse d'un nombre à virgule flottante qui s'exécute quatre fois plus vite qu'une division d'un tel nombre. à la première personne) utilisent la racine carrée inverse rapide pour calculer les angles d'incidence et de Sommaire réflexion. 1 Motivation 2 Aperçu du code 2.1 Un exemple pratique 3 Fonctionnement de l'algorithme 3.1 Représentation en nombre flottant 3.2 Approcher un logarithme en passant à l'entier 3.3 Première approximation du résultat 3.4 Méthode de Newton 4 Histoire et enquête 5 Note et références 6 Liens externes Motivation 2 Les racines carrées inverses d'un nombre à virgule flottante sont utilisées pour calculer un vecteur normalisé . En synthèse d'image 3D, ces vecteurs normalisés sont utilisés pour déterminer l'éclairage et l'ombrage. Des millions de ces calculs sont ainsi nécessaires chaque seconde. Avant l'apparition de matériel dédié au TCL, ces calculs pouvaient être lents. Ce fut particulièrement le cas lorsque cette technique a été développée au début des années 1990 où les opérations sur les nombres à virgule flottante étaient plus lentes que 1 les calculs sur entiers . Afin de normaliser un vecteur, on détermine la longueur de celui-ci en calculant sa norme euclidienne : la racine carrée de la somme du carré de ses composantes. Après avoir divisé chaque composante par cette longueur, on obtient alors un nouveau vecteur unitaire Les normales à une surface pointant dans la même direction. sont largement utilisées dans les calculs d'éclairage et d'ombrage, ce qui nécessite le est la norme euclidienne du vecteur, de la même manière que l'on calcule une distance dans un espace calcul des normes des vecteurs. Ici, on montre un euclidien. champ de vecteurs normaux à la surface. est le vecteur (unitaire) normalisé. Avec représentant , , liant le vecteur unitaire à la racine carrée inverse des composantes. Aperçu du code Le code source suivant est l'implémentation de la racine carrée inverse dans Quake III Arena dont on a retiré les directives du préprocesseur C mais qui contient les 3 commentaires originaux float Q_rsqrt( float number ) { long i; float x2, y; const float threehalfs = 1.5F; x2 = number * 0.5F; y = number; i = * ( long * ) &y; // evil floating point bit level hacking i = 0x5f3759df - ( i >> 1 ); // what the fuck? y = * ( float * ) &i; y = y * ( threehalfs - ( x2 * y * y ) ); // 1st iteration // y = y * ( threehalfs - ( x2 * y * y ) ); // 2nd iteration, this can be removed return y; } Afin de déterminer la racine carrée inverse, un programme calculerait une approximation de puis appliquerait ensuite une méthode numérique afin de peaufiner le résultat jusqu'à atteindre une erreur d'approximation acceptable. Des méthodes de calcul (en) du début des années 1990 ont permis d'avoir une première 4 approximation depuis une table de correspondance . Cette nouvelle fonction s'est montrée plus efficace que les tables de correspondance et environ quatre fois plus 5 6 rapide qu'une division flottante classique . L'algorithme a été conçu selon le standard pour les nombres à virgule flottante 32-bit, mais des recherches de Chris Lomont et ensuite Charles McEniry ont montré qu'il pouvait être implémenté en utilisant d'autres spécifications de nombres à virgule flottante. 7 Le gain de vitesse apporté par le kludge qu'est la racine carrée inverse rapide vient du traitement du mot double contenant le nombre à virgule flottante considéré comme entier qui est ensuite soustrait à une constante spécifique : 0x5f3759df. L'utilité de cette constante n'étant pas claire à première vue, on la considère alors 1, 8, 9, 10 comme un nombre magique Après cette soustraction d'entiers et ce décalage à droite on obtient un mot double qui, lorsqu'il est considéré comme un nombre à virgule flottante, devient une approximation grossière de la racine carrée inverse du nombre entré. Ensuite, une itération de la méthode de Newton est réalisée afin de gagner en précision et le résultat est retourné. L'algorithme génère des résultats raisonnablement précis en utilisant une seule approximation par la méthode de 11 Newton ; Toutefois, il reste plus lent que d'utiliser l'instruction SSE rsqrtss sortie elle aussi en 1999 sur les processeurs x86 . Un exemple pratique Considérons un nombre x = 0,156 25, pour lequel on souhaite calculer 1/√ x ≈ 2,529 82. Voici les premières étapes de l'algorithme : 0011_1110_0010_0000_0000_0000_0000_0000 Trame binaire de x et i 0001_1111_0001_0000_0000_0000_0000_0000 Décalage à droite d'une position : (i >> 1) 0101_1111_0011_0111_0101_1001_1101_1111 Le nombre magique 0x5f3759df 0100_0000_0010_0111_0101_1001_1101_1111 le résultat de 0x5f3759df - (i >> 1) En utilisant la représentation IEEE 32-bit : 0_01111100_01000000000000000000000 1.25 * 2^-3 0_00111110_00100000000000000000000 1.125 * 2^-65 0_10111110_01101110101100111011111 1.432430... * 2^+63 0_10000000_01001110101100111011111 1.307430... * 2^+1 En réinterprétant la dernière trame binaire en tant que nombre à virgule flottante on obtient l'approximation y = 2,614 86 ayant une erreur relative d'environ 3,4 %. Après une itération de la méthode de Newton, le résultat final est y = 2,525 49 avec une erreur de seulement 0,17 %. Fonctionnement de l'algorithme L'algorithme calcule 1/√ x en effectuant les étapes suivantes : 1. Transforme l'argument x en entier afin d'appliquer une approximation de log2(x) ; 2. Utilise cet entier pour calculer une approximation de log2(1/√ x) ; 3. Transforme celui-ci afin de revenir à un nombre flottant afin d'effectuer une approximation de l'exponentielle base-2 ; 4. Affine l'approximation en utilisant une itération de la méthode de Newton. Représentation en nombre flottant Puisque cet algorithme se base fortement sur la représentation bit à bit des nombres à virgule flottante de simple-précision, un aperçu rapide de ce système est fourni ici. Afin d'encoder un nombre réel non nul x en tant que flottant de simple-précision, on commence par écrire x comme un nombre binaire en notation scientifique : Où l'exposant ex est un entier, mx ∈ [0, 1), et 1.b1b2b3... est la représentation binaire de la "mantisse" (1 + mx). Notons qu'il n'est pas nécessaire d'enregistrer le bit avant le point dans la mantisse car il vaut toujours 1. Avec ce formalisme, on calcule 3 entiers : Sx, le "bit de signe", valant 0 si x > 0 ou 1 si x < 0 (1 bit) 12 Ex = ex + B est "l'exposant biaisé" où B = 127 est le "biais d'exposant" (en) (8 bits) 23 13 Mx = mx × L, où L = 2 (23 bits) Ces valeurs sont ensuite condensées de gauche à droite dans un conteneur 32 bit. Par exemple, en utilisant le nombre x = 0,156 25 = 0,001 012. En normalisant x on a : Donc, les trois valeurs entières non signées sont : S = 0 E = −3 + 127 = 124 = 011111002 23 M = 0.25 × 2 = 2097152 = 010000000000000000000002 Ces champs sont condensés comme ceci : Approcher un logarithme en passant à l'entier S'il fallait calculer 1/√ x sans un ordinateur ou une calculatrice, une table de logarithmes serait utile accompagnée de l'identité logb(1/√ x) = −½ logb(x) valide quelle que soit la base b. La racine carrée inverse rapide repose sur cette dernière ainsi que sur le fait que l'on puisse effectuer un logarithme approximatif d'un nombre en passant d'un float32 à un entier. Explications : Soit x un nombre normal positif : On a alors 14 Mais puisque mx ∈ [0, 1), le logarithme de la partie droite peut être arrondi par où σ est un paramètre arbitraire permettant de régler l'arrondi. Par exemple : σ = 0 fournit des résultats exacts aux bords de l'intervalle tandis que σ ≈ 0.0430357 fournit l'approximation optimale. Alors nous avons l'approximation 15 D'un autre côté, en interprétant la représentation binaire de x en tant qu'entier, on obtient : L'entier converti en nombre flottant (en bleu), comparé à On remarque alors que I est une approximation linéaire mise à l'échelle et décalée de log (x), comme présenté sur le graphique ci- x 2 un logarithme décalé et à contre. En d'autres termes, log2(x) est approché par l'échelle (en gris). Première approximation du résultat Le calcul de y = 1/√ x est basé sur l'identité En utilisant l'approximation du logarithme telle que précédemment définie et appliquée à x et y, l'équation devient : Qui s'écrit en code C : i = 0x5f3759df - ( i >> 1 ); Le premier terme étant le nombre magique 16 à partir duquel on déduit σ ≈ 0.0450466.