Výpočty v systému pevné řádové čárky na platformě IBM PC

Obsah

1. Výpočty v systému pevné řádové čárky na platformě IBM PC

2. Jakými způsoby je možné reprezentovat numerické hodnoty v operační paměti počítače?

3. Uložení čísel ve formátu pevné řádové binární tečky

4. Přednosti a zápory formátu pevné řádové tečky

5. Dvojkový doplněk a čísla s pevnou řádovou binární čárkou

6. Základní vlastnosti čísel reprezentovaných v systému pevné řádové čárky

7. Praktická část

8. Realizace operace součtu v systému pevné řádové čárky

9. Součet realizovaný formou makra

10. Realizace operace součinu: naivní varianta

11. Korektní implementace součinu

12. Úprava operandů před provedením součinu

13. Úprava operandů po provedení součinu

14. Krátká odbočka: jakým způsobem se přeloží FX operace při použití jazyka C

15. Výpočet Mandelbrotovy množiny ve formátu s pevnou řádovou tečkou

16. Základní způsob realizace výpočtů

17. Neoptimalizovaná verze výpočtu Mandelbrotovy množiny

18. Částečně optimalizovaná verze výpočtu Mandelbrotovy množiny

19. Repositář s demonstračními příklady

20. Odkazy na Internetu

1. Výpočty v systému pevné řádové čárky na platformě IBM PC

V seriálu o tvorbě her a dem pro úspěšnou i nenáviděnou platformu IBM PC jsme si popsali základní aritmetické instrukce mikroprocesorů řady Intel 80×86. Taktéž jsme si podrobně popsali matematický koprocesor Intel 8087 i jeho následovníky (zejména čipy 80287, 80387). Pokud mělo PC některý z těchto koprocesorů nainstalován, mohlo poměrně rychle provádět operace s hodnotami uloženými v systému plovoucí řádové čárky (FP – Floating Point). Ovšem zdaleka ne všechna PC byla tímto relativně drahým čipem vybavena. Pokud matematický koprocesor nebyl nainstalován, bylo nutné všechny FP operace emulovat, což bylo poměrně pomalé (o řád až dva řády v porovnání s reálným koprocesorem).

I z tohoto důvodu se například v mnoha hrách vůbec FP operace neprováděly a využívala se zde odlišná technika. Ta byla založena na uložení vybrané podmnožiny numerických hodnot v systému pevné řádové (binární) tečky. V tomto článku se budeme záměrně dopouštět drobného prohřešku oproti stávající normě českého jazyka, protože budeme neustále psát o řádové, desetinné a binární tečce a nikoli o čárce – z hlediska anglické terminologie to bude více konzistentní, i když z češtinského hlediska by bylo zcela jistě korektnější psát o řádové čárce, protože se v češtině celá část čísla od části desetinné odděluje právě čárkou a nikoli tečkou, jak je tomu zvykem v anglosaských zemích (programátoři, kterým je tento článek určen především, však tuto skutečnost zcela jistě znají – ostatně IT je plná podobných podivností a nepřesností – „kilobajt“ apod.).

V anglické literatuře se zmíněná forma reprezentace číselných hodnot označuje zkratkou FX nebo FXP (fixed point), zatímco dnes častěji používaná reprezentace v systému plovoucí řádové tečky se všeobecně označuje zkratkou FP (floating point). V jednom článku jsem dokonce místo zkratky FX viděl i zkratku XP (fixed point), ale to bylo před mnoha lety, v době Windows 95, tedy dávno před Windows XP :-).

Dnes si nejprve vysvětlíme princip obou metod použitých pro ukládání podmnožiny racionálních čísel a posléze si také řekneme, jaké výhody a nevýhody jednotlivé principy přináší v každodenní programátorské praxi a ve kterých situacích je vhodnější použít pevnou řádovou čárku. V dalším textu budeme formát pevné binární řádové tečky zkracovat na FX formát a formát používající plovoucí řádovou tečku budeme zapisovat jako FP formát.

2. Jakými způsoby je možné reprezentovat numerické hodnoty v operační paměti počítače?

Při ukládání numerických hodnot do operační paměti počítače poměrně záhy narazíme na některé problémy, z nichž některé souvisí s konečným počtem bitů, které pro uložení dané hodnoty „obětujeme“ a další vycházejí z vlastního způsobu zpracování hodnot mikroprocesorem či matematickým koprocesorem. V konečném počtu bitů je totiž pochopitelně možné uložit pouze konečné množství různých hodnot a je plně v rukou programátora, jak efektivně daný počet bitů využije či naopak promrhá ukládáním nepodstatných informací. Poměrně často se totiž stává, že i program využívající dvojitou či dokonce rozšířenou přesnost čísel při FP operacích (tj. když používá datové typy double a extended/temporary) dává nesprávné výsledky dané nepochopením principu práce FP aritmetiky a přitom je v některých případech možné se přesnějších výsledků dobrat i při použití pouhých 32 bitů, ale s pečlivě vyváženými aritmetickými a bitovými operacemi.

Na druhou stranu nejsou dnes používané mikroprocesory tak univerzálními zařízeními, jak by se na první pohled možná mohlo zdát. Mikroprocesory jsou totiž (většinou) navrženy tak, aby účinně, například v rámci jedné operace či instrukce, zpracovávaly pouze konstantní počet bitů zvolený výrobcem mikroprocesoru. Příkladem mohou být dnes velmi rozšířené procesory řady x86 (x86–64), které jsou velmi dobré při práci s 32 bitovými hodnotami nebo hodnotami 64bitovými, ale při požadavku na aritmetické výpočty probíhající na (řekněme) 21 bitech se veškerá jejich efektivita ztrácí a procesor se širokými vnitřními sběrnicemi, matematickým koprocesorem atd. se potýká s prohazováním jednotlivých bitů (a naopak – mnohé DSP pracují s dvaceti nebo 24 bity a nikoli s 32/64 bity).

Mnohem lepší situace nastane v případě, že se nějaká operace implementuje na programovatelném poli FPGA – zde je možné vytvořit obvody provádějící matematické a logické operace s libovolným počtem bitů, čímž se oproti univerzálním řešením (např. konstantní bitová šířka sběrnice a/nebo registrů) ušetří mnoho plochy těchto velmi zajímavých obvodů (FPGA mohou mimochodem znamenat i velkou šanci pro hnutí open source – pomocí nich by mohlo vznikat, a někde už vzniká open hardware, které by mohlo odstranit závislost na „uzavřených“ síťových a grafických kartách apod.).

Vraťme se však ke způsobům reprezentace číselných hodnot v operační paměti počítače. Nejprve předpokládejme, že pro reprezentaci vlastností určitého objektu či stavu z reálného světa použijeme N binárních číslic (bitů), tj. základních jednotek informace, která může nabývat pouze jedné ze dvou povolených hodnot (ty se značí například symboly yes/no nebo true/false, ale my se budeme spíše držet označení 0 a 1). Pomocí této uspořádané N-tice je možné popsat celkem:

2₀×2₁×2₂ … 2_N-1=2^N

jednoznačných, tj. navzájem odlišných, stavů. Množina těchto stavů může reprezentovat prakticky jakýkoliv abstraktní či reálný objekt. Přitom si musíme uvědomit, že u této množiny není nikde implicitně řečeno ani myšleno, že se jedná například o celá kladná čísla, to je pouze jedna z mnoha možných interpretací zvolené N-tice (my programátoři máme tendenci považovat celá kladná čísla za přirozenou interpretaci bitové N-tice, to však vychází pouze z našeho pohledu na svět a z našich zkušeností). Reprezentaci momentálního stavu abstraktního či reálného objektu si můžeme představit jako zobrazení z množiny binárních stavů na elementy vzorové (a obecně neuspořádané) množiny. Nejčastěji používanými zobrazeními jsou zobrazení množiny binárních stavů na interval celých kladných čísel (Unsigned Integers), popřípadě na interval celých čísel (Signed Integers).

3. Uložení čísel ve formátu pevné řádové binární tečky

Numerické hodnoty zapsané ve formátu pevné řádové binární tečky se chápou jako podmnožina racionálních čísel, což jsou taková čísla, jejichž hodnoty je možné vyjádřit vztahem:

x_FX=a/b    a,b leží v Z, b ≠ 0

Číselné hodnoty z uvažované podmnožiny jsou navíc omezeny další podmínkou:

b=2^k b leží v Z, k leží v Z⁺

Protože b je celočíselnou mocninou dvojky (a ne desítky či jiného základu), určuje jeho hodnota n polohu binární tečky v uloženém čísle. Další podmínkou, která má však spíše implementační charakter, je zachování stejného počtu binárních cifer v každém reprezentovaném čísle, což mimo jiné znamená, že všechna čísla mají řádovou binární tečku umístěnou na stejném místě – z této podmínky ostatně plyne i název popisovaného způsobu reprezentace vybrané podmnožiny racionálních čísel (to je zásadní rozdíl oproti FP formátům). Tak jako i v jiných reprezentacích čísel, jsou nulové číslice před první nenulovou cifrou a za poslední nenulovou cifrou nevýznamné, proto je není zapotřebí uvádět (naše příklady jsou ovšem napsány poměrně primitivně a budou vypisovat všechny uložené cifry).

Prakticky může být číselná hodnota v systému pevné řádové tečky uložena na osmi bitech například následujícím způsobem (uvažujeme pouze kladné hodnoty):

4. Přednosti a zápory formátu pevné řádové tečky

Ve výše uvedeném příkladu je pevná binární řádová tečka umístěna vždy napevno mezi třetím a čtvrtým bitem. A vzhledem k tomu, že je tato skutečnost dopředu známá algoritmům, které provádí zpracování čísel (součet, rozdíl, součin, výpočet druhé odmocniny, výpočet goniometrické funkce atd.), není zapotřebí spolu s číslem uchovávat i pozici binární tečky, což výrazně snižuje počet bitů, které je zapotřebí rezervovat pro čísla ze zadaného rozsahu. To je tedy první přednost systému pevné řádové tečky – pokud programátor dokáže dopředu určit rozsah všech zpracovávaných hodnot a požadovanou přesnost, může být výhodné tento systém použít. Programátor také díky explicitním určení polohy řádové tečky může určit, ve kterém místě programu se musí přesnost či rozsah zvýšit a kdy naopak snížit. Lépe se tak využije počet bitů, které můžeme pro uložení jednoho čísla obětovat (typicky je tento počet bitů roven délce slova mikroprocesoru, popř. jeho celočíselnému násobku či naopak podílu).

Jak se dozvíme v následujících kapitolách, je možné základní matematické operace (sčítání, odčítání, násobení a dělení) poměrně jednoduše implementovat i při použití formátu pevné řádové tečky. V případě, že není k dispozici specializovaný (a současně velmi komplikovaný) matematický koprocesor, je mnohdy mnohem jednodušší a rychlejší implementovat matematické operace v FX formátu. To je případ mnoha jednočipových mikroprocesorů (mikrořadičů), signálových procesorů, ale i specializovaných zařízení obsahujících programovatelné obvody CPLD či FPGA. A byl to i případ platformy IBM PC až do (přibližně) roku 1995 (u nás ještě později). Dnes sice mají komplikovanější (a dražší) FPGA implementovanou i jednotku FPU, ale mnohdy je výhodnější použít FPGA bez této jednotky a potřebné operace si do tohoto obvodu „vypálit“ po svém.

Třetí výhodou je fakt, že u FX formátu může programátor navrhnout a posléze také dodržet požadovanou přesnost všech prováděných výpočtů. To je velký rozdíl oproti FP formátu (resp. jeho podmnožinám, které se nejčastěji používají). Jak jsme si již řekli v úvodních kapitolách, není vzácností narazit na aplikace, které používají datové typy float či double a přitom jsou výpočty prováděné v těchto programech zatíženy velkou chybou, protože si programátoři plně neuvědomují některé zásadní limity FP formátu. Kritické jsou například výpočty s peněžními hodnotami, ale i pouhé sčítání čísel, jež se od sebe o mnoho řádů liší, vede k velkým chybám, které dokonce mohou zapříčinit vznik nekonečných smyček, populární dělení nulou atd.

FX formát má však i některé nevýhody. První nevýhoda spočívá v tom, že tento formát není příliš podporován, a to ani po programové stránce (podpora v programovacích jazycích), ani výrobci mikroprocesorů pro počítače PC. Situace je však odlišná v oblasti jednočipových mikropočítačů, signálových procesorů (DSP), řídicích systémů, nebo například u IBM RS 6000, který kromě jednotky FPU obsahuje i FXU – jednotku pro provádění výpočtů v pevné řádové binární čárce. Na platformě x86 je možné pro FX formát použít instrukce MMX resp. v moderních PC spíše SSEx a AVX.

Dále může být použití FX formátu nevýhodné v případě, že se mají zpracovávat numerické hodnoty, které mají velkou dynamiku, tj. poměr mezi nejvyšší a nejnižší absolutní hodnotou. V takovém případě by se mohlo stát, že by se při použití FX formátu muselo pro každé číslo alokovat velké množství bitů, které by mohlo dokonce překročit počet bitů nutných pro FP formát. Také v případě, kdy dopředu nevíme, jaké hodnoty se budou zpracovávat, může být výhodnější použití FP formátu. Zde se však nabízí otázka, ve kterých případech nevíme, jaké hodnoty můžeme na vstupu získat: většinou je již z podstaty úlohy dopředu známé, s čím je možné počítat a které hodnoty jsou naprosto nesmyslné.

Je však pravdou, že takovou analýzu málokdo dělá a když při výpočtech ve floatech dochází k chybám, tak se bez přemýšlení program přepíše na doubly a problém se tak buď odstraní, nebo alespoň odsune na pozdější dobu, například do chvíle, kdy jsou programu předložena reálná data a ne „pouze“ data testovací.

5. Dvojkový doplněk a čísla s pevnou řádovou binární čárkou

V praxi je pochopitelně mnohdy (ale zdaleka ne vždy!) nutné pracovat i se zápornými hodnotami. Zde se typicky využívá takzvaný dvojkový doplněk. Dvojkový doplněk hodnoty x (označovaný zde kvůli nedostatkům HTML symbolem #x) lze získat z jejího jedničkového doplňku ~x (tedy prosté negace všech bitů) velmi jednoduše tak, že se k tomuto doplňku přičte jednotka, tj.:

#x=~x+1=2^N-x

Operaci jedničkového i dvojkového doplňku je možné provádět kromě celočíselných reprezentací i u reprezentace v pevné řádové binární čárce. Pokud je N-bitové slovo interpretováno ve vyjádření v pevné řádové čárce, může nabývat hodnot ležících v podmnožině P₂ racionálních čísel:

P₂=p/2^b | –2^N-1 ≤ p ≤ 2^N-1-1

Podmnožina P₂ obsahuje stále 2^N prvků, stejně jako podmnožina P₁ definovaná v předchozích kapitolách. Novou reprezentaci čísel budu v dalším textu označovat symbolem A(a,b), kde platí a=N-b-1.

Hodnota N-bitového čísla x je v reprezentaci A(a,b) vyjádřena výrazem:

x=1/2^b(-2^N-1x_N-1+∑₀^N-22ⁿx_n)

kde symbol x_n značí hodnotu n-tého bitu čísla x. Rozsah čísel reprezentovaných v A(a,b) je možné vyjádřit nerovností:

-2^N-1-b ≤ x ≤ 2^N-1-b-1/2^b

Za zmínku stojí také skutečnost, že počet významových bitů je v reprezentaci A(a,b) vždy o jednotku nižší, než u reprezentace U(a,b). Pro reprezentaci absolutní hodnoty čísla je použito pouze nižších N-1 bitů, nejvyšší bit je díky své funkci označován jako znaménkový bit (sign bit), což je ostatně patrné z podvýrazu -2^N-1x_N-1.

6. Základní vlastnosti čísel reprezentovaných v systému pevné řádové čárky

V následujících odstavcích jsou vypsány základní vlastnosti numerických hodnot, které jsou reprezentovány v systému s pevnou řádovou binární čárkou. Pravidla jsou uvedena jak pro formát U(a,b) (tj. pouze pro podmnožinu z kladných racionálních čísel), tak i pro formát A(a,b), tj. pro podmnožinu z kladných i záporných racionálních čísel. Každé vlastnosti je věnována samostatná podkapitola.

6.1 Počet bitů

Počet bitů nutných pro uložení číselné hodnoty v reprezentaci U(a,b) je jednoduše roven výsledku výrazu a+b, což mimo jiné značí, že všechny bity daného bitového vektoru jsou beze zbytku použity pro uložení číselné hodnoty (nejsou rezervovány žádné speciální bity). V reprezentaci A(a,b) je počet bitů roven hodnotě a+b+1, protože jeden bit navíc je nutné rezervovat pro uložení znaménka ukládané číselné hodnoty – viz výše zmíněný znaménkový bit.

6.2 Rozsah hodnot

Rozsah hodnot v reprezentaci čísel ve formátu U(a,b) lze vyjádřit vztahem 0≤ x₁ ≤ 2^a-2^-b, pro reprezentaci A(a,b) je rozsah hodnot vyjádřen nerovností: -2^a≤ x₂ ≤ 2^a-2^-b, což značí, že ve druhém uvedeném typu reprezentace je možné zaznamenat dvojnásobné množství navzájem odlišných hodnot – tato skutečnost je ostatně dána i větším počtem bitů pro reprezentaci A(a,b) oproti reprezentaci U(a,b) při stejných hodnotách parametrů a i b.

6.3 Platnost aritmetické operace součtu či rozdílu

Platnost aritmetické operace součtu či rozdílu hodnot uložených ve formátu U(a,b) pro kladná čísla U(a₁,b₁) a U(a₂,b₂) lze zaručit pouze tehdy, jestliže je a₁ rovno a₂ a současně b₁ rovno b₂, tj. obě hodnoty jsou uloženy ve slově (bitovém vektoru) se stejným množstvím (počtem) bitů a poloha řádové binární čárky je konstantní. Pro číselné hodnoty uložené ve druhém popisovaném formátu A(a₁,b₁) a A(a₂,b₂) platí stejné podmínky. Pokud není alespoň jedna z podmínek splněna, je nutné před provedením aditivní operace provést konverzi hodnot na shodný formát U(a_x, b_y) resp. A(a_x, b_y).

6.4 Rozsah výsledků po aritmetické operaci sčítání

Rozsah výsledků po aritmetické operaci sčítání dvou číselných hodnot ve formátu U(a,b) lze vyjádřit následujícím způsobem:

U(a,b)+U(a,b)=U(a+1,b)

tj. pro uložení výsledku je obecně zapotřebí vyhradit slovo širší právě o jeden bit. Pro dvě hodnoty ve formátu A(a,b) platí stejný vztah, jelikož se počet bitů obecně také zvyšuje o jednotku bez ohledu na znaménko výsledku:

A(a,b)+A(a,b)=A(a+1,b)

6.5 Rozsah výsledků po provedené aritmetické operaci násobení

Rozsah výsledků po provedené aritmetické operaci násobení dvou libovolných číselných hodnot uložených ve formátu U(a₁,b₁) a U(a₂,b₂) je možné vyjádřit následujícím vztahem:

U(a₁, b₁) × U(a₂, b₂)=U(a₁+a₂, b₁+b₂)

Výše uvedeným vztahem je popsáno, že se při ukládání výsledků takto provedené multiplikativní operace zvyšuje jak počet významových bitů před binární řádovou čárkou, tak i stejnou měrou počet zlomkových bitů, tj. bitů umístěných za binární čárkou. Při provádění multiplikativní operace s číselnými hodnotami uloženými ve formátu A(a₁,b₁) a A(a₂,b₂) je situace při ukládání výsledků následující:

A(a₁,b₁) × A(a₂, b₂)=A(a₁+a₂+1, b₁+b₂)

Tento vztah je poněkud odlišný od vztahu předchozího, ale při bližším rozboru je opět snadno pochopitelný. U číselných hodnot ve formátu A(a,b) je totiž jeden (nejvyšší) bit rezervován pro vyjádření znaménka uložené hodnoty. Po násobení je také nutné vyjádřit znaménko výsledku, ale opětovně pouze na jednom bitu, nikoli na bitech dvou.

7. Praktická část

Praktická část dnešního článku je rozdělena na dvě poloviny. V první polovině si na jednoduchých příkladech ukážeme způsob realizace základních FX operací, konkrétně operace součtu a taktéž operace součinu. A posléze si ukážeme relativně složitější příklady, ve kterých budeme vykreslovat Mandelbrotovu množinu (autorův oblíbený matematický objekt), a to plně s využitím pouze FX operací a s využitím standardního grafického režimu karty VGA s rozlišením 320×200 pixelů a s 256 barvami. Tyto příklady tedy budou bez problémů spustitelné i na IBM PC bez matematického koprocesoru.

8. Realizace operace součtu v systému pevné řádové čárky

Implementačně nejjednodušší je realizace operace součtu nebo rozdílu, protože tuto operaci je možné provést instrukcemi typu ADD, SUB atd., a to bez ohledu na pozici binární řádové tečky. V případě, že budeme pracovat s hodnotami s celkovou šířkou 32 bitů, přičemž 16 bitů je rezervováno pro část před tečkou a 16 bitů pro část za tečkou, je součet triviální – použijeme instrukci ADD s 32bitovými registry použitými ve formě operandů:

;-----------------------------------------------------------------------------
org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        jmp main                   ; skok na zacatek kodu
 
%include "io.asm"                  ; nacist symboly, makra a podprogramy
%include "print.asm"               ; nacist symboly, makra a podprogramy
 
P       equ     65536              ; poloha desetinne tecky v FX-pointu
 
main:
        mov  eax, 1 * P            ; konstanta v FX-pointu: 1.0
        print_hex eax
 
        mov  eax, 1 * P            ; konstanta v FX-pointu: 1.0
        mov  ebx, 2 * P            ; konstanta v FX-pointu: 2.0
        add  eax, ebx              ; scitani v FX-pointu
        print_hex eax
 
        mov  eax, 1 * P / 2        ; konstanta v FX-pointu: 0.5
        print_hex eax
 
        mov  eax, 3 * P / 2        ; konstanta v FX-pointu: 1.5
        print_hex eax
 
        mov  eax, 1 * P / 2        ; konstanta v FX-pointu: 0.5
        mov  ebx, 3 * P / 2        ; konstanta v FX-pointu: 1.5
        add  eax, ebx              ; scitani v FX-pointu
        print_hex eax
 
finish:
        wait_key                   ; cekani na klavesu
        exit                       ; navrat do DOSu
 
 
; datova cast
section .data
 
section .bss

Výsledky v surové podobě tak, jak je vypsal příklad:

00010000
00030000
00008000
00018000
00020000

Což lze interpretovat následovně:

0001.0000 ≅ 1.0
 
0003.0000 ≅ 1.0 + 2.0 = 3.0
 
0000.8000 ≅ 0.5
0001.8000 ≅ 1.5
0002.0000 ≅ 0.5 + 1.5 = 2.0

9. Součet realizovaný formou makra

Vzhledem k jednoduchosti realizace součtu ve formátu pevné řádové tečky můžeme tuto operaci navrhnout i formou makra, což se v assembleru NASM provádí následujícím způsobem:

%macro fx_add 2
        add %1, %2
%endmacro

Celý příklad se potom změní jen nepatrně (expanze makra je podtržena):

;-----------------------------------------------------------------------------
org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
%macro fx_add 2
        add %1, %2
%endmacro
 
 
start:
        jmp main                   ; skok na zacatek kodu
 
%include "io.asm"                  ; nacist symboly, makra a podprogramy
%include "print.asm"               ; nacist symboly, makra a podprogramy
 
P       equ     65536              ; poloha desetinne tecky v FX-pointu
 
main:
        mov  eax, 1 * P            ; konstanta v FX-pointu: 1.0
        print_hex eax
 
        mov  eax, 1 * P            ; konstanta v FX-pointu: 1.0
        mov  ebx, 2 * P            ; konstanta v FX-pointu: 2.0
        fx_add eax, ebx            ; scitani v FX-pointu
        print_hex eax
 
        mov  eax, 1 * P / 2        ; konstanta v FX-pointu: 0.5
        mov  ebx, 3 * P / 2        ; konstanta v FX-pointu: 1.5
        fx_add eax, ebx            ; scitani v FX-pointu
        print_hex eax
 
finish:
        wait_key                   ; cekani na klavesu
        exit                       ; navrat do DOSu
 
 
; datova cast
section .data
 
section .bss

Výsledky by nyní měly vypadat následovně:

00010000 ≅ 1.0
00030000 ≅ 3.0 = 1.0 + 2.0
00020000 ≅ 2.0 = 0.5 + 1.5

10. Realizace operace součinu: naivní varianta

Jak jsme mohli vidět v předchozí dvojici kapitol, byla realizace operace součtu s FX hodnotami triviální. Ovšem jak tomu bude u operace součinu? Zkusme si nejdříve i tuto operaci realizovat tím nejvíce naivním způsobem, konkrétně zavoláním instrukce MUL:

;-----------------------------------------------------------------------------
org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        jmp main                   ; skok na zacatek kodu
 
%include "io.asm"                  ; nacist symboly, makra a podprogramy
%include "print.asm"               ; nacist symboly, makra a podprogramy
 
P       equ     65536              ; poloha desetinne tecky v FX-pointu
 
main:
        mov  eax, 2 * P            ; konstanta v FX-pointu: 2.0
        print_hex eax
 
        mov  eax, 3 * P            ; konstanta v FX-pointu: 3.0
        print_hex eax
 
        mov  eax, 2 * P            ; konstanta v FX-pointu: 1.0
        mov  ebx, 3 * P            ; konstanta v FX-pointu: 2.0
        mul  ebx                   ; nasobeni v FX-pointu do EDX:EAX
        print_hex eax
 
        mov  eax, 1 * P / 2        ; konstanta v FX-pointu: 0.5
        print_hex eax
 
        mov  eax, 3 * P            ; konstanta v FX-pointu: 3.0
        print_hex eax
 
        mov  eax, 1 * P / 2        ; konstanta v FX-pointu: 0.5
        mov  ebx, 3 * P            ; konstanta v FX-pointu: 3.0
        mul  ebx                   ; nasobeni v FX-pointu do EDX:EAX
        print_hex eax
 
finish:
        wait_key                   ; cekani na klavesu
        exit                       ; navrat do DOSu
 
 
; datova cast
section .data
 
section .bss

Výsledky nebudou příliš uspokojivé:

00020000 ≅ 2.0
00030000 ≅ 3.0
 
00000000 ≅ 0.0 ≠ 2.0 * 3.0
 
00008000 ≅ 0.5
00030000 ≅ 3.0
80000000 ≅ 32768.0 ≠ 1.5 = (0.5 * 3.0)

Vidíme, že tato realizace násobení je zcela evidentně nekorektní.

11. Korektní implementace součinu

Problémy s operací součinu (a vlastně i podílu, i když zde se bude postupovat „opačně“), které jsme mohli vidět v předchozí kapitole, je možné vyřešit dvěma základními způsoby:

1. Úpravou operandů před provedením operace součinu s tím, že výsledek bude korektní. Úpravou se zde myslí aritmetický nebo bitový posun operandů doprava o vhodný počet bitů (8, 16 atd. podle pozice řádové tečky).
2. Úpravou výsledku po provedení operace součinu, tj. výsledek bude nutné vhodným způsobem opravit/upravit. Tato úprava opět spočívá v aritmetickém nebo bitovém posunu doprava.

Oba výše naznačené způsoby mají své klady i zápory. Při použití prvního způsobu ztrácíme přesnost výpočtů (některé operandy totiž budou po úpravě vynulovány, některé budou naopak nepřesné), ovšem bitová šířka výsledku bude odpovídat bitové šířce operandů (což ovšem na platformě 8086 nemusíme docenit). A naopak druhý způsob je obecně přesnější, ovšem je nutné pracovat s mezivýsledkem, jehož bitová šířka je dvojnásobná oproti bitové šířce operandů, tedy například 64 bitů pro 32 bitové operandy atd.

12. Úprava operandů před provedením součinu

Podívejme se nyní na konkrétní způsob úpravy operandů před provedením operace součinu. Vstupem budou 32bitové operandy, takže pro jejich uložení budou použity 32bitové registry EAX a EBX (80386 a vyšší). Hodnotu každého z těchto operandů posuneme doprava o osm bitů, čímž vlastně snížíme přesnost a i řádová tečka se posune o osm pozic. Následně je možné provést běžný součin a výsledek bude korektní, resp. přesněji řečeno dolní registr výsledku bude korektní (výsledek je totiž obecně 64bitový). Operaci násobení ve formátu FX lze tedy realizovat relativně snadným způsobem:

mov  eax, první_operand
mov  ebx, druhý operand
shr  eax, 8                ; posun jeste pred nasobenim (ztrata presnosti)
shr  ebx, 8                ; posun jeste pred nasobenim (ztrata presnosti)
mul  ebx                   ; nasobeni v FX-pointu do EDX:EAX

Původní naivní variantu součinu můžeme upravit do této (sice nepřesné, ale rychlé) podoby:

;-----------------------------------------------------------------------------
org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        jmp main                   ; skok na zacatek kodu
 
%include "io.asm"                  ; nacist symboly, makra a podprogramy
%include "print.asm"               ; nacist symboly, makra a podprogramy
 
P       equ     65536              ; poloha desetinne tecky v FX-pointu
 
main:
        mov  eax, 2 * P            ; konstanta v FX-pointu: 2.0
        print_hex eax
 
        mov  eax, 3 * P            ; konstanta v FX-pointu: 3.0
        print_hex eax
 
        mov  eax, 2 * P            ; konstanta v FX-pointu: 1.0
        mov  ebx, 3 * P            ; konstanta v FX-pointu: 2.0
        shr  eax, 8                ; posun jeste pred nasobenim (ztrata presnosti)
        shr  ebx, 8                ; posun jeste pred nasobenim (ztrata presnosti)
        mul  ebx                   ; nasobeni v FX-pointu do EDX:EAX
        print_hex eax
 
        mov  eax, 1 * P / 2        ; konstanta v FX-pointu: 0.5
        print_hex eax
 
        mov  eax, 3 * P            ; konstanta v FX-pointu: 3.0
        print_hex eax
 
        mov  eax, 1 * P / 2        ; konstanta v FX-pointu: 0.5
        mov  ebx, 3 * P            ; konstanta v FX-pointu: 3.0
        shr  eax, 8                ; posun jeste pred nasobenim (ztrata presnosti)
        shr  ebx, 8                ; posun jeste pred nasobenim (ztrata presnosti)
        mul  ebx                   ; nasobeni v FX-pointu do EDX:EAX
        print_hex eax
 
finish:
        wait_key                   ; cekani na klavesu
        exit                       ; navrat do DOSu
 
 
; datova cast
section .data
 
section .bss

Ověřme si, zda výpočty skutečně probíhají podle očekávání:

00020000 ≅ 2.0
00030000 ≅ 3.0
 
00060000 ≅ 6.0 = 2.0 * 3.0
 
00008000 ≅ 0.5
00030000 ≅ 3.0
00018000 ≅ 1.5 = 0.5 * 3.0

Z výsledků je patrné, že pro tyto konkrétní operandy skutečně dostaneme správné výsledky. Příště se zaměříme na diskusi o ztrátě přesnosti atd.

13. Úprava operandů po provedení součinu

Můžeme se pokusit implementovat i „opačný“ způsob provedení operace součinu, tj. nejdříve oba operandy vynásobit a teprve poté provést bitový posun. Tato metoda je výhodnější z toho pohledu, že výsledek bude přesnější (bity totiž ztrácíme až po provedení součinu), ovšem nevýhodou je, že operace násobení musí výsledek uložit do dvojnásobného počtu bitů. To konkrétně znamená, že pro dvojici 32bitových operandů bude výsledek 64bitový. Na platformě 80386 je toho možné dosáhnout relativně snadno, protože operace MUL v tomto případě vrátí výsledek ve dvojici registrů EDX:EAX. Tento obsah musíme posunout doprava o šestnáct bitů. To lze provést malým trikem – přesunem šestnáctibitové části výsledku (bity 15 až 23 do bitů 0 až 7) a rotací 32bitového registru o šestnáct bitů (musí se jednat o rotaci, nikoli o posun):

mov  eax, první_operand
mov  ebx, druhý_operand
mul  ebx                   ; nasobeni v FX-pointu do EDX:EAX
mov  ax, dx                ; bity 16-32
ror  eax, 16               ; prohodit horni a spodni polovinu registru

Praktická realizace takto realizovaného součinu využívajícího FX formát vypadá následovně:

;-----------------------------------------------------------------------------
org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
start:
        jmp main                   ; skok na zacatek kodu
 
%include "io.asm"                  ; nacist symboly, makra a podprogramy
%include "print.asm"               ; nacist symboly, makra a podprogramy
 
P       equ     65536              ; poloha desetinne tecky v FX-pointu
 
main:
        mov  eax, 2 * P            ; konstanta v FX-pointu: 2.0
        print_hex eax
 
        mov  eax, 3 * P            ; konstanta v FX-pointu: 3.0
        print_hex eax
 
        mov  eax, 2 * P            ; konstanta v FX-pointu: 1.0
        mov  ebx, 3 * P            ; konstanta v FX-pointu: 2.0
        mul  ebx                   ; nasobeni v FX-pointu do EDX:EAX
        mov  ax, dx                ; bity 16-32
        ror  eax, 16               ; prohodit horni a spodni polovinu registru
        print_hex eax
 
        mov  eax, 1 * P / 2        ; konstanta v FX-pointu: 0.5
        print_hex eax
 
        mov  eax, 3 * P            ; konstanta v FX-pointu: 3.0
        print_hex eax
 
        mov  eax, 1 * P / 2        ; konstanta v FX-pointu: 0.5
        mov  ebx, 3 * P            ; konstanta v FX-pointu: 3.0
        mul  ebx                   ; nasobeni v FX-pointu do EDX:EAX
        mov  ax, dx                ; bity 16-32
        ror  eax, 16               ; prohodit horni a spodni polovinu registru
        print_hex eax
 
finish:
        wait_key                   ; cekani na klavesu
        exit                       ; navrat do DOSu
 
 
; datova cast
section .data
 
section .bss

Opět se podívejme na vypočtené výsledky a pokusme se je analyzovat:

00020000 ≅ 2.0
00030000 ≅ 3.0
 
00060000 ≅ 6.0 = 2.0 * 3.0
 
00008000 ≅ 0.5
00030000 ≅ 3.0
00018000 ≅ 1.5 = 0.5 * 3.0

Z výsledků je opět patrné, že jsou korektní.

14. Krátká odbočka: jakým způsobem se přeloží FX operace při použití jazyka C

Jen pro zajímavost se podívejme na to, jak dobře (nebo naopak špatně) jsou přeloženy operace s pevnou řádovou tečkou v případě, pokud pro jejich zápis použijeme programovací jazyk C. Výsledky nemusí dopadnout dobře tehdy, když explicitně nespecifikujeme, že mezivýsledky mohou mít vyšší počet bitů, než operandy (resp. parametry příslušných funkcí). Ostatně se o tom můžeme přesvědčit sami:

#include <stdint.h>
 
uint32_t fx_add(uint32_t x, uint32_t y) {
    return x+y;
}
 
uint32_t fx_mul_1(uint32_t x, uint32_t y) {
    return (x>>8) * (y>>8);
}
 
uint32_t fx_mul_2(uint32_t x, uint32_t y) {
    return (x*y)>>16;
}

Překlad provedený bez optimalizací, tj. s přepínačem -O0:

fx_add(unsigned int, unsigned int):
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], edi
        mov     DWORD PTR [rbp-8], esi
        mov     edx, DWORD PTR [rbp-4]
        mov     eax, DWORD PTR [rbp-8]
        add     eax, edx
        pop     rbp
        ret
 
fx_mul_1(unsigned int, unsigned int):
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], edi
        mov     DWORD PTR [rbp-8], esi
        mov     eax, DWORD PTR [rbp-4]
        shr     eax, 8
        mov     edx, eax
        mov     eax, DWORD PTR [rbp-8]
        shr     eax, 8
        imul    eax, edx
        pop     rbp
        ret
 
fx_mul_2(unsigned int, unsigned int):
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], edi
        mov     DWORD PTR [rbp-8], esi
        mov     eax, DWORD PTR [rbp-4]
        imul    eax, DWORD PTR [rbp-8]
        shr     eax, 16
        pop     rbp
        ret

Překlad provedený s optimalizacemi na výkon, tj. -O9:

fx_add(unsigned int, unsigned int):
        lea     eax, [rdi+rsi]
        ret
 
fx_mul_1(unsigned int, unsigned int):
        shr     edi, 8
        shr     esi, 8
        mov     eax, edi
        imul    eax, esi
        ret
 
fx_mul_2(unsigned int, unsigned int):
        imul    edi, esi
        mov     eax, edi
        shr     eax, 16
        ret

Překlad provedený s optimalizacemi na velikost výsledného kódu, tj. -Os:

fx_add(unsigned int, unsigned int):
        lea     eax, [rdi+rsi]
        ret
 
fx_mul_1(unsigned int, unsigned int):
        shr     edi, 8
        shr     esi, 8
        mov     eax, edi
        imul    eax, esi
        ret
 
fx_mul_2(unsigned int, unsigned int):
        imul    edi, esi
        mov     eax, edi
        shr     eax, 16
        ret

Pochopitelně je možné správným přetypováním dosáhnout kýženého výsledku, ovšem v tomto konkrétním případě si dovolím tvrdit, že assemblerovský kódu bude mnohem čitelnější v porovnání s céčkovou variantou.

15. Výpočet Mandelbrotovy množiny ve formátu s pevnou řádovou tečkou

V závěrečné části dnešního článku si ukážeme, jakým způsobem je možné formát s pevnou řádovou tečkou použít v praxi. Budeme provádět výpočet Mandelbrotovy množiny, který již byl na stránkách Roota realizován mnoha různými způsoby a v mnoha programovacích jazycích. Nyní se ovšem zaměříme na realizaci využívající assembler, reálný režim IBM PC a navíc bude pro vykreslování použit grafický režim karty VGA s rozlišením 320×200 pixelů s 256 barvami (což je z pohledu programátora ten nejjednodušší grafický režim vůbec). Díky použití formátu s pevnou řádovou čárkou není nutné, aby byl nainstalován matematický koprocesor – ten dokonce ani nemusí být emulován, protože není použita ani jedna jeho instrukce. V každém případě by výsledkem měl být přesně tento obraz (bude bitově totožný na všech variantách IBM PC, protože nezáleží na přesnosti FP výpočtů, na jeho zaokrouhlovacích režimech, optimalizacích překladače atd.):

16. Základní způsob realizace výpočtů

V pseudokódu (a Python můžeme v tomto kontextu za pseudokód považovat) může výpočet Mandelbrotovy množiny vypadat následovně. Většina použitých proměnných jsou typu double, pouze proměnná i je typu int/long:

def calc_mandelbrot(width, height, maxiter, palette):
 
    cy_ = -1.5
    for y in range(height):
        cx_ = -2.0
        for x in range(width):
            zx1 = 0.0
            zy1 = 0.0
            i = 0
            while i < maxiter:
                zx2 = zx1 * zx1
                zy2 = zy1 * zy1
                if zx2 + zy2 > 4.0:
                    break
                zy1 = 2.0 * zx1 * zy1 + cy_
                zx1 = zx2 - zy2 + cx_
                i += 1
 
            r = palette[i][0]
            g = palette[i][1]
            b = palette[i][2]
            putpixel(x, y, r, g, b)
            cx_ += 3.0/width
        cy_ += 3.0/height

Podívejme se nyní na realizaci některých výše uvedených výpočtů v assembleru s využitím formátu FX.

Proměnná cy_ je na začátku inicializována, další pak nikoli:

section .data
 
cy_     dd MIN                     ; poloha v komplexni rovine rovine
 
section .bss
 
cx_     resd 1                     ;
zx1     resd 1                     ;
zy1     resd 1                     ; aktualni poloha v komplexni rovine
zx2     resd 1                     ; zx2=zx1^2 (aby se to nemuselo pocitat 2x)
zy2     resd 1                     ; zy2=zy1^2

Realizace výpočtu zx2 = zx1 * zx1:

        mov     EAX, dword [zx1]   ;
        sar     EAX, 8             ;
        imul    EAX                ; zx2:=zx1^2 (v X-pointu)
        mov     dword [zx2], EAX   ;

Realizace výpočtu zy2 = zy1 * zy1:

        mov     EAX, dword [zy1]   ;
        sar     EAX, 8             ;
        imul    EAX                ; zy2:=zy1^2 (v X-pointu)
        mov     dword [zy2], EAX   ;

Realizace výpočtů:

zy1 = 2.0 * zx1 * zy1 + cy_
zx1 = zx2 - zy2 + cx_

vypadá následovně:

        mov     EAX, [zx1]         ;
        sar     EAX, 8             ; zx1 div 256 (pro mul v X-pointu)
 
        mov     EBX, [zy1]         ;
        sar     EBX, 7             ; zy1 div 256 * 2 (pro mul v X-pointu)
 
        imul    EBX                ; zy1:=2*zx1*zy1
        add     EAX, [cy_]         ; zy1:=2*zx1*zy1+CY (u Mandelbrota poc.iter.)
        mov     [zy1], EAX         ; ulozit novou hodnotu zy1
 
        mov     EAX, [zx2]         ;
        sub     EAX, [zy2]         ; zx2:=zx2-zy2=zx1^2-zy1^2
        add     EAX, [cx_]         ;
        mov     [zx1], EAX         ; zx1:=zx1^2-zy1^2+CX

A konečně test, zda zx2+zy2 nepřesáhla hodnotu BAILOUT:

        mov     EAX, [zx2]         ;
        add     EAX, [zy2]         ; ==zx1^2+zy1^2
        cmp     EAX, BAILOUT*P     ; kontrola na bailout (abs[Z]<4)
        jc      short iter_loop    ; abs[Z]<4 =>dalsi iterace

17. Neoptimalizovaná verze výpočtu Mandelbrotovy množiny

Neoptimalizovaná varianta programu, který po svém spuštění vykreslí Mandelbrotovu množinu, vypadá následovně. Velikost výsledného kódu je 188 bajtů:

;-----------------------------------------------------------------------------
org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
; konstanty
P       equ     65536              ; poloha desetinne tecky v X-pointu
K       equ     4*P/256            ; vzdalenost mezi dvema body (krok smycky)
L       equ     4*P/192
MIN     equ     -2*P               ; minimalni a maximalni hodnota konstant fraktalu
                                   ; v komplexni rovine
MAXITER equ     40                 ; maximalni pocet iteraci
BAILOUT equ     4
 
section .text
 
start:
        jmp main                   ; skok na zacatek kodu
 
%include "io.asm"                  ; nacist symboly, makra a podprogramy
 
 
main:
        mov     ax, 13h            ; graficky rezim 320x200x256
        int     10h
 
;:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
;: MANDELBROTOVA MNOZINA                                                    ::
;:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
 
        push    0xa000
        pop     ES                 ; segment obrazove pameti karty VGA
 
        mov     DI, 320*8+32       ; zacatek vykreslovani na obrazovce
        mov     BP, 192            ; BP==[x] fraktal bude velikosti 256x192 pixelu
mforx:  mov     dword [cx_], MIN   ; od -2 (imaginarni osa)
        mov     SI, 256            ; SI==[y]
mfory:  mov     CL, MAXITER        ; maximalni pocet iteraci
        xor     EAX, EAX           ;
        mov     dword [zx1], EAX   ; nastaveni real.casti zacatku
        mov     dword [zy1], EAX   ; nastaveni imag.casti zacatku
 
iter_loop:                         ; *** iteracni smycka ***
        mov     EAX, dword [zx1]   ;
        sar     EAX, 8             ;
        imul    EAX                ; zx2:=zx1^2 (v X-pointu)
        mov     dword [zx2], EAX   ;
 
        mov     EAX, dword [zy1]   ;
        sar     EAX, 8             ;
        imul    EAX                ; zy2:=zy1^2 (v X-pointu)
        mov     dword [zy2], EAX   ;
 
        mov     EAX, [zx1]         ;
        sar     EAX, 8             ; zx1 div 256 (pro mul v X-pointu)
 
        mov     EBX, [zy1]         ;
        sar     EBX, 7             ; zy1 div 256 * 2 (pro mul v X-pointu)
 
        imul    EBX                ; zy1:=2*zx1*zy1
        add     EAX, [cy_]         ; zy1:=2*zx1*zy1+CY (u Mandelbrota poc.iter.)
        mov     [zy1], EAX         ; ulozit novou hodnotu zy1
 
        mov     EAX, [zx2]         ;
        sub     EAX, [zy2]         ; zx2:=zx2-zy2=zx1^2-zy1^2
        add     EAX, [cx_]         ;
        mov     [zx1], EAX         ; zx1:=zx1^2-zy1^2+CX
 
        dec     CL                 ; upravit pocitadlo iteraci
        jz      short mpokrac      ; konec iteraci ?
        mov     EAX, [zx2]         ;
        add     EAX, [zy2]         ; ==zx1^2+zy1^2
        cmp     EAX, BAILOUT*P     ; kontrola na bailout (abs[Z]<4)
        jc      short iter_loop    ; abs[Z]<4 =>dalsi iterace
mpokrac:
        mov     AL, CL             ; pocet iteraci
        add     AL, 32             ; posun na vhodne barvy v palete
        stosb                      ; vykreslit pixel+posun na dalsi pixel
        add     dword [cx_], K     ; cy_:=cy_+K
        dec     si
        jnz     mfory              ; Y!=0 ->dalsi radek
        add     DI, 320-256        ; dalsi radek na obrazovce
        add     dword [cy_], L     ; cx_:=cx_+K
        dec     BP                 ; x=x-1
        jnz     mforx              ; X!=0 ->dalsi radek
 
finish:
        wait_key                   ; cekani na klavesu
        exit                       ; navrat do DOSu
 
 
section .data
 
cy_     dd MIN                     ; poloha v komplexni rovine rovine
 
section .bss
 
cx_     resd 1                     ;
zx1     resd 1                     ;
zy1     resd 1                     ; aktualni poloha v komplexni rovine
zx2     resd 1                     ; zx2=zx1^2 (aby se to nemuselo pocitat 2x)
zy2     resd 1                     ; zy2=zy1^2
 
 
 
; finito

18. Částečně optimalizovaná verze výpočtu Mandelbrotovy množiny

Některé výpočty prováděné v příkladu uvedeném v předchozí kapitole, je možné optimalizovat. Mezivýsledky mohou být uloženy přímo v pracovních registrech, polohu řádové tečky je možné posunout o několik bitů (a zmenšit tak rozsah registrů) a vykreslování může být prováděno přes všech 320 sloupců, což poněkud zjednoduší programovou logiku. Výsledný program bude generovat nepatrně odlišný obrázek a bude kratší (172 bajtů namísto 188 bajtů):

Zdrojový kód demonstračního příkladu byl upraven do této podoby:

;-----------------------------------------------------------------------------
org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
; konstanty
P       equ     4096               ; poloha desetinne tecky v X-pointu
K       equ     4*P/256            ; vzdalenost mezi dvema body (krok smycky)
L       equ     4*P/192
MIN     equ     -2*P               ; minimalni a maximalni hodnota konstant fraktalu
                                   ; v komplexni rovine
MAXITER equ     40                 ; maximalni pocet iteraci
BAILOUT equ     4
SLOUPCU equ     320                ; pocet sloupcu na obrazovce
 
section .text
 
start:
        jmp main                   ; skok na zacatek kodu
 
%include "io.asm"                  ; nacist symboly, makra a podprogramy
 
 
main:
        mov     ax, 13h            ; graficky rezim 320x200x256
        int     10h
 
;:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
;: MANDELBROTOVA MNOZINA                                                    ::
;:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
 
        push    0xa000
        pop     ES                 ; segment obrazove pameti karty VGA
 
        xor     DI, DI             ; zacatek vykreslovani na obrazovce
        mov     CL, 6              ; posun pro FX format
 
mforx:  mov     dword [cx_], MIN   ; od -2 (imaginarni osa)
        mov     SI, SLOUPCU        ; x
mfory:  mov     CH, MAXITER        ; pocet iteraci
        xor     EAX, EAX           ;
        mov     EBP, EAX           ; nastaveni real.casti zacatku
        mov     dword [zy1], EAX   ; nastaveni imag.casti zacatku
iter_loop:                         ; *** iteracni smycka ***
        mov     EAX, EBP           ;
        sar     EAX, CL            ;
        imul    EAX                ; zx2:=zx1^2 (v X-pointu)
        mov     dword [zx2], EAX   ;
 
        mov     EAX, dword [zy1]   ;
        sar     EAX, CL            ; 
        imul    EAX                ; zy2:=zy1^2 (v X-pointu)
        mov     dword [zy2], EAX   ;
 
        mov     EAX, EBP           ;
        sar     EAX, CL            ; zx1 div 256 (pro mul v X-pointu)
 
        mov     EBX, [zy1]         ;
        sar     EBX, 5             ; zy1 div 256 * 2 (pro mul v X-pointu)
 
        imul    EBX                ; zy1:=2*zx1*zy1
        add     EAX, [cy_]         ; zy1:=2*zx1*zy1+CY (u Mandelbrota poc.iter.)
        mov     [zy1], EAX         ; ulozit novou hodnotu zy1
 
        mov     EAX, [zx2]         ;
        sub     EAX, [zy2]         ; zx2:=zx2-zy2=zx1^2-zy1^2
        add     EAX, [cx_]         ;
        mov     EBP, EAX           ; zx1:=zx1^2-zy1^2+CX
 
        dec     CH                 ; pocitadlo iteraci
        jz      short mpokrac      ; konec iteraci ?
        mov     EAX, [zx2]         ;
        add     EAX, [zy2]         ; ==zx1^2+zy1^2
        cmp     EAX, BAILOUT*P     ; kontrola na bailout (abs[Z]<4)
        jc      short iter_loop    ; abs[Z]<4 =>dalsi iterace
mpokrac:
        mov     AL, CH             ; pocet iteraci
        add     AL, 32             ; posun na vhodne barvy v palete
        stosb                      ; vykreslit pixel+posun na dalsi pixel
        add     dword [cx_], K     ; cy_:=cy_+K
        dec     si
        jnz     short mfory        ; Y!=0 ->dalsi radek
 
        add     dword [cy_], L     ; cx_:=cx_+K
        cmp     di, 64000          ; konec obrazku ?
        jne     mforx
 
finish:
        wait_key                   ; cekani na klavesu
        exit                       ; navrat do DOSu
 
 
section .data
 
cy_     dd MIN                     ; poloha v komplexni rovine rovine
 
section .bss
 
cx_     resd 1                     ;
zy1     resd 1                     ; aktualni poloha v komplexni rovine
zx2     resd 1                     ; zx2=zx1^2 (aby se to nemuselo pocitat 2x)
zy2     resd 1                     ; zy2=zy1^2
 
 
 
; finito

19. Repositář s demonstračními příklady

Demonstrační příklady napsané v assembleru, které jsou určené pro překlad s využitím assembleru NASM, byly uloženy do Git repositáře, který je dostupný na adrese https://github.com/tisnik/8bit-fame. Jednotlivé demonstrační příklady si můžete v případě potřeby stáhnout i jednotlivě bez nutnosti klonovat celý (dnes již poměrně rozsáhlý) repositář:

20. Odkazy na Internetu

1. VESA BIOS Extensions
   https://en.wikipedia.org/wi­ki/VESA_BIOS_Extensions
2. Video Electronics Standards Association
   https://en.wikipedia.org/wi­ki/Video_Electronics_Stan­dards_Association
3. DJGPP (Wikipedia)
   https://cs.wikipedia.org/wiki/DJGPP
4. DJGPP home page
   http://www.delorie.com/djgpp/
5. DJGPP Zip File Picker
   http://www.delorie.com/djgpp/zip-picker.html
6. The Intel 8088 Architecture and Instruction Set
   https://people.ece.ubc.ca/~ed­c/464/lectures/lec4.pdf
7. x86 Opcode Structure and Instruction Overview
   https://pnx.tf/files/x86_op­code_structure_and_instruc­tion_overview.pdf
8. x86 instruction listings (Wikipedia)
   https://en.wikipedia.org/wi­ki/X86_instruction_listin­gs
9. x86 assembly language (Wikipedia)
   https://en.wikipedia.org/wi­ki/X86_assembly_language
10. Intel Assembler (Cheat sheet)
    http://www.jegerlehner.ch/in­tel/IntelCodeTable.pdf
11. 25 Microchips That Shook the World
    https://spectrum.ieee.org/tech-history/silicon-revolution/25-microchips-that-shook-the-world
12. Chip Hall of Fame: MOS Technology 6502 Microprocessor
    https://spectrum.ieee.org/tech-history/silicon-revolution/chip-hall-of-fame-mos-technology-6502-microprocessor
13. Chip Hall of Fame: Intel 8088 Microprocessor
    https://spectrum.ieee.org/tech-history/silicon-revolution/chip-hall-of-fame-intel-8088-microprocessor
14. Jak se zrodil procesor?
    https://www.root.cz/clanky/jak-se-zrodil-procesor/
15. Apple II History Home
    http://apple2history.org/
16. The 8086/8088 Primer
    https://www.stevemorse.or­g/8086/index.html
17. flat assembler: Assembly language resources
    https://flatassembler.net/
18. FASM na Wikipedii
    https://en.wikipedia.org/wiki/FASM
19. Fresh IDE FASM inside
    https://fresh.flatassembler.net/
20. MS-DOS Version 4.0 Programmer's Reference
    https://www.pcjs.org/docu­ments/books/mspl13/msdos/dos­ref40/
21. DOS API (Wikipedia)
    https://en.wikipedia.org/wiki/DOS_API
22. Bit banging
    https://en.wikipedia.org/wi­ki/Bit_banging
23. IBM Basic assembly language and successors (Wikipedia)
    https://en.wikipedia.org/wi­ki/IBM_Basic_assembly_lan­guage_and_successors
24. X86 Assembly/Bootloaders
    https://en.wikibooks.org/wi­ki/X86_Assembly/Bootloaders
25. Počátky grafiky na PC: grafické karty CGA a Hercules
    https://www.root.cz/clanky/pocatky-grafiky-na-pc-graficke-karty-cga-a-hercules/
26. Co mají společného Commodore PET/4000, BBC Micro, Amstrad CPC i grafické karty MDA, CGA a Hercules?
    https://www.root.cz/clanky/co-maji-spolecneho-commodore-pet-4000-bbc-micro-amstrad-cpc-i-graficke-karty-mda-cga-a-hercules/
27. Karta EGA: první použitelná barevná grafika na PC
    https://www.root.cz/clanky/karta-ega-prvni-pouzitelna-barevna-grafika-na-pc/
28. RGB Classic Games
    https://www.classicdosgames.com/
29. Turbo Assembler (Wikipedia)
    https://en.wikipedia.org/wi­ki/Turbo_Assembler
30. Microsoft Macro Assembler
    https://en.wikipedia.org/wi­ki/Microsoft_Macro_Assembler
31. IBM Personal Computer (Wikipedia)
    https://en.wikipedia.org/wi­ki/IBM_Personal_Computer
32. Intel 8251
    https://en.wikipedia.org/wi­ki/Intel_8251
33. Intel 8253
    https://en.wikipedia.org/wi­ki/Intel_8253
34. Intel 8255
    https://en.wikipedia.org/wi­ki/Intel_8255
35. Intel 8257
    https://en.wikipedia.org/wi­ki/Intel_8257
36. Intel 8259
    https://en.wikipedia.org/wi­ki/Intel_8259
37. Support/peripheral/other chips – 6800 family
    http://www.cpu-world.com/Support/6800.html
38. Motorola 6845
    http://en.wikipedia.org/wi­ki/Motorola_6845
39. The 6845 Cathode Ray Tube Controller (CRTC)
    http://www.tinyvga.com/6845
40. CRTC operation
    http://www.6502.org/users/an­dre/hwinfo/crtc/crtc.html
41. The 6845 Cathode Ray Tube Controller (CRTC)
    http://www.tinyvga.com/6845
42. Motorola 6845 and bitwise graphics
    https://retrocomputing.stac­kexchange.com/questions/10996/mo­torola-6845-and-bitwise-graphics
43. IBM Monochrome Display Adapter
    http://en.wikipedia.org/wi­ki/Monochrome_Display_Adap­ter
44. Color Graphics Adapter
    http://en.wikipedia.org/wi­ki/Color_Graphics_Adapter
45. Color Graphics Adapter and the Brown color in IBM 5153 Color Display
    https://www.aceinnova.com/en/e­lectronics/cga-and-the-brown-color-in-ibm-5153-color-display/
46. The Modern Retrocomputer: An Arduino Driven 6845 CRT Controller
    https://hackaday.com/2017/05/14/the-modern-retrocomputer-an-arduino-driven-6845-crt-controller/
47. flat assembler: Assembly language resources
    https://flatassembler.net/
48. FASM na Wikipedii
    https://en.wikipedia.org/wiki/FASM
49. Fresh IDE FASM inside
    https://fresh.flatassembler.net/
50. MS-DOS Version 4.0 Programmer's Reference
    https://www.pcjs.org/docu­ments/books/mspl13/msdos/dos­ref40/
51. DOS API (Wikipedia)
    https://en.wikipedia.org/wiki/DOS_API
52. IBM Basic assembly language and successors (Wikipedia)
    https://en.wikipedia.org/wi­ki/IBM_Basic_assembly_lan­guage_and_successors
53. X86 Assembly/Arithmetic
    https://en.wikibooks.org/wi­ki/X86_Assembly/Arithmetic
54. Art of Assembly – Arithmetic Instructions
    http://oopweb.com/Assembly/Do­cuments/ArtOfAssembly/Volu­me/Chapter₆/CH06–2.html
55. ASM Flags
    http://www.cavestory.org/gu­ides/csasm/guide/asm_flag­s.html
56. Status Register
    https://en.wikipedia.org/wi­ki/Status_register
57. Linux assemblers: A comparison of GAS and NASM
    http://www.ibm.com/develo­perworks/library/l-gas-nasm/index.html
58. Programovani v assembleru na OS Linux
    http://www.cs.vsb.cz/gryga­rek/asm/asmlinux.html
59. Is it worthwhile to learn x86 assembly language today?
    https://www.quora.com/Is-it-worthwhile-to-learn-x86-assembly-language-today?share=1
60. Why Learn Assembly Language?
    http://www.codeproject.com/Ar­ticles/89460/Why-Learn-Assembly-Language
61. Is Assembly still relevant?
    http://programmers.stackex­change.com/questions/95836/is-assembly-still-relevant
62. Why Learning Assembly Language Is Still a Good Idea
    http://www.onlamp.com/pub/a/on­lamp/2004/05/06/writegreat­code.html
63. Assembly language today
    http://beust.com/weblog/2004/06/23/as­sembly-language-today/
64. Assembler: Význam assembleru dnes
    http://www.builder.cz/rubri­ky/assembler/vyznam-assembleru-dnes-155960cz
65. Programming from the Ground Up Book – Summary
    http://savannah.nongnu.or­g/projects/pgubook/
66. DOSBox
    https://www.dosbox.com/
67. The C Programming Language
    https://en.wikipedia.org/wi­ki/The_C_Programming_Langu­age
68. Hercules Graphics Card (HCG)
    https://en.wikipedia.org/wi­ki/Hercules_Graphics_Card
69. Complete 8086 instruction set
    https://content.ctcd.edu/cou­rses/cosc2325/m22/docs/emu8086in­s.pdf
70. Complete 8086 instruction set
    https://yassinebridi.github.io/asm-docs/8086_instruction_set.html
71. 8088 MPH by Hornet + CRTC + DESiRE (final version)
    https://www.youtube.com/wat­ch?v=hNRO7lno_DM
72. Area 5150 by CRTC & Hornet (Party Version) / IBM PC+CGA Demo, Hardware Capture
    https://www.youtube.com/wat­ch?v=fWDxdoRTZPc
73. 80×86 Integer Instruction Set Timings (8088 – Pentium)
    http://aturing.umcs.maine­.edu/~meadow/courses/cos335/80×86-Integer-Instruction-Set-Clocks.pdf
74. Colour Graphics Adapter: Notes
    https://www.seasip.info/Vin­tagePC/cga.html
75. Restoring A Vintage CGA Card With Homebrew HASL
    https://hackaday.com/2024/06/12/res­toring-a-vintage-cga-card-with-homebrew-hasl/
76. Demoing An 8088
    https://hackaday.com/2015/04/10/de­moing-an-8088/
77. Video Memory Layouts
    http://www.techhelpmanual.com/89-video_memory_layouts.html
78. Screen Attributes
    http://www.techhelpmanual.com/87-screen_attributes.html
79. IBM PC Family – BIOS Video Modes
    https://www.minuszerodegre­es.net/video/bios_video_mo­des.htm
80. EGA Functions
    https://cosmodoc.org/topics/ega-functions/#the-hierarchy-of-the-ega
81. Why the EGA can only use 16 of its 64 colours in 200-line modes
    https://www.reenigne.org/blog/why-the-ega-can-only-use-16-of-its-64-colours-in-200-line-modes/
82. How 16 colors saved PC gaming – the story of EGA graphics
    https://www.custompc.com/retro-tech/ega-graphics
83. List of 16-bit computer color palettes
    https://en.wikipedia.org/wi­ki/List_of₁₆-bit_computer_color_palettes
84. Why were those colors chosen to be the default palette for 256-color VGA?
    https://retrocomputing.stac­kexchange.com/questions/27994/why-were-those-colors-chosen-to-be-the-default-palette-for-256-color-vga
85. VGA Color Palettes
    https://www.fountainware.com/EX­PL/vga_color_palettes.htm
86. Hardware Level VGA and SVGA Video Programming Information Page
    http://www.osdever.net/Fre­eVGA/vga/vga.htm
87. Hardware Level VGA and SVGA Video Programming Information Page – sequencer
    http://www.osdever.net/Fre­eVGA/vga/seqreg.htm
88. VGA Basics
    http://www.brackeen.com/vga/ba­sics.html
89. Introduction to VGA Mode ‚X‘
    https://web.archive.org/web/20160414072210/htt­p://fly.srk.fer.hr/GDM/ar­ticles/vgamodex/vgamx1.html
90. VGA Mode-X
    https://web.archive.org/web/20070123192523/htt­p://www.gamedev.net/referen­ce/articles/article356.asp
91. Mode-X: 256-Color VGA Magic
    https://downloads.gamedev­.net/pdf/gpbb/gpbb47.pdf
92. Instruction Format in 8086 Microprocessor
    https://www.includehelp.com/embedded-system/instruction-format-in-8086-microprocessor.aspx
93. How to use „AND,“ „OR,“ and „XOR“ modes for VGA Drawing
    https://retrocomputing.stac­kexchange.com/questions/21936/how-to-use-and-or-and-xor-modes-for-vga-drawing
94. VGA Hardware
    https://wiki.osdev.org/VGA_Hardware
95. Programmer's Guide to Yamaha YMF 262/OPL3 FM Music Synthesizer
    https://moddingwiki.shika­di.net/wiki/OPL_chip
96. Does anybody understand how OPL2 percussion mode works?
    https://forum.vcfed.org/in­dex.php?threads/does-anybody-understand-how-opl2-percussion-mode-works.60925/
97. Yamaha YMF262 OPL3 music – MoonDriver for OPL3 DEMO [Oscilloscope View]
    https://www.youtube.com/watch?v=a7I-QmrkAak
98. Yamaha OPL vs OPL2 vs OPL3 comparison
    https://www.youtube.com/wat­ch?v=5knetge5Gs0
99. OPL3 Music Crockett's Theme
    https://www.youtube.com/wat­ch?v=HXS008pkgSQ
100. Bad Apple (Adlib Tracker – OPL3)
     https://www.youtube.com/wat­ch?v=2lEPH6Y3Luo
101. FM Synthesis Chips, Codecs and DACs
     https://www.dosdays.co.uk/to­pics/fm_synthesizers.php
102. The Zen Challenge – YMF262 OPL3 Original (For an upcoming game)
     https://www.youtube.com/wat­ch?v=6JlFIFz1CFY
103. [adlib tracker II techno music – opl3] orbit around alpha andromedae I
     https://www.youtube.com/wat­ch?v=YqxJCu_WFuA
104. [adlib tracker 2 music – opl3 techno] hybridisation process on procyon-ii
     https://www.youtube.com/wat­ch?v=daSV5mN0sJ4
105. Hyper Duel – Black Rain (YMF262 OPL3 Cover)
     https://www.youtube.com/wat­ch?v=pu_mzRRq8Ho
106. IBM 5155–5160 Technical Reference
     https://www.minuszerodegre­es.net/manuals/IBM/IBM_5155_5160_Techni­cal_Reference_6280089_MAR86­.pdf
107. a ymf262/opl3+pc speaker thing i made
     https://www.youtube.com/watch?v=E-Mx0lEmnZ0
108. [OPL3] Like a Thunder
     https://www.youtube.com/wat­ch?v=MHf06AGr8SU
109. (PC SPEAKER) bad apple
     https://www.youtube.com/wat­ch?v=LezmKIIHyUg
110. Powering devices from PC parallel port
     http://www.epanorama.net/cir­cuits/lptpower.html
111. Magic Mushroom (demo pro PC s DOSem)
     http://www.crossfire-designs.de/download/articles/sou­ndcards//mushroom.rar
112. Píseň Magic Mushroom – originál
     http://www.crossfire-designs.de/download/articles/sou­ndcards/speaker_mushroom_con­verted.mp3
113. Píseň Magic Mushroom – hráno na PC Speakeru
     http://www.crossfire-designs.de/download/articles/sou­ndcards/speaker_mushroom_spe­aker.mp3
114. Pulse Width Modulation (PWM) Simulation Example
     http://decibel.ni.com/content/docs/DOC-4599
115. Resistor/Pulse Width Modulation DAC
     http://www.k9spud.com/trax­mod/pwmdac.php
116. Class D Amplifier
     http://en.wikipedia.org/wi­ki/Electronic_amplifier#Clas­s_D
117. Covox Speech Thing / Disney Sound Source (1986)
     http://www.crossfire-designs.de/index.php?lang=en&what=ar­ticles&name=showarticle.htm&ar­ticle=soundcards/&page=5
118. Covox Digital-Analog Converter (Rusky, obsahuje schémata)
     http://phantom.sannata.ru/kon­kurs/netskater002.shtml
119. PC-GPE on the Web
     http://bespin.org/~qz/pc-gpe/
120. Keyboard Synthesizer
     http://www.solarnavigator­.net/music/instruments/ke­yboards.htm
121. FMS – Fully Modular Synthesizer
     http://fmsynth.sourceforge.net/
122. Javasynth
     http://javasynth.sourceforge.net/
123. Software Sound Synthesis & Music Composition Packages
     http://www.linux-sound.org/swss.html
124. Mx44.1 Download Page (software synthesizer for linux)
     http://hem.passagen.se/ja_linux/
125. Software synthesizer
     http://en.wikipedia.org/wi­ki/Software_synthesizer
126. Frequency modulation synthesis
     http://en.wikipedia.org/wi­ki/Frequency_modulation_syn­thesis
127. Yamaha DX7
     http://en.wikipedia.org/wi­ki/Yamaha_DX7
128. Wave of the Future
     http://www.wired.com/wired/ar­chive/2.03/waveguides_pr.html
129. Analog synthesizer
     http://en.wikipedia.org/wi­ki/Analog_synthesizer
130. Minimoog
     http://en.wikipedia.org/wiki/Minimoog
131. Moog synthesizer
     http://en.wikipedia.org/wi­ki/Moog_synthesizer
132. Tutorial for Frequency Modulation Synthesis
     http://www.sfu.ca/~truax/fmtut.html
133. An Introduction To FM
     http://ccrma.stanford.edu/sof­tware/snd/snd/fm.html
134. John Chowning
     http://en.wikipedia.org/wi­ki/John_Chowning
135. I'm Impressed, Adlib Music is AMAZING!
     https://www.youtube.com/wat­ch?v=PJNjQYp1ras
136. Milinda- Diode Milliampere ( OPL3 )
     https://www.youtube.com/wat­ch?v=oNhazT5HG0E
137. Dune 2 – Roland MT-32 Soundtrack
     https://www.youtube.com/wat­ch?v=kQADZeB-z8M
138. Interrupts
     https://wiki.osdev.org/In­terrupts#Types_of_Interrup­ts
139. Assembly8086SoundBlasterDma­SingleCycleMode
     https://github.com/leonardo-ono/Assembly8086SoundBlas­terDmaSingleCycleMode/blob/mas­ter/sbsc.asm
140. Interrupts in 8086 microprocessor
     https://www.geeksforgeeks­.org/interrupts-in-8086-microprocessor/
141. Interrupt Structure of 8086
     https://www.eeeguide.com/interrupt-structure-of-8086/
142. A20 line
     https://en.wikipedia.org/wi­ki/A20_line
143. Extended memory
     https://en.wikipedia.org/wi­ki/Extended_memory#eXtended_Me­mory_Specification_(XMS)
144. Expanded memory
     https://en.wikipedia.org/wi­ki/Expanded_memory
145. Protected mode
     https://en.wikipedia.org/wi­ki/Protected_mode
146. Virtual 8086 mode
     https://en.wikipedia.org/wi­ki/Virtual_8086_mode
147. Unreal mode
     https://en.wikipedia.org/wi­ki/Unreal_mode
148. DOS memory management
     https://en.wikipedia.org/wi­ki/DOS_memory_management
149. Upper memory area
     https://en.wikipedia.org/wi­ki/Upper_memory_area
150. Removing the Mystery from SEGMENT : OFFSET Addressing
     https://thestarman.pcminis­try.com/asm/debug/Segments­.html
151. Segment descriptor
     https://en.wikipedia.org/wi­ki/Segment_descriptor
152. When using a 32-bit register to address memory in the real mode, contents of the register must never exceed 0000FFFFH. Why?
     https://stackoverflow.com/qu­estions/45094696/when-using-a-32-bit-register-to-address-memory-in-the-real-mode-contents-of-the
153. A Brief History of Unreal Mode
     https://www.os2museum.com/wp/a-brief-history-of-unreal-mode/
154. Segment Limits
     https://wiki.osdev.org/Segment_Limits
155. How do 32 bit addresses in real mode work?
     https://forum.osdev.org/vi­ewtopic.php?t=30642
156. The LOADALL Instruction by Robert Collins
     https://www.rcollins.org/ar­ticles/loadall/tspec_a3_doc­.html
157. How do you put a 286 in Protected Mode?
     https://retrocomputing.stac­kexchange.com/questions/7683/how-do-you-put-a-286-in-protected-mode
158. Control register
     https://en.wikipedia.org/wi­ki/Control_register
159. CPU Registers x86
     https://wiki.osdev.org/CPU_Re­gisters_x86
160. x86 Assembly/Protected Mode
     https://en.wikibooks.org/wi­ki/X86_Assembly/Protected_Mo­de
161. MSW: Machine Status Word
     https://web.itu.edu.tr/kes­gin/mul06/intel/intel_msw­.html
162. 80×87 Floating Point Opcodes
     http://www.techhelpmanual.com/876–80×87_floating_point_opcodes.html
163. Page Translation
     https://pdos.csail.mit.edu/6­.828/2005/readings/i386/s05_02­.htm
164. 80386 Paging and Segmenation
     https://stackoverflow.com/qu­estions/38229741/80386-paging-and-segmenation
165. 80386 Memory Management
     https://tldp.org/LDP/khg/Hy­perNews/get/memory/80386mm­.html
166. DOSEMU
     http://www.dosemu.org/
167. Intel 80386, a revolutionary CPU
     https://www.xtof.info/intel80386.html
168. PAI Unit 3 Paging in 80386 Microporcessor
     https://www.slideshare.net/Kan­chanPatil34/pai-unit-3-paging-in-80386-microporcessor
169. 64 Terabytes of virtual memory for 32-bit x86 using segmentation: how?
     https://stackoverflow.com/qu­estions/5444984/64-terabytes-of-virtual-memory-for-32-bit-x86-using-segmentation-how
170. Pi in the Pentium: reverse-engineering the constants in its floating-point unit
     http://www.righto.com/2025/01/pentium-floating-point-ROM.html
171. Simply FPU
     http://www.website.masmfo­rum.com/tutorials/fptute/
172. Art of Assembly language programming: The 80×87 Floating Point Coprocessors
     https://courses.engr.illi­nois.edu/ece390/books/arto­fasm/CH14/CH14–3.html
173. Art of Assembly language programming: The FPU Instruction Set
     https://courses.engr.illi­nois.edu/ece390/books/arto­fasm/CH14/CH14–4.html
174. INTEL 80387 PROGRAMMER'S REFERENCE MANUAL
     http://www.ragestorm.net/dow­nloads/387intel.txt
175. x86 Instruction Set Reference: FLD
     http://x86.renejeschke.de/html/fi­le_module_x86_id₁₀₀.html
176. x86 Instruction Set Reference: FLD1/FLDL2T/FLDL2E/FLDPI/­FLDLG2/FLDLN2/FLDZ
     http://x86.renejeschke.de/html/fi­le_module_x86_id₁₀₁.html
177. X86 Assembly/Arithmetic
     https://en.wikibooks.org/wi­ki/X86_Assembly/Arithmetic
178. 8087 Numeric Data Processor
     https://www.eeeguide.com/8087-numeric-data-processor/
179. Data Types and Instruction Set of 8087 co-processor
     https://www.eeeguide.com/data-types-and-instruction-set-of-8087-co-processor/
180. 8087 instruction set and examples
     https://studylib.net/doc/5625221/8087-instruction-set-and-examples
181. GCC documentation: Extensions to the C Language Family
     https://gcc.gnu.org/onlinedocs/gcc/C-Extensions.html#C-Extensions
182. GCC documentation: Using Vector Instructions through Built-in Functions
     https://gcc.gnu.org/online­docs/gcc/Vector-Extensions.html
183. SSE (Streaming SIMD Extentions)
     http://www.songho.ca/misc/sse/sse­.html
184. Timothy A. Chagnon: SSE and SSE2
     http://www.cs.drexel.edu/~tc365/mpi-wht/sse.pdf
185. Intel corporation: Extending the Worldr's Most Popular Processor Architecture
     http://download.intel.com/techno­logy/architecture/new-instructions-paper.pdf
186. SIMD architectures:
     http://arstechnica.com/ol­d/content/2000/03/simd.ar­s/
187. Tour of the Black Holes of Computing!: Floating Point
     http://www.cs.hmc.edu/~ge­off/classes/hmc.cs105…/sli­des/class02_floats.ppt
188. 3Dnow! Technology Manual
     AMD Inc., 2000
189. Intel MMX^TM Technology Overview
     Intel corporation, 1996
190. MultiMedia eXtensions
     http://softpixel.com/~cwrig­ht/programming/simd/mmx.phpi
191. AMD K5 („K5“ / „5k86“)
     http://www.pcguide.com/ref/cpu/fam/g5K5-c.html
192. Sixth Generation Processors
     http://www.pcguide.com/ref/cpu/fam/g6­.htm
193. Great Microprocessors of the Past and Present
     http://www.cpushack.com/CPU/cpu1.html
194. Very long instruction word (Wikipedia)
     http://en.wikipedia.org/wi­ki/Very_long_instruction_word
195. CPU design (Wikipedia)
     http://en.wikipedia.org/wi­ki/CPU_design
196. Grafické karty a grafické akcelerátory (14)
     https://www.root.cz/clanky/graficke-karty-a-graficke-akceleratory-14/
197. Grafické karty a grafické akcelerátory (15)
     https://www.root.cz/clanky/graficke-karty-a-graficke-akceleratory-15/
198. Grafické karty a grafické akcelerátory (16)
     https://www.root.cz/clanky/graficke-karty-a-graficke-akceleratory-16/
199. VESA Video Modes
     https://wiki.osdev.org/VE­SA_Video_Modes
200. Introduction to VESA programming
     http://www.monstersoft.com/tu­torial1/VESA_intro.html
201. Guide: VBE 2.0 graphics modes
     https://delorie.com/djgpp/doc/ug/grap­hics/vbe20.html
202. NASM instruction list
     https://userpages.cs.umbc­.edu/chang/cs313/nasmdoc/html/nas­mdocb.html
203. BitBlt function (wingdi.h)
     https://learn.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-bitblt
204. SetDIBitsToDevice function (wingdi.h)
     https://learn.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-setdibitstodevice
205. Why did line printers have 132 columns?
     https://retrocomputing.stac­kexchange.com/questions/7838/why-did-line-printers-have-132-columns
206. Tabulating machine
     https://en.wikipedia.org/wi­ki/Tabulating_machine
207. Why do printers print 132 columns on 14 7/8″ paper? It’s history
     https://blog.adafruit.com/2019/01/22/why-do-printers-print-132-columns-on-14–7–8-paper-its-history-vintagecomputing-kenshirriff-ibm/
208. IBM 1403 (Wikipedia)
     https://en.wikipedia.org/wi­ki/IBM_1403