Esercizio 28virgola mobile, conversioni e formati ridotti

Formato

Un numero normalizzato è $(-1)^s \cdot 1{,}f \cdot 2^{\,E - \text{bias}}$ con $\text{bias} = 2^{k-1} - 1$ ($k$ bit di esponente) e bit nascosto $1$ davanti alla frazione. Singola precisione: 1 bit di segno, 8 di esponente (bias $127$), 23 di frazione. Nei formati ridotti dei quesiti 5 e 6 si usa la stessa regola con $k = 3$ (bias $3$) e $k = 4$ (bias $7$); è l'unica interpretazione che porta a una delle opzioni elencate.

Codificare $x$:

1. segno: $s = 1$ se $x < 0$;
2. scrivere $|x|$ in binario e normalizzare: $1{,}f \times 2^e$;
3. esponente memorizzato $E = e + \text{bias}$, in binario su $k$ bit;
4. frazione: i bit dopo la virgola, riempiti con zeri a destra o troncati a $m$ bit.

Decodificare: l'inverso. Vedi gli esempi in Numeri in virgola mobile IEEE 754Virgola fissa e virgola mobile; formato IEEE 754 a 32 e 64 bit (segno, esponente in eccesso 127, mantissa con 1 implicito); conversioni svolte nei due versi; valori speciali, denormalizzati, intervallo, precisione e arrotondamento.Numeri in virgola mobile IEEE 754 →.

1. $-30{,}375$ in singola precisione

• Segno $s = 1$.
• $30 = 11110_2$; $0{,}375 = 0{,}011_2$ ($0{,}25 + 0{,}125$). Quindi $30{,}375 = 11110{,}011_2$.
• Normalizzando: $11110{,}011_2 = 1{,}1110011_2 \times 2^4$.
• Esponente memorizzato: $4 + 127 = 131 = 1000\,0011_2$.
• Frazione: 1110011 seguita da $16$ zeri (23 bit totali): 11100110000000000000000.

$$-30{,}375 = \texttt{1\ 10000011\ 11100110000000000000000} = \texttt{C1F30000}_{16}.$$

2. 0 10001100 10001100000000000000000

• Segno $0$: positivo.
• Esponente $10001100_2 = 140$; $140 - 127 = 13$.
• Frazione 1000110...: $0{,}1000110_2 = 2^{-1} + 2^{-5} + 2^{-6} = 0{,}5 + 0{,}03125 + 0{,}015625 = 0{,}546875$; con il bit nascosto $1{,}546875$.

$$+1{,}546875 \times 2^{13} = 1{,}546875 \times 8192 = \mathbf{12\,672}.$$

3. 1 10000001 11010100000000000000000

• Segno $1$: negativo; esponente $10000001_2 = 129$ → $129 - 127 = 2$.
• Frazione 1101010...: $2^{-1} + 2^{-2} + 2^{-4} + 2^{-6} = 0{,}5 + 0{,}25 + 0{,}0625 + 0{,}015625 = 0{,}828125$; con il bit nascosto $1{,}828125$.

$-1{,}828125 \times 2^2 = -7{,}3125$ → risposta a. ($-1{,}828125$ è la mantissa senza l'esponente: errore di chi dimentica $2^2$.)

4. 0 01111100 01110000000000000000000

• Segno $0$; esponente $01111100_2 = 124$ → $124 - 127 = -3$.
• Frazione 0111: $2^{-2} + 2^{-3} + 2^{-4} = 0{,}4375$; con il bit nascosto $1{,}4375$.

$1{,}4375 \times 2^{-3} = 1{,}4375 / 8 = 0{,}1796875$ → risposta c.

5. Formato 1 + 3 + 4 bit: $-7{,}3$

• Segno $1$. $7{,}3 = 111{,}0100110011\ldots_2 = 1{,}110100110011\ldots_2 \times 2^2$.
• Esponente memorizzato: $2 + 3 = 5 = 101_2$.
• Frazione: 4 bit: 1101 (i bit successivi, 00110011..., si troncano).

$$\texttt{1\ 101\ 1101} = \texttt{11011101} \quad \Rightarrow \text{risposta a.}$$

Il numero realmente rappresentato è $-1{,}1101_2 \times 2^2 = -(1 + 0{,}8125) \times 4 = -7{,}25$: la rappresentazione di $-7{,}3$ è approssimata (errore $0{,}05$): con 4 bit di frazione i numeri vicini a 7 distano $2^{-4} \cdot 2^2 = 0{,}25$.

6. Formato 1 + 4 + 11 bit: $-41{,}125$

• Segno $1$. $41 = 101001_2$, $0{,}125 = 0{,}001_2$: $41{,}125 = 101001{,}001_2 = 1{,}01001001_2 \times 2^5$.
• Esponente memorizzato: bias $7$: $5 + 7 = 12 = 1100_2$.
• Frazione, 11 bit: 01001001 completata con tre zeri: 01001001000.

$$\texttt{1\ 1100\ 01001001000} = \texttt{1110001001001000} \Rightarrow \text{risposta a.}$$

Questo numero è esatto: $41{,}125$ ha solo 8 bit dopo la virgola nella forma normalizzata, che stanno negli 11 bit di frazione.

Verifica con un programma

import struct
from fractions import Fraction

def codifica(x, bit_esp, bit_man):
    """x -> bit (segno, esponente con bias 2^(k-1)-1, 1.f troncata a bit_man bit); solo numeri normalizzati."""
    bias = 2 ** (bit_esp - 1) - 1
    s = "1" if x < 0 else "0"
    x = abs(Fraction(x))
    e = 0
    while x >= 2:
        x /= 2; e += 1
    while x < 1:
        x *= 2; e -= 1
    man = int((x - 1) * 2 ** bit_man)                 # troncamento
    return s + format(e + bias, f"0{bit_esp}b") + format(man, f"0{bit_man}b")

def decodifica(bits, bit_esp, bit_man):
    bias = 2 ** (bit_esp - 1) - 1
    segno = -1 if bits[0] == "1" else 1
    E = int(bits[1:1 + bit_esp], 2)
    m = int(bits[1 + bit_esp:], 2)
    return segno * (1 + Fraction(m, 2 ** bit_man)) * Fraction(2) ** (E - bias)

print(codifica(Fraction(-30375, 1000), 8, 23))                    # 11000001111100110000000000000000
print(hex(struct.unpack(">I", struct.pack(">f", -30.375))[0]))    # 0xc1f30000: il controllo con il float vero
print(float(decodifica("01000110010001100000000000000000", 8, 23)))   # 12672.0
print(float(decodifica("11000000111010100000000000000000", 8, 23)))   # -7.3125
print(float(decodifica("00111110001110000000000000000000", 8, 23)))   # 0.1796875
b5 = codifica(Fraction(-73, 10), 3, 4)
print(b5, float(decodifica(b5, 3, 4)))                            # 11011101 -7.25
print(codifica(Fraction(-41125, 1000), 4, 11))                    # 1110001001001000

Errori comuni

• Dimenticare il bit nascosto (usare $0{,}f$ invece di $1{,}f$).
• Non sottrarre il bias (o sottrarre 128, 255): per 8 bit il bias è $127$.
• Dimenticare di moltiplicare per $2^{E - \text{bias}}$ e dare come risposta la mantissa ($-1{,}828125$).
• Normalizzare male: $30{,}375 = 1{,}1110011 \times 2^4$ (si sposta la virgola di 4 posti).
• Usare il bias di 127 anche nei formati ridotti: con $k$ bit il bias è $2^{k-1} - 1$.
• Credere che $-7{,}3$ sia memorizzato esattamente: con pochi bit si rappresenta solo un numero vicino.