# 15. Floating-Point Arithmetic: Issues and Limitations

I numeri in virgola mobile sono rappresentati nell’hardware del computer come frazioni in base 2 (binari). Ad esempio, la frazione decimale `0.625` ha valore 6/10 + 2/100 + 5/1000, e allo stesso modo la frazione binaria `0.101` ha valore 1/2 + 0/4 + 1/8. Queste due frazioni hanno valori identici, l’unica vera differenza è che la prima è scritta in notazione frazionaria in base 10, e la seconda in base 2.

Sfortunatamente, la maggior parte delle frazioni decimali non può essere rappresentata esattamente come frazioni binarie. Una conseguenza è che, in generale, i numeri in virgola mobile decimali che inserisci sono solo approssimati dai numeri in virgola mobile binari effettivamente memorizzati nella macchina.

Il problema è più facile da comprendere inizialmente in base 10. Considera la frazione 1/3. Puoi approssimarla come una frazione in base 10:

    0.3

o, meglio,

    0.33

o, meglio,

    0.333

e così via. Non importa quanti cifre sei disposto a scrivere, il risultato non sarà mai esattamente 1/3, ma sarà una approssimazione sempre migliore di 1/3.

Allo stesso modo, non importa quante cifre in base 2 sei disposto a usare, il valore decimale 0.1 non può essere rappresentato esattamente come una frazione in base 2. In base 2, 1/10 è la frazione che si ripete all’infinito:

    0.0001100110011001100110011001100110011001100110011...

Fermati a un qualsiasi numero finito di bit, e otterrai un’approssimazione. Nella maggior parte delle macchine odierne, i float sono approssimati usando una frazione binaria con il numeratore che utilizza i primi 53 bit a partire dal bit più significativo e con il denominatore come potenza di due. Nel caso di 1/10, la frazione binaria è `3602879701896397 / 2 ** 55` che è vicino ma non esattamente uguale al valore vero di 1/10.

Molti utenti non sono a conoscenza dell’approssimazione a causa del modo in cui i valori sono visualizzati. Python stampa solo un’approssimazione decimale al valore decimale vero dell’approssimazione binaria memorizzata nella macchina. Nella maggior parte delle macchine, se Python dovesse stampare il valore decimale vero dell’approssimazione binaria memorizzata per 0.1, dovrebbe visualizzare:

    >>> 0.1
    0.1000000000000000055511151231257827021181583404541015625

Questo è un numero di cifre maggiore di quelle che la maggior parte delle persone trova utile, quindi Python mantiene il numero di cifre gestibile visualizzando invece un valore arrotondato:

    >>> 1 / 10
    0.1

Ricorda solo, anche se il risultato stampato sembra il valore esatto di 1/10, il valore effettivamente memorizzato è la frazione binaria rappresentabile più vicina.

Interessante è che ci sono molti numeri decimali diversi che condividono la stessa frazione binaria approssimata più vicina. Ad esempio, i numeri `0.1` e `0.10000000000000001` e `0.1000000000000000055511151231257827021181583404541015625` sono tutti approssimati da `3602879701896397 / 2 ** 55`. Poiché tutti questi valori decimali condividono la stessa approssimazione, qualsiasi di essi potrebbe essere visualizzato pur mantenendo l’invariante `eval(repr(x)) == x`.

Storicamente, il prompt di Python e la funzione integrata `repr()` avrebbero scelto quella con 17 cifre significative, `0.10000000000000001`. A partire da Python 3.1, Python (sulla maggior parte dei sistemi) è ora in grado di scegliere il più corto di questi e visualizzare semplicemente `0.1`.

Note that this is in the very nature of binary floating point: this is not a bug in Python, and it is not a bug in your code either. You’ll see the same kind of thing in all languages that support your hardware’s floating-point arithmetic (although some languages may not display the difference by default, or in all output modes).

Per un output più gradevole, potresti voler usare la formattazione delle stringhe per produrre un numero limitato di cifre significative:

    >>> format(math.pi, '.12g')  # give 12 significant digits
    '3.14159265359'

    >>> format(math.pi, '.2f')   # give 2 digits after the point
    '3.14'

    >>> repr(math.pi)
    '3.141592653589793'

È importante rendersi conto che questo è, in un certo senso, un’illusione: stai semplicemente arrotondando la visualizzazione del vero valore della macchina.

Un’illusione può generare un’altra. Ad esempio, poiché 0.1 non è esattamente 1/10, sommare tre valori di 0.1 potrebbe non dare esattamente 0.3, nemmeno:

    >>> 0.1 + 0.1 + 0.1 == 0.3
    False

Inoltre, poiché lo 0.1 non può avvicinarsi al valore esatto di 1/10 e lo 0.3 non può avvicinarsi al valore esatto di 3/10, il pre-arrotondamento con la funzione `round()` non può aiutare:

    >>> round(0.1, 1) + round(0.1, 1) + round(0.1, 1) == round(0.3, 1)
    False

Anche se i numeri non possono essere resi più vicini ai loro valori esatti previsti, la funzione `math.isclose()` può essere utile per confrontare valori inesatti:

    >>> math.isclose(0.1 + 0.1 + 0.1, 0.3)
    True

In alternativa, la funzione `round()` può essere utilizzata per confrontare approssimazioni grossolane:

    >>> round(math.pi, ndigits=2) == round(22 / 7, ndigits=2)
    True

Binary floating-point arithmetic holds many surprises like this. The problem with «0.1» is explained in precise detail below, in the «Representation Error» section. See Examples of Floating Point Problems for a pleasant summary of how binary floating point works and the kinds of problems commonly encountered in practice. Also see The Perils of Floating Point for a more complete account of other common surprises.

As that says near the end, «there are no easy answers.» Still, don’t be unduly wary of floating point! The errors in Python float operations are inherited from the floating-point hardware, and on most machines are on the order of no more than 1 part in 2**53 per operation. That’s more than adequate for most tasks, but you do need to keep in mind that it’s not decimal arithmetic and that every float operation can suffer a new rounding error.

Sebbene esistano casi patologici, per la maggior parte dell’uso occasionale dell’aritmetica in virgola mobile otterrai il risultato che ti aspetti alla fine se semplicemente arrotondi la visualizzazione dei tuoi risultati finali al numero di cifre decimali che ti aspetti. `str()` di solito è sufficiente, e per un controllo più fine vedi gli specificatori di formato del metodo `str.format()` in Format String Syntax.

Per utilizzi che richiedono una rappresentazione decimale esatta, prova ad usare il modulo `decimal` che implementa l’aritmetica decimale adatta per applicazioni contabili e applicazioni ad alta precisione.

Un’altra forma di aritmetica esatta è supportata dal modulo `fractions` che implementa l’aritmetica basata su numeri razionali (così i numeri come 1/3 possono essere rappresentati esattamente).

Se sei un utente assiduo delle operazioni in virgola mobile, dovresti dare un’occhiata al pacchetto NumPy e a molti altri pacchetti per operazioni matematiche e statistiche forniti dal progetto SciPy. Vedi <https://scipy.org>.

Python fornisce strumenti che possono aiutare in quelle rare occasioni in cui davvero vuoi conoscere il valore esatto di un float. Il metodo `float.as_integer_ratio()` esprime il valore di un float come una frazione:

    >>> x = 3.14159
    >>> x.as_integer_ratio()
    (3537115888337719, 1125899906842624)

Poiché il rapporto è esatto, può essere utilizzato per ricreare senza perdita il valore originale:

    >>> x == 3537115888337719 / 1125899906842624
    True

Il metodo `float.hex()` esprime un float in esadecimale (base 16), dando ancora una volta il valore esatto memorizzato dal tuo computer:

    >>> x.hex()
    '0x1.921f9f01b866ep+1'

Questa rappresentazione esadecimale precisa può essere utilizzata per ricostruire il valore del float esattamente:

    >>> x == float.fromhex('0x1.921f9f01b866ep+1')
    True

Poiché la rappresentazione è esatta, è utile per trasferire valori in modo affidabile tra diverse versioni di Python (indipendenza dalla piattaforma) e scambiare dati con altri linguaggi che supportano lo stesso formato (come Java e C99).

Un altro strumento utile è la funzione `sum()` che aiuta a mitigare la perdita di precisione durante la somma. Usa la precisione estesa per i passaggi di arrotondamento intermedi man mano che i valori vengono aggiunti a un totale incrementale. Questo può fare la differenza in termini di precisione complessiva in modo che gli errori non si accumulino al punto da influenzare il totale finale:

    >>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0
    False
    >>> sum([0.1] * 10) == 1.0
    True

The `math.fsum()` goes further and tracks all of the «lost digits» as values are added onto a running total so that the result has only a single rounding. This is slower than `sum()` but will be more accurate in uncommon cases where large magnitude inputs mostly cancel each other out leaving a final sum near zero:

    >>> arr = [-0.10430216751806065, -266310978.67179024, 143401161448607.16,
    ...        -143401161400469.7, 266262841.31058735, -0.003244936839808227]
    >>> float(sum(map(Fraction, arr)))   # Exact summation with single rounding
    8.042173697819788e-13
    >>> math.fsum(arr)                   # Single rounding
    8.042173697819788e-13
    >>> sum(arr)                         # Multiple roundings in extended precision
    8.042178034628478e-13
    >>> total = 0.0
    >>> for x in arr:
    ...     total += x                   # Multiple roundings in standard precision
    ...
    >>> total                            # Straight addition has no correct digits!
    -0.0051575902860057365

## 15.1. Errore di Rappresentazione

Questa sezione spiega l’esempio «0.1» in dettaglio, e mostra come puoi eseguire un’analisi esatta di casi come questo da solo. Si assume una familiarità di base con la rappresentazione in virgola mobile binaria.

Errore di rappresentazione si riferisce al fatto che alcune (anzi, la maggior parte) delle frazioni decimali non possono essere rappresentate esattamente come frazioni binarie (base 2). Questa è la principale ragione per cui Python (o Perl, C, C++, Java, Fortran e molti altri) spesso non visualizzeranno il numero decimale esatto che ti aspetti.

Perché questo? 1/10 non è esattamente rappresentabile come frazione binaria. Dal 2000 in poi, quasi tutte le macchine utilizzano l’aritmetica in virgola mobile binaria IEEE 754, e quasi tutte le piattaforme mappano i float di Python ai valori «doppia precisione» IEEE 754 binary64. I valori IEEE 754 binary64 contengono 53 bit di precisione, quindi in input il computer cerca di convertire 0.1 nella frazione più vicina della forma J/2**N dove J è un intero contenente esattamente 53 bit. Riscrivendo:

    1 / 10 ~= J / (2**N)

come:

    J ~= 2**N / 10

e ricordando che J ha esattamente 53 bit (è `>= 2**52` ma `< 2**53`), il miglior valore per N è 56:

    >>> 2**52 <=  2**56 // 10  < 2**53
    True

Cioè, 56 è l’unico valore per N che lascia J con esattamente 53 bit. Il miglior valore possibile per J è quindi quel quoziente arrotondato:

    >>> q, r = divmod(2**56, 10)
    >>> r
    6

Poiché il resto è più della metà di 10, la migliore approssimazione si ottiene arrotondando verso l’alto:

    >>> q+1
    7205759403792794

Pertanto la migliore approssimazione possibile di 1/10 in doppia precisione IEEE 754 è:

    7205759403792794 / 2 ** 56

Dividendo sia il numeratore che il denominatore per due si riduce la frazione a:

    3602879701896397 / 2 ** 55

Nota che poiché abbiamo arrotondato verso l’alto, questo è in realtà un po” più grande di 1/10; se non avessimo arrotondato verso l’alto, il quoziente sarebbe stato un po” più piccolo di 1/10. Ma in nessun caso può essere esattamente 1/10!

Quindi il computer non «vede» mai 1/10: quello che vede è la frazione esatta data sopra, la migliore approssimazione doppia precisione IEEE 754 che può ottenere:

    >>> 0.1 * 2 ** 55
    3602879701896397.0

Se moltiplichiamo quella frazione per 10**55, possiamo vedere il valore fino a 55 cifre decimali:

    >>> 3602879701896397 * 10 ** 55 // 2 ** 55
    1000000000000000055511151231257827021181583404541015625

il che significa che il numero esatto memorizzato nel computer è pari al valore decimale 0.1000000000000000055511151231257827021181583404541015625. Invece di visualizzare il valore decimale completo, molti linguaggi (compresi le vecchie versioni di Python), arrotondano il risultato a 17 cifre significative:

    >>> format(0.1, '.17f')
    '0.10000000000000001'

I moduli `fractions` e `decimal` rendono questi calcoli facili:

    >>> from decimal import Decimal
    >>> from fractions import Fraction

    >>> Fraction.from_float(0.1)
    Fraction(3602879701896397, 36028797018963968)

    >>> (0.1).as_integer_ratio()
    (3602879701896397, 36028797018963968)

    >>> Decimal.from_float(0.1)
    Decimal('0.1000000000000000055511151231257827021181583404541015625')

    >>> format(Decimal.from_float(0.1), '.17')
    '0.10000000000000001'