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

Obsah

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

2. Univerzální algoritmus CORDIC

3. Princip činnosti CORDICu: rotace vektoru okolo počátku souřadného systému

4. Modifikace výpočtu rotace vektoru pro algoritmus CORDIC

5. Náhrada výpočtu tangenty za bitový posun

6. Hodnoty úhlů, po kterých se provádí rotace vektoru

7. Výpočet funkcí sinus a kosinus pomocí algoritmu CORDIC

8. Úplný zdrojový kód programu pro výpočet funkcí sin a cos algoritmem CORDIC

9. Výsledky výpočtů goniometrických funkcí: absolutní a relativní chyby

10. Vizualizace výsledků pro 5, 7 a 10 iterací algoritmu CORDIC

11. Výpočet tangenty s využitím algoritmu CORDIC

12. Demonstrační příklad: realizace výpočtu funkce tan

13. Výsledky výpočtů hodnot funkce tan

14. Výpočet arkustangenty s využitím algoritmu CORDIC

15. Demonstrační příklad: realizace výpočtu funkce arctan

16. Výsledky výpočtů hodnot funkce arctan

17. FX varianty výpočtů prováděných algoritmem CORDIC

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

19. Literatura

20. Odkazy na Internetu

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

V předchozí části tohoto seriálu jsme si uvedli stručné informace o algoritmu CORDIC, neboli COordinate ROtation DIgital Computer. Připomeňme si ve stručnosti, že se jedná o výpočetní metodu využívající iteraci, kterou pro účely jednoduchého a rychlého výpočtu goniometrických funkcí bez použití násobiček a děliček navrhl a zpopularizoval Jack Volder už v polovině minulého století (viz literatura uvedená v devatenácté kapitole).

Později se ukázalo, že tuto metodu je možné po malých úpravách použít i pro výpočty dalších matematických funkcí, například arkustangenty, arkussinu, arkuskosinu, ale i pro vyčíslení délky vektoru či jeho rychlou rotaci o libovolný úhel; včetně transformace bodu či vektoru z polárních souřadnic do souřadnic kartézských. Již větší úpravy si vyžádala aplikace metody CORDIC pro výpočet hyperbolických funkcí (sinh(), cosh(), tanh()) a funkcí logaritmických. Základní myšlenka i princip práce tohoto algoritmu však zůstává prakticky stále stejný.

2. Univerzální algoritmus CORDIC

Vzhledem k tomu, že se při aplikaci algoritmu CORDIC využívají pouze ty nejzákladnější matematické operace (konkrétně bitový posun doleva a doprava, součet, rozdíl a porovnání dvou hodnot, na konci výpočtu pak součin či podíl), je možné CORDIC využít ve všech číslicových systémech, ve kterých je zapotřebí šetřit použitými prostředky, tj. počtem logických hradel, kapacitou obsazené paměti, možnostmi použitých čipů atd. CORDIC tak byl implementován a s úspěchem používán například v kalkulačkách, osmibitových mikrořadičích (řada Intel 8051 a Motorola 68HC11), osmibitových domácích počítačích (Atari, Sinclair ZX Spectrum atd.) a taktéž v mnoha specializovaných obvodech vytvořených pomocí programovatelných polí FPGA.

Zajímavá je implementace CORDICu na mikrořadičové stavebnici Basic STAMP. V největší míře však bylo CORDICu využito v některých matematických koprocesorech (FPU), protože bylo zjištěno, že některé funkční bloky zabezpečující chod CORDICu zůstávají stále stejné, bez ohledu na to, jaká funkce je počítána, což do značné míry zjednodušilo (a tím pádem i zlevnilo a zefektivnilo) výrobu FPU. Samozřejmě se také snížil počet hradel nutných pro implementaci goniometrických, hyperbolických a logaritmických funkcí.

3. Princip činnosti CORDICu: rotace vektoru okolo počátku souřadného systému

Princip činnosti algoritmu CORDIC vychází z vyjádření rotace vektoru o určitý (vhodný) úhel δ a z následné úpravy vzorce pro rotaci vektoru takovým způsobem, aby se eliminovaly zbytečně složité a časově náročné multiplikativní operace (typická rotace vyžaduje čtyři součiny a dva součty). Nejprve si napišme vzorce pro hodnoty funkcí sinus a kosinus součtu dvou úhlů. Jedná se o známé středoškolské vztahy používané pro úpravu výrazů s goniometrickými funkcemi:

sin(α+β) = sin α cos β + cos α sin β
cos(α+β) = cos α cos β – sin α sin β

Jak si ukážeme o několik odstavců níže, je možné tyto vzorečky použít pro vyjádření rotace vektoru. Vektor r, kterým budeme rotovat, může být vyjádřen souřadnicemi [x₀, y₀], přičemž je možné provést převod z kartézských souřadnic do souřadnic polárních (což přímo vychází z definice funkcí sin a cos):

x₀ = r cos φ
y₀ = r sin φ

kde r představuje délku vektoru r a φ je úhel vektoru měřený od kladné horizontální poloosy souřadného systému. V případě, že vektor r bude rotován o úhel δ, změní se koncový bod vektoru tak, že bude ležet na kružnici o stejném poloměru r, ale úhel vektoru (opět měřený od kladné horizontální poloosy) se zvětší o δ. Tuto skutečnost je možné vyjádřit vztahy:

x_r = r cos (φ+δ)
y_r = r sin (φ+δ)

V dalším kroku je možné rozepsat výrazy cos (φ+δ) a sin (φ+δ) podle prvních dvou uvedených vzorečků a následně zpětně dosadit za výrazy r cos φ a r sin φ původní souřadnice vektoru r, tj. x₀ a y₀:

x_r = r (cos φ cos δ – sin φ sin δ) = x₀ cos δ – y₀ sin δ
y_r = r (sin φ cos δ + cos φ sin δ) = x₀ sin δ + y₀ cos δ

Všimněte si, že se ve výsledných vztazích nevyskytuje ani hodnota r ani úhel původního vektoru φ. To znamená, že převod na polární souřadnice pro nás byl pouze matematickou pomůckou při odvozování vzorce pro rotaci vektoru a ve skutečnosti se nebude nikdy provádět.

4. Modifikace výpočtu rotace vektoru pro algoritmus CORDIC

V předchozí kapitole jsme si odvodili, že rotaci jakéhokoli vektoru o úhel δ je možné zapsat pomocí vztahů:

x_r = x₀ cos δ – y₀ sin δ
y_r = x₀ sin δ + y₀ cos δ

Pro účely algoritmu CORDIC se tento vztah dále upravuje. První úprava spočívá v tom, že se obě rovnice vydělí hodnotou cos δ, takže dostaneme vztahy:

x_r / cos δ = x₀ – y₀ sin δ/cos δ
y_r / cos δ = x₀ sin δ/cos δ + y₀

Pokud si uvědomíme skutečnost, že sin δ / cos δ = tan δ, můžeme pokračovat v úpravách:

x_r / cos δ = x₀ – y₀ tan δ
y_r / cos δ = y₀ + x₀ tan δ

a následně:

x_r = cos δ(x₀ – y₀ tan δ)
y_r = cos δ(y₀ + x₀ tan δ)

5. Náhrada výpočtu tangenty za bitový posun

Nyní přichází základní myšlenka, na které je CORDIC postaven. Pokud budeme volit úhel δ takovým vhodným způsobem, aby jeho tangenta nabývala hodnot 2^-i (pro i>0), je možné tangentu ve vzorci nahradit násobením zvolenou hodnotou 2^-i; v tomto případě je však možné násobení nahradit jednoduchým a přitom rychlým bitovým posunem. Omezení hodnoty tangenty na zvolenou sadu hodnot však znamená, že se vektor nemůže rotovat o libovolný úhel, ale pouze o úhel odpovídající tangentě z dané sady. To však není v praxi problém, protože rotaci o libovolný je možné zapsat pomocí série rotací (doprava či doleva), například:

δ=δ₁+δ₂-δ₃+…

Naproti tomu, že se parciální rotace mohou provádět v obou směrech (tj. jak doprava, tak i doleva), můžeme místo hodnoty cos δ dosadit konstantu K_i, protože platí cos δ=cos -δ. Nakonec místo tan δ přímo dosadíme mocninu dvojky 2^-i a s využitím parametru d_i směr rotace (parametr d_i nabývá pouze hodnot +1 a –1):

x_r=K_i (x₀ – y₀ d_i 2^-i)
y_r=K_i (y₀ + x₀ d_i 2^-i)

Zbývá nám zjistit hodnotu konstanty K_i. Platí:

K_i=cos (arctan 2^-i)=1/(1+2^-2i)^1/2

Limitně se součin hodnot K_i (po nekonečně mnoha iteracích) blíží k 0,6073. To znamená, že touto hodnotou bude v některých případech nutné vydělit výsledek (v jiných případech nám naopak toto zesílení při rotaci vadit nebude, protože se například vyruší podílem).

Veškerá práce algoritmu CORDIC spočívá v tom, že se nastaví počáteční souřadnice vektoru r a iterativně se provádí rotace o předem známé úhly δ₁…δ_n tak, aby se dosáhlo požadované hodnoty rotace δ.

6. Hodnoty úhlů, po kterých se provádí rotace vektoru

Jak jsme si již uvedli v předchozí kapitole, musí tangenty úhlů použitých v algoritmu CORDIC splňovat podmínku tan δ=2^-i (pro celočíselné hodnoty i). V případě, že budeme veškeré výpočty provádět v prvním kvadrantu (ve skutečnosti je však snadné počítat i ve čtvrtém kvadrantu), začíná se s úhlem 45°, tj. π/4, protože tan π/4=1. Další úhly použité při výpočtech jsou samozřejmě menší. O jaké hodnoty se v algoritmu CORDIC konkrétně jedná, nám dá přehled následující jednoduchý program:

#include <stdio.h>
#include <math.h>
 
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
 
int main(void)
{
    double tan_value=1.0;
    double delta;
    int i;
    for (i=0; i<10; i++) {
        delta=atan(tan_value)*180.0/M_PI;
        printf("%d\t%12.10f\t%12.9f\n", i+1, tan_value, delta);
        tan_value/=2.0;
    }
    return 0;
}

Výsledek běhu tohoto programu nám ukazuje, že se hodnoty úhlů postupně (logicky) zmenšují a to vždy na více než polovinu předchozí hodnoty (například 45/2<26 nebo 26/2<14). Z toho také vyplývá, že jakýkoli úhel v prvním a čtvrtém kvadrantu je opravdu možné složit ze součtu těchto úhlů (musíme je samozřejmě vhodně vybrat). Ideální by sice byly hodnoty odpovídající přesně polovině hodnoty úhlu předchozího, tj. řada úhlů 45°, 45/2°, 45/4°…, tím by se však porušila podmínka tan δ=2^-i, díky níž je algoritmus CORDIC tak rychlý a přitom implementačně velmi jednoduchý:

7. Výpočet funkcí sinus a kosinus pomocí algoritmu CORDIC

Nyní si konečně na reálném příkladu ukážeme, jakým způsobem je možné algoritmus CORDIC použít pro výpočet hodnot goniometrických funkcí sinus a kosinus pro zadaný vstupní úhel. Nejprve jsou spočteny tabulky úhlů a hodnota druhých záporných mocnin hodnoty 2 (viz též předchozí kapitolu). Při implementaci CORDICu na FPU či FPGA by se tyto tabulky samozřejmě znovu nevytvářely: tabulka úhlů by byla uložena v paměti (či masce obvodu) a tabulka mocnin hodnoty 2 by se triviálně implementovala pomocí bitových posunů:

// tabulka arkustangentu úhlů
double atans[MAX_ITER];
 
// tabulka záporných celočíselných mocnin hodnoty 2
double pows[MAX_ITER];
 
// naplnění tabulek atans[] a pows[]
void createTables(void) {
    int i;
    for (i = 0; i < MAX_ITER; i++) {
        double p = pow(2.0, -i);
        atans[i] = atan(p);
        pows[i] = p;
    }
}

Po konstrukci a naplnění tabulek je již možné algoritmus CORDIC spustit. Počáteční souřadnice vektoru r jsou nastaveny na hodnotu [1, 0]:

// výpočet funkcí sin() a cos() pro zadaný úhel delta
void sincos(double delta, double *sin_value, double *cos_value) {
    int i;
    double x0 = 1.0; // nastavení počátečních podmínek
    double y0 = 0.0;
    ...
    ...
    ...

Vektor je posléze v iterační smyčce rotován tak dlouho, dokud neproběhne daný počet iterací. Úhel vektoru r se přitom neustále přibližuje k zadanému úhlu δ, jelikož se v iterační smyčce adaptivně zadaný úhel buď zmenšuje či zvětšuje o hodnotu uloženou v tabulce atans[]:

    double xn;
    for (i = 0; i < MAX_ITER; i++) { // iterační smyčka
        if (delta < 0) {             // úhel je záporný => rotace doleva
            xn = x0 + y0 * pows[i];
            y0 -= x0 * pows[i];
            delta += atans[i];
        } else { // úhel je kladný => rotace doprava
            xn = x0 - y0 * pows[i];
            y0 += x0 * pows[i];
            delta -= atans[i];
        }
        x0 = xn;
    }
    ...
    ...
    ...

Výsledek, tj. hodnoty funkcí sinus a kosinus, je uložen v nových souřadnicích vektoru r (vynásobený o konstantu K) a to z toho důvodu, že vektor rotoval na jednotkové kružnici a souřadnice jakéhokoli bodu ležícího na jednotkové kružnici přímo odpovídají hodnotám sinu a kosinu úhlu tohoto bodu počítaného od kladné horizontální poloosy:

    *sin_value = y0 * K; // opravit "zesílení" výsledku
    *cos_value = x0 * K;
}

8. Úplný zdrojový kód programu pro výpočet funkcí sin a cos algoritmem CORDIC

Celý program, který vypočte tabulku hodnot funkcí sin a cos s využitím algoritmu CORDIC a následně ještě vyjádří absolutní a relativní chyby výpočtu, vypadá následovně:

// --------------------------------------------------------
// Výpočet hodnot funkcí sin() a cos() pomocí iteračního
// algoritmu CORDIC.
// --------------------------------------------------------
 
#include <math.h>
#include <stdio.h>
 
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
 
// maximální počet iterací při běhu algoritmu
#define MAX_ITER 10
 
// "zesílení" při rotacích
#define K 0.6073
 
// tabulka arkustangentu úhlů
double atans[MAX_ITER];
 
// tabulka záporných celočíselných mocnin hodnoty 2
double pows[MAX_ITER];
 
// naplnění tabulek atans[] a pows[]
void createTables(void) {
    int i;
    for (i = 0; i < MAX_ITER; i++) {
        double p = pow(2.0, -i);
        atans[i] = atan(p);
        pows[i] = p;
    }
}
 
// výpočet funkcí sin() a cos() pro zadaný úhel delta
void sincos(double delta, double *sin_value, double *cos_value) {
    int i;
    double x0 = 1.0; // nastavení počátečních podmínek
    double y0 = 0.0;
    double xn;
    for (i = 0; i < MAX_ITER; i++) { // iterační smyčka
        if (delta < 0) {             // úhel je záporný => rotace doleva
            xn = x0 + y0 * pows[i];
            y0 -= x0 * pows[i];
            delta += atans[i];
        } else { // úhel je kladný => rotace doprava
            xn = x0 - y0 * pows[i];
            y0 += x0 * pows[i];
            delta -= atans[i];
        }
        x0 = xn;
    }
    *sin_value = y0 * K; // opravit "zesílení" výsledku
    *cos_value = x0 * K;
}
 
int main(void) {
    int i;
    createTables();
    for (i = 0; i <= 90; i++) { // výpočetní smyčka
        double delta;           // úhel, ze kterého se počítá sin a cos
        double sin_value;          // vypočtené hodnoty
        double cos_value;
        double sin_error; // absolutní chyby
        double cos_error;
        delta = i * M_PI / 180.0;           // převod úhlu na radiány
        sincos(delta, &sin_value, &cos_value);    // výpočet sinu a kosinu
        sin_error = fabs(sin_value - sin(delta)); // výpočet absolutních chyb
        cos_error = fabs(cos_value - cos(delta));
        // tisk výsledků
        printf("%02d\t%12.10f\t%12.10f\t%12.10f\t%12.10f\t%8.3f%%\t%8.3f%%\n",
               i,
               sin_value,
               cos_value,
               sin_error,
               cos_error,
               (sin_value != 0.0) ? 100.0 * sin_error / fabs(sin_value) : 0.0,
               (cos_value != 0.0) ? 100.0 * cos_error / fabs(cos_value) : 0.0);
    }
    return 0;
}
 
// finito

9. Výsledky výpočtů goniometrických funkcí: absolutní a relativní chyby

Výsledek běhu předchozího programu je zobrazen v následující tabulce. Kromě vypočtených hodnot sinů a kosinů zadaného úhlu je spočtena i absolutní a relativní chyba, přičemž je zapotřebí upozornit na to, že relativní chyba pro obě krajní hodnoty (ty by měly vyjít nulové) je poněkud zavádějící. V každém případě však výsledky běhu algoritmu pro deset iterací nejsou špatné, zvláště když si uvědomíme, že se v každé iteraci provádělo pouze několik základních operací, konkrétně dva bitové posuvy a tři součty (či rozdíly):

10. Vizualizace výsledků pro 5, 7 a 10 iterací algoritmu CORDIC

Numerické výsledky z předchozí kapitoly nám sice dají poměrně dobrý přehled o numerických chybách algoritmu CORDIC (které ovšem do značné míry závisí na počtu provedených iterací), ovšem taktéž je vhodné se podívat na to, jaký je průběh vypočtených funkcí sin a cos v porovnání s očekávaným průběhem. Pro tento účel si můžeme nechat průběhy porovnat například s využitím knihovny Matplotlib:

import numpy as np
 
import matplotlib.pyplot as plt
 
data_10_iter=[
    ...
    ...
    ...
]
 
data_7_iter=[
    ...
    ...
    ...
]
 
data_5_iter=[
    ...
    ...
    ...
]
 
 
 
def plot_results(data, filename, offset=0):
    a = np.array(data)
 
    plt.plot(a[:,0], a[:,1], "r-", label="cordic")
    plt.plot(a[:,0], offset+np.sin(np.deg2rad(a[:,0])), "b-", label="numpy")
 
    # přidání legendy
    plt.legend(loc="upper left")
 
    # povolení zobrazení mřížky
    plt.grid(True)
 
    # uložení do souboru
    plt.savefig(filename)
 
    # zobrazení grafu
    plt.show()
 
 
# vysledky
plot_results(data_5_iter, "cordic_5_iterations.png", offset=0)
plot_results(data_7_iter, "cordic_7_iterations.png", offset=0.02)
plot_results(data_10_iter, "cordic_10_iterations.png", offset=0.02)

V prvním případě jsou průběhy zobrazeny přesně tak, jak byly vypočteny:

Ve druhém a třetím případě je křivka s očekávaným průběhem posunuta o vzdálenost 0,02 jednotek vertikálním směrem, protože jinak by se oba průběhy překrývaly a nebyly by vidět žádné (podstatné) rozdíly:

11. Výpočet tangenty s využitím algoritmu CORDIC

Výpočet goniometrické funkce tangent je odvozen z výše popsaného algoritmu pro výpočet funkcí sin() a cos(), jelikož je možné použít známý vztah:

tan α=sin α / cos α

Funkce sin() a cos() se pomocí algoritmu CORDIC počítají současně, výpočet dokonce není možné žádným způsobem rozdělit, neboť obě hodnoty jsou na sobě závislé (rotace vektoru). To znamená, že tangentu je možné vypočítat s podobnou složitostí, jako tyto dvě funkce. Jediný rozdíl spočívá v tom, že není zapotřebí obě vypočtené hodnoty násobit konstantou K_i, protože se hodnota této konstanty vzájemným vydělením vypočtených hodnot vyruší. Na druhou stranu se musí aplikovat dělení, které se v některých případech (jednodušší FPU bez děličky) opět řeší iteračními metodami. Vzhledem k tomu, že se vzájemně dělí dvě obecně nepřesné hodnoty, relativní chyba výsledku (obecně) roste, přesněji řečeno, je součtem relativních chyb obou mezivýsledků. Z tohoto důvodu se při výpočtu tangenty používá větší počet iterací, než je nutné pro samostatný výpočet funkcí sin() a cos().

12. Demonstrační příklad: realizace výpočtu funkce tan

V této kapitole je uveden výpis demonstračního příkladu, který slouží pro výpočet goniometrické funkce tangent. Všimněte si, že před vlastním iteračním výpočtem je proveden test na vstup nulové hodnoty. Je to z toho důvodu, že pro nulový úhel (a také úhel blízký úhlu pravému) je relativní chyba velká a test na nulovou vstupní hodnotu je implementačně velmi jednoduchý: při HW realizaci postačuje hradlo AND s více vstupy. Na konci iteračního výpočtu je ošetřen stav, kdy je vypočtená tangenta nekonečná, tj. jedná se buď o úhel +90° nebo –90° (π/2 resp. -π/2). V tomto případě je vrácena hodnota +∞ nebo -∞ (jedná se o makra podle normy C99).

// --------------------------------------------------------
// Výpočet hodnot funkce tan() pomocí iteračního algoritmu
// CORDIC.
// --------------------------------------------------------
 
#include <math.h>
#include <stdio.h>
 
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
 
// maximální počet iterací při běhu algoritmu
#define MAX_ITER 10
 
// "zesílení" při rotacích
#define K 0.6073
 
// tabulka arkustangentu úhlů
double atans[MAX_ITER];
 
// tabulka záporných celočíselných mocnin hodnoty 2
double pows[MAX_ITER];
 
// naplnění tabulek atans[] a pows[]
void createTables(void) {
    int i;
    for (i = 0; i < MAX_ITER; i++) {
        double p = pow(2.0, -i);
        atans[i] = atan(p);
        pows[i] = p;
    }
}
 
// výpočet funkce tan() pro zadaný úhel delta
double tan_cordic(double delta) {
    int i;
    double x0 = 1.0; // nastavení počátečních podmínek
    double y0 = 0.0;
    double xn;
    if (delta==0) return 0.0;        // ošetření nulového úhlu
    for (i = 0; i < MAX_ITER; i++) { // iterační smyčka
        if (delta < 0) {             // úhel je záporný => rotace doleva
            xn = x0 + y0 * pows[i];
            y0 -= x0 * pows[i];
            delta += atans[i];
        } else { // úhel je kladný => rotace doprava
            xn = x0 - y0 * pows[i];
            y0 += x0 * pows[i];
            delta -= atans[i];
        }
        x0 = xn;
    }
    if (x0 == 0) // ošetření tangenty pravého úhlu
        if (y0 > 0) return INFINITY;
        else return -INFINITY;
    else
        return y0/x0;
}
 
int main(void) {
    int i;
    createTables();
    for (i = 0; i <= 90; i++) {                  // výpočetní smyčka
        double delta;                            // úhel, ze kterého se počítá sin a cos
        double tan_value;                        // vypočtené hodnoty
        double tan_error;                        // absolutní chyby
        delta = i * M_PI / 180.0;                // převod úhlu na radiány
        tan_value = tan_cordic(delta);           // výpočet funkce tan
        tan_error = fabs(tan_value-tan(delta));  // výpočet absolutních chyb
        // tisk výsledků
        printf("%02d\t%14.10f\t%14.10f\t%12.10f\t%8.3f%%\n",
               i,
               tan_value,
               tan(delta),
               tan_error,
               tan_error==0.0 ? 0:100.0*tan_error/tan(delta));
    }
    return 0;
}
 
// finito

13. Výsledky výpočtů hodnot funkce tan

Výsledky běhu demonstračního příkladu z předchozí kapitoly jsou vypsány v následující tabulce:

14. Výpočet arkustangenty s využitím algoritmu CORDIC

Výpočet arkustangenty se provádí poněkud odlišným způsobem, než výše uvedený výpočet sinu, kosinu či tangenty. Stále se však jedná o aplikaci velmi univerzálního principu, který algoritmus CORDIC představuje. Využívá se zde takzvaný vektorový režim výpočtu, ve kterém se – na rozdíl od výše popsaného rotačního režimu výpočtu – iterativně snažíme dosáhnout toho, aby se vynulovala hodnota uložená v registru y, tj. aby rotovaný vektor ležel na kladné či záporné horizontální poloose.

Výsledek běhu algoritmu CORDIC není v tomto případě uložen v registrech x nebo y (ty mají jiný význam), ale naopak v registru delta, který měl v rotačním režimu úlohu arbitru o směru rotace (ve vektorovém režimu tuto úlohu převzala hodnota v registru y,  resp. přesněji řečeno znaménko hodnoty v tomto registru uložené).

Vstupem algoritmu jsou počáteční hodnoty x a y (ty byly u předchozích metod jedničkové resp. nulové), přičemž se počítá arctan(y/x). To je velmi praktické, protože takto je možné vypočítat i arkustangentu kladného a záporného nekonečna (1/0 resp. –1/0), což jsou legální operace (stejným způsobem tento problém řeší standardní céčkovská knihovní funkce atan2()). Demonstrační příklad na výpočet arkustangenty je, spolu s tabulkou výsledků, uveden v navazujících kapitolách.

15. Demonstrační příklad: realizace výpočtu funkce arctan

V této kapitole je uveden výpis demonstračního příkladu, který provádí výpočet arkustangenty na základě čitatele a jmenovatele zlomku, tj. provádí se stejná operace, jaká je představována céčkovskou funkcí atan2(). Po překladu a spuštění tohoto příkladu se vypočte tabulka arkustangent pro hodnoty z intervalu 0,0 – 1,0, které odpovídají úhlům 0° – 45° (tj. 0 – π/4):

// --------------------------------------------------------
// Výpočet hodnot funkce atan() pomocí iteračního algoritmu
// CORDIC.
// --------------------------------------------------------
 
#include <math.h>
#include <stdio.h>
 
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
 
// maximální počet iterací při běhu algoritmu
#define MAX_ITER 10
 
// "zesílení" při rotacích
#define K 0.6073
 
// tabulka arkustangentu úhlů
double atans[MAX_ITER];
 
// tabulka záporných celočíselných mocnin hodnoty 2
double pows[MAX_ITER];
 
// naplnění tabulek atans[] a pows[]
void createTables(void) {
    int i;
    for (i = 0; i < MAX_ITER; i++) {
        double p = pow(2.0, -i);
        atans[i] = atan(p);
        pows[i] = p;
    }
}
 
// výpočet funkce atan() pro zadané souřadnice x, y
double atan_cordic(double y, double x) {
    int i;
    double x0 = x; // nastavení počátečních podmínek
    double y0 = y;
    double xn;
    double delta = 0.0;
    for (i = 0; i < MAX_ITER; i++) { // iterační smyčka
        if (y0 > 0) {                // kladná polorovina => rotace doleva
            xn = x0 + y0 * pows[i];
            y0 -= x0 * pows[i];
            delta += atans[i];
        } else { // záporná polorovina => rotace doprava
            xn = x0 - y0 * pows[i];
            y0 += x0 * pows[i];
            delta -= atans[i];
        }
        x0 = xn;
    }
    return delta; // výsledek je uložen v akumulátoru úhlu
}
 
int main(void) {
    double i;
    createTables();
    for (i = 0.0; i < 1.05; i += 0.05) { // výpočetní smyčka
        double atan_value;               // vypočtená hodnoty
        double atan_error;               // absolutní chyba
        double atan_float;               // korektní hodnota
 
        atan_value = atan_cordic((double)i, 1.0) * 180.0 / M_PI; // výpočet funkce atan
        atan_float = atan(i) * 180.0 / M_PI;
        atan_error = fabs(atan_value - atan_float); // výpočet absolutní chyby
                                              // tisk výsledků
        printf("%3.2f\t%14.10f\t%14.10f\t%12.10f\t%8.3f%%\n",
               i,
               atan_value,
               atan_float, atan_error,
               atan_float == 0 ? 0 : 100.0 * atan_error / atan_float);
    }
    // důkaz, že atan se spočte i pro nekonečno, tj. pravý úhel:
    printf("\natan nekonecna: %f\n", atan_cordic(1.0, 0.0) * 180.0 / M_PI);
    return 0;
}
 
// finito

16. Výsledky výpočtů hodnot funkce arctan

V následující tabulce je ukázán výstup z předchozího programu spolu s absolutními a relativními chybami oproti hodnotě vypočtené pomocí standardní céčkovské funkce atan():

17. FX varianty výpočtů prováděných algoritmem CORDIC

V předchozích kapitolách jsme si uvedli, jakým způsobem je možné algoritmus CORDIC použít pro výpočet goniometrických funkcí s hodnotami uloženými ve formátu plovoucí řádové binární čárky (FP). Tentýž algoritmus je však po mírné modifikaci možné použít i při práci s formátem pevné řádové binární čárky (FX) a dá se říci, že teprve zde se plně ukazuje jeho implementační jednoduchost a současně i velká vyjadřovací síla – pomocí jednoho iteračního postupu je možné vypočítat poměrně velké množství navzájem značně odlišných funkcí, přičemž paměťové nároky algoritmu jsou minimální a rovnají se tabulce s cca deseti až dvaceti prvky s rozsahem 32 (popř. pouze 16) bitů. To je výhodné především při implementaci na mikrořadičích (oblíbená řada 8051, PICy, řada 68HC11 atd.) a také při práci s programovatelnými obvody typu FPGA.

Tímto velmi zajímavým tématem se budeme zabývat příště.

18. 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ář:

19. Literatura

1. Andraka, Ray: „A survey of CORDIC algorithms for FPGA based computers“,
   ACM, 1998
2. Despain, A.M.:„Fourier Transform Computations Using CORDIC Iterations“,
   IEEE Transactions on Computers, Volume 23, strany 993–1001, 1974
3. Mazenc C., Merrheim, X., Muller, J.M.: „Computing Functions Arccos and Arcsin Using CORDIC“,
   IEEE Transactions on Computers, Volume 42, strany 118–122, 1993
4. Volder, Jack: „Binary computation algorithms for coordinate rotation and function generation“,
   Convair Report IAR-1, 1956
5. Volder, Jack: „The CORDIC Trigonometric Computing Technique“,
   IRE Transactions on Electronic Computing, Vol EC-8, strany 330–334, 1959
6. NVIDIA Corporation: „Floating-Point Specials on the GPU“,
   2005
7. Grant R. Griffin: CORDIC FAQ,
   http://www.dspguru.com/in­fo/faqs/cordic.htm
8. Andraka Consulting Group, Inc.: What is all this CORDIC stuff anyhow?,
   http://www.andraka.com/cordic.htm
9. Cyliax Ingo: CORDIC (COordinate Rotation DIgital Computer), the swiss army knife for computing math functions…
   http://www.ee.ualberta.ca/cou­rses/ee401/microboard/cor­dic_CCink.html

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