Codage des nombres à virgule

✎ Travail n° 1 Virgule fixe

  1. Se référer à Virgule fixe puis donner “de tête” la représentation en virgule fixe des nombres suivants avec le format indiqué :

    Rappel

    2-1 = 0.5

    2-2 = 0.25

    2-3 = 0.125

    2-4= 0.0625

    Valeur à convertir en virgule fixe

    Nb bits partie entière

    Nb bits partie décimale

    5.5

    3

    1

    18.75

    5

    2

    4.125

    3

    3

    29.25

    5

    3

    12.5625

    4

    4
    Solution

    • 5.5 ⇒ 101.1|2

    • 18.75 ⇒ 10010.11|2

    • 4.125 ⇒ 100.001|2

    • 29.25 ⇒ 11101.010|2

    • 12.5625 ⇒ 1100.1001|2

  2. Utiliser la méthode des multiplications successives pour donner la représentation en virgule fixe des nombres réels suivants en utilisant 7 bits pour coder la partie décimale :

    • 3.9375

    • 7.21875

    • 10.6953125

    Solution

    • 3.9375 ⇒ 11.1111000|2

      Partie entière :
      3 => 11|2
      Partie décimale :
      2 * 0.9375 = 1.875 +
2 * 0.875  = 1.75 +
2 * 0.75   = 1.50 +
2 * 0.50   = 1

      …​puis on complète par 3 zéros pour avoir 7 bits

    • 7.21875 ⇒ 111.0011100|2

      Partie entière :
      7 => 111|2
      Partie décimale :
      2 * 0.21875 = 0.4375 +
2 * 0.4375  = 0.875 +
2 * 0.875   = 1.75 +
2 * 0.75    = 1.50 +
2 * 0.50    = 1

      …​puis on complète par 2 zéros pour avoir 7 bits

    • 10.6953125 ⇒ 1010.1011001|2

      Partie entière :
      10 => 1010|2
      Partie décimale :
      2 * 0.6953125 = 1.390625 +
2 * 0.390625  = 0.78125 +
2 * 0.78125   = 1.5625 +
2 * 0.5625    = 1.125 +
2 * 0.125     = 0.250 +
2 * 0.250     = 0.50 +
2 * 0.50      = 1

      Inutile de compléter avec des zéros cette fois car la partie décimale est codée sur 7 bits

  3. Quelle sera l’erreur sur la valeur obtenue si on décide de coder le nombre 3.14 en virgule fixe avec 5 bits pour la partie décimale ?

    Solution

    L’erreur sera de -0.015.

    En effet , si on essaye de coder 3.14 avec la méthode des multiplications successives, on parvient à :

    3.14 ⇒ 11.0010001111010111000010…​|2 (suite infinie de bits après la virgule)

    Si on se limite à 5 bits pour la partie décimale (→ 11.00100|2), la valeur réelle correspondante est :

    Puissances de 2

    21

    20

    2-1

    2-2

    2-3

    2-4

    2-5

    Écriture binaire

    1

    1

    ,

    0

    0

    1

    0

    0

    		 
    ⇒ 1011101|2 = 1 x 22 + 1 x 20 + 0 x 2-1 + 0 x 2-2 + 1 x 2-3 + 0 x 2-4 + 0 x 2-5
            = 2 + 1 + 0 + 0 + 0.125 + 0 + 0
            = 3.125

    Donc, l’erreur de codage est bien de : 3.125 - 3.14 = -0.015.

✎ Travail n° 2 Virgule flottante

  1. En utilisant le convertisseur en ligne Online Binary-Decimal Converter link déterminer parmi les valeurs suivantes celles qui peuvent être codées exactement en représentation IEEE754 (c-à-d pas par une valeur approchée) :

    • 7

    • 0.1

    • -1.5

    • 26.65625

    • 1,602176634 10−19 (charge électrique d’un électron en Coulomb ou A.s)

    • 2.8352689733632 1014

  2. En utilisant le même convertisseur en ligne, déterminer parmi les représentations IEEE754 suivantes lesquelles correspondent à des valeurs de nombre réels ?

    • 01010101010101010101010101010101

    • 01111111100000000000000000000000

    • 10000000011111111111111111111111

    • 11111111100000000000000000000000

    • 01111111110000000000000000000000

    • 00111111111000000000000000000000

    • 00000000000000000000000000000000

  3. Quelle sera l’erreur sur la valeur obtenue si on décide de coder le nombre 3.14 en virgule flottante (simple précision) ? Comparer cette erreur avec la valeur obtenue dans le travail précédent avec la représentation en virgule fixe.

  4. Ci-dessous figure un script Python [1] qui met en œuvre 2 fonctions :

    • floatToBinary64() : donne la représentation IEEE754 double précision (→ 64 bits) d’un nombre réel

    • binaryToFloat() : donne la valeur d’un nombre réel à partir d’une chaîne donnant sa représentation IEEE754 en double précision

      Script Python
      ieee754.py
      # Attention : En Python, les nombres réels sont représentés en IEEE754
# dooble précision (64bits) et non en simple précision (32 bits)
import struct

# Conversion réel -> IEEE754
def floatToBinary64(value):
    val = struct.unpack('Q', struct.pack('d', value))[0]
    if (val > 0) :
        return str(bin(val))[2:]
    else :
        return "-" + str(bin(val))[3:]

# Conversion IEEE754 -> réel
def binaryToFloat(value):
    hx = hex(int(value, 2))
    return struct.unpack("d", struct.pack("q", int(hx, 16)))[0]

# Représentation IEEE754 double précision d'un nombre réel
realNb = 3.0
binstr = floatToBinary64(realNb)
print('Représentation IEEE754 double précision de ' + str(realNb) + ' : ')
print(binstr + '\n')

# Valeur correspondant à un codage IEEE754 double précision
fl = binaryToFloat(binstr)
print('Valeur ' + binstr + ' : ')
print(fl)

      1. Tester le script sur quelques valeurs numériques pour s’assurer qu’il donne les mêmes résultats que le convertisseur en ligne Online Binary-Decimal Converter link

      2. Modifier le script de façon à demander à l’utilisateur de saisir le nombre à convertir plutôt que de le définir “en dur” dans le script

        • La fonction Python permettant la saisie d’une chaîne de caractères depuis la console s’appelle input().

        • Ne pas oublier de convertir chaine saisie en nombre réel (→ double(<chaine-saisie>)) avant d’appeler la fonction binaryToFloat()

      3. Se renseigner sur les fonctions Python pack() et unpack() et expliquer le code des lignes 7 et 16

        Ces 2 fonctions sont très utiles dès lors que l’on veut interpréter des flux d’octets provenant d’une liaison série, du réseau, d’une base de données…​

🞄  🞄  🞄