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

Obsah

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

2. Problémy, které nastávají při omezení výpočtů pouze na n-bitové hodnoty

3. Násobení příliš malých hodnot

4. Výpočty omezené na 2n-bitové hodnoty

5. Snížení počtu bitů reprezentujících numerické hodnoty při výpočtu Mandelbrotovy množiny

6. Původní výpočet s 32 bitovými hodnotami

7. Výpočet Mandelbrotovy množiny omezený na 16bitové hodnoty

8. Rozdíly ve zdrojových kódech

9. Rozdíly ve vypočtených obrázcích

10. Výpočty složitějších funkcí

11. Iterativní výpočet druhé odmocniny

12. Demonstrační příklad na výpočet druhé odmocniny ve formátu plovoucí řádové tečky

13. Demonstrační příklad na výpočet druhé odmocniny ve formátu pevné řádové tečky

14. Překlad jedné iterace pro výpočet druhé odmocniny do assembleru

15. Goniometrické funkce počítané pomocí číselných řad

16. Demonstrační příklad: výpočet sinu s využitím Taylorova rozvoje

17. Výsledky výpočtu hodnot funkce sin()

18. Univerzální algoritmus CORDIC

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 (2. část)

Na úvodní článek o realizaci aritmetických výpočtů bez využití matematického koprocesoru dnes navážeme. Opět se budeme zabývat matematickými výpočty, které využívají numerické hodnoty s pevnou řádovou binární tečkou (čárkou) – fixed point. Nejprve si na několika demonstračních příkladech ukážeme některé limity tohoto způsobu reprezentace numerických hodnot (pro vizualizaci opět použijeme Mandelbrotovu množinu), dále budeme realizovat výpočty některých často používaných funkcí (druhá odmocnina, goniometrické funkce) iteračními algoritmy a v závěru dnešního článku se taktéž seznámíme s univerzálním algoritmem nazvaným CORDIC (COordinate ROtation DIgital Computer), který je možné relativně snadno použít pro výpočet goniometrických funkcí, logaritmů atd.

2. Problémy, které nastávají při omezení výpočtů pouze na n-bitové hodnoty

Již v předchozím článku jsme se zmínili o problémech, které mohou nastat při provádění výpočtů s hodnotami s pevnou řádovou čárkou (tečkou) v případě, že všechny části výpočtu provádíme s n-bitovými hodnotami, kde n je bitová šířka operandů i výsledné hodnoty. Příkladem může být operace součinu, která v takovém případě vyžaduje, aby se operandy bitově posunuly doprava ještě před provedením instrukce MUL nebo IMUL. Ovšem pokud provádíme bitový posun doprava, ztrácíme (pochopitelně) vysunuté bity a tudíž ztrácíme i přesnost. To může vést až k tomu, že se jeden operand vynuluje a výsledkem součinu tedy bude nekorektní nulová hodnota.

Nejprve se podívejme na příklad, ve kterém ke ztrátě přesnosti nebo vynulování operandu nedochází. Využíváme formát 16.16, tedy šestnáct bitů před pevnou binární tečkou a šestnáct bitů za ní. A násobíme hodnoty 2.0 a 1/256 (zhruba 0.00390625):

;-----------------------------------------------------------------------------
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
 
x       equ     2 * P              ; konstanty, ktere se budou nasobit
y       equ     P / 256
 
main:
        mov  eax, x
        print_hex eax              ; vytisknout hodnotu prvni konstanty
 
        mov  eax, y
        print_hex eax              ; vytisknout hodnotu druhe konstanty
 
        mov  eax, x
        mov  ebx, y
        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

Výsledky i s jejich popisem:

operand: 00020000 ≅ 2.0
operand: 00000100 ≅ 1.0 / 256 ≅ 0.00390625
součin:  00000200 ≅ 2.0 / 256 ≅ 0.00781250

V tomto případě tedy výpočty dopadly podle očekávání.

3. Násobení příliš malých hodnot

V dalším kroku výpočet nepatrně upravíme. Nebudeme násobit hodnoty 2.0 a 1/256, ale hodnoty 2.0 a 1/512, což znamená, že druhý operand bude mít obsazeno pouze spodních osm bitů a vyšších 24 bitů bude nulových. Zde se již musí projevit fakt, že před instrukcí MUL či IMUL posunujeme operandy o osm bitů doprava:

;-----------------------------------------------------------------------------
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
 
x       equ     2 * P              ; konstanty, ktere se budou nasobit
y       equ     P / 512
 
main:
        mov  eax, x
        print_hex eax              ; vytisknout hodnotu prvni konstanty
 
        mov  eax, y
        print_hex eax              ; vytisknout hodnotu druhe konstanty
 
        mov  eax, x
        mov  ebx, y
        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

Opět se podívejme na zprávy vypsané tímto příkladem, ke kterým jsou doplněny vysvětlivky:

operand: 00020000 ≅ 2.0
operand: 00000080 ≅ 1.0 / 512 ≅ 0.001953125
součin:  00000000 = 0.0 ⇒ nekorektní!

V tomto případě tedy došlo k tomu, že byl druhý operand posunut o osm bitů doprava, čímž byl mezivýsledek vynulován. A operace součinu tedy podle očekávání vrátila nulu!

4. Výpočty omezené na 2n-bitové hodnoty

V případě, že CPU podporuje provádění operací součinu tak, že výsledkem součinu dvou n-bitových hodnot je hodnota 2n-bitová, je pochopitelně situace jednodušší a k žádným ztrátám přesnosti nebo vynulování výsledků vůbec nemusí dojít. Pouze je nutné zajistit bitový posun výsledku. Na platformě x86 (nebo x86–64) obecně platí, že operace součinu, tedy MUL a IMUL mají jako svůj vstup dvojici n-bitových registrů (n=8, 16, 32 nebo 64) a výsledek je uložen ve dvojici taktéž n-bitových registrů:

a:

Předchozí demonstrační příklad tedy můžeme upravit do této 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
 
x       equ     2 * P              ; konstanty, ktere se budou nasobit
y       equ     P / 512
 
main:
        mov  eax, x
        print_hex eax              ; vytisknout hodnotu prvni konstanty
 
        mov  eax, y
        print_hex eax              ; vytisknout hodnotu druhe konstanty
 
        mov  eax, x
        mov  ebx, y
        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

Výsledky nyní budou, na rozdíl od příkladu předchozího, zcela korektní:

operand: 00020000 ≅ 2.0
operand: 00000080 ≅ 1.0 / 512 ≅ 0.001953125
součin:  00000100 = 1.0 / 256 ⇒ korektní!

5. Snížení počtu bitů reprezentujících numerické hodnoty při výpočtu Mandelbrotovy množiny

V navazujících kapitolách si ukážeme (zejména ve vizuální podobě), jaké problémy může přinést snaha o provádění výpočtů s hodnotami s pevnou řádovou binární čárkou (fixed point) v případě, že není k dispozici dostatečný počet bitů pro zajištění potřebné přesnosti výpočtů a/nebo pro zajištění potřebného rozsahu hodnot (minimální a maximální reprezentovatelné hodnoty). Aby se nejednalo pouze o strohé numerické výpočty s výstupem ve formě tabulek, budeme provádět – podobně jako v předchozím článku – vizualizaci Mandelbrotovy množiny.

Výpočet bodů v této množině je dostatečně jednoduchý na implementaci a současně jsou všechny chyby (nedostatečná přesnost či rozsah) ihned viditelné na výsledných rastrových obrázcích. Pokusíme se o výpočet bodů Mandelbrotovy množiny s využitím pouze šestnáctibitových hodnot, přičemž (pochopitelně) je nutné několik bitů rezervovat pro celou část a zbytek bitů pro část za řádovou tečkou. K dispozici je tedy několik formátů, od formátu označovaného „16.0“ (celočíselné 16bitové hodnoty) přes „8.8“ (osm bitů pro celou část, osm bitů za tečkou) až po „0.16“ (pouze bity umístěné za řádovou tečkou).

6. Původní výpočet s 32 bitovými hodnotami

Jen pro krátké připomenutí, jak vypadal původní výpočet s 32bitovými hodnotami (a tedy i 32bitovými pracovními registry) si zopakujme zdrojový kód programu, který vypočítá body v Mandelbrotově množině a zobrazí je s využitím standardního grafického režimu s rozlišením 320×200 pixelů a s 256 barvami (karta VGA a všechny karty SVGA). Program je napsán pro reálný režim, ovšem kvůli 32bitovým operacím vyžaduje minimálně mikroprocesor 80386 nebo vyšší. Povšimněte si zejména pozice pevné řádové binární tečky mezi bitem číslo 11 a 12. Tím je určen jak rozsah hodnot, tak i jejich přesnost:

;-----------------------------------------------------------------------------
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

7. Výpočet Mandelbrotovy množiny omezený na 16bitové hodnoty

Relativně snadným způsobem můžeme dosáhnout toho, že všechny výpočty budou probíhat pouze se šestnáctibitovými hodnotami (a navíc je program napsán pro zaručení kompatibility s čipem 80286). V tomto případě je vhodné si velmi dobře rozmyslet, na které místo umístit binární řádovou tečku. Můžeme bez dalších odhadů použít formát 8.8, tedy osm bitů před binární tečkou a osm bitů za tečkou, ovšem to nemusí být ideální, protože může docházet k velké ztrátě přesnosti nebo naopak k přetečení hodnot (mezivýsledků). Proto může být výhodnější omezit počet bitů před tečkou a naopak zvýšit počet bitů za ní (například realizovat formát 5.11 nebo dokonce 4.12). Podívejme se nejdříve na příklad použití formátu, ve kterém je tečka umístěna mezi jedenáctým a dvanáctým bitem:

;-----------------------------------------------------------------------------
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     word [cx_], MIN    ; od -2 (imaginarni osa)
        mov     SI, SLOUPCU        ; x
mfory:  mov     CH, MAXITER        ; pocet iteraci
        xor     AX, AX             ;
        mov     BP, AX             ; nastaveni real.casti zacatku
        mov     word [zy1], AX     ; nastaveni imag.casti zacatku
iter_loop:                         ; *** iteracni smycka ***
        mov     AX, BP             ;
        sar     AX, CL             ;
        imul    AX                 ; zx2:=zx1^2 (v X-pointu)
        mov     word [zx2], AX     ;
        mov     AX, [zy1]          ;
        sar     AX,CL              ;
        imul    AX                 ; zy2:=zy1^2 (v X-pointu)
        mov     word [zy2], AX     ;
 
        mov     AX, BP             ;
        sar     AX,CL              ; zx1 div 256 (pro mul v X-pointu)
        mov     BX, [zy1]          ;
        sar     BX,5               ; zy1 div 256 * 2 (pro mul v X-pointu)
        imul    BX                 ; zy1:=2*zx1*zy1
        add     AX, [cy_]          ; zy1:=2*zx1*zy1+CY (u Mandelbrota poc.iter.)
        mov     [zy1], AX          ; ulozit
 
        mov     AX, [zx2]          ;
        sub     AX, [zy2]          ; zx2:=zx2-zy2=zx1^2-zy1^2
        add     AX, [cx_]          ;
        mov     BP, AX             ; zx1:=zx1^2-zy1^2+CX
        dec     CH                 ; pocitadlo iteraci
        jz      short mpokrac      ; konec iteraci ?
        mov     AX, [zx2]          ;
        add     AX, [zy2]          ; ==zx1^2+zy1^2
        cmp     AX, 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     word [cx_], K      ; cy_:=cy_+K
        dec     si
        jnz     short mfory        ; Y!=0 ->dalsi radek
 
        add     word [cy_], L      ; cx_:=cx_+L
        cmp     di, 64000          ; konec obrazku ?
        jne     short mforx
 
finish:
        wait_key                   ; cekani na klavesu
        exit                       ; navrat do DOSu
 
 
section .data
 
cy_     dw MIN                     ; poloha v komplexni rovine rovine
 
section .bss
 
cx_     resw 1                     ;
zy1     resw 1                     ; aktualni poloha v komplexni rovine
zx2     resw 1                     ; zx2=zx1^2 (aby se to nemuselo pocitat 2x)
zy2     resw 1                     ; zy2=zy1^2
 
 
 
; finito

Můžeme se ovšem pokusit o „poladění“ pozice binární tečky. Příkladem může být odlišná realizace posunu, která vyžaduje pouze změnu tří konstant v kódu:

;-----------------------------------------------------------------------------
org  0x100        ; zacatek kodu pro programy typu COM (vzdy se zacina na 256)
 
; konstanty
P       equ     4096/4             ; 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, 5              ; posun pro FX format
 
mforx:  mov     word [cx_], MIN    ; od -2 (imaginarni osa)
        mov     SI, SLOUPCU        ; x
mfory:  mov     CH, MAXITER        ; pocet iteraci
        xor     AX, AX             ;
        mov     BP, AX             ; nastaveni real.casti zacatku
        mov     word [zy1], AX     ; nastaveni imag.casti zacatku
iter_loop:                         ; *** iteracni smycka ***
        mov     AX, BP             ;
        sar     AX, CL             ;
        imul    AX                 ; zx2:=zx1^2 (v X-pointu)
        mov     word [zx2], AX     ;
        mov     AX, [zy1]          ;
        sar     AX,CL              ;
        imul    AX                 ; zy2:=zy1^2 (v X-pointu)
        mov     word [zy2], AX     ;
 
        mov     AX, BP             ;
        sar     AX,CL              ; zx1 div 256 (pro mul v X-pointu)
        mov     BX, [zy1]          ;
        sar     BX,4               ; zy1 div 256 * 2 (pro mul v X-pointu)
        imul    BX                 ; zy1:=2*zx1*zy1
        add     AX, [cy_]          ; zy1:=2*zx1*zy1+CY (u Mandelbrota poc.iter.)
        mov     [zy1], AX          ; ulozit
 
        mov     AX, [zx2]          ;
        sub     AX, [zy2]          ; zx2:=zx2-zy2=zx1^2-zy1^2
        add     AX, [cx_]          ;
        mov     BP, AX             ; zx1:=zx1^2-zy1^2+CX
        dec     CH                 ; pocitadlo iteraci
        jz      short mpokrac      ; konec iteraci ?
        mov     AX, [zx2]          ;
        add     AX, [zy2]          ; ==zx1^2+zy1^2
        cmp     AX, 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     word [cx_], K      ; cy_:=cy_+K
        dec     si
        jnz     short mfory        ; Y!=0 ->dalsi radek
 
        add     word [cy_], L      ; cx_:=cx_+L
        cmp     di, 64000          ; konec obrazku ?
        jne     short mforx
 
finish:
        wait_key                   ; cekani na klavesu
        exit                       ; navrat do DOSu
 
 
section .data
 
cy_     dw MIN                     ; poloha v komplexni rovine rovine
 
section .bss
 
cx_     resw 1                     ;
zy1     resw 1                     ; aktualni poloha v komplexni rovine
zx2     resw 1                     ; zx2=zx1^2 (aby se to nemuselo pocitat 2x)
zy2     resw 1                     ; zy2=zy1^2
 
 
 
; finito

8. Rozdíly ve zdrojových kódech

Přechod z 32bitových hodnot s pevnou řádovou čárkou na použití pouze šestnáctibitových hodnot ve skutečnosti vyžaduje relativně malé zásahy do zdrojových kódů. Modifikovaných programových řádků je sice velké množství, ovšem jen kvůli tomu, že v assembleru nemáme k dispozici „centrální místo“ pro specifikaci datových typů proměnných (tedy obdobu céčkovských deklarací proměnných a parametrů funkcí). Podívejme se tedy, jaké úpravy bylo nutné provést (výstup je proveden formou unifikovaného diffu):

--- fx_mandel_2.asm     2025-07-02 13:00:19.307893801 +0200
+++ fx_mandel_3.asm     2025-07-02 13:20:35.772896137 +0200
@@ -33,55 +33,51 @@
         xor     DI, DI             ; zacatek vykreslovani na obrazovce
         mov     CL, 6              ; posun pro FX format
 
-mforx:  mov     dword [cx_], MIN   ; od -2 (imaginarni osa)
+mforx:  mov     word [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
+        xor     AX, AX             ;
+        mov     BP, AX             ; nastaveni real.casti zacatku
+        mov     word [zy1], AX     ; 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
-
+        mov     AX, BP             ;
+        sar     AX, CL             ;
+        imul    AX                 ; zx2:=zx1^2 (v X-pointu)
+        mov     word [zx2], AX     ;
+        mov     AX, [zy1]          ;
+        sar     AX,CL              ;
+        imul    AX                 ; zy2:=zy1^2 (v X-pointu)
+        mov     word [zy2], AX     ;
+
+        mov     AX, BP             ;
+        sar     AX,CL              ; zx1 div 256 (pro mul v X-pointu)
+        mov     BX, [zy1]          ;
+        sar     BX,5               ; zy1 div 256 * 2 (pro mul v X-pointu)
+        imul    BX                 ; zy1:=2*zx1*zy1
+        add     AX, [cy_]          ; zy1:=2*zx1*zy1+CY (u Mandelbrota poc.iter.)
+        mov     [zy1], AX          ; ulozit
+
+        mov     AX, [zx2]          ;
+        sub     AX, [zy2]          ; zx2:=zx2-zy2=zx1^2-zy1^2
+        add     AX, [cx_]          ;
+        mov     BP, AX             ; 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)
+        mov     AX, [zx2]          ;
+        add     AX, [zy2]          ; ==zx1^2+zy1^2
+        cmp     AX, 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
+        add     word [cx_], K      ; cy_:=cy_+K
         dec     si
         jnz     short mfory        ; Y!=0 ->dalsi radek

-        add     dword [cy_], L     ; cx_:=cx_+K
+        add     word [cy_], L      ; cx_:=cx_+L
         cmp     di, 64000          ; konec obrazku ?
-        jne     mforx
+        jne     short mforx
  
 finish:
         wait_key                   ; cekani na klavesu
@@ -90,14 +86,14 @@
 
 section .data
 
-cy_     dd MIN                     ; poloha v komplexni rovine rovine
+cy_     dw 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
+cx_     resw 1                     ;
+zy1     resw 1                     ; aktualni poloha v komplexni rovine
+zx2     resw 1                     ; zx2=zx1^2 (aby se to nemuselo pocitat 2x)
+zy2     resw 1                     ; zy2=zy1^2

9. Rozdíly ve vypočtených obrázcích

Výpočty Mandelbrotovy množiny ve formátu s minimálně šestnácti bity před binární tečkou a šestnácti bity za binární tečkou jsou sice nepřesné, ovšem (pokud nedojde k velkému zvětšení nebo nepoužijeme příliš velký maximální počet iterací) nejsou tyto nepřesnosti příliš patrné. Ovšem naprosto odlišná je situace v případě, že celá hodnota má pouze šestnáct bitů, přičemž se do těchto bitů musí „vejít“ jak celá část hodnoty, tak i desetinná část. Nejlépe jsou chyby viditelné po vykreslení Mandelbrotovy množiny:

10. Výpočty složitějších funkcí

V praxi se kromě čtyř základních aritmetických operací (součet, rozdíl, součin, podíl) pochopitelně používají i další operace a matematické funkce. V případě matematického koprocesoru je množství těchto funkcí implementováno formou instrukcí (nebo jejich kombinací), ovšem v případě, že namísto FP formátu (a přímého volání instrukcí koprocesoru) budeme chtít použít numerický formát s pevnou řádovou tečkou (čárkou), bude nutné nějakým způsobem implementovat i všechny požadované funkce. Některé z těchto funkcí lze realizovat triviálně; příkladem je výpočet absolutní hodnoty. Ovšem většina často používaných funkcí nemá triviální implementaci a výpočty jsou více či méně komplikované. Proto se často setkáme i s tím, že jsou hodnoty funkcí předvypočteny (například pro 256 vstupních hodnot) a zbylé hodnoty se dopočítají lineární či jinou interpolací.

V dalších kapitolách se zaměříme na dvojici často volaných matematických funkcí. V první řadě se jedná o výpočet druhé odmocniny, který nalezneme v grafických algoritmech (normalizace vektorů, výpočet vzdálenosti) a v řadě druhé o goniometrické funkce (rotace apod.).

11. Iterativní výpočet druhé odmocniny

Výpočet druhé odmocniny (square root) je v praxi velmi často používaný (počítačová grafika, dnes například zpracování přirozeného jazyka atd.) a i z tohoto důvodu je implementován ve většině FPU, ale i GPU. My si v tomto článku ukážeme jednu z možností implementace, která spočívá v iterativním zpřesňování odhadu výsledku. Nyní se tedy povězme, jakým způsobem se může iterativní výpočet druhé odmocniny provádět. Vstupní hodnotou algoritmu je původní číslo y, výstupem je (po i-té iteraci) odhad výsledku x_i. V každé iteraci se provádí poměrně jednoduchá operace vyžadující dělení:

x_i+1=1/2 (x_i+y/x_i)

Zbývá nám pouze nastavit počáteční odhad x₁. Většinou se volí hodnota x₁=y/2, protože je ji možné velmi jednoduše spočítat prostým bitovým posunem mantisy nebo snížením hodnoty exponentu (a u FX operací ještě jednodušeji pouhým bitovým posunem). Přesnější (a tím pádem i rychlejší, jelikož se provede méně iterací) je však odhad vypočtený z mantisy a exponentu vstupující hodnoty y, což lze ovšem provést jen u FP hodnot:

x₁=m×2^e/2

tj. hodnota exponentu se sníží na polovinu. Důkaz pro korektnost takto vytvořeného prvního odhadu je poměrně přímočarý. Vstupní hodnota y může být rozepsána na mantisu a exponent:

y=m×2^e

Znaménko můžeme ignorovat, protože odmocniny se počítají pouze pro kladné hodnoty. Prvotní odhad vychází z aplikace odmocniny na výše uvedený rozepsaný vztah:

y^1/2=m^1/2×2^e/2

Hodnotu mantisy je možné (resp. nutné) ignorovat, protože normalizovaná mantisa představuje hodnoty z intervalu <1, 2-ε> a tento interval se aplikací odmocniny nijak nemění.

12. Demonstrační příklad na výpočet druhé odmocniny ve formátu plovoucí řádové tečky

Pro ilustraci iterativního výpočtu druhé odmocniny a zejména faktu, že řešení poměrně rychle (jen po několika iteracích) spěje ke korektnímu výsledku, si ukažme demonstrační příklad napsaný pro jednoduchost v programovacím jazyku C. Po překladu a spuštění tohoto příkladu se zobrazí tabulka s postupně zpřesňovaným výpočtem druhé odmocniny hodnoty 10 000. Kromě průběžných výsledků je zobrazována i absolutní a relativní chyba výpočtu:

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
 
/* tato funkce provede jednu iteraci
 * se zlepšeným odhadem výsledku x_i
 */
float sqrt_step(float xi, float y)
{
    return 1.0 / 2.0 * (xi + y / xi);
}
 
int main(void) {
    /* vstupní hodnota, ze které se počítá odmocnina */
    double y = 10000;
 
    /* postupně zpřesňovaný odhad výsledku */
    double xi = y;
 
    /* hodnota pro porovnání výsledků */
    double sqr = sqrt(y);
 
    /* počitadlo iterací */
    int i;
 
    /* iterativní výpočet */
    for (i = 0; i < 20; i++) {
        double abs_error, rel_error;
        xi = sqrt_step(xi, y);                      /* zpřesnění odhadu */
        abs_error = fabs(xi - sqr);                 /* absolutní chyba */ 
        rel_error = 100.0f * fabs(xi - sqr) / sqr;  /* relativní chyba */
        printf("%d\t%11.5f\t%11.5f\t%10.2f%%\n", i + 1, xi, abs_error, rel_error);
    }
    return 0;
}
 
/* finito */

Podívejme se nyní na výsledky vypočtené a vypsané tímto příkladem. Všimněte si, že již po deseti iteracích klesá relativní chyba pod setinu procenta (alespoň v rámci dané přesnosti FP formátu), takže iterační metoda je zvolena vhodně, protože řešení konverguje velmi rychle:

iterace  mezivýsledek    absolutní chyba   relativní chyba
----------------------------------------------------------
1        5000.50000      4900.50000        4900.50%
2        2501.25000      2401.25000        2401.25%
3        1252.62402      1152.62402        1152.62%
4         630.30365       530.30365         530.30%
5         323.08450       223.08450         223.08%
6         177.01808        77.01808          77.02%
7         116.75475        16.75475          16.75%
8         101.20218         1.20218           1.20%
9         100.00714         0.00714           0.01%
10        100.00000         0.00000           0.00%
11        100.00000         0.00000           0.00%
12        100.00000         0.00000           0.00%
13        100.00000         0.00000           0.00%
14        100.00000         0.00000           0.00%
15        100.00000         0.00000           0.00%
16        100.00000         0.00000           0.00%
17        100.00000         0.00000           0.00%
18        100.00000         0.00000           0.00%
19        100.00000         0.00000           0.00%
20        100.00000         0.00000           0.00%

13. Demonstrační příklad na výpočet druhé odmocniny ve formátu pevné řádové tečky

Demonstrační příklad z předchozí kapitoly si můžeme relativně snadno přepsat do varianty používající formát pevné řádové tečky (čárky). Namísto FP výpočtů tedy využijeme celočíselné operace a pouze zajistíme, aby byla zachována pozice řádové tečky. Konkrétně budou všechny výpočty probíhat s hodnotami int32_t (C99 a vyšší) a pozice řádové tečky bude nastavena mezi bit s indexem 15 a 16:

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
 
/* počet míst před a za binární řádovou tečkou */
#define A 16
#define B 16
 
/* datový typ, se kterým budeme pracovat */
typedef int32_t fx;
 
/* hlavičky použitých funkcí */
void fx_print(fx x);
fx fp2fx(double x);
double fx2fp(fx x);
 
/*
 * Tisk numerické hodnoty uložené ve formátu pevné
 * řádové binární čárky (FX)
 */
void fx_print(fx x)
{
    int i;
    int val = x;                /* pomocná proměnná pro převod do dvojkové soustavy */
    printf("bin: ");
    for (i = 0; i < A + B; i++) {       /* převod na řetězec bitů (do dvojkové soustavy) */
        putchar(!!(val & (1 << (A + B - 1))) + '0');    /* výpis hodnoty aktuálně nejvyššího bitu */
        if (i == B - 1)
            putchar('.');       /* po řádové binární čárce vypsat značku */
        val = val << 1;         /* posun na další (méně významný) bit */
    }
 
    printf("   hex: %08x   fp: %+11.5f\n", x, fx2fp(x));
}
 
/*
 * Převod z formátu plovoucí řádové binární čárky (FP)
 * do formátu pevné řádové binární čárky (FX)
 */
fx fp2fx(double x)
{
    return (fx) (x * (2 << (B - 1)));
}
 
/*
 * Převod z celočíselného formátu (integer)
 * do formátu pevné řádové binární čárky (FX)
 */
fx int2fx(int x)
{
    return (fx) (x << B);
}
 
/*
 * Převod z formátu pevné řádové binární čárky (FX)
 * do formátu plovoucí řádové binární čárky (FP)
 */
double fx2fp(fx x)
{
    return (double) x / (2 << (B - 1));
}
 
/*
 * Součet dvou hodnot uložených ve shodném formátu
 * pevné binární řádové čárky (FX)
 */
fx fx_add(fx x, fx y)
{
    return x + y;
}
 
/*
 * Rozdíl dvou hodnot uložených ve shodném formátu
 * pevné binární řádové čárky (FX)
 */
fx fx_sub(fx x, fx y)
{
    return x - y;
}
 
/*
 * Součin dvou hodnot uložených ve shodném formátu
 * pevné binární řádové čárky (FX)
 */
fx fx_mul(fx x, fx y)
{
    fx result = (x >> (B / 2)) * (y >> (B / 2));
    return result;
}
 
/*
 * Podíl dvou hodnot uložených ve shodném formátu
 * pevné binární řádové čárky (FX)
 */
fx fx_div(fx x, fx y)
{
    fx result = x / (y >> (B / 2));
    return result << (B / 2);
}
 
/* jeden krok odhadu druhé odmocniny */
fx sqrt_step_calc(fx f1, fx f2, fx xi, fx y)
{
    return fx_mul(fx_div(f1, f2), xi + fx_div(y, xi));
}
 
/* tato funkce provede jednu iteraci
 * se zlepšeným odhadem výsledku x_i
 */
fx sqrt_step(fx xi, fx y)
{
    fx f1 = fp2fx(1.0);
    fx f2 = fp2fx(2.0);
    return sqrt_step_calc(f1, f2, xi, y);
}
 
int main(void) {
    double orig_y = 10000.0;
 
    /* vstupní hodnota, ze které se počítá odmocnina */
    fx y = fp2fx(orig_y);
 
    /* postupně zpřesňovaný odhad výsledku */
    fx xi = y;
 
    /* hodnota pro porovnání výsledků */
    double sqr = sqrt(orig_y);
 
    /* počitadlo iterací */
    int i;
 
    /* iterativní výpočet */
    for (i = 0; i < 20; i++) {
        double abs_error, rel_error;
        double xf;
        xi = sqrt_step(xi, y);                      /* zpřesnění odhadu */
        xf = fx2fp(xi);                             /* převést na FP pro výpočty a tisk */
        abs_error = fabs(xf - sqr);                 /* absolutní chyba */ 
        rel_error = 100.0f * fabs(xf - sqr) / sqr;  /* relativní chyba */
        printf("%d\t%11.5f\t%11.5f\t%10.2f%%\n", i + 1, xf, abs_error, rel_error);
    }
    return 0;
}
 
/* finito */

Výsledky ukazují, že ke korektní hodnotě opět dospějeme relativně rychle; po deseti iteracích:

iterace  mezivýsledek    absolutní chyba   relativní chyba
----------------------------------------------------------
1        5000.50000      4900.50000        4900.50%
2        2501.24805      2401.24805        2401.25%
3        1252.62109      1152.62109        1152.62%
4         630.30078       530.30078         530.30%
5         323.08203       223.08203         223.08%
6         177.01562        77.01562          77.02%
7         116.75391        16.75391          16.75%
8         101.20117         1.20117           1.20%
9         100.00586         0.00586           0.01%
10        100.00000         0.00000           0.00%
11        100.00000         0.00000           0.00%
12        100.00000         0.00000           0.00%
13        100.00000         0.00000           0.00%
14        100.00000         0.00000           0.00%
15        100.00000         0.00000           0.00%
16        100.00000         0.00000           0.00%
17        100.00000         0.00000           0.00%
18        100.00000         0.00000           0.00%
19        100.00000         0.00000           0.00%
20        100.00000         0.00000           0.00%

14. Překlad jedné iterace pro výpočet druhé odmocniny do assembleru

Výpočty jsme sice ve formátu FX realizovali relativně snadno, ovšem ještě se musíme podívat na to, jak kvalitně nebo nekvalitně byl kód přeložen do assembleru. Při vypnutí optimalizací (-O0) bude výsledkem otrocký překlad původních příkazů zapsaných v jazyku C a výsledek bude dlouhý a pomalý (ostatně přesně podle předpokladů):

sqrt_step_calc(int, int, int, int):
        push    rbp
        mov     rbp, rsp
        push    rbx
        sub     rsp, 16
        mov     DWORD PTR [rbp-12], edi
        mov     DWORD PTR [rbp-16], esi
        mov     DWORD PTR [rbp-20], edx
        mov     DWORD PTR [rbp-24], ecx
        mov     edx, DWORD PTR [rbp-20]
        mov     eax, DWORD PTR [rbp-24]
        mov     esi, edx
        mov     edi, eax
        call    fx_div(int, int)
        mov     edx, DWORD PTR [rbp-20]
        lea     ebx, [rax+rdx]
        mov     edx, DWORD PTR [rbp-16]
        mov     eax, DWORD PTR [rbp-12]
        mov     esi, edx
        mov     edi, eax
        call    fx_div(int, int)
        mov     esi, ebx
        mov     edi, eax
        call    fx_mul(int, int)
        mov     rbx, QWORD PTR [rbp-8]
        leave
        ret

Při použití optimalizací (-O9) bude výsledek nepatrně lepší:

sqrt_step_calc(int, int, int, int):
        mov     eax, ecx
        mov     r9d, edx
        mov     r8d, edx
        sar     esi, 8
        sar     r9d, 8
        cdq
        idiv    r9d
        mov     ecx, eax
        mov     eax, edi
        cdq
        sal     ecx, 8
        idiv    esi
        add     ecx, r8d
        sar     ecx, 8
        mov     edi, eax
        mov     eax, ecx
        sal     edi, 8
        sar     edi, 8
        imul    eax, edi
        ret

I zde však máme prostor pro další optimalizace. Například není nutné předávat konstanty 1 a 2 ve formátu FX. Ovšem důležitější je, že lze využít odlišný algoritmus, který výsledek odhadne rychleji. Podrobnosti si řekneme příště.

15. Goniometrické funkce počítané pomocí číselných řad

Goniometrické funkce, které jsou velmi důležité například v počítačové grafice, je možné počítat více způsoby. V navazující části tohoto seriálu si ukážeme výpočet goniometrických funkcí pomocí algoritmu CORDIC, dnes si pouze řekneme, jakým způsobem je možné použít číselné řady. Uvažujme například funkci sin(), která je, jak víme už ze střední školy, funkcí periodickou s periodou 2π (pro další goniometrické funkce platí podobné vztahy a závěry, tj. v dalším textu se jimi nebudu zabývat).

Na první pohled to vypadá, že se můžeme omezit pouze na výpočet této funkce pro vstupní hodnoty z intervalu <0, 2π>. Ve skutečnosti však můžeme využít velké symetrie této funkce, a to dokonce dvakrát. V intervalu <π, 2π> je funkce zrcadlově otočena vůči vzoru z intervalu <0, π>. Kromě toho je funkce na intervalu <0, π/2> vertikálně symetrická s intervalem <π/2, π>. Z obou těchto symetrií vyplývá, že je zapotřebí přímým výpočtem zjistit hodnoty funkce sin() pouze na intervalu <0, π/2>, hodnoty v ostatních intervalech se dopočítají buď změnou znaménka výsledku, nebo změnou vstupní hodnoty. Daný interval jednoho „kvadrantu“ má i další přednost: funkce sin() je v něm neustále rostoucí bez nežádoucích zákmitů a lokálních minim či maxim.

Všechny goniometrické funkce je možné na určitém intervalu (typicky kvadrantu) rozepsat s využitím Taylorova rozvoje. V případě funkce sin() dostaneme nekonečný rozvoj, který vypadá následovně:

sin(x)=x¹/1! – x³/3! + x⁵/5! – x⁷/7! + …

16. Demonstrační příklad: výpočet sinu s využitím Taylorova rozvoje

Taylorův rozvoj sice na první pohled vypadá výpočetně velmi náročně, ve skutečnosti je však v praxi zapotřebí pro dosažení relativně dobré přesnosti vypočítat poměrně malé množství jeho členů, o čemž nás přesvědčí demonstrační příklad uvedený pod tímto odstavcem, který pro výpočet funkce sin() na intervalu <0, π/2> používá pouze první tři nenulové členy posloupnosti (což se může zdát jako pouze velmi hrubé přiblížení):

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
 
#define EPSILON 10.0e-20
 
/* tato funkce provede výpočet funkce
 * sin() pomocí tří nenulových členů
 * Taylorova rozvoje
 */
double compute_sin(double x)
{
    double t1=x/1.0;
    double t3=x*x*x/6.0;
    double t5=x*x*x*x*x/120.0;
    return t1-t3+t5;
}
 
int main(void)
{
    /* počitadlo iterací */
    double alfa;
    for (alfa=0.0; alfa<=M_PI/2.0; alfa+=M_PI/40.0) {
        /* korektní výpočet */
        double sin1=sin(alfa);
 
        /* náš odhad */
        double sin2=compute_sin(alfa);
 
        /* absolutní chyba */ 
        double abs_error = fabs(sin2-sin1);
 
        /* relativní chyba */
        double rel_error = fabs(sin1)<EPSILON ? 0.0 : 100.0*fabs(sin2-sin1)/sin1;
 
        /* tisk řádku tabulky */
        printf("%5.3f\t%8.6f\t%8.6f\t%8.6f\t%6.2f%%\n",
                alfa,
                sin1,
                sin2,
                abs_error,
                rel_error);
    }
    return 0;
}
 
/* finito */

17. Výsledky výpočtu hodnot funkce sin()

Po překladu a spuštění příkladu z předchozí kapitoly se zobrazí následující tabulka (bez prvního řádku), s vyčíslenými hodnotami funkce sin() pro 21 úhlů z prvního kvadrantu. Ve druhém sloupci je výsledek standardní matematické operace sin(), třetí sloupec obsahuje hodnoty vypočtené pomocí tří členů Taylorova rozvoje a v posledních dvou sloupcích je spočtena a zobrazena absolutní a relativní chyba. Všimněte si, že chyba postupně stoupá od prakticky nulové hodnoty (přesný výsledek) až po cca 0,5%. To je jedna z vlastností Taylorova rozvoje; při vzdalování se od počáteční hodnoty chyba obecně roste. Pokud by bylo zapotřebí použít vyšší přesnosti, není nic jednoduššího, než přidat další jeden či dva členy rozvoje.

úhel    sin()           Taylorův rozvoj absolutní chyba   relativní chyba
0.000   0.000000        0.000000        0.000000          0.00%
0.079   0.078459        0.078459        0.000000          0.00%
0.157   0.156434        0.156434        0.000000          0.00%
0.236   0.233445        0.233445        0.000000          0.00%
0.314   0.309017        0.309017        0.000000          0.00%
0.393   0.382683        0.382684        0.000000          0.00%
0.471   0.453990        0.453992        0.000001          0.00%
0.550   0.522499        0.522502        0.000003          0.00%
0.628   0.587785        0.587793        0.000008          0.00%
0.707   0.649448        0.649465        0.000017          0.00%
0.785   0.707107        0.707143        0.000036          0.01%
0.864   0.760406        0.760477        0.000071          0.01%
0.942   0.809017        0.809146        0.000129          0.02%
1.021   0.852640        0.852866        0.000226          0.03%
1.100   0.891007        0.891386        0.000379          0.04%
1.178   0.923880        0.924493        0.000613          0.07%
1.257   0.951057        0.952017        0.000961          0.10%
1.335   0.972370        0.973834        0.001464          0.15%
1.414   0.987688        0.989867        0.002178          0.22%
1.492   0.996917        1.000088        0.003170          0.32%
1.571   1.000000        1.004525        0.004525          0.45%

18. Univerzální algoritmus CORDIC

CORDIC neboli COordinate ROtation DIgital Computer je výpočetní metoda používající specializovaný iterativní algoritmus, který slouží v první řadě k výpočtu trigonometrických funkcí s předem známou přesností, tj. funkcí sin(), cos(), tan() atd. Po malých úpravách je možné tento algoritmus využít i pro další výpočty, například fáze (úhlu) a velikosti komplexních čísel, vyčíslení logaritmických funkcí, hyperbolických funkcí (sinh(), cosh(), tanh()) atd.

Jednou ze základních vlastností metody CORDIC, která se snad nejvíce v minulosti postarala o jeho velké rozšíření, je jednoduchost operací, které se v každé iteraci provádí – používá se zde totiž pouze sečítání, odečítání a bitové posuny, žádné další operace nejsou zapotřebí; dokonce není ani nutné implementovat násobičku (přesněji řečeno, u některých „odvozených“ funkcí, například tan() je zapotřebí dělička k vydělení vypočtených hodnot sin() a cos(), viz další článek). Díky této vlastnosti bylo možné CORDIC využít i ve velmi (z pohledu moderních CPU) omezených zařízeních, například kalkulačkách či osmibitových mikrořadičích (omezením zde mám na mysli relativně malý počet logických členů i ALU bez násobiček a děliček). Podrobnější informace o této velmi zajímavé metodě budou uvedeny v následujícím pokračování tohoto seriálu.

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