conversione da decimale a binario

CONVERSIONE DA DECIMALE A BINARIO
Il procedimento per convertire in forma binaria un certo numero decimale n consiste nello scrivere, andando da destra verso
sinistra, le cifre 0 oppure 1 seguendo delle determinate regole che sono:
- Se n è pari si scrive 0;
- Se n è dispari si scrive 1 e si sostituisce n con n-1;
Se n è dispari, sottraendo uno ad n, esso diventerà pari e si potrà effettuare il procedimento dividendo n per due e si continua così
finché non si arriva allo 0 arrivando così al termine del procedimento.
Esempio:
Scriviamo 25 in forma binaria. Il numero binario di 25 è 110012.
N = 25; n è dispari quindi scriviamo 1
N -1 = 24; 24/2 = 12. N = 12; n è pari quindi scriviamo 0
N = 12; 12/2 = 6. N = 6; n è pari quindi scriviamo 0
N = 6; 6/2 = 3. N = 3; n è dispari quindi scriviamo 1
N-1 = 2; 2/2 = 1. N = 1; n è dispari quindi scriviamo 1
N-1 = 0. N = 0; n è zero quindi abbiamo terminato il procedimento
Ora leggiamo i numeri dal basso verso l’alto e otterremmo 11001 il valore che noi volevamo. Per effettuare un’ulteriore prova basta
si fa:
110012 = 1 * 20 + 0 *21 + 0 * 22 + 1 *23 + 1*24 = 1 + 0 + 0 + 8 + 16 = 25.
In sintesi possiamo anche scrivere
25|1
12 |0
6 |0
3 |1
1 |1
Così abbiamo trasformato il nostro valore decimale intero in binario.
1
CONVERSIONE DA DECIMALE IN FLOATING POINT
Per la conversione da decimale in floating point bisogna suddividere il numero decimale in due parti; una parte è la parte intera
quindi il numero prima della virgola mentre la seconda è la parte frazionaria cioè la parte dopo la virgola.
Per trasformare la parte intera si fa nella maniera riportata precedentemente. Se volessimo convertire un numero decimale come
11.87610 in binario prima di tutto si trasforma l’intero 11;
1110 = 10012
Ora trasformiamo la parte decimale ovvero 0.87610
Per fare questo bisogna moltiplicare per 2 la cifra con la virgola e vedere se il risultato dato, sia maggiore di uno se lo è scriviamo 1
e togliamo uno
MANTISSA:
Esempio
0.876*2 = 1,752 1
0.752*2 = 1,504 1
0.504*2=1.008 1
0.008*2=0.016 0
0.016*2=0.032 0
0.032*2=0.064 0
0.064*2=0.128 0
0.128*2=0.256 0
…… e così via fino ad arrivare al numero di bit assegnatoci e fino ad ottenere un valore del tipo 0.11100000010000011000 2
Quindi il nostro valore 11.87610 = 1001. 111000000100000110002
Per ottenere la mantissa, in questo caso di 24 cifre, bisogna normalizzare cioè avere un numero 1. e in seguito qualcosa. Noi, per
avere la forma richiesta, dobbiamo spostare la virgola a sinistra di 3 posizioni per far si che la mantissa diventi
1.001111000000100000110002 *23
La prima cifra della mantissa, ovvero l’1, si omette sempre quindi la mantissa sarà pari a 00111100000010000011000 2
ESPONENTE:
Avendo dovuto fare lo shift della mantissa di 3 posizioni a sinistra (quindi queste 3 posizioni verranno sommate ai bit
dell’esponente es: 5 bit per l’esponente si farà 25 = 32 / 2 – 1 = 15 + 3 = 18) si sommeranno le posizioni shiftate al valore
dell’esponente. In questo caso l’esponente è espresso in codice ECCESSO 127 quindi si farà 127 + 3 = 130 10 e verrà trasformato
anch’esso in un binario che sarà 100000102
SEGNO:
Se il numero in virgola mobile tra trasformare è positivo il segno avrà valore 0 altrimenti avrà valore 1.
Alla fine avremmo il seguente risultato
SEGNO
0
ESPONENTE
1000010
MANTISSA
00111100000010000011000
2
CONVERSIONE DA FLOATING POINT IN DECIMALE
Per convertire un numero decimale in un floating point si utilizzano due modi differenti, uno per la parte intera uno per la parte
frazionaria. Prendiamo ad esempio questo numero decimale:
1101.001011002
Effettuiamo ora la conversione della parte intera ovvero di 11012
Parte intera: 1*20 + 0*21 + 1*22 + 1*23= 1 + 0 + 4 + 8 = 13
Parte decimale: 0*2-1 + 0*2-2 + 1*2-3 + 1*2-4 + 0*2-5 + 1*2-6 = 0 + 0 + 0-125 + 0 + 0.03125 +0.015625 = 0.171875
Quindi il valore trasformato in decimale è:
1101.001011002 = 13.12187510
3
OPERAZIONI BINARIE
ADDIZIONE BINARIA
Tabella dell’addizione:
+
0
1
0
0
1
1
1
0
Esempio:
(A)101112
(B)1012
(A)1 0 1 1 1 +
(B) 1 0 1
(A + B) 1 1 1 0 02
Quando si ha un 1 + 1 si effettua un riporto di uno e si scrive 0 e si aggiunge l’1 all’operazione che segue
SOTTRAZIONE BINARIA
Per effettuare la sottrazione il metodo più semplice, è quello di fare il COMPLEMENTO A 2 del sottraendo. Per fare il
complemento a due basta invertire tutti i numeri appena si trova il primo uno leggendo da destra a sinistra e, invertire tutti gli altri
valori. ESEMPIO: 5: 0 1 0 12 complemento a due -5: 1 0 1 12 (il primo bit serve per il segno)
Esempio:
(A)1 0 1 1 0 1
(B) 1 1 0 1 0
(-B) 1 0 0 1 1 0
(A)1 0 1 1 0 1 +
(B)1 0 0 1 1 0
(A+(-B))1 0 1 0 0 1 1
Il risultato finale di (A + (- B)) è di 0 1 0 0 1 12. Ho tolto un bit in quanto se effettuo una somma a 6 bit devo restituire un
risultato con i medesimi bit.
4
MOLTIPLICAZIONE BINARIA
Tabella della moltiplicazione:
*
0
1
0
0
0
1
0
1
Le regole della moltiplicazione sono sintetizzate nella tabella. È consigliabile sommare 2 a 2 i risultati in maniera da non
incombere in una specie di doppio riporto.
Esempio:
(A)1 1 1 0 1 1 02
(B) 1 1 0 0 12
A
1110110
B
11001
1110110
0000000 0000000 - 1110110--1110110----
F
G
*
Sommo queste 3 celle
(v.di punto 1)
Sommo queste 2 celle
(v.di punto 2)
Punto 1)
001110110+
000000 0 0 - +
000000 0 - 0 0 1 1 1 0 1 1 02 (val F)
Punto 2)
01110110---+
1110110---0 0 0 1 0 1 1 0 0 0 1 02 (val G)
Ora sommo F con G e trovo il risultato della moltiplicazione:
00001110110 +
000101100010
1011100001102
(A * B) 1 0 1 1 1 0 0 0 0 1 1 02
5
DIVISIONE BINARIA
Le regole della divisione binaria sono uguali a quelle della divisione decimale. Nella divisione binaria si mette un 1 se il dividendo è
contenuto nel divisore altrimenti 0. Ogni volta tiro ‘giù’ un’altra cifra. Se arrivo in fondo con un valore ma nessun’altra cifra, vuol
dire che la divisone ha il resto.
Esempio:
(A)1 1 1 0 1 12
(B)1 0 12
111011
101
100
101
1001
101
1001
101
100
101
1011
 Resto della divisione
Il risultato di questa divisione è 10112 con il resto di 1002.
6
ALGORITMO DI BOOTH
La moltiplicazione tra binari, oltre che con il metodo normale, la si può fare in maniera differente utilizzando l’algoritmo di
Booth. L’algoritmo di Booth fa riferimento ad una semplice tabella. Prende in ingresso una coppia di bit del moltiplicando e
guarda la seguente tabella:
00 0
01 1
10 -1
11 0
La prima colonna rappresenta la coppia di bit e la seconda colonna rappresenta il valore da attribuire alla moltiplicazione.
Esempio:
(A) 00102
(B) 01102
Ora eseguiamo il complemento a 2 nell’eventualità che si possa avere una coppia di bit che sia 10 quindi il complemento di (A) è
1110. Ora trasformiamo (B) utilizzando l’algoritmo di Booth.
A (B) aggiungeremo uno 0 fittizio e quindi diventerà 0 1 1 0 | 0 e si trasformerà in: 0 0 -> 0, 1 0 -> -1, 1 1 -> 0, 0 1 -> +1
Quindi l’algoritmo di Booth di (B) sarà 1 0 -1 0.
Siccome si ha una moltiplicazione di 4 bit * 4 bit il risultato sarà di 8 bit.
La moltiplicazione sarà:
00102 *
1 0 -1 0
00000000
11111110–
00000000 - 00000010 - - 10 0000 11002
Togliamo l’1 0 di bit in quanto i bit devono essere 8 e quindi il risultato sarà 0000 11002;
7
OPERAZIONI SU FLOATING POINT
ADDIZIONE FLOATING POINT
Per effettuare una somma avendo due floating point bisogna eseguire degli step.
Step 1:
Controllare se gli esponenti sono uguali. Se in un floating point ho un esponente a 5 bit che ha valore 12 = 01100 e un altro
esponente SEMPRE a 5 bit dal valore 13 = 01101 non posso effettuare la somma. Per renderli uguali devo rendere l’esponente del
numero minore uguale a quello del numero maggiore. In questo caso devo aggiungere 1 a 12.
Esempio:
Numero 1
0 01100 00011101
Numero 2
0 01101 01001011
Il numero 1, al cui esponente verrà sommato 1, verrà modificato come segue e si effettuerà l’addizione sul nuovo numero:
Numero 1 new:
0 01101 10001110
Numero 2:
0 01101 01001011
Step 2:
Ora che abbiamo reso uguali gli esponenti sommiamo le mantisse. Prendiamo come esempio i due numeri dati in precedenza:
Numero 1:
0 01101 10001110
Numero 2:
0 01101 01001011
0,10001110 +
1,01001011
1,11010101  Già normalizzato quindi non serve che venga normalizzato. Con normalizzazione si intende che il numero venga
portato alla forma base della mantissa quindi 1,…
Risultato somma:
0 01101 11010101
8
Esempio utilizzando la normalizzazione e il troncamento.
Numero 1:
0 01101 10001110
Numero 2:
0 01101 01001011
0,10001110 +
1,11001011
10,01010001
In questo caso la nuova mantissa non è normalizzata quindi si effettua uno switch della virgola di una posizione verso sinistra in
modo da avere la forma canonica della mantissa ovvero 1,…
Switchando otteniamo questa mantissa:
1,001010001 Questa mantissa, però, ha 9 bit e quindi si dovrà troncare l’ultimo bit in quanto è in eccesso e ‘uscirebbe’ dal limite
degli 8 bit per la mantissa quindi numero della somma sarà:
Risultato somma:
0 01101 11010101
SOTTRAZIONE FLOATING POINT
Per effettuare la sottrazione tra due floating point bisogna eseguire i stessi passaggi che riguardano la somma cioè:
1) Prendere il numero con esponente più piccolo e rendere l’esponente uguale al più grande, shiftando a sinistra la virgola
per un numero di bit pari alla differenza tra gli esponenti;
2) Sottrarre la mantissa
3) Normalizzare il risultato finale
Esempio:
Numero 1:
0 01100 00011101
Numero 2:
0 01101 01001011
Il numero 1, al cui esponente verrà sommato 1, verrà modificato come segue e si effettuerà la sottrazione sul nuovo numero:
Numero 1 new:
0 01101 10001110
Numero 2:
0 01101 01001011
9
Ora che abbiamo reso uguali gli esponenti sommiamo le mantisse. Prendiamo come esempio i due numeri dati in precedenza:
Numero 1:
0 01101 10001110
Numero 2:
0 01101 01001011
0,10001110 –
1,01001011
1,01000011
In questo caso la mantissa non si normalizza in quanto abbiamo già la forma canonica ovvero 1,… (si poteva pure fare il
complemento a due e fare una somma tra i due membri dell’operazione, il risultato non sarebbe cambiato).
Quindi il risultato è:
0 01101 01000011
MOLTIPLICAZIONE FLOATING POINT
Per eseguire la moltiplicazione bisogna seguire dei semplici passi:
1) ER = EA + EB – BIAS
2) MR = MA * MB
3) SR = SA + SB
4) Normalizzare
E = Esponente; M = mantissa; S = segno; BIAS = (2n/2)-1 [n = numero bit dell’esponente]
Esempio:
Prendiamo due numeri come per esempio (5,6875)10 e (-1,65625)10 e trasformiamoli in floating point:
(5,6875)10
0 10001 011011
(-165625)10
1 01111 101010
Verifichiamo che i numeri siano stati convertiti in maniera esatta:
(5,6875) 10
Primo bit segno: 0 (+)
Seconda parte esponente: 17 – 15 (bias) = 2 (numero di posizioni shiftate)
Terza parte mantissa: 1,011011 = 1 + 0*0,5 + 1*0,25 + 1*1/8 + 1*1/32 + 1*1/64 = 1,421875 * 22 = (5,6875)10
10
(-1,65625)10
-
Primo bit segno: 1 (-)
Seconda parte esponente: 15 – 15 (bias) = 0 (numero di posizioni shiftate)
Terza parte mantissa: 1,101010 = 1 + 1*0,5 + 1*1/8 + 1*1/32 = 1,65625 * 20 = (-1,65625)10
Ora calcoliamo il risultato
1)
ER = 17 + 15 – 15 (BIAS) = 17 + 1 (normalizzazione) = 18
2)
SR = 1 (-)
3)
MR = 1011011*
1101010
10,010110101110
4)
MR = 1,001011
Risultato:
1 10010 001011
DIVISIONE FLOATING POINT
Per eseguire la divisione bisogna seguire 4 semplici passi:
1)
ER = EA – EB + BIAS
2)
SR = SA + SB
3)
MR = MA / MB
4)
Normalizzare
Prendiamo due numeri (10)10 e (2,5)10 rendiamoli numeri in floating point e dividiamoli tra loro:
(10)10
0 10010 010000
(10)10 = (1010)2
1,010 * 23
Calcolo dell’esponente:
BIAS
01111+
Pos. Shiftate 00011
Esponente
10010
11
(2,5)10
0 10000 010000
(2,5)10 = (10,1)2
1,01 * 21
BIAS
Pos. Shiftate
Esponente
01111+
00001
10000
Ora calcoliamo il risultato:
1)
ER = 18-16+15 = 17 (in questo caso non serve la normalizzazione in quanto la mantissa è già in formato 1,…)
2)
SR = 0 (+)
3)
MR = MA / MB
101000 101000
101000 1
MR = 100000
Risultato divisione:
0 10001 100000
Per vedere se è giusto il risultato si effettua questa conferma:
17 – 15 = 2 (posizioni da shiftare)
Shifto l’1 di 2 posizioni a sinistra in modo da ottenere:
100 = 4; 10:2,5 = 4;
La divisione è corretta.
12