Implémentation d'un additionneur flottant — exercice corrigé de Python (école d'ingénieur) (chapitre 3)

Implémentation d'un additionneur flottant

Représentation des nombres en machine

Énoncé

Simuler l'addition de deux flottants IEEE-754 simple précision (32 bits) en suivant l'algorithme :

Extraire signe, exposant, mantisse

Aligner les exposants (décaler la mantisse du plus petit)

Additionner/soustraire les mantisses selon le signe

Normaliser le résultat (ajuster exposant, décaler mantisse)

Arrondir

Corrigé

Le code suivant simule cet additionneur en utilisant les opérations bit à bit en Python :

import struct

def float32_to_bits(x):
    bits = struct.unpack('>I', struct.pack('>f', x))[0]
    signe = (bits >> 31) & 1
    exposant = (bits >> 23) & 0xFF
    mantisse = bits & 0x7FFFFF
    return signe, exposant, mantisse

def bits_to_float32(signe, exposant, mantisse):
    bits = (signe << 31) | (exposant << 23) | mantisse
    return struct.unpack('>f', struct.pack('>I', bits))[0]

def addition_flottante(a, b):
    s1, e1, m1 = float32_to_bits(a)
    s2, e2, m2 = float32_to_bits(b)
    
    if e1 == 0xFF or e2 == 0xFF:
        return a + b
        
    m1 |= 0x800000 if e1 != 0 else 0
    m2 |= 0x800000 if e2 != 0 else 0
    
    if e1 < e2:
        s1, e1, m1, s2, e2, m2 = s2, e2, m2, s1, e1, m1
        
    diff_exp = e1 - e2
    if diff_exp > 24:
        m2 = 0
    else:
        m2 >>= diff_exp
        
    if s1 == s2:
        m = m1 + m2
        s = s1
    else:
        if m1 >= m2:
            m = m1 - m2
            s = s1
        else:
            m = m2 - m1
            s = s2
            
    if m == 0:
        return 0.0
        
    while m >= 0x1000000:
        m >>= 1
        e1 += 1
    while m < 0x800000 and e1 > 0:
        m <<= 1
        e1 -= 1
        
    mantisse = m & 0x7FFFFF
    if e1 >= 0xFF:
        return float('inf') if s == 0 else float('-inf')
        
    return bits_to_float32(s, e1, mantisse)

a, b = 1.25, 0.375
print(f"Résultat : {addition_flottante(a, b)}")