Lezione 04 · Rappresentazione dei numeri reali in binario¶

Con gli interi ci siamo fermati: ma un ingegnere lavora soprattutto con numeri reali, come 9,81 m/s² o 0,000012 mm. In un intervallo di numeri reali, anche piccolissimo, ci sono infiniti valori, mentre un calcolatore ha un numero finito di bit. In questa lezione vedi come si risolve il problema e quali errori comporta.

La notazione scientifica: virgola mobile¶

Un numero reale si rappresenta in notazione scientifica, detta anche virgola mobile o floating point:

r = ± m × bᵉ

Lo stesso valore si può scrivere in infiniti modi, perché la virgola "si sposta" cambiando l'esponente:

• 48000 = 48 × 10³ = 4,8 × 10⁴ = 0,48 × 10⁵ …
• (0,1011)₂ = (1011)₂ × 2⁻⁴ = (1,011)₂ × 2⁻¹ …

Per avere una sola scrittura si usa la mantissa normalizzata:

1 ≤ |m| < b

cioè la prima cifra prima della virgola è diversa da zero e la mantissa è minore della base. Nell'esempio: 4,8 × 10⁴ e (1,011)₂ × 2⁻¹.

Perché i reali sono approssimati¶

I numeri reali formano un continuo: tra due numeri qualsiasi ce ne sono infiniti altri. Con un numero finito di bit si può rappresentare solo un insieme finito di valori X₀, X₁, …, Xₙ. Questo passaggio da continuo a finito si chiama discretizzazione.

• Solo i valori Xᵢ sono rappresentati esattamente.
• Ogni altro valore x compreso tra Xᵢ e Xᵢ₊₁ viene sostituito con uno dei due estremi (troncando, o arrotondando al più vicino).

La differenza tra il valore vero e quello memorizzato è l'errore di approssimazione.

L'errore massimo¶

Pensa a una calcolatrice con quattro cifre decimali dopo la virgola, che arrotonda l'ultima cifra.

L'errore non supera mai mezza unità dell'ultima cifra, cioè 0,5 × 10⁻⁴. In generale, con base b e m cifre dopo la virgola:

errore massimo ε = 0,5 × b⁻ᵐ

dove b⁻ᵐ è il valore di un'unità nell'ultima posizione.

Un esempio: la calcolatrice in virgola mobile¶

Immagina una calcolatrice decimale con:

• mantissa di 5 cifre, normalizzata: da 1,0000 a 9,9999;
• base b = 10;
• esponente di 2 cifre più il segno: da −99 a +99.

Gli intervalli non sono tutti uguali. Tra due numeri rappresentabili consecutivi c'è sempre un'unità sull'ultima cifra della mantissa, ma il suo valore dipende dall'esponente:

• vicino al massimo, tra 9,9998 × 10⁹⁹ e 9,9999 × 10⁹⁹, c'è un "buco" di 10⁹⁵;
• vicino allo zero, tra 1,0000 × 10⁻⁹⁹ e 1,0001 × 10⁻⁹⁹, c'è un buco di 10⁻¹⁰³.

I numeri rappresentabili sono fitti vicino allo zero e radi lontano dallo zero. L'errore relativo però resta circa lo stesso.

Overflow e underflow¶

Le operazioni in virgola mobile¶

Con la virgola mobile le operazioni si complicano e possono introdurre nuovi errori.

Somma e sottrazione richiedono di allineare gli esponenti: il numero con esponente più piccolo viene riscritto con l'esponente dell'altro, e così perde cifre.

Prodotto e divisione trattano separatamente mantisse ed esponenti: le mantisse si moltiplicano (o dividono), gli esponenti si sommano (o sottraggono).

123 × 10⁰ × 678 × 10⁻² = (123 × 678) × 10⁽⁰⁻²⁾ = 83394 × 10⁻²

Attenzione alla divisione per numeri molto piccoli: il risultato può diventare enorme e andare in overflow.

La virgola mobile nel calcolatore¶

In binario il numero normalizzato ha la forma:

± 1,xxxxxx × 2ʸʸʸʸ

Il calcolatore memorizza solo ciò che serve:

Lo standard IEEE 754¶

Fino agli anni '80 ogni costruttore aveva un suo formato per i numeri reali. Nel 1985 nasce lo standard IEEE 754, oggi usato da quasi tutti i calcolatori. Definisce tre formati:

• singola precisione: 32 bit;
• doppia precisione: 64 bit;
• precisione estesa: 80 bit.

Singola precisione (32 bit)¶

• Esponente: 8 bit in eccesso 127. Gli esponenti normali vanno da −126 a +127. Le parole 00000000 e 11111111 (che corrisponderebbero a −127 e +128) sono riservate a casi speciali.
• Mantissa: 23 bit, sono le cifre dopo "1,". L'1 iniziale è sottinteso.
• Precisione: circa 7 cifre decimali (23 / 3,3 ≈ 7: servono circa 3,3 bit per ogni cifra decimale).

Valore = (−1)ˢ × 1,mantissa × 2^(esponente − 127)

I valori di esponente e mantissa dividono i numeri in categorie: zeri, numeri normalizzati, numeri denormalizzati (molto vicini a zero), infiniti e NaN (Not a Number, ad esempio il risultato di 0/0). L'esponente distingue le categorie in modo principale, la mantissa in modo secondario.

Doppia precisione (64 bit)¶

• Esponente: 11 bit in eccesso 1023, esponenti normali da −1022 a +1023. Le parole 0 e 2047 (tutti 0 e tutti 1) sono riservate.
• Mantissa: 52 bit, con l'1 iniziale sottinteso.
• Precisione: circa 15 cifre decimali (52 / 3,3 ≈ 15).

Da IEEE 754 a decimale¶

Procedimento:

1. Dividi i 32 bit in segno (1), esponente (8), mantissa (23).
2. Segno: 0 → positivo, 1 → negativo.
3. Esponente: converti gli 8 bit in decimale e sottrai 127.
4. Mantissa: scrivi 1, seguito dai bit della mantissa (gli zeri finali si possono togliere) e convertila.
5. Calcola (−1)ˢ × M × 2ᴱ.

Verifica con Python (facoltativo). Incolla i 32 bit (puoi lasciare gli spazi) e il programma rifà i passaggi. Funziona per i numeri normalizzati, cioè quelli degli esercizi.

parola = input('32 bit (spazi ammessi): ').replace(' ', '').replace('|', '')
s = parola[0]
esponente = parola[1:9]
mantissa = parola[9:]

E = int(esponente, 2) - 127          # si toglie l'eccesso 127
M = 1                                # il bit implicito
peso = 0.5
for bit in mantissa:
    if bit == '1':
        M = M + peso
    peso = peso / 2

valore = M * 2 ** E
if s == '1':
    valore = -valore
print('Segno:', '-' if s == '1' else '+')
print('Esponente:', esponente, '=', int(esponente, 2), '- 127 =', E)
print('Mantissa: M =', M)
print('Valore:', valore)

Da decimale a IEEE 754¶

Procedimento:

1. Segno: 0 se positivo, 1 se negativo. Da qui in poi lavora con il valore assoluto.
2. Converti in binario parte intera (divisioni successive) e parte frazionaria (moltiplicazioni successive), come nella lezione 02.
3. Normalizza: sposta la virgola subito dopo il primo 1. Ogni posto verso sinistra aggiunge 1 all'esponente E (ogni posto verso destra toglie 1).
4. Esponente: calcola E + 127 e scrivilo in binario su 8 bit.
5. Mantissa: prendi le cifre dopo "1," e completale con zeri a destra fino a 23 bit.

Verifica con Python (facoltativo). Il programma segue gli stessi cinque passi e stampa i 32 bit.

x = float(input('Numero reale da codificare (es. 8.5): '))

if x == 0:
    print('Lo zero ha una codifica speciale: tutti i bit a 0')
else:
    # 1) segno
    if x < 0:
        s = '1'
        x = -x
    else:
        s = '0'

    # 2) parte intera (divisioni successive) e parte frazionaria (moltiplicazioni successive)
    intera = int(x)
    frazione = x - intera
    bit_interi = ''
    while intera > 0:
        bit_interi = str(intera % 2) + bit_interi
        intera = intera // 2
    bit_fraz = ''
    while frazione != 0 and len(bit_fraz) < 200:
        frazione = frazione * 2
        if frazione >= 1:
            bit_fraz = bit_fraz + '1'
            frazione = frazione - 1
        else:
            bit_fraz = bit_fraz + '0'
    print('In binario:', (bit_interi or '0') + ',' + (bit_fraz[:30] or '0'), '...' if len(bit_fraz) > 30 else '')

    # 3) normalizzazione: 1,xxxx * 2^E
    if bit_interi != '':
        E = len(bit_interi) - 1
        dopo_virgola = bit_interi[1:] + bit_fraz
    else:
        primo_uno = bit_fraz.find('1')
        E = -(primo_uno + 1)
        dopo_virgola = bit_fraz[primo_uno + 1:]
    print('Normalizzato: 1,' + (dopo_virgola[:30] or '0'), '* 2^' + str(E))

    # 4) esponente in eccesso 127 su 8 bit
    ecc = E + 127
    bit_esp = ''
    for i in range(8):
        bit_esp = str(ecc % 2) + bit_esp
        ecc = ecc // 2

    # 5) mantissa: i primi 23 bit dopo la virgola, completati con zeri
    mantissa = (dopo_virgola + '0' * 23)[:23]
    print('Esponente:', E, '+ 127 =', E + 127, '->', bit_esp)
    print('Risultato:', s, bit_esp, mantissa)

Prova con 8.5, -67.25 e 0.1. Il programma tronca la mantissa dopo 23 bit; lo standard invece arrotonda l'ultimo bit, quindi per numeri non esatti come 0,1 l'ultimo bit può essere diverso. Negli esercizi d'esame il numero è sempre esatto e il problema non si pone.

Errori frequenti negli esercizi¶

Esercizi¶

Esercizio 1 · Da IEEE 754 a decimale. Determina il valore decimale di 1 10000010 10110100000000000000000.

Esercizio 2 · Da decimale a IEEE 754. Rappresenta 40,125 in IEEE 754 a singola precisione.

Esercizio 3 · Un numero minore di 1 (come allo scritto). Rappresenta −0,75 in IEEE 754 a singola precisione. Poi decodifica il risultato per controllarlo.

Verifica¶