Algoritmus CORDIC a numerické formáty s pevnou řádovou čárkou

Obsah

1. Algoritmus CORDIC a numerické formáty s pevnou řádovou čárkou

2. Výpočet délky vektoru pomocí algoritmu CORDIC

3. První demonstrační příklad: výpočet délky vektoru

4. Výpočet logaritmu algoritmem CORDIC

5. Druhý demonstrační příklad: výpočet přirozeného logaritmu

6. Výsledky získané předchozím příkladem

7. Algoritmus CORDIC s hodnotami uloženými ve formátu pevné řádové binární čárky

8. Realizace funkce určené pro naplnění tabulky atans[] (arkustangenty vhodně zvolených úhlů)

9. Výpočet goniometrické funkce tan s využitím algoritmu CORDIC: neoptimalizovaná varianta výpočtu

10. Celý demonstrační příklad: výpočet funkce tan s využitím algoritmu CORDIC

11. Výsledky výpočtu funkce tan: absolutní a relativní chyby

12. Výpočet goniometrické funkce tan s využitím algoritmu CORDIC – optimalizovaná varianta výpočtů

13. Celý demonstrační příklad: výpočet funkce tan s využitím algoritmu CORDIC

14. Výsledky výpočtu funkce tan: absolutní a relativní chyby

15. Způsob překladu algoritmu CORDIC do assembleru

16. Výpočet goniometrické funkce sin

17. Výsledky výpočtu funkce sin: absolutní a relativní chyby, statistiky

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

19. Literatura

20. Odkazy na Internetu

1. Algoritmus CORDIC a numerické formáty s pevnou řádovou čárkou

V předchozích článcích jsme si uvedli, jakým způsobem je možné algoritmus CORDIC (COordinate ROtation DIgital Computer) 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.

Dnes se budeme zabývat právě tímto problémem. Nejdříve si však v kapitolách 2–6 ukážeme, jak lze CORDIC po úpravách použít i pro další (sofistikovanější) výpočty, například pro výpočet délky vektoru, výpočet hyperbolických funkcí, ale i pro výpočet logaritmů.

2. Výpočet délky vektoru pomocí algoritmu CORDIC

Délka vektoru (pro jednoduchost zůstaneme v rovině) se kupodivu počítá naprosto stejným způsobem, jako funkce arkustangenty. Je tomu tak z toho důvodu, že se arkustangenta iterativně vypočítá pootočením vstupního vektoru do polohy, ve které má y-ovou souřadnici nulovou. To však logicky znamená, že jeho x-ová souřadnice odpovídá délce vektoru, protože platí:

d=sqrt(x²+y²)=sqrt(x²+0)=­sqrt(x²)=x

To tedy znamená, že se minule uvedená funkce pro výpočet arkustangenty je po malých úpravách použitelná i pro výpočet délky vektoru. Postačuje ji jen upravit tak, že se výsledná hodnota x_i (vzniklá po i iteracích) vynásobí konstantou K_i stejným způsobem, jaký jsme prováděli u výpočtů funkcí sin() a cos() v předchozím pokračování tohoto seriálu.

Vlastnosti algoritmu CORDIC, díky které je možné jednoduše spočítat délku vektoru, není (resp. přesněji řečeno nebyla) široce známa, proto některé FPU pro tuto činnost ani neobsahují instrukci, což je škoda, zejména při práci s grafikou, kde se délky velmi často počítají a je pro ně nutné použít dvojici násobení, jedno sečítání a k tomu ještě druhou odmocninu, tj. poměrně zdlouhavé a složité operace.

3. První demonstrační příklad: výpočet délky vektoru

Po překladu a spuštění dnešního prvního demonstračního příkladu se zobrazí tabulka s délkami vektorů, jejichž souřadnice postupně nabývají hodnot od nuly do desíti (včetně):

// --------------------------------------------------------
// Výpočet délky vektoru 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 20
 
// "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 velikosti vektoru pomocí algoritmu CORDIC
double mag_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 x0 * K;      // délka vektoru
}
 
int main(void) {
    double x, y;
    createTables();
    printf("%f\n", mag_cordic(3, 4));       // výpočet Pythagorova trojúhelníka
    for (y=0.0; y<=10.0; y+=1.0) {          // tabulka velikostí různých vektorů
        for (x=0.0; x<=10.0; x+=1.0) {
            printf("%5.2f ", mag_cordic(x,y));
        }
        putchar('\n');
    }
    return 0;
}
 
// finito

Povšimněte si, že přesnost výpočtů je poměrně velká, například pro vektor (6,8) je prakticky přesně vypočtena délka 10:

4. Výpočet logaritmu algoritmem CORDIC

Algoritmus CORDIC ve své prapůvodní podobě pracoval na principu rotace vektoru v běžném L2 prostoru. Díky tomu bylo možné počítat goniometrické funkce, délky vektorů atd. Ovšem například výpočty hyperbolických funkcí nebo logaritmů vyžadují více či méně podstatné úpravy algoritmu, které spočívají v tom, že se (snadno pochopitelné) rotace nahradí odlišnými operacemi. Ovšem princip činnosti CORDICu zůstává stále stejný – máme k dispozici předpočítanou tabulku hodnot (původně úhlů) vypočtenou tak, aby jeden sloupec obsahoval mocniny dvou nebo podobné velmi snadno spočitatelné hodnoty. A snažíme se vektorem postupně „otočit“ tak, aby jedna z jeho složek byla nulová. Ze druhé složky je poté odvozena výsledná hodnota.

Pro zajímavost se podívejme na způsob výpočtu hodnoty přirozeného logaritmu (se základem e), opět s využitím upraveného algoritmu CORDIC. Sice se jedná o výpočet odlišný od (například) výpočtu goniometrických funkcí, ovšem původní myšlenka s postupnými rotacemi zůstává zachována (dokonce i včetně úpravy výsledné hodnoty vynásobením konstantou log(2)):

// výpočet logaritmu algoritmem CORDIC
double log_cordic(double a)
{
    const double three_eigth = 0.375;
    int sk, expo;
    double sum = tabm[0];
    double x = 2.0 * frexpf (a, &expo);
    double ex2 = 1.0; // dvojková mocnina
    int k;
 
    for (k = 0; k < MAXITER; k++) {
        sk = 0;
        // zjistit směr rotace
        if ((x - 1.0) <  (-three_eigth * ex2)) {
            sk = +1;
        }
        if ((x - 1.0) >= (+three_eigth * ex2)) {
            sk = -1;
        }
        ex2 /= 2.0;
        if (sk == 1) { // přímá rotace
            x = x + x * ex2;
            sum = sum - tabp [k];
        }
        if (sk == -1) { // opačná rotace
            x = x - x * ex2;
            sum = sum - tabm [k];
        }
    }
    return expo * K + sum; // přepočet logaritmu
}

Povšimněte si, že tento výpočet závisí na dvojici tabulek tabm a tabp. Jejich obsah je možné vypočítat buď při inicializaci programu, nebo může program obsahovat již předpočtené hodnoty (viz například Problems with CORDIC for Logarithm in C):

// ln(1+2*(-i))
double tabp[MAXITER] =
{
    0.40546510810816,
    0.22314355131421,
    0.11778303565638,
    0.06062462181643,
    0.03077165866675,
    0.01550418653597,
    0.00778214044205,
    0.00389864041566,
    0.00195122013126,
    0.00097608597306,
};
 
// ln(1-2*(-i))
double tabm[MAXITER] =
{
    -0.69314718055995,
    -0.28768207245178,
    -0.13353139262452,
    -0.06453852113757,
    -0.03174869831458,
    -0.01574835696814,
    -0.00784317746103,
    -0.00391389932114,
    -0.00195503483580,
    -0.00097703964783,
};

5. Druhý demonstrační příklad: výpočet přirozeného logaritmu

Úplný zdrojový kód dnešního druhého demonstračního příkladu vypadá následovně:

// --------------------------------------------------------
// Výpočet hodnot funkce log() pomocí iteračního
// algoritmu CORDIC.
// --------------------------------------------------------
 
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
 
// maximální počet iterací při běhu algoritmu
#define MAXITER 10
 
// "zesílení" při rotacích (odpovídá ln(2))
#define K 0.69314718056
 
// ln(1+2*(-i))
double tabp[MAXITER] =
{
    0.40546510810816,
    0.22314355131421,
    0.11778303565638,
    0.06062462181643,
    0.03077165866675,
    0.01550418653597,
    0.00778214044205,
    0.00389864041566,
    0.00195122013126,
    0.00097608597306,
};
 
// ln(1-2*(-i))
double tabm[MAXITER] =
{
    -0.69314718055995,
    -0.28768207245178,
    -0.13353139262452,
    -0.06453852113757,
    -0.03174869831458,
    -0.01574835696814,
    -0.00784317746103,
    -0.00391389932114,
    -0.00195503483580,
    -0.00097703964783,
};
 
// výpočet logaritmu algoritmem CORDIC
double log_cordic(double a)
{
    const double three_eigth = 0.375;
    int sk, expo;
    double sum = tabm[0];
    double x = 2.0 * frexpf (a, &expo);
    double ex2 = 1.0; // dvojková mocnina
    int k;
 
    for (k = 0; k < MAXITER; k++) {
        sk = 0;
        // zjistit směr rotace
        if ((x - 1.0) <  (-three_eigth * ex2)) {
            sk = +1;
        }
        if ((x - 1.0) >= (+three_eigth * ex2)) {
            sk = -1;
        }
        ex2 /= 2.0;
        if (sk == 1) { // přímá rotace
            x = x + x * ex2;
            sum = sum - tabp [k];
        }
        if (sk == -1) { // opačná rotace
            x = x - x * ex2;
            sum = sum - tabm [k];
        }
    }
    return expo * K + sum; // přepočet logaritmu
}
 
 
int main(void) {
    double a = M_E - 2.0; // "pěkná" počáteční hodnota
 
    for (; a<=2.0*M_E; a+=0.1) {
        double log_value = log_cordic(a);
        double log_correct = log(a);
        double log_error = fabs(log_correct - log_value);
        // tisk výsledků
        printf("%5.3f\t%12.10f\t%12.10f\t%8.3f%%\n",
               a,
               log_value,
               log_error,
               (log_value != 0.0) ? 100.0 * log_error / fabs(log_value) : 0.0);
    }
    return 0;
}
 
// finito

6. Výsledky získané předchozím příkladem

Po spuštění demonstračního příkladu uvedeného v předchozí kapitole získáme tabulku se vstupními hodnotami x (v rozsahu od e-2 do 2e), vypočtené přirozené logaritmy vstupních hodnot, absolutní chybu i chybu relativní:

7. Algoritmus CORDIC s hodnotami uloženými ve formátu pevné řádové binární čárky

Hlavním tématem dnešního článku je přepis algoritmu CORDIC do podoby, ve které se již nepoužije matematický koprocesor (a tedy ani datové typy float či double), ale výpočty budou probíhat na běžné celočíselné aritmeticko-logické jednotce.

Před vlastním uvedením implementace algoritmu CORDIC s čísly uloženými ve formátu pevné řádové binární čárky je zapotřebí provést náležitou přípravu, protože formát FX (většinou) není ani mikroprocesory ani překladači podporován. Z tohoto důvodu si v této kapitole pro připomenutí uvedeme všechny základní aritmetické funkce určené pro práci s formátem FX. Jedná se o funkce fx_add(), fx_sub(), fx_mul() a fx_div() (tyto funkce byly podrobněji vysvětleny v předchozím díle). Kromě toho jsou uvedena i těla dalších pomocných funkcí, zejména fx_print() i maker určených pro převod stupňů na radiány a naopak. Pomocí konstant A a B je určen rozsah a přesnost numerických hodnot uložených ve formátu fx – ten je v naší implementaci shodný s třicetidvoubitovým datovým typem signed int, jelikož potřebujeme pracovat jak s kladnými, tak i se zápornými hodnotami.

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
 
/* počet míst před a za binární řádovou tečkou */
#define A 16
#define B 16
 
/* Ludolfovo číslo */
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
 
/* maximální počet iterací při běhu algoritmu */
#define MAX_ITER 16
 
/* "zesílení" při rotacích */
#define K 0.6073
 
/* převody mezi stupni a radiány */
#define rad2deg(rad) ((rad)*180.0/M_PI)
#define deg2rad(deg) ((deg)/180.0*M_PI)
 
/* datový typ, se kterým budeme pracovat */
typedef signed int fx;
 
/* hlavičky použitých funkcí */
void   fx_print(fx x);
fx     fp2fx(double x);
double fx2fp(fx x);
 
/* tabulka arkustangentu úhlů */
fx atans[MAX_ITER];
 
/* tabulka záporných celočíselných mocnin hodnoty 2 */
fx pows[MAX_ITER];
 
/*
 * 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);
}

8. Realizace funkce určené pro naplnění tabulky atans[] (arkustangenty vhodně zvolených úhlů)

Podobně jako při implementaci algoritmu CORDIC pro hodnoty ve formátu FP (tedy s plovoucí řádovou čárkou), i v případě práce s formátem FX je nutné některé hodnoty předpočítat. Opět se jedná o tabulku atans[] obsahující arkustangenty vybraných úhlů. Kromě toho naplníme i tabulku pows[], ve které jsou uloženy záporné mocniny čísla 2. Jak však uvidíme v dalším textu, není v případě FX výpočtů tato tabulka využita a algoritmus CORDIC se z tohoto důvodu poněkud zjednoduší. Funkce pro výpočet obou zmiňovaných tabulek vypadá následovně:

/*
 * Vytvoření tabulky pro výpočet goniometrických
 * funkcí pomocí algoritmu CORDIC
 */
void fx_create_tables(void)
{
    int i;
    for (i=0; i<MAX_ITER; i++) {
        double p=pow(2.0, -i);
        atans[i]=fp2fx(atan(p));
        pows[i]=fp2fx(p);
    }
}

To, zda je tabulka korektně naplněna, je možné otestovat velmi jednoduše:

    /* kontrolní výpis tabulky atans[] */
    for (i=0; i<MAX_ITER; i++)
        printf("%d\t%f\n", i, fx2fp(rad2deg(atans[i])));

Výsledkem běhu předchozího testu je tabulka hodnot arkustangent úhlů (zhruba) odpovídajících FP verzi:

S takto připravenou tabulkou je možné pokračovat v dalších výpočtech.

9. Výpočet goniometrické funkce tan s využitím algoritmu CORDIC: neoptimalizovaná varianta výpočtu

Pravděpodobně nejjednodušším výpočtem, který je možné s využitím algoritmu CORDIC provést, je vyjádření tangenty zadaného úhlu. Nejprve si uvedeme neoptimalizovanou verzi, která vznikla v podstatě přímým převodem minule uvedené implementace určené pro FP reprezentaci (viz jedenáctou kapitolu). Převod spočívá v náhradě aritmetických funkcí za jejich ekvivalenty s pevnou řádovou tečkou:

/* výpočet funkce tan() pro zadaný úhel delta */
// (neoptimalizovaná verze)
fx fx_tan_cordic(fx delta)
{
    int i;
    /* nastavení počátečních podmínek */
    fx x0=fp2fx(1.0);
    fx y0=fp2fx(0.0);
    fx xn;
    if (delta==0) return 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=fx_add(x0, fx_mul(y0, pows[i]));
            y0=fx_sub(y0, fx_mul(x0, pows[i]));
            delta=fx_add(delta, atans[i]);
        }
        else {                              /* úhel je kladný => rotace doprava */
            xn=fx_sub(x0, fx_mul(y0, pows[i]));
            y0=fx_add(y0, fx_mul(x0, pows[i]));
            delta=fx_sub(delta, atans[i]);
        }
        x0=xn;
/*        printf("%i\t%+f\t%+f\t%+f\n", i, fx2fp(x0), fx2fp(y0), fx2fp(delta)); */
    }
    if (x0==0)                              /* ošetření tangenty pravého úhlu */
        if (y0<0) return 0;
        else return 0;
    else
        return fx_div(y0,x0);               /* vrátit výsledek operace */
}

Výše uvedenou funkci fx_tan_cordic si můžeme jednoduchým způsobem otestovat. Postačí použít programovou smyčku, ve které se počítají tangenty úhlů v rozsahu 0°..89° spolu s vyjádřením absolutních a relativních chyb vzniklých použitím algoritmu CORDIC a bitově omezené FP reprezentace:

    /* výpis tabulky tangent úhlů v rozsahu 0..89° */
    for (i=0; i<90; i++) {                  /* výpočetní smyčka */
        delta=deg2rad(i);                   /* převod úhlu na radiány */
        tanfx=fx_tan_cordic(fp2fx(delta));  /* aplikace algoritmu CORDIC */
        tanval=fx2fp(tanfx);                /* výpočet funkce tan */
        tanerr=fabs(tanval-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,
                tanval,
                tan(delta),
                tanerr,
                tanerr==0 ? 0:100.0*tanerr/tan(delta));
    }

10. Celý demonstrační příklad: výpočet funkce tan s využitím algoritmu CORDIC

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
 
/* počet míst před a za binární řádovou tečkou */
#define A 16
#define B 16
 
/* Ludolfovo číslo */
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
 
/* maximální počet iterací při běhu algoritmu */
#define MAX_ITER 16
 
/* "zesílení" při rotacích */
#define K_float 0.6073
 
/* převody mezi stupni a radiány */
#define rad2deg(rad) ((rad) * 180.0 / M_PI)
#define deg2rad(deg) ((deg) / 180.0 * M_PI)
 
/* datový typ, se kterým budeme pracovat */
typedef signed int fx;
 
/* hlavičky použitých funkcí */
void fx_print(fx x);
fx fp2fx(double x);
double fx2fp(fx x);
 
/* tabulka arkustangentu úhlů */
fx atans[MAX_ITER];
 
/* tabulka záporných celočíselných mocnin hodnoty 2 */
fx pows[MAX_ITER];
 
/*
 * 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);
}
 
/*
 * Vytvoření tabulky pro výpočet goniometrických
 * funkcí pomocí algoritmu CORDIC
 */
void fx_create_tables(void)
{
    int i;
    for (i = 0; i < MAX_ITER; i++) {
        double p = pow(2.0, -i);
        atans[i] = fp2fx(atan(p));
        pows[i] = fp2fx(p);
    }
}
 
/* výpočet funkce tan() pro zadaný úhel delta */
/* (neoptimalizovaná verze) */
fx fx_tan_cordic(fx delta)
{
    int i;
    /* nastavení počátečních podmínek */
    fx x0 = fp2fx(1.0);
    fx y0 = fp2fx(0.0);
    fx xn;
    if (delta == 0)
        return 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 = fx_add(x0, fx_mul(y0, pows[i]));
            y0 = fx_sub(y0, fx_mul(x0, pows[i]));
            delta = fx_add(delta, atans[i]);
        } else {                /* úhel je kladný => rotace doprava */
            xn = fx_sub(x0, fx_mul(y0, pows[i]));
            y0 = fx_add(y0, fx_mul(x0, pows[i]));
            delta = fx_sub(delta, atans[i]);
        }
        x0 = xn;
/*        printf("%i\t%+f\t%+f\t%+f\n", i, fx2fp(x0), fx2fp(y0), fx2fp(delta)); */
    }
    if (x0 == 0)                /* ošetření tangenty pravého úhlu */
        if (y0 < 0)
            return 0;
        else
            return 0;
    else
        return fx_div(y0, x0);  /* vrátit výsledek operace */
}
 
 
int main(void)
{
    int i;
    fx tanfx;
    double delta;               /* úhel, ze kterého se funkce počítá */
    double tan_value;           /* absolutní chyby */
    double tan_error;           /* relativní chyby */
 
    fx_create_tables();
 
    /* výpis tabulky tangent úhlů v rozsahu 0..89° */
    for (i=0; i<90; i++) {                     /* výpočetní smyčka */
        delta=deg2rad(i);                      /* převod úhlu na radiány */
        tanfx=fx_tan_cordic(fp2fx(delta));     /* aplikace algoritmu CORDIC */
        tan_value=fx2fp(tanfx);                /* 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:100.0*tan_error/tan(delta));
    }
 
    return 0;
}
 
// finito

11. Výsledky výpočtu funkce tan: absolutní a relativní chyby

V tabulce s výsledky si všimněte, že pro některé úhly je vzniklá chyba rovna až deseti procentům. Je to způsobeno nízkým rozlišením použitého FX formátu, zejména hodnot arctan() těch nejmenších úhlů, a chybu již není možné snížit ani zvýšením počtu iterací (ten je nastaven na hodnotu šestnáct, to odpovídá počtu bitů za binární řádovou čárkou):

12. Výpočet goniometrické funkce tan s využitím algoritmu CORDIC – optimalizovaná varianta výpočtů

V případě, že se nad výše uvedenou funkcí fx_tan_cordic() zamyslíme, pravděpodobně zjistíme, že se v ní zbytečně provádí některé aritmetické operace. Zejména se jedná o průběžné násobení koeficienty uloženými v tabulce pows[]. Tato tabulka měla svůj význam při práci s FP formátem, u formátu FX však ztrácí prakticky všechny své výhody, protože násobení zápornou mocninou čísla 2 je vlastně totožné s bitovým posunem doprava. Optimalizovaná funkce pro výpočet tangenty úhlu algoritmem CORDIC vypadá následovně:

/* výpočet funkce tan() pro zadaný úhel delta */
/* optimalizovaná varianta */
fx fx_tan_cordic_optim(fx delta)
{
    int i;
    /* nastavení počátečních podmínek */
    fx x0=int2fx(1);
    fx y0=0;
    fx xn;
    if (delta==0) return 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=fx_add(x0, y0>>i);           /* místo násobení bitový posuv */
            y0=fx_sub(y0, x0>>i);
            delta=fx_add(delta, atans[i]);
        }
        else {                              /* úhel je kladný => rotace doprava */
            xn=fx_sub(x0, y0>>i);
            y0=fx_add(y0, x0>>i);
            delta=fx_sub(delta, atans[i]);
        }
        x0=xn;
    }
    if (x0==0)                              /* ošetření tangenty pravého úhlu */
        if (y0<0) return 0;
        else return 0;
    else
        return fx_div(y0,x0);               /* vrátit výsledek operace */
}

(Pokud by někdo pocítil potřebu provádět další optimalizace, nabízí se zde použití MMX či lépe SSEx instrukcí s paralelním výpočtem obou alternativních větví). Za povšimnutí stojí fakt, že se v iterační smyčce používají pouze aritmetické operace součtu, rozdílu a bitového posuvu. Kromě toho se i při inicializaci hodnot x0 a y0 používá pouze celočíselná aritmetika, tj. ve výpočtech se vůbec nevyskytuje volání instrukcí matematického koprocesoru. Tato absence složitých a implementačně náročných operací představuje další z důvodů velké oblíbenosti algoritmu CORDIC v komunitě vývojářů pro malé mikrořadiče a mikroprocesory.

13. Celý demonstrační příklad: výpočet funkce tan s využitím algoritmu CORDIC

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
 
/* počet míst před a za binární řádovou tečkou */
#define A 16
#define B 16
 
/* Ludolfovo číslo */
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
 
/* maximální počet iterací při běhu algoritmu */
#define MAX_ITER 16
 
/* "zesílení" při rotacích */
#define K_float 0.6073
 
/* převody mezi stupni a radiány */
#define rad2deg(rad) ((rad) * 180.0 / M_PI)
#define deg2rad(deg) ((deg) / 180.0 * M_PI)
 
/* datový typ, se kterým budeme pracovat */
typedef signed int fx;
 
/* hlavičky použitých funkcí */
void fx_print(fx x);
fx fp2fx(double x);
double fx2fp(fx x);
 
/* tabulka arkustangentu úhlů */
fx atans[MAX_ITER];
 
/* tabulka záporných celočíselných mocnin hodnoty 2 */
fx pows[MAX_ITER];
 
/*
 * 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);
}
 
/*
 * Vytvoření tabulky pro výpočet goniometrických
 * funkcí pomocí algoritmu CORDIC
 */
void fx_create_tables(void)
{
    int i;
    for (i = 0; i < MAX_ITER; i++) {
        double p = pow(2.0, -i);
        atans[i] = fp2fx(atan(p));
        pows[i] = fp2fx(p);
    }
}
 
 
/* výpočet funkce tan() pro zadaný úhel delta */
/* (optimalizovaná verze) */
fx fx_tan_cordic_optim(fx delta)
{
    int i;
    /* nastavení počátečních podmínek */
    fx x0 = int2fx(1);
    fx y0 = 0;
    fx xn;
    if (delta == 0)
        return 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 = fx_add(x0, y0 >> i);   /* místo násobení bitový posuv */
            y0 = fx_sub(y0, x0 >> i);
            delta = fx_add(delta, atans[i]);
        } else {                /* úhel je kladný => rotace doprava */
            xn = fx_sub(x0, y0 >> i);
            y0 = fx_add(y0, x0 >> i);
            delta = fx_sub(delta, atans[i]);
        }
        x0 = xn;
    }
    if (x0 == 0)                /* ošetření tangenty pravého úhlu */
        if (y0 < 0)
            return 0;
        else
            return 0;
    else
        return fx_div(y0, x0);  /* vrátit výsledek operace */
}
 
 
int main(void)
{
    int i;
    fx tanfx;
    double delta;               /* úhel, ze kterého se funkce počítá */
    double tan_value;           /* absolutní chyby */
    double tan_error;           /* relativní chyby */
 
    fx_create_tables();
 
    /* výpis tabulky tangent úhlů v rozsahu 0..89° */
    for (i=0; i<90; i++) {                         /* výpočetní smyčka */
        delta=deg2rad(i);                          /* převod úhlu na radiány */
        tanfx=fx_tan_cordic_optim(fp2fx(delta));   /* aplikace algoritmu CORDIC */
        tan_value=fx2fp(tanfx);                    /* 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:100.0*tan_error/tan(delta));
    }
 
    return 0;
}
 
// finito

14. Výsledky výpočtu funkce tan: absolutní a relativní chyby

V případě, že výše uvedenou funkci fx_tan_cordic_optim() podrobíme stejnému testu, jako funkci fx_tan_cordic(), dostaneme následující (do značné míry podobné) výsledky:

15. Způsob překladu algoritmu CORDIC do assembleru

Zajímavé bude zjistit, jakým způsobem se vlastně funkce fx_tan_cordic_optim přeloží do assembleru, pochopitelně v případě, že jsou povoleny optimalizace. Taktéž zjistíme, jak a kdy jsou pomocné funkce pro provádění FX operací (součet, rozdíl atd.) vkládány do kódu a kdy jsou naopak volány:

Překlad s optimalizacemi na co nejkratší kód:

fx_tan_cordic_optim:
        test    edi, edi
        je      .L21
        mov     edx, edi
        xor     ecx, ecx
        xor     eax, eax
        mov     edi, 65536
.L24:
        mov     r9d, eax
        mov     r8d, edi
        mov     esi, DWORD PTR atans[0+rcx*4]
        sar     r9d, cl
        sar     r8d, cl
        test    edx, edx
        jns     .L22
        add     edi, r9d
        sub     eax, r8d
        add     edx, esi
        jmp     .L23
.L22:
        sub     edi, r9d
        add     eax, r8d
        sub     edx, esi
.L23:
        inc     rcx
        cmp     rcx, 16
        jne     .L24
        test    edi, edi
        je      .L21
        sar     edi, 8
        cdq
        idiv    edi
        sal     eax, 8
        mov     edi, eax
.L21:
        mov     eax, edi
        ret

Překlad s povolením agresivních optimalizací s rozbalením smyčky vede k dlouhému, ovšem velmi rychlému kódu:

fx_tan_cordic_optim:
        xor     eax, eax
        test    edi, edi
        je      .L19
        mov     edx, edi
        js      .L21
        mov     ecx, 65536
        sub     edx, DWORD PTR atans[rip]
        mov     eax, ecx
        sar     eax
        test    edx, edx
        js      .L23
.L58:
        mov     esi, 65536
        add     ecx, 32768
        sub     edx, DWORD PTR atans[rip+4]
        sub     esi, eax
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 2
        sar     eax, 2
        test    edx, edx
        js      .L25
.L59:
        sub     esi, edi
        add     ecx, eax
        sub     edx, DWORD PTR atans[rip+8]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 3
        sar     eax, 3
        test    edx, edx
        js      .L27
.L60:
        sub     esi, edi
        add     ecx, eax
        sub     edx, DWORD PTR atans[rip+12]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 4
        sar     eax, 4
        test    edx, edx
        js      .L29
.L61:
        sub     esi, edi
        add     ecx, eax
        sub     edx, DWORD PTR atans[rip+16]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 5
        sar     eax, 5
        test    edx, edx
        js      .L31
.L62:
        sub     esi, edi
        add     ecx, eax
        sub     edx, DWORD PTR atans[rip+20]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 6
        sar     eax, 6
        test    edx, edx
        js      .L33
.L63:
        sub     esi, edi
        add     ecx, eax
        sub     edx, DWORD PTR atans[rip+24]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 7
        sar     eax, 7
        test    edx, edx
        js      .L35
.L64:
        sub     esi, edi
        add     ecx, eax
        sub     edx, DWORD PTR atans[rip+28]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 8
        sar     eax, 8
        test    edx, edx
        js      .L37
.L65:
        sub     esi, edi
        add     ecx, eax
        sub     edx, DWORD PTR atans[rip+32]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 9
        sar     eax, 9
        test    edx, edx
        js      .L39
.L66:
        sub     esi, edi
        add     ecx, eax
        sub     edx, DWORD PTR atans[rip+36]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 10
        sar     eax, 10
        test    edx, edx
        js      .L41
.L67:
        sub     esi, edi
        add     ecx, eax
        sub     edx, DWORD PTR atans[rip+40]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 11
        sar     eax, 11
        test    edx, edx
        js      .L43
.L68:
        sub     esi, edi
        add     ecx, eax
        sub     edx, DWORD PTR atans[rip+44]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 12
        sar     eax, 12
        test    edx, edx
        js      .L45
.L69:
        sub     esi, edi
        add     ecx, eax
        sub     edx, DWORD PTR atans[rip+48]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 13
        sar     eax, 13
        test    edx, edx
        js      .L47
.L70:
        sub     esi, edi
        add     ecx, eax
        sub     edx, DWORD PTR atans[rip+52]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 14
        sar     eax, 14
        test    edx, edx
        js      .L49
.L71:
        sub     esi, edi
        add     ecx, eax
        sub     edx, DWORD PTR atans[rip+56]
.L50:
        mov     r8d, ecx
        mov     r9d, esi
        mov     eax, esi
        sar     r8d, 15
        sar     r9d, 15
        sub     eax, r8d
        add     r8d, esi
        lea     edi, [r9+rcx]
        test    edx, edx
        cmovs   eax, r8d
        sub     ecx, r9d
        test    edx, edx
        cmovs   edi, ecx
        test    eax, eax
        je      .L19
        sar     eax, 8
        mov     ecx, eax
        mov     eax, edi
        cdq
        idiv    ecx
        sal     eax, 8
.L19:
        ret
.L21:
        mov     ecx, -65536
        add     edx, DWORD PTR atans[rip]
        mov     eax, ecx
        sar     eax
        test    edx, edx
        jns     .L58
.L23:
        lea     esi, [rax+65536]
        sub     ecx, 32768
        add     edx, DWORD PTR atans[rip+4]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 2
        sar     eax, 2
        test    edx, edx
        jns     .L59
.L25:
        add     esi, edi
        sub     ecx, eax
        add     edx, DWORD PTR atans[rip+8]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 3
        sar     eax, 3
        test    edx, edx
        jns     .L60
.L27:
        add     esi, edi
        sub     ecx, eax
        add     edx, DWORD PTR atans[rip+12]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 4
        sar     eax, 4
        test    edx, edx
        jns     .L61
.L29:
        add     esi, edi
        sub     ecx, eax
        add     edx, DWORD PTR atans[rip+16]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 5
        sar     eax, 5
        test    edx, edx
        jns     .L62
.L31:
        add     esi, edi
        sub     ecx, eax
        add     edx, DWORD PTR atans[rip+20]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 6
        sar     eax, 6
        test    edx, edx
        jns     .L63
.L33:
        add     esi, edi
        sub     ecx, eax
        add     edx, DWORD PTR atans[rip+24]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 7
        sar     eax, 7
        test    edx, edx
        jns     .L64
.L35:
        add     esi, edi
        sub     ecx, eax
        add     edx, DWORD PTR atans[rip+28]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 8
        sar     eax, 8
        test    edx, edx
        jns     .L65
.L37:
        add     esi, edi
        sub     ecx, eax
        add     edx, DWORD PTR atans[rip+32]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 9
        sar     eax, 9
        test    edx, edx
        jns     .L66
.L39:
        add     esi, edi
        sub     ecx, eax
        add     edx, DWORD PTR atans[rip+36]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 10
        sar     eax, 10
        test    edx, edx
        jns     .L67
.L41:
        add     esi, edi
        sub     ecx, eax
        add     edx, DWORD PTR atans[rip+40]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 11
        sar     eax, 11
        test    edx, edx
        jns     .L68
.L43:
        add     esi, edi
        sub     ecx, eax
        add     edx, DWORD PTR atans[rip+44]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 12
        sar     eax, 12
        test    edx, edx
        jns     .L69
.L45:
        add     esi, edi
        sub     ecx, eax
        add     edx, DWORD PTR atans[rip+48]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 13
        sar     eax, 13
        test    edx, edx
        jns     .L70
.L47:
        add     esi, edi
        sub     ecx, eax
        add     edx, DWORD PTR atans[rip+52]
        mov     edi, ecx
        mov     eax, esi
        sar     edi, 14
        sar     eax, 14
        test    edx, edx
        jns     .L71
.L49:
        add     esi, edi
        sub     ecx, eax
        add     edx, DWORD PTR atans[rip+56]
        jmp     .L50

Opět si povšimněte, že každé rozbalené tělo smyčky obsahuje jen základní aritmetické operace a posuny.

16. Výpočet goniometrické funkce sin

Výpočet goniometrické funkce sin() pomocí algoritmu CORDIC je při použití formátu pevné řádové binární čárky velmi snadný a současně i přímočarý. Dokonce je možné říci, že výpočet je oproti verzi používající plovoucí řádovou čárku jednodušší, a to z toho důvodu, že se místo pomocné tabulky s druhými mocninami čísla dvě přímo používá operace pro aritmetický posuv doprava (ten je podporován přímo centrální procesorovou jednotkou, jedná se tedy o znatelné zrychlení celého výpočtu). Při implementaci algoritmu CORDIC v programovacím jazyku C může funkce pro výpočet sinu vypadat následovně (připomeňme si, že výsledek je uložen v y-ové složce orotovaného vektoru r):

/* výpočet funkce sin() pro zadaný úhel delta */
fx fx_sin_cordic_optim(fx delta)
{
    int i;
    static fx K_fx=(fx)(K_float*(2<<(B-1)));
    /* nastavení počátečních podmínek */
    fx x0=int2fx(1);
    fx y0=0;
    fx xn;
    for (i=0; i<MAX_ITER; i++) {            /* iterační smyčka */
        if (delta<0) {                      /* úhel je záporný => rotace doleva */
            xn=fx_add(x0, y0>>i);           /* místo násobení bitový posuv */
            y0=fx_sub(y0, x0>>i);
            delta=fx_add(delta, atans[i]);
        }
        else {                              /* úhel je kladný => rotace doprava */
            xn=fx_sub(x0, y0>>i);
            y0=fx_add(y0, x0>>i);
            delta=fx_sub(delta, atans[i]);
        }
        x0=xn;
    }
    return fx_mul(y0, K_fx);                /* opravit "zesílení" výsledku */
}

17. Výsledky výpočtu funkce sin: absolutní a relativní chyby, statistiky

Výše uvedenou céčkovskou funkci fx_sin_cordic_optim() si můžeme otestovat na výpočtu úhlů ležících v prvním kvadrantu, tj. od 0° do 90°. Kromě vypočtených hodnot je u každého úhlu uvedena i hodnota vypočtená pomocí FPU, dále pak absolutní a relativní chyba. Tučně jsou zvýrazněny ty relativní chyby, které jsou menší než jedno procento:

Statistické vlastnosti výpočtu

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

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