Elementy Logiki i Arytmetyki Komputerów

Ćwiczenie nr 2
Reprezentacja liczb zmiennoprzecinkowych. Standard IEEE 754. Algorytm Bootha.

1. Reprezentacja liczb zmiennoprzecinkowych

Ze względu na fakt, iż zapis ułamków w naturalnym kodzie binarnym jest niewygodny przy operowaniu
na dużych i małych liczb jednocześnie (ograniczeniem jest liczba bitów), komputery do obliczeń stosują
zapis zmiennoprzecinkowy (zmiennopozycyjny). Zapis zmiennopozycyjny umożliwia zapisywanie
zarówno bardzo dużych, jak i bardzo małych liczb - na tej samej liczbie bitów.
Liczbę zmiennoprzecinkową x zapisuje się w postaci: 𝒙 = 𝑴 ∙ 𝑷𝑪
gdzie: M – mantysa, P – podstawa systemu, C – cecha (wykładnik).
Położenie przecinka w mantysie nie jest ustalone – można je dowolnie zmieniać:
1230000000000(10) = 123 × 1010 = 123e+10 = 12,3 × 1011 = 12,3e+11 = 1,23 × 1012
= 1,23e+12 = 0,123 × 1013 = 0,123e+13 = 0,0123 × 1014 = 0,0123e+14, itd.
Przy czym przesunięcie przecinka w mantysie ma wpływ na wartość cechy liczby:
 przesuwając przecinek o 1 pozycję w lewo należy zwiększyć cechę o 1,
 przesuwając przecinek o 1 pozycję w prawo należy zmniejszyć cechę o 1.
W związku z tym, że liczbę zmiennoprzecinkową można zapisywać na różne sposoby, przyjęto tzw.
postać znormalizowaną. Znormalizowana liczba zmiennoprzecinkowa to taka, w której mantysa
spełnia nierówność: 𝑷 > |𝑴| ≥ 𝟏
Innymi słowy, przed przecinkiem z lewej strony powinna znajdować się tylko jedna cyfra.
Według tej definicji, jedynie zapis 1,23 × 1012 (1,23e+12) z podanych wcześniej przykładów zapisu liczby
1230000000000 w postaci zmiennoprzecinkowej jest postacią znormalizowaną.
Liczby binarne możemy zapisać w formacie zmiennoprzecinkowym w naturalnym kodzie binarnym
(liczby nieujemne), w kodzie U2 lub wykorzystując kod z nadmiarem (ang. offset binary/excess
code/biased representation) – tak jak robi się to w standardzie IEEE 754.

Reprezentacja liczb binarnych w formacie zmiennoprzecinkowym - przykłady:

a) w notacji naukowej:
Zapis zmiennopozycyjny dla liczb binarnych jest analogiczny do zapisu dziesiętnego:
0,0625(10) = 6,25 x 10-2 = 6,25e-2  w zapisie dziesiętnym
0,0625(10) = 0,0001(2)
0,0001(2) = 1 x 2-4 = 1,0e-100  w zapisie dwójkowym

mgr inż. Alicja Gerka

Zakład Systemów Złożonych, Politechnika Rzeszowska im. Ignacego Łukasiewicza
b) w NKB:
Założenia wstępne (przykładowe): mantysa ma postać znormalizowaną, liczby chcemy zakodować na
12 bitach, przy założeniu, że 9 bitów ma kodować mantysę, 3 bity cechę.
Przykład: Dokonać konwersji liczb 125,75(10) i 2,125(10) zgodnie z przyjętymi założeniami
125,75(10) = 1111101,11(2) = 1,11110111 x 26  111110111|110
1 1 1 1 1 0 1 1 1 1 1 0
2,125(10) = 10,001(2) = 1,0001 x 21  100010000|001  rozszerzenie znakowe
1 0 0 0 1 0 0 0 0 0 0 1

c) w kodzie U2:
Założenia wstępne (przykładowe): liczby chcemy zakodować na 12 bitach, przy założeniu, że 8 bitów
ma kodować mantysę, 4 bity cechę, a przecinek w mantysie znajduje się pomiędzy bitem 9 a 10.

Przykład: Dokonać konwersji liczby 125,75(10) zgodnie z przyjętymi założeniami

125,75(10) = 01111101,11(U2) = 01,11110111 x 26
6(10) = 0110(U2)
W tym wypadku mantysa przekracza nam dozwolony zakres, więc zostanie ucięta:
0 1 1 1 1 1 0 1 0 1 1 0  liczba
11 10 9 8 7 6 5 4 3 2 1 0  numeracja bitów liczby

Sprawdzenie:
01111101|0110
0110 (U2) = 6(10)
01,111101 x 26 = 01111101(U2) = 125(10)  wynik nie zgadza się z liczbą przed konwersją

Przykład: Dokonać konwersji liczby -5,125(10) zgodnie z przyjętymi założeniami

Rozwiązanie I
-5,125(10) = 1010,111(U2) = 1,010111 x 23
3(10) = 011(U2) = 0011(U2)  rozszerzenie znakowe (część całkowitą liczby w kodzie U2 rozszerzamy
znakowo dopisując przed liczbą wartość, która znajduje się na najstarszym bicie – w wypadku liczby
nieujemnej jest to 0)
1,010111(U2) = 11,010111(U2)  rozszerzenie znakowe (część całkowitą liczby w kodzie U2 rozszerzamy
znakowo dopisując przed liczbą wartość, która znajduje się na najstarszym bicie – w wypadku liczby
ujemnej jest to 1)
1 1 0 1 0 1 1 1 0 0 1 1
Rozwiązanie II
-5,125(10) = 1010,111(U2) = 10,10111 x 22
2(10) = 010(U2) = 0010(U2)  rozszerzenie znakowe
1,010111(U2) = 10,101110(U2)  rozszerzenie znakowe (część ułamkową liczby w kodzie U2 rozszerzamy
znakowo wg zasad dla NKB – dopisujemy zera za najmłodszym bitem)
1 0 1 0 1 1 1 0 0 0 1 0
Sprawdzenie dla I i II:
11010111|0011
0011 (U2) = 3(10) 1,0101110 x 23 =1010,111(U2) = -5,125(10)
10101110|0010
0010 (U2) = 2(10) 10,101110 x 22 =1010,111(U2) = -5,125(10)
mgr inż. Alicja Gerka
Zakład Systemów Złożonych, Politechnika Rzeszowska im. Ignacego Łukasiewicza
 2. Standard IEEE 754
IEEE 754 to powszechnie stosowany (m.in. w procesorach) standard reprezentacji binarnej i operacji
na liczbach zmiennopozycyjnych. Standard określa liczby pojedynczej (ang. float) i podwójnej (ang.
double) precyzji, przy czym na potrzeby niniejszej instrukcji zostanie omówiony tylko pierwszy z nich.
S C C C C C C C C M M M M M M … M M M M M M M
1bit 8 bitów 23 bity
ZNAK CECHA (WYKŁADNIK) MANTYSA

Liczba w formacie IEEE-754 jest zapisywana za pomocą 32 bitów, gdzie:

 najstarszy (pierwszy z lewej) bit określa znak liczby (ang. sign): dla liczby ujemnej S = 1, dla liczby
dodatniej S = 0.
 kolejne 8 bitów koduje wykładnik potęgi 2 (cecha), przy czym stosuje się tu kod z nadmiarem (ang.
bias) równym 127 (aby zamiast wykładników z zakresu 0..255 móc przestawić wykładniki z zakresu
-127..128, dzięki czemu istnieje możliwość reprezentacji ułamków),
 ostatnie 23 bity koduje mantysę, przy czym standard zakłada, że mantysa jest znormalizowana i
w zapisie pomija się jej pierwszy niezerowy bit (pozwala to uzyskać 7–8 dziesiętnych miejsc
znaczących, a co za tym idzie zwiększyć zakres reprezentowanych liczb).
Konieczność normalizacji mantysy pociąga za sobą pewną komplikację - skoro przecinek zawsze musi
zostać przesunięty za pierwszą jedynkę, w jaki sposób przedstawić w standardzie liczbę 0? Jako
rozwiązanie tego problemu przyjęto, że gdy wykładnik jest równy 0 (tzn. w rzeczywistości ma on
wartość dziesiętną -127, bo po uwzględnieniu przesunięcia otrzymujemy 0 – 127 = -127) i wszystkie
bity mantysą wynoszą 0, to taka liczba jest równa 0. W związku z tym, że do rozważenia pozostaje także
bit znaku, który może być równy 0 lub 1, w standardzie tym istnieją dwie reprezentacje zera, przy czym
ta z bitem znaku ustawionym na 1 nazywana jest „zerem ujemnym”. Generalnie w standardzie IEEE
754 możliwa jest reprezentacja jednego z kilku rodzajów wartości:
 wartość normalna (ang. normal),
 zero (ujemne bądź dodatnie),
 nieskończoność (ujemna bądź dodatnia),
 wartość zdenormalizowana (ang. denormal, subnormal),
 NaN – nie-liczba (ang. Not a Number).

Wykładnik Wykładnik Wykładnik

Liczba Znak Mantysa Wartość
BIAS=127 dziesiętnie + 127
Zero 0 0000 0000 -127 0 000 0000 0000 0000 0000 0000 0.0
Zero ujemne 1 0000 0000 -127 0 000 0000 0000 0000 0000 0000 -0.0
Jeden 0 0111 1111 0 127 000 0000 0000 0000 0000 0000 1.0
Minus jeden 1 0111 1111 0 127 000 0000 0000 0000 0000 0000 −1.0
Najmniejsza liczba ±2−126 ≈
0 lub 1 0000 0001 -126 1 000 0000 0000 0000 0000 0000
(normalna) ±1,18 × 10-38
Największa liczba ±(2−2−23) × 2127 ≈
0 lub 1 1111 1110 127 254 111 1111 1111 1111 1111 1111
(normalna) ±3,4 × 1038
Najmniejsza liczba 0 lub 1 0000 0000 -127 0 000 0000 0000 0000 0000 0001 2-149 ≈
zdenormalizowana (-126) ±1,4 × 10-45
Nieskończoność 0 lub 1 1111 1111 128 255 000 0000 0000 0000 0000 0000 +∞ lub -∞
„Nie liczba” 0 lub 1 1111 1111 128 255 nie zero NaN

mgr inż. Alicja Gerka

Zakład Systemów Złożonych, Politechnika Rzeszowska im. Ignacego Łukasiewicza
Zgodnie z powyższą tabelką wartość, w której wszystkie bity wykładnika są ustawione na 1, a mantysa
równa jest 0 odczytuje się jako nieskończoność (dodatnia bądź ujemna – w zależności od bitu znaku).
Gdyby w takim przypadku którykolwiek bit mantysy został ustawiony na 1 – wartość taka zostałaby
odczytana jako NaN (ang. Not a Number). Zatem największa liczba jaką można przedstawić
w standardzie IEEE 754 wymaga ustawienia wszystkich bitów mantysy na 1 oraz ustawienia wszystkich
poza ostatnim (najmniej znaczącym) bitów wykładnika na 1. Z kolei najmniejsza liczba wymaga
wyzerowania wszystkich bitów w mantysie i ustawienia tylko jednego (najmniej znaczącego) bitu
w wykładniku.

Reprezentacja liczb w standardzie IEEE 754 - przykłady:

Liczbę L w standardzie IEEE 754 można zatem przedstawić za pomocą wzoru:
𝐿𝐼𝐸𝐸𝐸 754 = (−1)𝑆 ∙ 𝑀 ∙ 2𝐶
gdzie S – bit znaku, M – mantysa, C – cecha (wykładnik).

Przy konwersji liczb na standard IEEE 754 należy pamiętać o odpowiednim przekształceniu wartości
wykładnika – należy uwzględnić nadmiar (dodać lub odjąć wartość nadmiaru = 127).

Przykład: Przedstawić liczbę 118,625(10) w standardzie IEEE 754.

118,625(10) = 1110110,101(2)
1110110,101 = 1,110110101 ∙ 26
M = 11011010100000000000000(2)
C = 6 + 127 = 133(10) = 10000101(2)
S = 0 - liczba jest dodatnia
0 | 10000101 | 11011010100000000000000
118,625(10) = 01000010111011010100000000000000(IEEE754)

Przykład: Przedstawić liczbę -1364,13(10) w standardzie IEEE 754.

1364,13(10) = 10101010100,00(100001010001111010111)(2)
10101010100,00(100001010001111010111) = 1,010101010000(100001010001111010111) ∙ 210
M = 01010101000010000101000 (2)  mantysa zostaje ucięta (przekroczenie zakresu 23 bitów)
C = 10 + 127 = 137(10) = 10001001(2)
S = 1 - liczba jest ujemna
1 | 10001001| 01010101000010000101000
-1364,13(10) = 11000100101010101000010000101000(IEEE754)

mgr inż. Alicja Gerka

Zakład Systemów Złożonych, Politechnika Rzeszowska im. Ignacego Łukasiewicza
Przykład: Przedstawić liczbę -1000000(10) w standardzie IEEE 754.
1000000(10) = 11110100001001000000(2)
11110100001001000000 = 1,1110100001001000000 ∙ 219
M = 1110100001001000000(2)
C = 19 + 127 = 146(10) = 10010010(2)
S = 1 - liczba jest ujemna
1 | 10010010 | 1110100001001000000
-1000000(10) = 1100100101110100001001000000(IEEE754)

Przykład: Dokonać konwersji liczby 01000010110010000000000000000000IEEE754 na system dziesiętny.

0 | 10000101 | 10010000000000000000000
S = 0 - liczba jest dodatnia
C = 10000101(BIAS=127) = 133 - 127 = 6
9
M = 1,10010000000000000000000(2) = 1 16

9 25 6 25 6
𝐿𝐼𝐸𝐸𝐸 754 = (−1)𝑆 ∙ 𝑀 ∙ 2𝐶 = (−1)0 ∙ 1 ∙ 26 = ∙ 2 = 4 ∙ 2 = 25 ∙ 22 = 25 ∙ 4 = 100
16 16 2
01000010110010000000000000000000(IEEE 754) = 100(10)

Przykład: Dokonać konwersji liczby 11000001110110000000000000000000IEEE754 na system dziesiętny.

1 | 10000011 | 10110000000000000000000
S = 1 - liczba jest ujemna
C = 10000011(BIAS=127) = 131 - 127 = 4
11
M = 1,10110000000000000000000(2) = 1 16

11 4 27 27
𝐿𝐼𝐸𝐸𝐸 754 = (−1)𝑆 ∙ 𝑀 ∙ 2𝐶 = (−1)1 ∙ 1 ∙ 2 = − ∙ 24 = − 4 ∙ 24 = −27
16 16 2
11000001110110000000000000000000(IEEE 754) = -27(10)

Przykład: Dokonać konwersji liczby 10111110000000000000000000000000IEEE754 na system dziesiętny.

1 | 01111100 | 00000000000000000000000
S = 1 - liczba jest ujemna
C = 01111100(BIAS=127) = 124 - 127 = -3
M = 1,000000000000000000000000(2) = 1
1
𝐿𝐼𝐸𝐸𝐸 754 = (−1)𝑆 ∙ 𝑀 ∙ 2𝐶 = (−1)1 ∙ 1 ∙ 2−3 = − = −0,125
23
10111110000000000000000000000000(IEEE 754) = -0,125(10)

mgr inż. Alicja Gerka

Zakład Systemów Złożonych, Politechnika Rzeszowska im. Ignacego Łukasiewicza
3. Operacje arytmetyczne na liczbach zmiennoprzecinkowych
Wykonanie operacji arytmetycznych na liczbach zmiennoprzecinkowych jest problematycznym
zadaniem.
Dodawanie (a co za tym idzie także odejmowanie) liczb w zapisie zmiennopozycyjnym wymaga
doprowadzenia tych liczb do takiej postaci, aby ich wykładniki były równe. Zazwyczaj wiąże się to
z koniecznością przesunięcia przecinka w jednej z liczb, w wyniku czego jedna z liczb stanie się
nieznormalizowana, co z kolei wymusza konieczność sprawdzania czy po wykonaniu operacji
arytmetycznej wynik nie wymaga ponownej normalizacji. Regułą podczas sprowadzania liczb do
wspólnego wykładnika jest przesuwanie przecinka zawsze u liczby, której wykładnik jest mniejszy, co
oznacza, że podczas wykonywania operacji dodawania/odejmowania obie liczby będą miały wykładnik
taki, jaki jest przypisany liczbie z największą wartością. Dzięki temu w najgorszym wypadku zostaną
utracone najmniej znaczące bity mniejszej liczby, a nie najbardziej znaczące bity liczby większej, co jest
niezwykle istotne dla zapewnienia maksymalnej dokładności wyniku.
W wypadku mnożenia sprawa jest nieco prostsza, ponieważ nie ma konieczności przesuwania
przecinków przed wykonaniem obliczeń. Mnożenie dwóch liczb w standardzie IEEE 754 polega na
wykonaniu mnożenia na mantysach, a następnie dodaniu wykładników obu liczb bez nadmiaru
(nadmiar należy uwzględnić przy zapisywaniu wyniku w standardzie IEEE 754).

Obliczenia arytmetyczne na liczbach zmiennopozycyjnych - przykłady:

a) dodawanie licz nieujemnych
Kolejne kroki działania:
 sprawdzenie, czy jeden z argumentów nie jest zerem,
 wyrównanie wykładników,
 sumowanie mantys z uwzględnieniem znaku,
 normalizacja wyniku.

𝑾𝒚𝒏𝒊𝒌 = (𝑴𝒂𝒏𝒕𝒚𝒔𝒂𝟏 + 𝑴𝒂𝒏𝒕𝒚𝒔𝒂𝟐 ) ∙ 𝟐(𝑪𝒆𝒄𝒉𝒂)

Przykład: Dodawanie liczb w standardzie IEEE 754

13,625(10) + 3,75(10)
13,625(10) = 1101,101(2) =1,101101 ∙ 23
3,75(10) = 11,11(2) = 1,111 ∙ 21 = 0,01111 ∙ 23  W drugim składniku dodawania (mniejszy wykładnik)
przecinek musi zostać przesunięty (tak aby wykładnik wyniósł 3) w lewo o dwie pozycje.
13,625(10) = 01000001010110100000000000000000IEEE754
3,75(10) = 01000001001111000000000000000000IEEE754
Wykonujemy operację dodawania (tylko dla mantys):
1 , 1 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+ 0 , 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 , 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
10,001011(2) ∙ 23 = 10001,011(2) = 17,375(10)  Obliczony wynik jest poprawny, ale to jeszcze nie koniec

mgr inż. Alicja Gerka

Zakład Systemów Złożonych, Politechnika Rzeszowska im. Ignacego Łukasiewicza
W wyniku operacji dodawania otrzymujemy wynik: 10,001011, który NIE jest znormalizowany
(przecinek nie znajduje się tuż za pierwszą jedynką). Taki wynik należy powtórnie znormalizować
(w tym wypadku przesuwając przecinek o jedną pozycję w lewo pamiętając, by do wykładnika
w standardzie dodać wartość przesunięcia = 1)
10,001011(2) ∙ 23 = 1,0001011(2) ∙ 24
Ostatecznie więc wynik ma postać: 010000011000101100000000000000000IEEE754

b) odejmowanie (lub dodawane liczb ujemnych)

Kolejne kroki działania:
 sprawdzenie znaków i przedstawienie działania w postaci dodawania,
 sprawdzenie, czy jeden z argumentów nie jest zerem,
 konwersja na kod U2,
 wyrównanie wykładników,
 sumowanie mantys z uwzględnieniem znaku,
 konwersja wyniku z powrotem na standard IEEE 754 (konwersja liczby na NKB, ustawienie bitu
znaku, normalizacja).

Przykład: Odejmowanie liczb w standardzie IEEE 754

-13,625(10) - 3,75(10) = (-13,625(10)) + (-3,75(10))
-13,625(10) = 11000001010110100000000000000000IEEE754
-3,75(10) = 11000001001111000000000000000000IEEE754
13,625(10) = 1101,101(2) =1,101101 ∙ 23
3,75(10) = 11,11(2) = 1,111 ∙ 21 = 0,01111 ∙ 23
-13,625(10) = 10010,011(U2) = 1,0010011 ∙ 24
-3,75(10) = 100,01(U2) = 1,0001 ∙ 22 = 1,110001 ∙ 24  Pamiętamy o odpowiednim dla kodu U2
rozszerzeniu znakowym
W związku z tym, że chcemy wykonać operacje na liczbach ujemnych – dodajemy mantysy w kodzie
U2:
1 , 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+ 1 , 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0, 1 1 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
10,1110101(U2) ∙ 24 = 101110,101(U2) = -17,375(10)  Obliczony wynik jest poprawny, ale to jeszcze nie
koniec
W wyniku operacji dodawania otrzymujemy wynik: 10,1110101, który jest wynikiem w kodzie U2,
należy tę liczbę przekonwertować z powrotem na standard IEEE 754. Ze względu na to, że jest to liczba
ujemna należy znaleźć jej moduł oraz pamiętać o ustawieniu odpowiedniego bitu znaku oraz
normalizacji manstysy.
Liczba przeciwna do 10,1110101(U2) ∙ 24 to 01,0001011(U2) ∙ 24  Mantysa jest znormalizowana
Ostatecznie więc wynik ma postać: 110000011000101100000000000000000IEEE754
mgr inż. Alicja Gerka
Zakład Systemów Złożonych, Politechnika Rzeszowska im. Ignacego Łukasiewicza
c) mnożenie (metodą mnożenia bezpośredniego)
Kolejne kroki działania:
 sprawdzenie, czy jeden z argumentów nie jest zerem,
 ustalenie znaku wyniku,
 wykonanie mnożenia mantys,
 dodanie wykładników,
 ewentualna normalizacja wyniku.

𝑾𝒚𝒏𝒊𝒌 = (𝑴𝒂𝒏𝒕𝒚𝒔𝒂𝟏 ∙ 𝑴𝒂𝒏𝒕𝒚𝒔𝒂𝟐 ) ∙ 𝟐(𝑪𝒆𝒄𝒉𝒂𝟏+𝑪𝒆𝒄𝒉𝒂𝟐)

Przykład Mnożenie (metodą mnożenia bezpośredniego) w standardzie IEEE 754

13,625(10) ∙ 3,75(10) = 51,09375(10)
13,625(10) = 1101,101(2) = 1,101101(2) ∙ 23
3,75(10) = 11,11(2) = 1,111(2) ∙ 21

Liczba 13,625(10) zapisana w standardzie IEEE754 ma postać:

0 | 10000010 | 10110100000000000000000

Zaś liczba 3,75(10) ma postać:

0 | 10000000 | 11100000000000000000000

W wyniku mnożenia mantys otrzymujemy:

1 , 1 0 1 1 0 1
x 1 , 1 1 1
1 1 0 1 1 0 1
1 1 0 1 1 0 1
1 1 0 1 1 0 1
+ 1 1 0 1 1 0 1
1 1, 0 0 1 1 0 0 0 1 1

𝑾𝒚𝒏𝒊𝒌 = (𝑴𝒂𝒏𝒕𝒚𝒔𝒂𝟏 ∙ 𝑴𝒂𝒏𝒕𝒚𝒔𝒂𝟐 ) ∙ 𝟐(𝑪𝒆𝒄𝒉𝒂𝟏+𝑪𝒆𝒄𝒉𝒂𝟐) = 𝟏𝟏, 𝟎𝟎𝟏𝟏𝟎𝟎𝟎𝟏𝟏 ∙ 𝟐(𝟑+𝟏) =

= 𝟏𝟏, 𝟎𝟎𝟏𝟏𝟎𝟎𝟎𝟏𝟏 ∙ 𝟐𝟒

Kolejnym krokiem jest ponowna normalizacja mantysy, aby wynik można było zapisać z powrotem w
standardzie IEEE 754:
11,001100011 ∙ 24 = 1,1001100011 ∙ 25
127 + 5 = 132(10) = 10000100 (10)
0 | 10000100 | 10011000110000000000000

mgr inż. Alicja Gerka

Zakład Systemów Złożonych, Politechnika Rzeszowska im. Ignacego Łukasiewicza
4. Algorytm Bootha
W celu zoptymalizowania operacji mnożenia i ułatwienia jej fizycznej implementacji zostały
opracowane metody mające na celu zrównoleglenie obliczeń. Jedną z takich metod jest algorytm
Booth’a, który optymalizuje operację mnożenia poprzez zrównoleglenie obliczeń.
W odróżnieniu od standardowej arytmetyki, zamiast czynników w mnożeniu metodą Booth’a mamy
mnożną P i mnożnik Q (to, który czynnik obierzemy jako mnożnik, a który jako mnożną nie ma
większego znaczenia). Podczas wykonywania obliczeń liczby te zapisuje się w kodzie U2.
Dla ułatwienia algorytm zostanie omówiony na przykładzie mnożenia dwóch liczb: 9(10) ∙ 5(10)
P = 9(10) = 01001(U2) Q = 5(10) = 00101(U2) 9(10) ∙ 5(10) = 45(10) = 0101101(U2)
Algorytm polega na cyklicznym sprawdzaniu aktualnego stanu ostatniego bitu mnożnika i stanu
ostatniego bitu mnożnika przed wykonaniem operacji przesunięcia bitowego, przy czym wykonuje się
tyle kroków algorytmu ile bitów liczą mnożone liczby. Należy pamiętać o konieczności zapisania obu
liczb na takiej samej liczbie bitów (ponieważ wynik mnożenia zapisujemy na 2n bitach, gdzie n to
długość dłuższej liczby). W zależności od konfiguracji sprawdzanych bitów wykonuje się konkretne
operacje:
 jeśli porównywane bity znajdują się w konfiguracji 01 – do wyniku pośredniego należy dodać P,
 jeśli porównywane bity znajdują się w konfiguracji 10 – od wyniku pośredniego należy odjąć P (czyli
dodać -P w kodzie U2),
 jeśli porównywane bity znajdują się w konfiguracji 00 lub 11 – wynik pozostaje bez zmian,
 następnie każdy krok, niezależnie od konfiguracji bitów, kończy operacja przesunięcia bitowego
w prawo (ang. Shift Right) oznaczane jako SHR.

Q = 5(10) = 00101(U2) P = 9(10) = 01001(U2) -P = -9(10) = 10111(U2)

0 1  +P  SHR 1 0  -P  SHR 0 0 lub 1 1  SHR

KROK A Q Q -1 Operacja
1 0 0 0 0 0 0 0 1 0 1 0 -P
+ 1 0 1 1 1 0 0 0 0 0 0 ADD
1 0 1 1 1 0 0 1 0 1 0 SHR
2 1 1 0 1 1 1 0 0 1 0 1 +P
+ 0 1 0 0 1 0 0 0 0 0 0 ADD
1 0 0 1 0 0 1 0 0 1 0 0 SHR
3 0 0 0 1 0 0 1 0 0 1 0 -P
+ 1 0 1 1 1 0 0 0 0 0 0 ADD
1 1 0 0 1 0 1 0 0 1 0 SHR
4 1 1 1 0 0 1 0 1 0 0 1 +P
+ 0 1 0 0 1 0 0 0 0 0 0 ADD
1 0 0 1 0 1 1 0 1 0 0 1 SHR
5 0 0 0 1 0 1 1 0 1 0 0 SHR
0 0 0 0 1 0 1 1 0 1 0 STOP
WYNIK

W kolumnie A (ang. addition) przechowywyany jest wynik pośredni kolejnych kroków algorytmu.
W kolumnie Q w pierwszym kroku zostaje wpisany mnożnik.
mgr inż. Alicja Gerka
Zakład Systemów Złożonych, Politechnika Rzeszowska im. Ignacego Łukasiewicza
W kolumnie Q-1 znajduje się zawartość najmniej znaczącego bitu z kolumny Q przed wykonaniem
operacji przesunięcia bitowego (z czego wynika wartość 0 tego bitu w stanie początkowym).
Pierwsze porównanie bitów zawsze odbywa się z bitem 0 w kolumnie Q-1. Operacja SHR wykonywana
jest w ten sposób, że jeżeli najbardziej znaczący bit (ten z lewej) równy jest 0, to po przesunięciu
w prawo bit ten także jest równy 0, jeżeli zaś jest on równy 1, to po przesunięciu w prawo nadal wynosi
1 (wynika to z rozszerzania znakowego liczby w kodzie U2). Jak widać wykonanych jest tyle operacji
SHR - ilu bitowe są liczby, a w prezentowanym przykładzie wykonano tylko 4 operacje dodawania
(ADD). Jak łatwo zauważyć algorytm ten zdecydowanie zmniejsza liczbę wykonywanych dodawań,
jeżeli w mnożniku występują długie ciągi zer lub jedynek.

W kolejnym przykładzie zrealizowano mnożenie metodą Booth’a dla liczb stałoprzecinkowych.

4,1875(10) ∙ -7,5(10)
Q = 4,1875(10) = 0100,0011(U2)
P = -7,5(10) = 1000,1(U2) = 1111000,1(U2)  Pamiętamy o konieczności zapisania mnożnika i mnożnej na
takiej samej liczbie bitów (w tym wypadku 8) oraz regułach rozszerzania znakowego w kodzie U2
-P = 7,5(10) = 0111,1(U2) = 0000111,1(U2)
Oczekiwany wynik: 4,1875(10) ∙ -7,5(10) = -31,40625(10) = 100000,10011(U2)
Algorytm wykonujemy analogicznie jak w wypadku liczb całkowitych, przy czym należy pamiętać o
postawieniu przecinka we właściwym miejscu w wyniku. W tym celu należy zsumować miejsca po
przecinku mnożnej i mnożnika – w tym wypadku jest to 4 + 1 = 5, co oznacza, że w wyniku przecinek
znajduje się na pozycji za 5 bitem licząc od prawej (analogicznie jak w systemie dziesiętnym).
Q = 4,1875(10) = 0100,0011(U2) P = -7,5(10) = 1111000,1(U2) -P = 7,5(10) = 0000111,1(U2)
W związku z tym, że liczby zostały zapisane na 8 bitach – wykonujemy 8 koków algorytmu.
KROK A Q Q -1 Operacja
1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 -P
+ 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 ADD
0 0 0 0 1 1 1 1 0 1 0 0 0 0 1 1 0 SHR
2 0 0 0 0 0 1 1 1 1 0 1 0 0 0 0 1 1 SHR
3 0 0 0 0 0 0 1 1 1 1 0 1 0 0 0 0 1 +P
+ 1 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 ADD
1 1 1 1 0 1 0 0 1 1 0 1 0 0 0 0 0 SHR
4 1 1 1 1 1 0 1 0 0 1 1 0 1 0 0 0 0 SHR
5 1 1 1 1 1 1 0 1 0 0 1 1 0 1 0 0 0 SHR
6 1 1 1 1 1 1 1 0 1 0 0 1 1 0 1 0 0 SHR
7 1 1 1 1 1 1 1 1 0 1 0 0 1 1 0 1 0 -P
+ 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 ADD
1 0 0 0 0 1 1 1 0 0 1 0 0 1 1 0 1 0 SHR
8 0 0 0 0 0 1 1 1 0 0 1 0 0 1 1 0 1 +P
+ 1 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 ADD
1 1 1 1 1 0 0 0 0 0 1 0 0 1 1 0 1 SHR
1 1 1 1 1 1 0 0 0 0 0 1 0 0 1 1 0 STOP
WYNIK

mgr inż. Alicja Gerka

Zakład Systemów Złożonych, Politechnika Rzeszowska im. Ignacego Łukasiewicza
Otrzymany wynik to 11111100000,10011U2 = 100000,10011U2 = -31,40625(10)
Aby zapisać wynik mnożenia w standardzie IEEE 754, jeśli mamy do czynienia z liczbą ujemną – należy
znaleźć jej moduł (bo znak w IEEE 754 jest kodowany przez bit znaku) i oczywiście znormalizować
mantysę (jeśli jest w postaci nieznormalizowanej).
|100000,10011U2| = 011111,01101U2 = 31,40625(10)
011111,011012 = 1,111101101 ∙ 24
M = 11110110100000000000000
C = 4 + 127 = 10000011
S = 1 – liczba jest ujemna
100000,10011U2 = 11000001111110110100000000000000IEEE754

Mnożenie z wykorzystaniem algorytmu Booth’a - przykłady:

a) mnożenie liczb całkowitych

Przykład: 15(10) ∙ -6(10)

15(10) ∙ -6(10) = -90(10) = 10100110(U2)
Q =15(10) = 01111(U2)
P = -6(10) = 11010(U2)
-P = 6(10) = 00110(U2)
KROK A Q Q -1 Operacja
1 0 0 0 0 0 0 1 1 1 1 0 -P
+ 0 0 1 1 0 0 0 0 0 0 0 ADD
0 0 1 1 0 0 1 1 1 1 0 SHR
2 0 0 0 1 1 0 0 1 1 1 1 SHR
3 0 0 0 0 1 1 0 0 1 1 1 SHR
4 0 0 0 0 0 1 1 0 0 1 1 SHR
5 0 0 0 0 0 0 1 1 0 0 1 +P
+ 1 1 0 1 0 0 0 0 0 0 0 ADD
1 1 0 1 0 0 1 1 0 0 1 SHR
1 1 1 0 1 0 0 1 1 0 0 STOP
WYNIK

1110100110(U2) = 10100110(U2) = -90(10)

mgr inż. Alicja Gerka

Zakład Systemów Złożonych, Politechnika Rzeszowska im. Ignacego Łukasiewicza
b) mnożenie liczb stałoprzecinkowych

Przykład: -6,75(10) ∙ 19,625(10)

-6,75(10) ∙ 19,625(10) = -132,46875(10) = 101111011,10001(U2)

Q = 19,625(10) = 010011,101(U2)
P = -6,75(10) = 1001,01(U2) = 1111001,01(U2)
-P = 6,75(10) = 0110,11(U2) = 0000110,11(U2)

KROK A Q Q -1 Operacja
1 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 0 1 0 -P
+ 0 0 0 0 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 ADD
0 0 0 0 1 1 0 1 1 0 1 0 0 1 1 1 0 1 0 SHR
2 0 0 0 0 0 1 1 0 1 1 0 1 0 0 1 1 1 0 1 +P
+ 1 1 1 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 ADD
1 1 1 1 1 0 0 1 0 1 0 1 0 0 1 1 1 0 1 SHR
3 1 1 1 1 1 1 0 0 1 0 1 0 1 0 0 1 1 1 0 -P
+ 0 0 0 0 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 ADD
1 0 0 0 0 1 0 1 0 0 0 1 0 1 0 0 1 1 1 0 SHR
4 0 0 0 0 0 1 0 1 0 0 0 1 0 1 0 0 1 1 1 SHR
5 0 0 0 0 0 0 1 0 1 0 0 0 1 0 1 0 0 1 1 SHR
6 0 0 0 0 0 0 0 1 0 1 0 0 0 1 0 1 0 0 1 +P
+ 1 1 1 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 ADD
1 1 1 1 0 0 1 1 1 1 0 0 0 1 0 1 0 0 1 SHR
7 1 1 1 1 1 0 0 1 1 1 1 0 0 0 1 0 1 0 0 SHR
8 1 1 1 1 1 1 0 0 1 1 1 1 0 0 0 1 0 1 0 -P
+ 0 0 0 0 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 ADD
1 0 0 0 0 1 0 1 0 0 1 1 1 0 0 0 1 0 1 0 SHR
9 0 0 0 0 0 1 0 1 0 0 1 1 1 0 0 0 1 0 1 +P
+ 1 1 1 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 ADD
1 1 1 1 0 1 1 1 1 0 1 1 1 0 0 0 1 0 1 SHR
1 1 1 1 1 0 1 1 1 1 0 1 1 1 0 0 0 1 0 STOP
WYNIK

1111101111011,10001(U2) = 101111011,10001(U2) = -132,46875(10)

mgr inż. Alicja Gerka

Zakład Systemów Złożonych, Politechnika Rzeszowska im. Ignacego Łukasiewicza
Zadania
1. Przedstaw podane liczby w standardzie IEEE 754:
710
-88810
1000,110
-12354,62510
50005,062510

2. Dokonaj konwersji następujących liczb na system dziesiętny:

011000011111001100000000000000000IEEE754
011000000011000000000000000000000IEEE754
111011011101010100000000000000000IEEE754
111000011000000011000000000000000IEEE754
111100000001100000000000000000000IEEE754

3. Wykonaj obliczenia na liczbach zmiennoprzecinkowych w standardzie IEEE 754:

100,25(10) + 8,75(10)
1025,5(10) + 45,125(10)
18,75(10) - 3,75(10)
99,0625(10) - 103,75(10)

4. Wykonaj obliczenia metodą mnożenia bezpośredniego dla liczb zmiennoprzecinkowych:

19,75(10) ∙ 3,75(10)

5. Wykonaj obliczenia z wykorzystaniem algorytmu Booth’a:

2410 ∙ 610
3010 ∙ 1510
-2410 ∙ 610
-1310 ∙ -2010

6. Wykonaj obliczenia z wykorzystaniem algorytmu Booth’a:

19,75(10) ∙ 3,75(10)
-9,375(10) ∙ 4,5(10)
100,5(10) ∙ -12,125(10)

7. Wykonaj obliczenia z wykorzystaniem algorytmu Booth’a, wynik podaj w standardzie IEEE 754
245,375(10) ∙ 2,5(10)
-50,75(10) ∙ -4,75(10)

mgr inż. Alicja Gerka

Zakład Systemów Złożonych, Politechnika Rzeszowska im. Ignacego Łukasiewicza