nombre à virgule flottante

Un virgule flottante souvent - nombre à virgule flottante appelé ( Anglais nombre à virgule flottante ou un court flottant , littéralement numéro avec flottierendem points ou [probablement continuer lehnübersetzt ] à virgule flottante ) - est une approximative représentation d'un nombre réel .

Nombres à virgule flottante exactement représentables pour différentes longueurs de mantisse, base : 2, exposant -3 à 1

L'ensemble des nombres à virgule flottante est un sous-ensemble des nombres rationnels . Avec les opérations définies sur eux ( arithmétique à virgule flottante ), les nombres à virgule flottante forment une arithmétique finie qui a été développée principalement en ce qui concerne les calculs numériques avec des ordinateurs ( binaires ) .

Notions de base

problème

Toutes les aides arithmétiques (mécaniques ou électroniques) de l' abaque à l'ordinateur utilisent des nombres à virgule fixe comme forme la plus simple de représentation des nombres . Une séquence de chiffres essentiellement limitée est enregistrée et la virgule est supposée à une position fixe.

Dans le cas de calculs plus importants, des débordements se produisent inévitablement , ce qui oblige à mettre à l'échelle les valeurs et à les recalculer afin de ramener le résultat final et tous les résultats intermédiaires dans la plage de valeurs autorisée. Cette mise à l'échelle prend du temps et doit être automatisée.

Notation exponentielle

Une idée évidente qui mène directement aux nombres à virgule flottante est de stocker également la place exacte de la virgule pour chaque valeur. Cela ne signifie mathématiquement que la représentation du nombre à deux valeurs, la mantisse et l' exposant : . La liberté dans le choix de l'exposant peut être utilisée pour ramener la mantisse dans une plage de valeurs fixe, par exemple . Cette étape est appelée normalisation de la mantisse. ${\ style d'affichage x}$ ${\ style d'affichage m}$ ${\ style d'affichage e}$${\ displaystyle x = m \ cdot 10 ^ {e}}$${\ displaystyle 1 \ leq m <10}$

Exemple : La valeur de la vitesse de la lumière est

${\ displaystyle {\ begin {aligned} c & = 299 \, 792 \, 458 \; {\ text {m/s}} \\ & = 299 \, 792 {,} 458 \ cdot 10 ^ {3} { \ text {m / s}} \\ & = 0 {,} 299 \, 792 \, 458 \ cdot 10 ^ {9} {\ text {m / s}} \\ & = 2 {,} 997 \, 924 \ .58 \ cdot 10 ^ {8} {\ text {m/s}} \ end {aligned}}}$

Seule la mantisse de la dernière représentation est normalisée.

Cette notation a longtemps été utilisée par les physiciens et les mathématiciens pour indiquer les très grands et les très petits nombres. Même aujourd'hui, la notation à virgule flottante sur les calculatrices de poche est donc spécifiquement appelée format scientifique (sci) .

Une variante compacte de la notation exponentielle est souvent utilisée par les programmeurs pour entrer et sortir des nombres sous forme de texte, par ex. Par exemple dans le code source ou dans le débogueur : 2.99792458e8 (= 2.997.924.58 · 10 ⁸ ) ou 3.141592653589793d0 ( d est utilisé pour les nombres en double précision ). Le e ou le d est à comprendre comme une forme abrégée de « fois 10 à la puissance ».

Arithmétique à virgule flottante

Pour les calculs avec des nombres à virgule flottante, chaque nombre et chaque résultat intermédiaire est mis à l'échelle individuellement (par opposition à la mise à l'échelle globale). La mise à l'échelle (calcul de l'exposant) de chaque résultat intermédiaire nécessite un effort de calcul supplémentaire et a donc été évitée autant que possible jusque dans les années 1980. Les PC de l'époque n'avaient pas de processeur à virgule flottante en standard . Un autre facteur était les exigences de mémoire plus élevées des nombres à virgule flottante, qui ne pouvaient être limitées qu'en renonçant à une précision plus élevée. En conséquence, seuls les premiers avaient des superordinateurs (nombre cruncher) une virgule flottante ou au moins un matériel prenant en charge une arithmétique logicielle à virgule flottante.

Le choix de la base 10 est arbitraire et uniquement dû au système décimal habituel. Les nombres à virgule flottante peuvent être représentés avec n'importe quelle base ; en général, toute base sélectionnée s'applique . Utilisez des calculatrices (principalement), (rarement aujourd'hui) ou (par exemple pour les mathématiques financières, voir ci-dessous). Toute base est la condition pour les nombres normalisés . ${\ displaystyle x = m \ cdot b ^ {e}}$${\ style d'affichage b}$${\ style d'affichage b = 2}$${\ style d'affichage b = 16}$${\ style d'affichage b = 10}$${\ displaystyle 1 \ leq m <b}$

développement historique

La première utilisation documentée de la virgule flottante remonte à environ 2700 ans : En Mésopotamie (Mésopotamie) des calculs scientifiques ont été effectués à l'aide de la base réalisée et l'exposant (un entier généralement petit) est simplement porté dans la tête. Jusqu'à récemment, la même procédure était courante pour les calculs avec une règle à calcul . ${\ style d'affichage b = 60}$

Dans les machines à calculer , Konrad Zuse a utilisé pour la première fois sa propre représentation en virgule flottante pour ses ordinateurs Z1 et Z3 .

présentation

Dans la section précédente, les paramètres de base d'un nombre à virgule flottante ont déjà été présentés. Il y a la base , le nombre de places de mantisse et le nombre de places d'exposant . De plus, il existe d'autres paramètres destinés à faciliter les opérations arithmétiques lors des calculs. Cette section décrit brièvement les paramètres et les champs de bits d' un nombre à virgule flottante général. ${\ style d'affichage b}$${\ style d'affichage p}$${\ style d'affichage r}$

Base

${\ displaystyle 2 {,} 997.924.58 \ cdot {\ color {red} 10} ^ {8}}$

Un paramètre est la base choisie . Les nombres directement traités par les humains utilisent soit ou . Dans ce cas particulier, les préfixes kilo = 1000 ¹ , mega = 1000 ² , giga = 1000 ³ , tera = 1000 ⁴ et milli = 1000 ⁻¹ , micro = 1000 ⁻² , nano = 1000 ⁻³ , pico sont utilisés pour le exposant = 1000 ^{-4 de} la système international d'unités . ${\ displaystyle {\ boldsymbol {b}}}$${\ style d'affichage b = 10}$${\ style d'affichage b = 1000}$

Dans l'informatique le système dual et ses proches ont prévalu et c'est les bases , et communes. Depuis la norme IEEE 754 pour les nombres à virgule flottante, la base a été utilisée presque exclusivement dans les ordinateurs modernes . ${\ style d'affichage b = 2}$${\ style d'affichage b = 8}$${\ style d'affichage b = 16}$${\ style d'affichage b = 2}$

mantisse

${\ displaystyle {\ color {red} 2} {,} {\ color {red} 997} {.} {\ color {red} 924} {.} {\ color {red} 58} \ cdot 10 ^ {8 }}$

La mantisse contient les chiffres du nombre à virgule flottante. Si vous enregistrez plus de chiffres, la précision augmente. Le nombre de chiffres de la mantisse exprime comment exactement le nombre est approximé. Cette virgule flottante est soit directement indiquée, soit sous la forme du plus petit nombre décrit qui peut être ajouté une à une aux différentes sources de résultats ( ; minimal !) (W d dans les propriétés..). ${\ displaystyle {\ boldsymbol {m}}}$${\ style d'affichage p}$${\ style d'affichage \ epsilon}$${\ displaystyle 1+ \ epsilon> 1}$${\ style d'affichage \ epsilon}$

Exemple : Pour les nombres IEEE-754 du type Single avec la base , la mantisse est composée de chiffres. Voici 1.19209289551e − 0007. ${\ style d'affichage b = 2}$${\ style d'affichage p = 23}$${\ style d'affichage \ epsilon =}$

exposant

${\ displaystyle 2 {,} 997.924.58 \ cdot 10 ^ {\ color {red} 8}}$

Après normalisation, l' exposant enregistre la place exacte de la virgule et donc l'ordre de grandeur du nombre. Le nombre de chiffres exposants limite les variations possibles de la virgule et décrit ainsi la plage de valeurs des nombres à virgule flottante affichés. Pour décrire un système de nombres à virgule flottante, on précise le plus petit et le plus grand exposant possible ou le nombre d'exposants et le passage à 0 (biais) . ${\ displaystyle {\ boldsymbol {e}}}$${\ style d'affichage r}$

Exemple : pour les nombres IEEE 754 du type Single avec la base , le plus petit exposant possible est -126 et le plus grand est 127. Cela signifie que le plus grand nombre à virgule flottante qui peut être représenté dans ce système et le plus petit nombre à virgule flottante normalisé positif . Ces valeurs, et , décrivent la plage de valeurs autorisée. ${\ style d'affichage b = 2}$${\ displaystyle \ max = 1 {,} 1111 \ ldots \ cdot 2 ^ {127} \ approx 3 {,} 4 \ cdot 10 ^ {+ 38}}$${\ displaystyle \ operatorname {minpos} = 1 {,} 00000 \ ldots \ cdot 2 ^ {- 126} \ approx 1 {,} 175 \ cdot 10 ^ {- 38}}$${\ displaystyle \ max = 3 {,} 4 \ cdot 10 ^ {+ 38}}$${\ displaystyle \ operatorname {minpos} = 1 {,} 175 \ cdot 10 ^ {- 38}}$

normalisation

${\ displaystyle {\ color {red} 2 {,}} 997.924.58 \ cdot 10 ^ {8}}$

La représentation d'un nombre à virgule flottante n'est initialement pas clairement définie. Le chiffre 2 peut s'écrire comme ou aussi . ${\ displaystyle 2 {,} 0 \ cdot 10 ^ {0}}$${\ displaystyle 0 {,} 2 \ cdot 10 ^ {1}}$

Afin de forcer l'utilisation d'une représentation clairement définie, on utilise donc souvent des nombres à virgule flottante normalisés , dans lesquels la mantisse est ramenée dans une plage définie. Deux conditions de normalisation évidentes sont et . Selon la première règle , le chiffre 2 s'écrirait ainsi, la représentation ne serait alors pas autorisée. Le calcul avec des nombres normalisés est plus facile, c'est pourquoi, dans le passé, certains implémenteurs d'arithmétique à virgule flottante n'autorisaient que les nombres normalisés. Cependant, le nombre 0 ne peut pas être affiché de manière normalisée. ${\ displaystyle 1 / b \ leq m <1}$${\ displaystyle 1 \ leq m <b}$${\ displaystyle 0 {,} 2 \ cdot 10 ^ {1}}$${\ displaystyle 2 {,} 0 \ cdot 10 ^ {0}}$

Une distinction est faite - par rapport à la base 10 habituelle dans le système de numération :

• Notation scientifique avec normalisation conséquente sur${\ displaystyle 1 \ leq m <10}$
  • Exemple : 10000 = 1e^4e
• Notation technique avec normalisation à , avec f comme puissance du nombre de chiffres significatifs restants de l' incertitude de mesure pour la précision de calcul (chiffres dénormalisés) . Seuls les multiples de 3 apparaissent dans l'exposant - lors du calcul avec des unités de mesure , cette représentation peut être facilement convertie en préfixes d' unité ainsi que le regroupement de chiffres avec des milliers les séparant, ou peut être généré à partir d'eux ${\ displaystyle 1 / f \ leq m <1000}$
  • Exemple : 10 000 m = 10e³ m= 10 km
  • Importance : 10.00e³ m= 10 000 ± 5 m (4 chiffres significatifs relatifs à la mesure en kilomètres avecarrondi), mais0.01e⁶ m= 10 000 ± 5 000 m (2 chiffres significatifs par rapport à la mesure en mm) - les informations précises sur l'incertitude de mesure standard et étendue sontconformes à lanorme DIN1319-3 ou auguide ISO / BIPM(GUM, ENV 13005)
• IEEE 754 (nombres à virgule flottante pour microprocesseurs) utilise la condition de normalisation pour les nombres normalisés et autorise des nombres dénormalisés (subnormaux) supplémentaires entre 0 et minpos.${\ displaystyle 1 \ leq m <2}$

Représentation du signe de l'exposant avec ou sans biais

Dans les systèmes à virgule flottante, l'exposant est un nombre signé. Cela nécessite la mise en œuvre d'une arithmétique d'entier signé supplémentaire pour les calculs d'exposant. Cet effort supplémentaire peut être évité si un nombre fixe , la valeur de biais ou l'excès, est ajouté à l'exposant et la somme est enregistrée à la place de l'exposant . Cette somme est alors un nombre positif non signé. La plupart du temps, l'utilisation d'un biais est combinée à la représentation du 0 à . ${\ style d'affichage e}$${\ style d'affichage B}$${\ style d'affichage e}$${\ style d'affichage E = e + B}$${\ style d'affichage B}$${\ style d'affichage e = 0}$

Une alternative que l'on trouve rarement aujourd'hui est la représentation de l'exposant en complément à deux, en complément à un ou en signe de la quantité.

L'avantage de la représentation biaisée est qu'elle facilite la comparaison de la taille de deux nombres à virgule flottante positifs. Il suffit que les séquences de nombres em , donc chaque exposant e suivi de la mantisse m , lexikografisch pour comparer. Une soustraction à virgule flottante suivie d'une comparaison à zéro serait beaucoup plus complexe. L'inconvénient de la représentation biaisée par rapport à la représentation du complément à deux est qu'après avoir ajouté deux exposants biaisés, le biais doit être soustrait afin d'obtenir le résultat correct.

IEEE 754 utilise la représentation avec B = 127 pour simple et B = 1023 pour double.

Signe du nombre

Le signe v d'un nombre à virgule flottante (+ ou - ; également +1 ou -1) peut toujours être codé dans un bit. La plupart du temps, le bit est utilisé pour les nombres positifs (+) et le bit pour les nombres négatifs (-). Mathématiquement, vous pouvez écrire${\ style d'affichage S = 0}$${\ style d'affichage S = 1}$${\ displaystyle v = (- 1) ^ {S}}$

Brève description des paramètres

Ces dernières années, le résumé suivant des paramètres essentiels a appliqué , , et un nombre à virgule flottante. Ici, vous écrivez séparément les tailles 1, par points , , et dans cet ordre. Le 1 est le nombre de bits de signe. Un nombre unique IEEE-754 avec 1 bit de signe, 8 bits d'exposant et 23 bits de mantisse est donc un nombre à virgule flottante 1.8.23.127.2. Si la base et le biais ressortent du contexte, les deux peuvent être omis et on parle d'un nombre à virgule flottante 1.8.23. ${\ style d'affichage b}$${\ style d'affichage p}$${\ style d'affichage r}$${\ style d'affichage B}$${\ style d'affichage r}$${\ style d'affichage p}$${\ style d'affichage B}$${\ style d'affichage b}$${\ style d'affichage b}$${\ style d'affichage B}$

Une deuxième notation commune omet le bit de signe et ne précise que la longueur de la mantisse et la longueur de l'exposant : s23e8.

Avec ces notations, ce qui suit s'applique aux numéros IEEE-754 :

half:   1.5.10.15.2,       1.5.10          oder s10e5
single: 1.8.23.127.2,      1.8.23          oder s23e8
double: 1.11.52.1023.2,    1.11.52         oder s52e11
quad:   1.15.112.16383.2,  1.15.16383      oder s112e15
oct:    1.19.236.262143.2, 1.19.236.262143 oder s236e19

Morceau caché

Lors de l'affichage des mantisses normalisées dans le système binaire , un bit peut être enregistré. Comme le premier chiffre d'un nombre normalisé n'est toujours pas égal à 0, ce chiffre est toujours égal à 1. Un chiffre avec la valeur fixe 1 n'a plus besoin d'être enregistré explicitement, comme cela est connu implicitement. Lorsqu'il est implémenté, il s'agit d'un bit caché ( Engl. Littéralement " bit caché parlé"). Le format IEEE susmentionné pour les nombres à virgule flottante utilise cette option d'économie, mais pas le format interne 80 bits des processeurs Intel.

Si, par exemple, le nombre 5.25 doit être converti en un réel court (nombre en simple précision) selon IEEE 754, la virgule est décalée deux fois vers la gauche après l'étape intermédiaire de conversion binaire en 101.01, de sorte qu'une représentation binaire normalisée avec 1.0101e2 est donné. En raison du bit caché, seule la séquence 0101 est reprise dans la mantisse à 23 chiffres. L'utilisation d'un bit caché, cependant, nécessite une représentation séparée du zéro, puisque chaque mantisse représente une valeur supérieure à 0 en raison du bit caché.

Propriétés d'une arithmétique à virgule flottante

Les nombres à virgule flottante réservent quelques surprises, en particulier pour le profane en mathématiques, qui influencent souvent les résultats des calculatrices de poche et des calculs informatiques. Les plus importantes sont les règles mathématiques communes qui ont été outrepassées. Toute personne travaillant de manière intensive avec une aide au calcul doit être familiarisée avec ces propriétés. Ils proviennent de la précision limitée avec laquelle la mantisse et l'exposant sont stockés. La conséquence de cette limitation devient claire lorsque l'on considère que les nombres réels infiniment nombreux doivent être représentés par un nombre fini de combinaisons de chiffres. Les nombres à virgule flottante dans le domaine d' un système peuvent être considérés comme un long tableau de valeurs discrètes. Une fonction à virgule flottante attribue ensuite une valeur différente à chaque valeur de cette liste. Il en va de même pour les opérations à deux chiffres et à plusieurs chiffres. Les plages de valeurs correspondantes sont représentées graphiquement dans l' article Minifloats .

Il en résulte une imprécision légère à absolue des calculs et la validité invalidée des règles de calcul mathématiques courantes.

Extinction

L'effacement est l'effet qu'en soustrayant des nombres de presque la même taille, le résultat est faux.

Exemple:

Si vous soustrayez et le nombre 3,141 dans une arithmétique à virgule flottante à quatre chiffres ( , ), le profane s'attend à ce que le résultat soit correctement arrondi . ${\ displaystyle \ pi = 3 {,} 141592653589793 \ ldots}$${\ style d'affichage b = 10}$${\ style d'affichage p = 4}$${\ displaystyle \ pi -3 {,} 141 = 0 {,} 000592653589793 \ ldots \ approx 5 {,} 927 \ ldots \ cdot 10 ^ {- 4}}$

En fait, le résultat est : La valeur arrondie à quatre chiffres de est , donc le résultat du calcul devient . Ce résultat est dû au fait que les variables de sortie, en particulier en arithmétique à virgule flottante, sont déjà affichées et ne sont pas exactement disponibles. ${\ displaystyle 1 {,} 0000 \ cdot 10 ^ {- 3}}$${\ displaystyle \ pi = 3 {,} 141592653589793 \ ldots}$${\ style d'affichage \ pi = 3 {,} 142 \}$${\ displaystyle 3 {,} 142-3 {,} 141 = 0 {,} 001 = 1 {,} 0000 \ cdot 10 ^ {- 3}}$${\ style d'affichage \ pi}$

Nombres de grandeurs diverses (absorption)

L'addition ou la soustraction d'un nombre beaucoup plus petit ne change pas le nombre plus grand.

Dans l'exemple de l'arithmétique décimale à quatre chiffres ( , ), l'ajout de 0,001 à 100 ne change rien sur le plus grand opérande. Idem pour la soustraction : ${\ style d'affichage b = 10}$${\ style d'affichage p = 4}$

• ${\ displaystyle 1 {,} 000 \ fois 10 ^ {2} +1 {,} 000 \ fois 10 ^ {- 3} = 1 {,} 000 \ fois 10 ^ {2} +0 {,} 000 | 01 \ cdot 10 ^ {2} = 1 {,} 000 \ cdot 10 ^ {2} +0 {,} 000 \ cdot 10 ^ {2} = 1 {,} 000 \ cdot 10 ^ {2}}$

(Les chiffres derrière la ligne | sont omis pour la mise à l'échelle)

Cours inférieur

Comme il existe un plus petit nombre positif dans la représentation à virgule flottante, en dessous duquel aucune valeur ne peut être représentée, un résultat dans cette zone est généralement représenté par 0. Dans ce cas on parle de sous-débit. Si le résultat est un résultat intermédiaire, toutes les informations sur le résultat ont été perdues à ce stade. Dans certains cas, la précision du résultat final n'est pas affectée, mais dans d'autres cas, le résultat final obtenu peut être complètement faux.

Invalidité des lois associatives et distributives

L'addition et la multiplication de nombres à virgule flottante ne sont pas associatives , c'est-à-dire en général :

• ${\ displaystyle (x + y) + z \ neq x + (y + z)}$
• ${\ displaystyle (x \ cdot y) \ cdot z \ neq x \ cdot (y \ cdot z)}$

L'addition et la multiplication de nombres à virgule flottante ne sont pas non plus distributives , ce qui signifie en général :

• ${\ displaystyle x \ cdot (y + z) \ neq (x \ cdot y) + (x \ cdot z)}$
• ${\ displaystyle (x + y) \ cdot z \ neq (x \ cdot z) + (y \ cdot z)}$

Solvabilité des équations

En arithmétique à virgule flottante, certaines équations normalement insolubles ont une solution. Cet effet est même utilisé pour décrire un tel système à virgule flottante.

Exemple:

Dans le domaine des nombres réels, l'équation d' une solution. ${\ style d'affichage (1 + x) = 1}$${\ displaystyle x \ neq 0}$

En arithmétique à virgule flottante, cette équation a de nombreuses solutions, à savoir tous les nombres qui sont trop petits pour avoir un effet sur la somme. Encore une fois avec l'exemple des fractions décimales à quatre chiffres ( , ), ce qui suit s'applique (le tiret | marque les endroits omis dans l'addition) : ${\ style d'affichage b = 10}$${\ style d'affichage p = 4}$

• 1 + 1e − 3 , 0= 1 000 + 0,001 | 000 000… = 1 000 + 0,001 = 1,001> 1
• 1 + 1e − 4 , 0= 1 000 + 0 000 | 10 000 ... 0= 1 000 + 0 000 = 1 000 = 1
• 1 + 2,3e − 5 = 1 000 + 0 000 | 023000 ... = 1 000 + 0 000 = 1 000 = 1

Le plus petit nombre déjà mentionné ci-dessus qui peut être ajouté à un et un à un fournit des résultats différents ( ;  ! Minimal) appelé précision de la machine . ${\ style d'affichage \ epsilon}$${\ displaystyle 1+ \ epsilon> 1}$${\ style d'affichage \ epsilon}$

Conversions

Si la base est autre que 10, les nombres doivent être convertis entre le système à virgule flottante actuel et le système décimal afin d'obtenir une représentation lisible par l'homme. Ceci est généralement programmé rapidement (et souvent de manière imprécise). Une exigence déjà ancienne et importante pour cette conversion est sa réversibilité au bit près. Un résultat représenté dans le système décimal doit pouvoir être relu et reproduire la même représentation dans le système à virgule flottante avec une précision binaire.

Cette exigence n'est souvent pas prise en compte. Une exception à cela est Java, qui observe la phrase suivante :

Théorème : On peut montrer qu'il ne suffit pas d'arrondir le nombre de décimales calculé à partir de la précision de la mantisse et de produire ces décimales arrondies. Cependant, un chiffre supplémentaire est suffisant (théorème 15). C'est la raison pour laquelle une place supplémentaire et apparemment superflue apparaît toujours dans la représentation des nombres réels produits par les programmes Java.

Fractions décimales

Même les fractions décimales simples telles que 0,1 ne peuvent pas être représentées exactement comme des nombres binaires à virgule flottante, car chaque nombre rationnel dont le dénominateur abrégé n'est pas une puissance de deux conduit à une représentation périodique non terminée dans le système binaire. Seuls les premiers chiffres de celui-ci sont enregistrés, ce qui entraîne une inexactitude. Décimal 0,1 est binaire 0,0001100110011 ... Cependant, pour les systèmes binaires à virgule flottante avec des règles d'arrondi appropriées, il a été prouvé que la représentation de 0,1 multipliée par 10 donne exactement à nouveau 1. En général, avec un arrondi correct, (m / 10) · 10 = m (théorème de Goldberg 7 pour le cas particulier n = 2 ¹ + 2 ³ = 10). ${\ style d'affichage p}$

Dans des disciplines telles que les mathématiques financières , il faut souvent des résultats qui correspondent exactement à un calcul manuel. Ceci n'est possible qu'avec l'arithmétique décimale à virgule flottante ou - avec quelques « contorsions » - avec l'arithmétique à virgule fixe.

Vérifier l'égalité

La restriction mentionnée dans la section sur les fractions décimales que beaucoup de ces nombres décimaux ne peuvent pas être représentés exactement dans le système binaire d' un ordinateur a un impact sur les comparaisons entre les nombres à virgule flottante lors de la programmation . Un exemple dans le langage de programmation C devrait clarifier ceci : ${\ style d'affichage x = y}$

#include <stdio.h>
int main(void) {
 if (0.362 * 100.0 != 36.2)
  puts("verschieden");

 if (0.362 * 100.0 / 100.0 != 0.362)
  puts("auch verschieden");
 return 0;
}

Bien que les deux équations et soient mathématiquement correctes, elles deviennent incorrectes en raison de la conversion inexacte vers le système binaire informatique. Dans l'exemple de programme, les deux inégalités sont donc considérées comme vraies. ${\ displaystyle 0 {,} 362 \ cdot 100 = 36 {,} 2}$${\ displaystyle 0 {,} 362 \ cdot 100/100 = 0 {,} 362}$

Les comparaisons doivent donc être remplacées par une requête pour savoir si les valeurs à comparer peuvent être considérées comme identiques dans le cadre d'une précision atteignable (généralement appelée tolérance ). ${\ style d'affichage \ varepsilon}$

Si l'on tolère une erreur absolue dans la comparaison, une formulation possible est . ${\ displaystyle \ vert xy \ vert \ leq \ varepsilon}$

Si l'on tolère une erreur relative dans la comparaison, une formulation possible est . Le deuxième cas doit généralement être connecté à la requête de cas particulier . ${\ displaystyle \ vert 1 - {\ tfrac {y} {x}} \ vert \ leq \ varepsilon}$${\ displaystyle x \ neq 0}$

Alternativement, tous les facteurs ou sommes, y compris le résultat attendu de ces comparaisons problématiques dans le cas de nombres à virgule flottante rationnels, peuvent également être multipliés par, l'index indiquant la dernière décimale. Plus généralement : Tous les nombres à virgule flottante doivent - si possible - être convertis en fractions. Ceux-ci peuvent à leur tour être convertis dans le système de nombres binaires clairement et sans arrondir la mantisse. Les compilateurs de certains langages de programmation (par exemple Java , Ruby , C ++ , Objective-C , Swift , Rust , etc.) peuvent calculer directement avec les fractions et comparer les fractions dans les instructions conditionnelles mentionnées ci-dessus (instructions If), qui ne sont pas entrés en conséquence deviennent. D'autres langages de programmation (par exemple, Object Pascal , PHP , JavaScript , Perl , Python , etc.), à leur tour, reconvertissent la fraction ou le quotient en un nombre binaire dans la toute première étape et ensuite seulement comparer les deux valeurs, ce qui dans ce cas rend les deux conditions vraies et les dépenses indiquées ci-dessus sont effectuées. ${\ displaystyle n_ {1} n_ {2} \ points n_ {m}}$${\ displaystyle 10 ^ {\ gauche (n_ {m} \ droite)}}$${\ style d'affichage m}$

Les nombres pairs avec exactement le même modèle binaire et donc des valeurs exactement identiques ne sont parfois pas considérés comme identiques par l'ordinateur . Cela est dû aux formats parfois non identiques dans la mémoire (par exemple Intel 64 bits) et lors d'un calcul dans l'unité à virgule flottante (par exemple Intel 80 bits). Si les mêmes motifs binaires qui doivent être comparés proviennent une fois de la mémoire et ainsi arrondis et une fois de la FPU et donc avec une précision totale, une comparaison conduit à un résultat erroné. Le remède est le même que déjà décrit. Ce problème peut également se poser avec des comparaisons plus grandes/plus petites, selon le langage et l'architecture utilisés, des commandes spéciales et/ou un détour par la mémoire principale doivent être pris pour résoudre ce problème. ${\ style d'affichage x = y}$

Utilisation cachée d'autres représentations

Certains systèmes informatiques utilisent plusieurs formats différents lors du calcul. Avec Intel et les processeurs associés tels que AMD, le FPU calcule avec un format 80 bits. Les numéros sont enregistrés dans un format 64 bits ou 32 bits compatible IEEE-754. Lors de l'utilisation des extensions MMX / SSE , d'autres formats de calcul sont à nouveau utilisés. Cela conduit à d'autres propriétés qui sont initialement très opaques pour les profanes. Une simple comparaison de modèles de bits identiques pour l'égalité peut conduire au résultat que les modèles de bits apparemment identiques sont différents. Le programme suivant produit parfois des résultats paradoxaux lorsqu'il est appelé avec la même valeur pour x et y :

void vergleiche (double x, double y) {
 if(x != cos (y))
  printf("paradox\n");
 else
  printf("wuerde jeder so erwarten\n");
}
...
double z = 0.2; // der Wert ist nicht wichtig
vergleiche (cos (z), z);

 mit dem Ergebnis:  paradox 

L'explication de ce comportement est que le compilateur génère deux calculs de cos indépendants, l'un avant l'appel à Compare , l'autre dans Compare . La variable x reçoit le cos (z) avec 64 bits. Chez Intel, le cos (y) peut être calculé avec 80 bits ; les deux résultats sont différents si cos (y) est comparé à la variable 64 bits x non en mémoire mais directement issue du registre de travail 80 bits.

Nombres binaires à virgule flottante dans la technologie numérique

Les exemples ci-dessus sont tous donnés dans le système décimal , c'est-à-dire avec une base b  = 10. Les ordinateurs utilisent le système binaire avec une base b  = 2 à la place .

Simple et double précision

Les nombres à virgule flottante sont normalement représentés sous forme de séquences de 32 bits informatiques  ( simple précision , anglais simple précision ) et 64 bits ( double précision , double précision ) .

Certains processeurs autorisent également de longs nombres à virgule flottante, ainsi par les processeurs familiers de la série Intel - x86 dérivés (entre autres Intel.. Pentium et AMD Athlon ) un Gleitkommazahldarstellung avec 80 bits pour des résultats intermédiaires. Certains systèmes autorisent également les nombres à virgule flottante de 128 bits ( précision quadruple ) . Certains systèmes plus anciens utilisaient également d'autres longueurs telles que 36 bits ( IBM 704 , PDP-10 , UNIVAC 1100/2200 series ), 48 bits (Burroughs) ou 60 bits ( CDC 6600 ),

En outre, il existe également des systèmes appelés minifloats avec très peu de bits (environ 8 ou 16) qui sont utilisés dans les systèmes à faible mémoire ( contrôleurs ) ou à flux de données limités (par exemple, les cartes graphiques).

IEEE 754 et autres normes

Le système à virgule flottante le plus courant et le plus connu aujourd'hui a été conçu par IEEE en 1985 , défini dans IEEE 754 , et est présent dans la plupart des ordinateurs sous forme d' arithmétique matérielle ou logicielle. IEEE 854 est une norme pour les nombres décimaux à virgule flottante ou les fractions décimales . Les deux normes sont fusionnées et étendues dans la révision IEEE 754r .

L'IEEE réglemente la représentation des nombres à virgule flottante dans sa norme IEEE 754 depuis 1985 ; presque tous les processeurs modernes suivent cette norme. Contre-exemples, le 754 ne répond pas aux spécifications de l'IEEE, de certains systèmes IBM - mainframe (format Hexfloat), de l' architecture VAX et de certains supercalculateurs comme ceux de Cray . Le langage Java est basé étroitement sur IEEE 754, mais ne répond pas complètement à la norme.

La définition du format hex float d' IBM se trouve dans le livre "Principles of Operation" de l' architecture z .

Le Power6 d'IBM est l'un des premiers processeurs à implémenter l'arithmétique décimale à virgule flottante dans le matériel ; la base est donc 10. Dans ce qui suit, seule la base 2 est traitée.

À proprement parler, seuls les nombres normalisés des nombres à virgule flottante IEEE 754 le sont. Les nombres dénormalisés sont en fait des nombres à virgule fixe ; ces cas spéciaux ont été créés à des fins numériques spéciales.

Représentation interne

La représentation réelle dans l'ordinateur se compose donc d'un bit de signe, de quelques bits d'exposant et de quelques bits de mantisse. Par quoi la mantisse est principalement normalisée et les nombres dans l' intervalle [1; 2 [représente. (Étant donné que le premier bit avec la valeur un est toujours défini dans cet intervalle , il est généralement supposé implicitement et n'est pas enregistré, voir Hidden Bit ). L'exposant est généralement affiché dans un format biaisé ou en complément à deux . De plus, pour représenter des valeurs spéciales (zéro, infini, pas de nombre), certaines valeurs d'exposant, par exemple le plus grand possible et le plus petit possible, sont généralement réservées.

Un nombre f est donc représenté par f = s · m · 2 ^e , où s est 1 ou -1.

Les limites et leurs bases mathématiques

La représentation binaire différente des nombres peut conduire à des artefacts dans les deux systèmes. Cela signifie : les nombres rationnels qui apparaissent « ronds » dans le système décimal, par exemple , ne peuvent pas être représentés exactement dans le système binaire (la valeur est ). Au lieu de cela, leur représentation binaire est arrondie dans le cadre de la précision de calcul respective, de sorte que lors de la reconversion dans le système décimal, par ex. B. reçoit la valeur 12.44999999900468785. Cela peut entraîner des erreurs imprévues d'arrondi vers le haut ou vers le bas dans les calculs ultérieurs. ${\ displaystyle \ textstyle {\ frac {249} {20}} = 12 {,} 45}$${\ displaystyle 1100 {,} 01 {\ overline {1100}} _ {2}}$

Les artefacts mentionnés ci-dessus sont inévitables dans le système binaire, car un nombre infini de nombres pouvant être représentés exactement dans le système décimal sont des nombres périodiques dans le système binaire avec un nombre infini de décimales. Ils ne pouvaient être évités qu'en utilisant des encodages en base 10 (ou d'autres bases de la forme avec any ), voir aussi code BCD . Cependant, les nombres binaires à virgule flottante sont toujours utilisés pour diverses raisons. ${\ displaystyle 10 \ cdot n}$${\ displaystyle n \ in \ mathbb {N}}$

En général, il existe un nombre infini de nombres rationnels pour chaque base d , qui ont une représentation finie (période 0) pour une autre base et une représentation infinie avec une période pour la base d . La seule caractéristique distinctive du système décimal ici est que les gens y sont habitués, et donc le système décimal est souvent préféré pour le format d'entrée et de sortie des factures.

En mathématiques, un système de nombres à virgule flottante est un tuple , qui représente la base, la plage de l'exposant et la longueur de la mantisse. ${\ displaystyle \ left (d, [e _ {\ mathrm {min}}, e _ {\ mathrm {max}}], l \ right)}$${\ style d'affichage d}$${\ displaystyle \ left [e _ {\ mathrm {min}}, e _ {\ mathrm {max}} \ right]}$${\ style d'affichage l}$

Ainsi un nombre réel x ≠ 0 peut être représenté par un a et un e , de sorte que : et avec . ${\ displaystyle a = \ sum _ {i = 1} ^ {l} a_ {i} \ cdot d ^ {- i}}$${\ displaystyle x = annonce ^ {e}}$${\ displaystyle e \ in \ left [e _ {\ mathrm {min}}, e _ {\ mathrm {max}} \ right]}$

Ceci permet une considération mathématique de l'erreur d'arrondi. La représentation ci-dessus réalise une projection

${\ displaystyle fl \ colon \ mathbb {R} \ to \ {x \ in \ mathbb {R} \ mid \ existe a, e \ colon x = ad ^ {e} \}}$

et donc l'erreur d'arrondi est définie comme

${\ displaystyle {\ frac {| x-fl (x) |} {| x |}} \ leq \ varepsilon: = {\ frac {1} {2}} d ^ {1-l}.}$

Pour les valeurs doubles, même égal (environ ). ${\ style d'affichage \ varepsilon}$${\ displaystyle 2 ^ {- 53}}$${\ displaystyle 1 {,} 1 \ cdot 10 ^ {- 16}}$

Exemple : calcul d'un nombre à virgule flottante

18.4 ₁₀ est à convertir en nombre à virgule flottante, nous utilisons le standard IEEE unique (IEEE 754, binary32).

1. Calcul de la franchise

(L'excès ou le biais est une constante appartenant à la norme numérique. A cet effet, les bits réservés à l'exposant dans la représentation numérique comptent, soit 8 chiffres dans la norme IEEE 754).

Exzess = 2(n-1) - 1
           (n Bits des Exponenten in der Zahlendarstellung)
       = 2(8-1) - 1
       = (27) - 1
       = 128 - 1
       = 127

2. Conversion d'une fraction décimale en un nombre à virgule fixe double sans signe

Gleitkommazahl = 18,4

Vorkommaanteil = 18
 18 / 2 = 9 Rest 0 (Least-Significant Bit)
  9 / 2 = 4 Rest 1
  4 / 2 = 2 Rest 0
  2 / 2 = 1 Rest 0
  1 / 2 = 0 Rest 1 (Most-Significant-Bit)
   = 10010

Nachkommaanteil = 0.4
 0,4 * 2 = 0,8 → 0 (Most-Significant-Bit)
 0,8 * 2 = 1,6 → 1
 0,6 * 2 = 1,2 → 1
 0,2 * 2 = 0,4 → 0
 0,4 * 2 = 0,8 → 0
 0,8 * 2 = 1,6 → 1 (Least-Significant-Bit)
    •
    •
    •
     = 0,0110011001100110011...

18,4 = 10010,011001100110011...

3. Normaliser

10010,01100110011... * 2^0 = 1,001001100110011... * 2^4

4. Calcul de l'exposant double

da 2^4 → Exponent = 4
Exponent + Exzess
   4 + 127 = 131

131/2 = 65 Rest 1 (Least-Significant-Bit)
 65/2 = 32 Rest 1
 32/2 = 16 Rest 0
 16/2 = 8  Rest 0
  8/2 = 4  Rest 0
  4/2 = 2  Rest 0
  2/2 = 1  Rest 0
  1/2 = 0  Rest 1 (Most-Significant-Bit)
   = 10000011

5. Déterminer le bit de signe

Le signe est calculé à partir de la formule (-1) ^ s :

 positiv → 0
 negativ → 1
   = 0

6. Former le nombre à virgule flottante

1 Bit Vorzeichen + 8 Bit Exponent + 23 Bit Mantisse
0 10000011 00100110011001100110011
  → die Vorkomma-Eins wird als Hidden Bit weggelassen;
    da dort immer eine 1 steht,
    braucht man diese nicht zu speichern

Calcul d'un nombre à virgule flottante simple précision IEEE (nombre à virgule flottante 32 bits)

Ici, les étapes de calcul exactes sont présentées pour convertir une fraction décimale en un nombre à virgule flottante binaire du type single selon IEEE 754. Pour ce faire, les trois valeurs ( signe (1 bit), mantisse et exposant ) qui composent le nombre doivent être calculées l' une après l'autre : ${\ style d'affichage v}$ ${\ style d'affichage m}$${\ style d'affichage e}$${\ style d'affichage x}$

${\ displaystyle x = (- 1) ^ {v} \ cdot m \ cdot 2 ^ {e}}$

signe

Selon que le nombre est positif ou négatif, il est 0 ou 1 : ou${\ style d'affichage v}$${\ style d'affichage (-1) ^ {0} = 1}$${\ style d'affichage (-1) ^ {1} = - 1}$

Tous les autres calculs sont effectués avec le montant du nombre.

exposant

Ensuite, l'exposant est enregistré. Avec le type de données unique IEEE , 8 bits sont prévus à cet effet. L'exposant doit être choisi pour que la mantisse ait une valeur comprise entre 1 et 2 :

${\ displaystyle e = \ left \ lfloor \ log _ {2} (| x |) \ right \ rfloor}$

Si le résultat est une valeur pour l'exposant inférieure à -126 ou supérieure à 127, le nombre ne peut pas être enregistré avec ce type de données. Au lieu de cela, le nombre est enregistré comme 0 (zéro) ou comme "infini".

Cependant, la valeur de l'exposant n'est pas enregistrée directement, mais augmentée d'une valeur de biais afin d'éviter les valeurs négatives. Avec IEEE single, la valeur de polarisation est de 127. Cela signifie que les valeurs d'exposant -126 ... + 127 sont enregistrées en tant que "caractéristiques" entre 1 ... 254. Les valeurs 0 et 255 comme caractéristiques sont réservées aux valeurs numériques spéciales " Zero ", " Infinite " et " NaN ".

mantisse

La mantisse est maintenant stockée dans les 23 bits restants :

${\ displaystyle m = \ left ({\ frac {| x |} {2 ^ {e}}} - 1 \ right) \ cdot 2 ^ {23}}$

Exemple numérique avec le nombre 11.25

Nombre = +11,25

Signe = + → 0 _binaire

${\ displaystyle {\ text {Exponent}} = \ left \ lfloor \ log _ {2} (11 {,} 25) \ right \ rfloor = \ left \ lfloor 3 {,} 49 \ right \ rfloor = 3}$→ 3 + 127 = 130 → 10000010 _binaire

${\ displaystyle {\ text {Mantissa}} = \ left ({\ frac {11 {,} 25} {2 ^ {3}}} - 1 \ right) \ cdot 2 ^ {23} = (1 {,} 40625-1) \ cdot 2 ^ {23} = 3407872}$→ 011010000000000000000000 _binaire

Cela donne le nombre à virgule flottante simple précision suivant :

0 100000010 011010000000000000000000

renversement

Si vous souhaitez calculer un nombre décimal à partir d'un nombre à virgule flottante dans le mot machine (32 bits), vous pouvez le faire très rapidement avec la formule suivante :

${\ displaystyle Z = (- 1) ^ {VZ} \ cdot (1 {,} 0 + M / 2 ^ {23}) \ cdot 2 ^ {E-127}}$

Calcul d'un nombre à virgule flottante double précision IEEE (nombre à virgule flottante 64 bits)

Renversement:

La formule suivante permet de calculer un nombre décimal à partir d'un nombre à virgule flottante dans le mot machine (64 bits) :

${\ displaystyle Z = (- 1) ^ {VZ} \ cdot (1 {,} 0 + M / 2 ^ {52}) \ cdot 2 ^ {E-1023}}$

Exemple:

Le nombre binaire 64 bits suivant doit être interprété comme un nombre à virgule flottante :

0 10001110100 0000101001000111101011101111111011000101001101001001

(le bit le plus à gauche est le bit 63 et le bit le plus à droite est le bit 0)

Le bit 63 représente le signe (1 bit), c'est-à-dire

  VZ = 0binär = 0

Les bits 62 à 52 représentent l'exposant (11 bits), donc :

 E = 10001110100binär = 1140

Les bits 51 à 0 représentent la mantisse (52 bits), soit :

  M = 0000101001000111101011101111111011000101001101001001binär = ${\displaystyle 180847918207817}$

Inséré dans la formule donne le résultat (valeurs arrondies) :

 ${\displaystyle Z=(-1)^{0}\cdot (1{,}0+180847918207817/2^{52})\cdot 2^{1140-1023}=1\cdot (1{,}040156304549969)\cdot 2^{117}=1{,}7282561\cdot 10^{35}}$

Remarques

1. ↑ A savoir tous les nombres rationnels qui peuvent être représentés avec une puissance de dix comme dénominateur, mais pas avec une puissance de deux.

Voir également

• Entier (type de données)
• Nombres à virgule flottante dans les applications audio numériques

liens web

Wiktionnaire : nombre à virgule flottante  - explications des significations, origines des mots, synonymes, traductions

Wiktionnaire : nombre à virgule flottante  - explications de sens, origines des mots, synonymes, traductions

Wikibooks : Maths pour l'école${\ displaystyle {\ color {BlueViolet} {\ begin {smallmatrix} {\ mathbf {MATHE} \ mu \ alpha T \ mathbb {R} ix} \ end {smallmatrix}}}}$  - Préfixes et notation à virgule flottante

• Formats binaires de nombres réels (PDF; 192 Ko)
• Robert Munafo : Enquête sur le format à virgule flottante - Aperçu des formats à virgule flottante historiques (Anglais)
• Chris Hecker : Allons au point (flottant) - Allons au point (flottant) (PDF, anglais)
• David Goldberg : Ce que tout informaticien devrait savoir sur l'arithmétique à virgule flottante . (Anglais)
• David Monniaux : Les pièges de la vérification des calculs en virgule flottante (anglais)
• Nombres à virgule flottante / nombres binaires en informatique (représentation relativement simplifiée)
• Une applet pour s'entraîner (nécessite Java)
• Convertisseur binaire-décimal en ligne (anglais)

Preuve individuelle

1. ^ Otto Neugebauer : Les sciences exactes dans l'antiquité. Presses de l'Université de Princeton, 1952.
2. ↑ Bartel Leendert van der Waerden : L'éveil de la science. P. Noordhoff, Groningue, 1954.
3. ^ Donald E. Knuth : Anciens algorithmes babyloniens. Dans : Commun. ACM. 15, 1972, pp. 671-677, Corr. In Commun. ACM. 19, 1976, page 108.
4. ^ Donald E. Knuth : L'art de la programmation informatique . Tome 2 : Algorithmes séminumériques. 3. Édition. Addison-Wesley, 1997, p.196.
5. ^ ^{Un b} David Goldberg: Ce que tout informaticien devrait savoir sur l'arithmétique à virgule flottante . Dans : Enquêtes informatiques ACM . enregistrer 23 , 1991, p. 5-48 , doi : 10.1145 / 103162.103163 ( sun.com [consulté le 2 septembre 2010]). 
6. ↑ général décimal arithmétique. Société IBM
7. ^ Principes de fonctionnement. (PDF; 4,7 Mo) 2e édition. IBM Corporation, 2001, chapitres 19-4