Représentation des nombres entiers

Nombres positifs

Principe

Représentation d’un nombre entier positif ou nul : binaire de base

Nombres négatifs

Problème

comment représenter le signe -

  • avec uniquements des bits
  • dans un nombre de bits fixé

Bit de signe

1 bit indique le signe, le reste = le nombre en valeur absolue

exemples sur 8 bits :

  • 00000101=+50\ 000\ 0101\ =\ +5
  • 10000101=−51\ 000\ 0101\ =\ -5

inconvénients :

  • comment représenter zéro ? 100000001\ 000\ 0000 et 000000000\ 000\ 0000
  • l’addition marche plus : −5+3-5 + 3

10000101+00000011=10001000=−81\ 000\ 0101 + 0\ 000\ 0011 = 1\ 000\ 1000 = -8

Complément à deux

  • change rien pour les nombres positifs

  • on obtient les nombres négatifs en

    • inversant tous les bits de la valeur absolue (= complément à 1)
    • on ajoute 1 au résultat (sans s’occuper des dépassements)

Complément à deux : exemples

  • pour coder -5 sur 8 bits

    1. 000001010000\ 0101
    2. 111110101111\ 1010
    3. 111110111111\ 1011

  • coder -3 sur 16 bits

    1. 00000000000000110000\ 0000\ 0000\ 0011
    2. 11111111111111001111\ 1111\ 1111\ 1100
    3. 11111111111111011111\ 1111\ 1111\ 1101

    vérification dans RISC simulator 1111 1111 1111 1101

  • pour coder -0

    1. 000000000000\ 0000
    2. 111111111111\ 1111
    3. 000000000000\ 0000

avantage : l’addition fonctionne correctement

−5+8=11111011+00001000=00000011=3-5 + 8 = 1111 1011 + 0000 1000 = 00000011 = 3

Complement à deux : exos conversion

Exercice

Écrire les nombres suivants en complément à deux sur 8 bits

  • −14-14
  • −55-55
  • −20-20
Exercice

Convertir les nombres suivants (écrits en complément à deux) en décimal

  • 110110111101\ 1011
  • 101101101011\ 0110
  • 000100110001\ 0011

Complément à deux : exos opérations

Exercice

Faire les opérations suivantes en décimal puis en binaire complément à deux; vérifier le résultat

  • −8+−5-8 + -5
  • −12+15-12 + 15
  • −8+9-8 + 9
  • 9+−129 + -12

Représentation des nombres décimaux

Représentation en virgule fixe

Principe

lorsque le nombre de chiffres en base 10 après la virgule est fixé, on peut simplement décaler tous les nombres d’un facteur donné

exemple opérations financières en 64 bits :

  • on ne se préoccupe pas des millièmes de centimes
  • on a rarement à traiter des opérations dépassant plusieurs milliers de milliards d’euros (264=184467440737095516152^{64} = 18 446 744 073 709 551 615)

=> on code les montants en centimes, ou en décicentimes, ou en centicentimes

Exercices

Exercice

Sur 32 bits, en complément à deux, peut-on représenter en virgule fixe les montants d’une grosse société, sachant que

  • on veut une précision au millième de centimes
  • on veut pouvoir manipuler des montants jusqu’à 1010 milliards d’euros

Conversion décimal à virgule - binaire à virgule

Principe

Conversion en binaire à virgule :

  • on fait des divisions successives pour la partie entière
  • on fait des multiplications successives par 2 pour la partie à virgule

Exemple : conversion de 28,8625 en binaire

– Conversion de 28 : 11100211100_2 – Conversion de 0,8625 :

  • 0,8625×2=1,725=1+0,7250,8625 \times 2 = 1,725 = 1 + 0,725
  • 0,725×2=1,45=1+0,450,725 \times 2 = 1,45 = 1 + 0,45
  • 0,45×2=0,9=0+0,90,45 \times 2 = 0,9 = 0 + 0,9
  • 0,9×2=1,8=1+0,80,9 \times 2 = 1,8 = 1 + 0,8
  • 0,8×2=1,6=1+0,60,8 \times 2 = 1,6 = 1 + 0,6
  • 0,6×2=1,2=1+0,20,6 \times 2 = 1,2 = 1 + 0,2
  • 0,2×2=0,4=0+0,40,2 \times 2 = 0,4 = 0 + 0,4
  • 0,4×2=0,8=0+0,80,4 \times 2 = 0,8 = 0 + 0,8

==> 11100,11011100...211100,11011100..._2

Exercices

Exercice

Représenter en binaire à virgule les nombres suivants :

  • 0,10,1
  • 0,250,25
  • 1/31/3
Exercice

Convertir, puis calculer en binaire : 0,1+0,20,1 + 0,2

Représentation en virgule flottante

Principe

pour les calculs scientifiques (la mole :) on peut avoir besoin de nombres très grands ou très petits => notation scientifique

pour représenter un nombre en notation scientifique dans un nombre fixé de bits, on utilise une représentation normalisée (IEEE 754)

en gros

  • 1er bit = le signe
  • e bits suivants = l’exposant
  • le reste des bits = la mantisse

l’exposant peut être positif ou négatif; on pourrait le représenter en complément à deux, mais c pas facile pour les comparaisons => on décale de 2e−1−12^{e-1}-1 sa valeur

Flottant 32 bits (float32)

  • 1 bit de signe (1 pour négatif)
  • 8 bits pour l’exposant
  • 23 bits pour la mantisse (la partie après la virgule)

==> on décale l’exposant de 28−1−1=1272^{8-1}-1=127

  • exposant 3 = exposant 130
  • exposant 0 = exposant 127
  • exposant 10 = exposant 137

Valeur du nombre

v=s×2e−1272×(m+1)v = s \times 2^{e-127_2} \times (m + 1)

  • s = 1 ou -1 selon le bit de signe
  • e est l’exposant
  • m est la mantisse

Exemple : −118,625-118,625 en float32

  • le signe (1er bit) : nombre négatif, le premier bit est 11

  • écriture du nombre (sans le signe) en binaire : 1110110,101111\ 0110,101

  • décalage de la virgule vers la gauche, de façon à ne laisser qu’un 1 sur sa gauche : 1110110,1012=1,1101101012×261110110,101_2 = 1,110110101_2 \times 2^6. C’est un nombre flottant normalisé : la mantisse est la partie à droite de la virgule, remplie de 0 vers la droite pour obtenir 23 bits. Cela donne 11011010100000000000000110\ 1101\ 0100\ 0000\ 0000\ 0000 (on omet le 1 avant la virgule, qui est implicite).

  • l’exposant est égal à 66, il faut le décaler et le convertir. Pour le format 32-bit IEEE 754, le décalage est 28−1−1=12728-1-1 = 127. Donc 6+127=1336 + 127 = 133 et 13310=100001012133_{10} = 1000\ 0101_2.

Résultat : −118,62510=110000101110110101000000000000002=C2ED400016-118,625_{10} = 1100\ 0010\ 1110\ 1101\ 0100\ 0000\ 0000\ 0000_2 = C2ED4000_{16}

Exercices

Exercice

Ecrire 452,778452,778 en float32.

Exercice

Combien vaut 010000110101111010000000000000000\ 10000110\ 10111101000000000000000 en décimal ?

Aide : vérification et entraînement sur

https://www.h-schmidt.net/FloatConverter/IEEE754.html

Conséquences

Les valeurs stockées en virgule flottante ne sont pas exactes, idem pour les calculs

  • on ne teste pas l’égalité de deux flottants
  • on fait attention aux erreurs qui s’accumulent dans les calculs