IEEE-754

All’inizio siamo partiti con la codifica in binario e a complemento a due ( utile per fare somme e sottrazioni ) , queste codifiche ci permettono di codificare i numeri interi … ma per i numeri frazionari ? e per i caratteri ? ai Prendiamo per esempio il numero $(7,625{)}_{10}$ , osserviamo che questo numero sarebbe :

$$7\ast 10^0+6\ast 10^{-1}+2\ast 10^{-2}+5\ast 10^{-3}$$

quindi è come se seguiamo un pattern dell’esponente di $10$ nelle posizioni del tipo $(\dots 3210,-1-2-3\dots )$.

Quindi possiamo usare lo stesso pattern di posizioni per i numeri in binario , infatti se consideriamo $(101,101{)}_2$ avremo :

$$\begin{array}{r}101,101=1\ast 2^2+0\ast 2^1+1\ast 2^0,1\ast 2^{-1}+0\ast 2^{-2}+1\ast 2^{-3}=\\ =5,\frac{1}{2}+\frac{1}{8}=5,(0,5)+(0,125)=(5,625{)}_{10}\end{array}$$

Ok ma il contrario , se voglio esprimere il numero $(0,625{)}_{10}=(0,?{)}_2$ , funziona cosi in pratica :

• si moltiplica per $2$
• se il prodotto è $\ge 1$ ⇒ mettiamo $1$
• se il prodotto è $<0$ ⇒ mettiamo $0$
• al prodotto devo levare $1$ e ripeto il processo

quindi per il nostro numero otteniamo :

$$\begin{array}{cc}0,625& 1\\ 0,25& 0\\ 0,5& 1\\ 1& \end{array}$$

quindi otteniamo che $(0,625{)}_{10}=(0,101{)}_2$ .01100110. Ok ora se ho un numero in decimale dopo la virgola posso codificarlo in binario… ma la virgola come la codifico ?

Una prima idea sarebbe usare una codifica dei numeri frazionari chiamata a virgola fissa ,
ovvero per esempio se abbiamo $n=8$ bit, dedichiamo i primi $4$ bit per la parte intera e $4$ per la parte frazionaria.

Siccome l’utilizzo della codifica in virgola fissa non è molto conveniente , siccome non riusciamo a lavorare con numeri molto grandi o molto piccoli. Un metodo migliore è usare la notazione scientifica , ovvero invece di scrivere questo numero in questo modo :

$$987000000000\text{oppure}0.000000064$$

è meglio scriverlo in questo modo :

$$9,87\times 10^{11}\text{e}6.4\times 10^{-8}$$

quando utilizziamo una sola cifra prima della virgola , si dice che la notazione scientifica è normalizzata . Quindi possiamo utilizzare lo stesso metodo in binario e infatti possiamo scrivere $(5,625{)}_{10}$ come :

$$101,101=1,01101\times 2^2$$

siccome sappiamo che la parte intera è $101$ e la parte dopo la virgola è $101$ , quindi avremo $101,101$ , spostiamo ora verso sinistra la virgola di $2$ posizioni , quindi otteniamo $1,01101$ , ora siccome spostare la virgola di una posizione vuol dire moltiplicare per $2$ , dobbiamo “moltiplicare” ( $\times$ ) per $2^2$ .

Notiamo inoltre che il primo bit prima della virgola sarà sempre $1$ , questo perché quando scriviamo in notazione scientifica normalizzata , in decimale il primo numero prima della virgola è un numero $\in \{1,\dots ,9\}$ , mentre in binario necessariamente potrà essere solo $1$ .

Quindi adesso se abbiamo a disposizione $n$ bit possiamo dedicare alcuni per l’esponente di $2$ , e altri per la mantissa ( la roba dopo la virgola ).

Lo standard IEEE-754 a precisione singola utilizza proprio questa metodologia e prevede $n=32$ bit a disposizione , dove :

• 1 bit per il segno
• 8 bit per l’esponente
• 23 bit per la mantissa

$$\stackrel{\text{segno}}{\overbrace{\begin{array}{c}\end{array}}}\stackrel{\text{esponente}}{\overbrace{\begin{array}{cccccccc}& & & & & & & \end{array}}}\stackrel{\text{mantissa}}{\overbrace{\begin{array}{ccccccccccccccccccccccc}& & & & & & & & & & & & & & & & & & & & & & \end{array}}}$$

dove il primo bit identifica il segno , se $0$ ⇒ positivo e se $1$ ⇒ negativo. L’esponente è codificato in eccesso , ovvero che si aggiunge $127$ al numero in decimale e poi si codifica in binario ( a $8$ bit ).

Per esempio , codifichiamo il numero $-76,28125$ :

• il primo bit è $1$ siccome il numero da codificare è negativo.
• ora dobbiamo scrivere $76,28125$ in binario, come abbiamo fatto all’inizio :
• $76$ sarebbe : $$\begin{array}{cc}76& 0\\ 38& 0\\ 19& 1\\ 9& 1\\ 4& 0\\ 2& 0\\ 1& 1\end{array}$$ quindi sarebbe $1001100$ in binario.
  • $0,28125$ sarebbe :
  $$\begin{array}{cc}0,28125& 0\\ 0,5625& 1\\ 0,125& 0\\ 0,25& 0\\ 0,5& 1\\ 0& \end{array}$$ quindi sarebbe $0,01001$
  • quindi avremo che il nostro numero sarà in binario : $1001100,01001$ , ora dobbiamo spostare la virgola di $6$ posizioni quindi avremo che in notazione scientifica sarà $1,00110001001\times 2^6$
• per l’esponente avremo $6+127=133$ , ora codifichiamo $133$ in binario e otteniamo $10000101$.
• la mantissa l’abbiamo ottenuta prima ed è $00110001001$

quindi il nostro numero diventa secondo lo standard IEEE-754 :

$$\stackrel{\text{segno}}{\overbrace{\begin{array}{c}1\end{array}}}\stackrel{\text{esponente}}{\overbrace{\begin{array}{cccccccc}1& 0& 0& 0& 0& 1& 0& 1\end{array}}}\stackrel{\text{mantissa}}{\overbrace{\begin{array}{ccccccccccccccccccccccc}0& 0& 1& 1& 0& 0& 0& 1& 0& 0& 1& .& .& .& .& .& .& .& .& .& .& .& 0\end{array}}}$$

dove nei puntini rimangono gli $0$ . In HEX diventa :

$$\stackrel{\text{C}}{\overbrace{1100}}\stackrel{2}{\overbrace{0010}}\stackrel{9}{\overbrace{1001}}\stackrel{8}{\overbrace{1000}}\stackrel{9}{\overbrace{1001}}\stackrel{0}{\overbrace{0000}}\stackrel{0}{\overbrace{0000}}\stackrel{0}{\overbrace{0000}}$$

ovvero $C2989000$ .

Alcune sequenze di $32$ bit sono riservate a codificare dei numeri speciali :

• $X000000000000000000000000000000$ sarebbe lo $zero$ ( dove $X$ può essere $0$ o $1$ )
• $0111111110000000000000000000000$ sarebbe $+\infty$
• $1111111110000000000000000000000$ sarebbe $-\infty$
• una sequenza con i bit dell’esponente tutti a $1$ ma quelli della mantissa non tutti $0$ ( misti ) , non sarebbe nessun numero ( $NaN$ - Not a Number )

Somma tra due numeri in virgola mobile

Supponiamo dobbiamo fare $x+y$ ⇒ gli steps sono :

• troviamo esponente , mantissa e scriviamo i due numeri $x$ e $y$ in notazione scientifica normalizzata ( in binario )
• “allineiamo” gli esponenti e decide il più grande
• facciamo la somma tra i due numeri in notazione scientifica
• otteniamo un nuovo numero e da quello ricostruiamo il nuovo numero
• per sapere il segno della somma ( solo se i due numeri hanno segno opposto ) devo confrontare gli esponenti di $x$ e $y$ e le loro mantisse ( esponenti uguali )

Consideriamo per esempio :

$$\begin{array}{r}x=0100001000001111000\dots 0\\ y=0100000110100100000\dots 0\end{array}$$

quindi per $x$ abbiamo :

• $\text{esp}=(10000100{)}_2=128+4=132-127=5$
• $\text{man}=0001111$ quindi otteniamo che $x=1,0001111\times 2^5$

mentre per $y$ abbiamo che :

• $\text{esp}=(10000011{)}_2=128+3=131-127=4$
• $\text{man}=01001$ quindi otteniamo che $y=1,01001\times 2^4$

ora dobbiamo allineare secondo $5$ , quindi avremo che $y=0,101001\times 2^5$ . Ora facciamo la somma in colonna :

$$\begin{array}{c}\\ 1,0001111+\\ 0,1010010\\ 1,1100001\end{array}$$

quindi otteniamo $s=1,1100001\times 2^5$ , che avrà :

• $\text{esp}=5+127=132=(10000100{)}_2$
• $\text{man}=(1100001{)}_2$

e quindi otteniamo :

$$s=0100001001100001\dots 0$$

Codifica dei caratteri : ASCII - Unicode - UTF-8

Per codificare i caratteri , il primo standard a imporsi è stato la codifica ASCII ( American Standard Code for Information Interchange ) , che usa 7 bit per codificare 128 caratteri ( sarebbe 1 byte → 8 bit e il primo bit a 0 ). Nel mondo però non bastano 128 caratteri ( il cinese ha circa 7000 caratteri ) , quindi è nato lo standard Unicode. In questo standard viene associato ogni carattere un numero compreso tra 0 e 1.114.111 , con in totale $2^{16}+2^{20}$ caratteri disponibili. Esistono diverse codifiche per utilizzare lo standard Unicode , e i più famosi sono : UTF-8 , UTF-16 , UTF-32. La codifica UTF-8 è una codifica a lunghezza variabile ( adatta la lunghezza al carattere che deve codificare ).

Inoltre è retro-compatibile con ASCII :

• si usa un 1 byte ( 8 bit e il primo a 0 ) e il successivi 7 uguale ad ASCII

Per i caratteri non ASCII , quelle che richiedono più byte , UTF-8 usa una sequenza specifica : dove il primo byte inizia una sequenza di 1 lunga quanto i numeri di byte utilizzati , e il secondo byte inizia con 10 ( sempre ) :

dove "$-$" vengono dedicati per la codifica binaria del numero Unicode che associa al carattere da codificare .