CORDIC

A CORDIC („coordinate rotation digital computer”), más néven Volder-algoritmus vagy számjegyenkénti módszer, cirkuláris CORDIC (Jack E. Volder), lineáris CORDIC, hiperbolikus CORDIC (John Stephen Walther) és általánosított hiperbolikus CORDIC (GH CORDIC) (Yuanyong Luo et al.), egyszerű, hatékony módszer trigonometriai, hiperbolikus függvények, négyzetgyökök, szorzások, osztások, valamint tetszőleges alapú exponenciális függvények és logaritmusok számítására, mely jellemzően alkalmanként 1 számjeggyel nagyobb pontosságot ad, így a CORDIC egy számjegyenként haladó algoritmus. A CORDIS és hasonló álszorzás-, álosztás- vagy tényezőkombinációs módszerek általában elérhető hardveres szorzó nélkül (például egyszerű mikrokontrollerekben és FPGA-kban) használatos, mivel hozzá csak öszeadás, kivonás, bitenkénti eltolás és keresési táblák kellenek. Így ez egy eltoló-összeadó művelet. A CORDIC-ot gyakran használják lebegőpontos számábrázoláshoz, ha a célplatform korlátozott költség vagy tárhely miatt nem rendelkezik hardveres szorzóval.

Története

Hasonló módszereket írt le Henry Briggs 1624-ben és Robert Flower 1771-ben, de a CORDIC alacsony komplexitású processzorokra optimalizált.

A CORDIC-ot 1956-ban fogalmazta meg Jack E Volder a Convair aeroelektronikai részlegénél a B–58 navigációs számítógépének analóg feloldójának cseréjére egy pontosabb, gyorsabb valós idejű digitális megoldásra. Így a CORDIC-ot nvezik néha digitális feloldónak.

Volder kutatását a CRC Handbook of Chemistry and Physics 1946-os kiadásában szereplő alábbi képlet inspirálta:

${\begin{aligned}K_{n}R\sin(\theta \pm \varphi )&=R\sin(\theta )\pm 2^{-n}R\cos(\theta ),\\K_{n}R\cos(\theta \pm \varphi )&=R\cos(\theta )\mp 2^{-n}R\sin(\theta ),\\\end{aligned}}$

ahol $\varphi$ értéke úgy van megválasztva, hogy ${\text{tg}}\ \varphi =2^{-n}$, és $K_{n}:={\sqrt {1+2^{-2n}}}$.

Kutatása egy belső technikai jelentéshez vezetett, melyben a CORDIC algoritmust javasolták szinusz- és koszinuszfüggvények megoldására, valamint egy vele rendelkező kezdeti számítógépet. Itt a hiperbolikus forgatás, logaritmusok és exponenciális függvények számításának módosított CORDIC algoritmusokkal való megoldásáról is szó volt. A CORDIC szorzásra és osztásra való használatát is ekkor fogalmazták meg. A CORDIC elvein alapulva Dan H. Daggett, Volder munkatársa a bináris és a binárisan kódolt decimális (BCD) közti átváltási algoritmusokat javasolt.

1958-ban a Convair elkezdte egy bemutató rendszer építését radarrögzítést igénylő problémák megoldására, melynek neve CORDIC I volt, melyet 1960-ban Volder nélkül fejeztek be, aki elhagyta a társaságot. A több célra használható CORDIC II A (stacionárius) és B (repülő) modelleket Daggett és Harry Schuss készítették el és építették 1962-ben.

Volder CORDIC algoritmusát nyilvánosan 1959-ben írták le, emiatt többek közt a Martin Orlando, a Computer Control, a Litton, a Kearfott, a Lear-Siegler, a Sperry, a Raytheon és a Collins Radio navigációs számítógépeibe is ez került.

Volder Malcolm McMillannel együtt kívánta megépíteni az Athenát, mely egy bináris CORDIC algoritmust használó fixpontos számológép lett volna. A terveket a Hewlett-Packardnak mutatták be 1965 júniusában, de nem fogadták el. Azonban McMillan David S. Cochrannek (HP) bemutatta Volder algoritmusát, és mikor Cochran később Volderrel találkozott, egy hasonló módszert mutatott be, melyet John E. Meggitt (IBM) javasolt álszorzásnak és álosztásnak nevezve 1961-ben. Meggitt módszere a 10-es alap használatát javasolta a 2-es helyett, melyet Volder CORDIC-ja használt. Ez egy decimális CORDIC-prototípus 1966-os ROM-olható logikai implementációjának az előzménye volt a Hewlett-Packardnál, mely Thomas Osborne prototipikus Green Machine-jéből származik, mely négyfunkciós, lebegőpontos számológép, melyet DTL logikával alkotott meg 1964 decemberében. Ez a Hewlett Packard első tudományos funkciókkal rendelkező számológépének, az 1968. márciusi HP 9100A-nak az előzménye volt, melynek ugyanez évben kezdődött a sorozatgyártása.

Mikor a Wang Laboratories felfedezte, hogy a HP 9100A hasonló módszert használt, mint a korábbi LOCI–1 (1964. szeptember) és LOCI–2 (1965. január) Logarithmic Computing Instrument számológép, sikertelenül vádolták a Hewlett-Packardot An Wang szabadalmának sértéséért 1968-ban.

John Stephen Walther, a Hewlett-Packard dolgozója az algoritmust általánosította egy „egységes CORDIC” algoritmussá 1971-ben, lehetővé téve hiperbolikus és exponenciális függvények, logaritmusok, szorzások, osztások és négyzetgyökök számítását. A trigonometriai és hiperbolikus függvények CORDIC-programrészeinek kódja nagyrészt közös lehet. Ezután 1972-ben megjelent az első tudományos hordozható számológép, a HP-35. A hiperbolikus CORDIC-on alapulva Yuanyong Luo és társai javasolták az általános hiperbolikus CORDIC (GH CORDIC) használatát tetszőleges alapú logaritmusok és exponenciális függvényekhez 2019-ben. Elvileg a hiperbolikus CORDIC a GH CORDIC speciális esete.

Eredetileg a CORDIC-ot csak bináris számrendszerben alkották meg, és bár Meggitt javasolta a decimális rendszer használatát az álszorzáshoz, a decimális CORDIC iránt kevés érdeklődés volt néhány további évig, így Hermann Schmid és Anthony Bogacki még 1973-ban is újdonságként tekintettek rá, és csak később derült ki, hogy a Hewlett-Packard már 1966-ban létrehozta.

A decimális CORDIC a hordozható számológépekben gyakori, melyek nagy része binárisan kódolt decimális számrendszert használ a bináris helyett. E be- és kimeneti változás nem változtatja meg a CORDIC alap számítási algoritmusait. A CORDIC jól használható hordozható számológépekben, ahol az alacsony költség – így a kevés kapu – fontosabb a sebességnél.

A CORDIC-ot használja az ARM-alapú STM32G4, az Intel 8087, a 80287, az 80387 és a 80486 koprocesszor-sorozat, továbbá a Motorola 68881 és a 68882 bizonyos lebegőpontos utasításokhoz, különösképp az FPU alrendszer kapuszámának és összetettségének csökkentésére.

Alkalmazások

A CORDIC eltolást és összeadást használ bizonyos számításokhoz, például trigonometriai, hiperbolikus és logaritmikus függvényekhez, valós és komplex szorzásokhoz, osztáshoz, négyzetgyökszámításhoz, lineáris rendszerek megoldásához, sajátértékbecsléshez, szinguláris értékek felbontásához, QR-felbontáshoz stb. Így a CORDIC többek közt jel-, kép-, robotikában és 3D-grafikában is használatos általános tudományos és technikai számításokon kívül.

Hardver

Az algoritmus az Apollo-program holdjárójában is használatos volt az azimut és a holdmodultól való távolság számításához. A CORDIC az Intel 8087 matematikai koprocesszorban (1980) is használatos volt, így nem kellett hardveres szorzás.

A CORDIC általában gyorsabb más módszereknél hardveres szorzó nélküli rendszerekben (például mikrokontrollerekben) vagy ha a támogatott funkciókhoz szükséges kapuk száma minimalizálandó (például FPGA-ban vagy ASIC-ben). A CORDIC gyakori az FPGA-fejlesztésben, például a Xilinx Vivadójában, míg egy hatványsoros változat nem a specificitása miatt, vagyis a CORDIC számos különböző függvényt képes kiszámítani (általános célú), míg egy hatványsorokat végző hardveres szorzó csak a függvényt tudja számítani, melyre tervezték.

Az STM32G4 sorozat, valamint az STM32H7 MCU-sorozat néhány tagjában CORDIC-modul van, melyek néhány vegyes jeles alkalmazást gyorsítanak, például a felhasználói felület grafikáját és a vektorirányítást. Bár nem oly gyors, mint egy hatványsoros közelítés, a CORDIC gyorsabb a táblázatalapú implementációk, például az ARM CMSIS vagy a C szabványkönyvtárak interpolációjánál. Bár az eredmények kissé pontatlanabbak lehetnek, ugyanis a CORDIC-modulokban csak 20 bit pontosság érhető el az eredményben. Például az ARM-hoz képest lévő teljesítménykülönbség nagy részét a teljes lebegőpontos pontosság (24 bit) interpolációs algoritmus költségei okozzák, melyhez viszonyított relatív hiba érhető el. További előny, hogy a CORDIC modul koprocesszor, így más processzorfeladatokkal párhuzamosan futhat.

A Taylor-sorok hátránya, hogy bár abszolút hibájuk kicsi, a relatív hiba nem viselkedik egyszerűen. Más polinomiális megközelítések, például a minimax közelítőalgoritmus mindkét hiba korlátozására megfelelők.

Szoftver

Számos, csak egész számokat kezelő processzorú rendszer a CORDIC-ot használja bizonyos mértékig a lebegőpontos számábrázoláshoz való könyvtárakhoz. Mivel a legtöbb modern, általános célú processzorban van lebegőpontos regiszter gyakori műveletekkel, például összeadással, kivonással, szorzással, osztással, szinusszal, koszinusszal, négyzetgyökkel, 10-es alapú és természetes logaritmussal, a CORDIC implementáció szinte fölösleges. Csak mikrokontrollerekben és speciális biztonsági és időkorlátos szoftverek esetén használatos gyakran a CORDIC.

Módszerek

Forgatásos módszer

A CORDIC számos különböző függvény számítására használható. E magyarázat megmutatja a CORDIC rotációs módú használatát egy szög szinuszának és koszinuszának számításához, feltéve, hogy a szög radiánban van megadva, és formátumban. Egy $\beta$ szög szinuszának vagy koszinuszának megadásához az adott szögnek megfelelő pont y vagy x koordinátája kell. CORDIC esetén a $v_{0}$ vektorból indulunk ki:

$v_{0}={\begin{bmatrix}1\\0\end{bmatrix}}.$

Folyamatban lévő CORDIC algoritmus illusztrációja

Az első lépés ennek 45°-kal való elfordítása, mely a $v_{1}$ vektort adja meg. A további iterációk az egyik vagy a másik irányba forgatják a vektort egyre kisebb lépésekkel a kívánt szög eléréséig. A szögek értékei $\gamma _{i}={\text{arctg}}\ 2^{-i}$, ahol $i=0,1,2,\dots$.

Formálisabban minden iteráció egy fordítást számít ki, mely a $v_{i}\ R_{i}$ forgatási mátrixszal való szorzását jelenti:

$v_{i+1}=R_{i}v_{i}.$

A forgatási mátrixot az alábbi képlet adja meg:

$R_{i}={\begin{bmatrix}\cos(\gamma _{i})&-\sin(\gamma _{i})\\\sin(\gamma _{i})&\cos(\gamma _{i})\end{bmatrix}}.$

Az alábbi két trigonometriai azonosság felhasználásával:

${\begin{aligned}\cos(\gamma _{i})&={\frac {1}{\sqrt {1+\tan ^{2}(\gamma _{i})}}},\\\sin(\gamma _{i})&={\frac {\tan(\gamma _{i})}{\sqrt {1+\tan ^{2}(\gamma _{i})}}},\end{aligned}}$

a forgatási mátrix ez lesz:

$R_{i}={\frac {1}{\sqrt {1+\tan ^{2}(\gamma _{i})}}}{\begin{bmatrix}1&-\tan(\gamma _{i})\\\tan(\gamma _{i})&1\end{bmatrix}}.$

Az elfordított vektor ($v_{i+1}=R_{i}v_{i}$) képlete:

${\begin{bmatrix}x_{i+1}\\y_{i+1}\end{bmatrix}}={\frac {1}{\sqrt {1+\tan ^{2}(\gamma _{i})}}}{\begin{bmatrix}1&-\tan(\gamma _{i})\\\tan(\gamma _{i})&1\end{bmatrix}}{\begin{bmatrix}x_{i}\\y_{i}\end{bmatrix}},$

ahol $x_{i}$ és $y_{i}$ $v_{i}$ koordinátái. A $\gamma _{i}$ szögek korlátozása ${\text{tg}}\gamma _{i}=\pm 2^{-i}$ értékekre a tangenssel való szorzás cserélhető a kettő hatványával való osztásra, mely egy bitekkel való eltolás. A kifejezés ezzé válik:

${\begin{bmatrix}x_{i+1}\\y_{i+1}\end{bmatrix}}=K_{i}{\begin{bmatrix}1&-\sigma _{i}2^{-i}\\\sigma _{i}2^{-i}&1\end{bmatrix}}{\begin{bmatrix}x_{i}\\y_{i}\end{bmatrix}},$

ahol

$K_{i}={\frac {1}{\sqrt {1+2^{-2i}}}},$

és a $\sigma _{i}$ határozza meg a forgatás szögét: ha $\gamma _{i}$ pozitív, $\sigma _{i}$ +1, ellenkező esetben –1.

Minden $K_{i}$ tényező elhagyható az iterációs folyamatban, majd mind egyszerre alkalmazható $K(n)$ mérettényezővel.

$K(n)=\prod _{i=0}^{n-1}K_{i}=\prod _{i=0}^{n-1}{\frac {1}{\sqrt {1+2^{-2i}}}},$

melyet előre kiszámít és táblázatban vagy konstansként tárol fix számú iteráció esetén. Ez a javítás megtehető előre is a $v_{0}$ méretezésével, mely eggyel csökkenti a szorzások számát. Ezenkívül megjegyezhető, hogy

$K=\lim _{n\to \infty }K(n)\approx 0{,}6072529350088812561694,$

mely lehetővé teszi az algoritmus összetételének további csökkentését. Egyes esetekben nincs korrekció $K$-ra, így $A$ mértékű értéknövekedést okozva:

$A={\frac {1}{K}}=\lim _{n\to \infty }\prod _{i=0}^{n-1}{\sqrt {1+2^{-2i}}}\approx 1{,}64676025812107.$

Elegendően sok iteráció után a vektor szöge közel lesz a kívánt $\beta$ szöghöz. A legtöbb általános célhoz 40 iteráció ($n=40$) elegendő a helyes eredményhez 10 tizedesjegyig.

Ezután az egyetlen megmaradt feladat, hogy a forgatásnak minden iterációban pozitív vagy negatív irányba kell történnie ($\sigma$ értékének választása), mely az egyes iterációkban történő elfordulás számításával és annak a kívánt szögből való kivonásával, majd a szükséges $\beta$ szöghöz való közelítéssel tehető meg: ha $\beta _{n+1}$ pozitív, negatív irányba történik a forgatás, ellenkező esetben pozitívba:

$\beta _{0}=\beta$

$\beta _{i+1}=\beta _{i}-\sigma _{i}\gamma _{i},\quad \gamma _{i}=\arctan(2^{-i}).$

$\gamma _{n}$ értékeit előre kell számítani és tárolni, azonban kis szögek esetén ${\text{arctg}}\ \gamma _{n}=\gamma _{n}$ fixpontos jelölésben, csökkentve a táblázatméretet.

Ahogy a fenti illusztrációban is látható, $\sin \beta$ a végső $v_{n}$ vektor y koordinátája, míg az x koordináta $\cos \beta$.

Vektormódszer

A fent leírt forgatásos algoritmus bármilyen vektort el tud forgatni bármilyen –90 és +90° közti szöggel. A forgatás iránya függ $\beta _{i}$ előjelétől.

A vektoros művelet az algoritmus kis módosítását igényli. Egy vektorral kezdődik, melynek x koordinátája pozitív, y koordinátája tetszőleges. Az egymást követő forgatások célja a vektor x tengelyre való forgatása (azaz az y koordináta 0-ra módosítása). Minden lépésben y értéke meghatározza a forgatás irányát. $\beta _{i}$ végső értéke a teljes forgásszög, x végső értéke az eredeti vektor nagysága K-val méretezve. A vektormódszer hasznos Descartes-koordinátákról polárkoordinátákra váltáshoz.

Megvalósítások

Szoftveres példa (MATLAB)

Alább a CORDIC egy MATLAB/GNU Octave-megvalósítása látható, mely nem függ transzcendens függvényektől, kivéve táblázatok előszámításában. Ha az iterációk száma előre meg van határozva, a második táblázat konstansra cserélhető. A MATLAB dupla pontosságával és a format long kimenetével az eredmények pontossága nagyjából 48 iterációig nő.

function v = cordic(alpha,iteration)
% This function computes v = [cos(alpha), sin(alpha)] (alpha in radians)
% using iteration increasing iteration value will increase the precision.

if alpha < -pi/2 || alpha > pi/2
    if alpha < 0
        v = cordic(alpha + pi, iteration);
    else
        v = cordic(alpha - pi, iteration);
    end
end

% Initialization of tables of constants used by CORDIC
% need a table of arctangents of negative powers of two, in radians:
% angles = atan(2.^-(0:27));
angles =  [  ...
    0.78539816339745   0.46364760900081   0.24497866312686   0.12435499454676 ...
    0.06241880999596   0.03123983343027   0.01562372862048   0.00781234106010 ...
    0.00390623013197   0.00195312251648   0.00097656218956   0.00048828121119 ...
    0.00024414062015   0.00012207031189   0.00006103515617   0.00003051757812 ...
    0.00001525878906   0.00000762939453   0.00000381469727   0.00000190734863 ...
    0.00000095367432   0.00000047683716   0.00000023841858   0.00000011920929 ...
    0.00000005960464   0.00000002980232   0.00000001490116   0.00000000745058 ];
% and a table of products of reciprocal lengths of vectors [1, 2^-2j]:
% Kvalues = cumprod(1./sqrt(1 + 1j*2.^(-(0:23))))
Kvalues = [ ...
    0.70710678118655   0.63245553203368   0.61357199107790   0.60883391251775 ...
    0.60764825625617   0.60735177014130   0.60727764409353   0.60725911229889 ...
    0.60725447933256   0.60725332108988   0.60725303152913   0.60725295913894 ...
    0.60725294104140   0.60725293651701   0.60725293538591   0.60725293510314 ...
    0.60725293503245   0.60725293501477   0.60725293501035   0.60725293500925 ...
    0.60725293500897   0.60725293500890   0.60725293500889   0.60725293500888 ];
Kn = Kvalues(min(iteration, length(Kvalues)));

% Initialize loop variables:
v = [1;0]; % start with 2-vector cosine and sine of zero
poweroftwo = 1;
angle = angles(1);

% Iterations
for j = 0:iteration-1;
    if alpha < 0
        sigma = -1;
    else
        sigma = 1;
    end
    factor = sigma * poweroftwo;
    % Note the matrix multiplication can be done using scaling by powers of two and addition subtraction
    R = [1, -factor; factor, 1];
    v = R * v; % 2-by-2 matrix multiply
    alpha = alpha - sigma * angle; % update the remaining angle
    poweroftwo = poweroftwo / 2;
    % update the angle from table, or eventually by just dividing by two
    if j+2 > length(angles)
        angle = angle / 2;
    else
        angle = angles(j+2);
    end
end

% Adjust length of output vector to be [cos(alpha), sin(alpha)]:
v = v * Kn;
return

endfunction

A kétszer kettes mátrixok szorzása egyszerű eltolásokkal és összeadásokkal végezhető el.

    x = v[0] - sigma * (v[1] * 2^(-j));
    y = sigma * (v[0] * 2^(-j)) + v[1];
    v = [x;y];

Javában a Math osztályban van egy ilyen eltolást végző scalb(double x,int scale) metódus, C-ben van ldexp függvény, az x86 processzorosztályban pedig van fscale lebegőpontos művelet.

Példa Pythonban

from math import atan2, sqrt, sin, cos, pi, radians

ITERS = 16
theta_table = [atan2(1, 2**i) for i in range(ITERS)]

def compute_K(n):
    """
    Compute K(n) for n = ITERS. This could also be
    stored as an explicit constant if ITERS above is fixed.
    """
    k = 1.0
    for i in range(n):
        k *= 1 / sqrt(1 + 2 ** (-2 * i))
    return k

def CORDIC(alpha, n):
    K_n = compute_K(n)
    theta = 0.0
    x = 1.0
    y = 0.0
    P2i = 1  # This will be 2**(-i) in the loop below
    for arc_tangent in theta_table:
        sigma = +1 if theta < alpha else -1
        theta += sigma * arc_tangent
        x, y = x - sigma * y * P2i, sigma * P2i * x + y
        P2i /= 2
    return x * K_n, y * K_n

if __name__ == "__main__":
    # Print a table of computed sines and cosines, from -90° to +90°, in steps of 15°,
    # comparing against the available math routines.
    print("  x       sin(x)     diff. sine     cos(x)    diff. cosine ")
    for x in range(-90, 91, 15):
        cos_x, sin_x = CORDIC(radians(x), ITERS)
        print(
            f"{x:+05.1f}°  {sin_x:+.8f} ({sin_x-sin(radians(x)):+.8f}) {cos_x:+.8f} ({cos_x-cos(radians(x)):+.8f})"
        )

Kimenet

$ python cordic.py
  x       sin(x)     diff. sine     cos(x)    diff. cosine
-90.0°  -1.00000000 (+0.00000000) -0.00001759 (-0.00001759)
-75.0°  -0.96592181 (+0.00000402) +0.25883404 (+0.00001499)
-60.0°  -0.86601812 (+0.00000729) +0.50001262 (+0.00001262)
-45.0°  -0.70711776 (-0.00001098) +0.70709580 (-0.00001098)
-30.0°  -0.50001262 (-0.00001262) +0.86601812 (-0.00000729)
-15.0°  -0.25883404 (-0.00001499) +0.96592181 (-0.00000402)
+00.0°  +0.00001759 (+0.00001759) +1.00000000 (-0.00000000)
+15.0°  +0.25883404 (+0.00001499) +0.96592181 (-0.00000402)
+30.0°  +0.50001262 (+0.00001262) +0.86601812 (-0.00000729)
+45.0°  +0.70709580 (-0.00001098) +0.70711776 (+0.00001098)
+60.0°  +0.86601812 (-0.00000729) +0.50001262 (+0.00001262)
+75.0°  +0.96592181 (-0.00000402) +0.25883404 (+0.00001499)
+90.0°  +1.00000000 (-0.00000000) -0.00001759 (-0.00001759)

Hardveres példa

A logikai kapuk száma a CORDIC-hoz nagyjából egy szorzóéhoz hasonló, mivel mindkettőben összeadás és eltolás szükséges. A szorzó- vagy CORDIC-alapú megvalósítás választása kontextusfüggő. Két valós és képzetes rész (Descartes-koordináták) által meghatározott komplex szám szorzása 4 szorzást igényel, de a polárkoordináták által meghatározott komplex számoké elvégezhető CORDIC-kal is, különösen ha a számok nagyságrendje nem számít (egy komplex vektor egységkörön lévő vektorral való szorzása forgatást eredményez). A CORDIC-ot gyakran használják telekommunikációs áramkörökben, például digitális lekonvertálókban.

Dupla iterációs CORDIC

Vlagyimir Bajkov két publikációjában javasolta a dupla iterációs módszert az árkusz szinusz, az árkusz koszinusz, a természetes logaritmus, az exponenciális és a hiperbolikus függvények számítására. A dupla iterációs módszer, szemben a klasszikus CORDIC módszerrel, ahol az iterációs lépésszám mindig változik, a dupla iterációs módszerben az iteráció sorszáma kétszer ismétlődik, egyszer változik. Így az iterációk sorszámai: $i=0,0,1,1,2,2\dots$, szemben az egyszerű ismétléssel, ahol $i=0,1,2$. A dupla iterációs módszer biztosítja a módszer konvergenciáját az argumentumok változásának érvényes tartományában.

A CORDIC konvergenciaproblémák tetszőleges $R$ alapú helyiértékes számrendszerre való általánosítása megmutatta, hogy a szinusz, koszinusz, árkusz tangens esetén elég $R-1$ iteráció minden i értékre, vagyis az eredmény minden számjegyére. A természetes logaritmus, exponenciális, szinusz, koszinusz és área tangens hiperbolikusz esetén $R$ iteráció kell minden i-re, illetve két $R-1$ minden számjegyre, vagyis i minden értékére.

Az área szinusz és koszinusz hiperbolikusz esetén az iterációszám $2R$ minden i, vagyis minden számjegy esetén.

Kapcsolódó algoritmusok

A CORDIC eltoló-összeadó algoritmus, ahogy a logaritmus- és exponenciálisfüggvény-számító algoritmus, melyek Henry Briggs művében szerepelnek. További, sok elemi függvény számítására használható algoritmus a BKM algoritmus, mely a logaritmust és az exponenciális függvényt általánosítja a komplex síkba. Például a BKM felhasználható valós x radiános szög szinuszának és koszinuszának számításra $e^{ix}$ számításával, mely $\cos x+i\sin x$. A BKM algoritmus kissé összetettebb a CORDIC-nál, de nem kell hozzá a K mérettényező.

Források

• (1966. szeptember 5.) „DIVIC Gives Answer to Complex Navigation Questions”. Electronics, 105–111. o. ISSN 0013-5070.   (NB. A DIVIC jelentése DIgital Variable Increments Computer. Egyes források tévesen J. M. Parininek nevezik a szerzőt.)
• (1965. november 1.) „The IBM System/360 Model 91: Floating-Point Execution Unit”. IBM Journal of Research and Development, Riverton, New Jersey, USA 11 (1), 34–53. o. [2016. március 5-i dátummal az eredetiből archiválva]. DOI:10.1147/rd.111.0034. (Hozzáférés: 2023. július 31.)  
• An Interconnect Processor with Emphasis on CORDIC Mode Operation. Berkeley, CA, USA: University of California, Berkeley, Department of Electrical Engineering (1968. szeptember 1.). OCLC 500565168 
• U.S. Patent 3576983A ([14])
• (1972. július 1.) „Automatic Computation of Exponentials, Logarithms, Ratios, and Square Roots”. IBM Journal of Research and Development 16 (4), 380–388. o. [2016. augusztus 12-i dátummal az eredetiből archiválva]. DOI:10.1147/rd.164.0380. ISSN 0018-8646. (Hozzáférés: 2023. július 31.)  
• (1977. május 1.) „Personal Calculator Algorithms I: Square Roots”. Hewlett-Packard Journal, Palo Alto, California, USA 28 (9), 22–24. o, Kiadó: Hewlett-Packard. [2015. december 18-i dátummal az eredetiből archiválva]. (Hozzáférés: 2023. július 31.)   ([15])
• (1977. június 1.) „Personal Calculator Algorithms II: Trigonometric Functions”. Hewlett-Packard Journal, Palo Alto, California, USA 28 (10), 17–20. o, Kiadó: Hewlett-Packard. [2016. március 4-i dátummal az eredetiből archiválva]. (Hozzáférés: 2023. július 31.)   ([16])
• (1977. november 1.) „Personal Calculator Algorithms III: Inverse Trigonometric Functions”. Hewlett-Packard Journal, Palo Alto, California, USA 29 (3), 22–23. o, Kiadó: Hewlett-Packard. [2016. március 4-i dátummal az eredetiből archiválva]. (Hozzáférés: 2023. július 31.)   ([17])
• (1978. április 1.) „Personal Calculator Algorithms IV: Logarithmic Functions”. Hewlett-Packard Journal, Palo Alto, California, USA 29 (8), 29–32. o, Kiadó: Hewlett-Packard. [2016. március 4-i dátummal az eredetiből archiválva]. (Hozzáférés: 2023. július 31.)   ([18])
• (1975. április 25.) „Calculator Algorithms”. IEEE Compcon Reader Digest, 139–141. o, Kiadó: IEEE. IEEE Catalog No. 75 CH 0920-9C.  
• {{{title}}} (orosz nyelven). Leningrad State University of Electrical Engineering (1972. április 25.) 
• Apparaturnaja realizatsija elementarnikh funktsij v CVM (orosz nyelven). Leningrad State University (1975. április 25.) 
• {{{title}}} (orosz nyelven). Moscow: Radio i svjaz (Радио и связь) (1982. április 25.) 
• {{{title}}} (orosz nyelven). Moscow: Radio i svjaz (Радио и связь) (1985. április 25.) 
• (1980. január 1.) „CORDIC constants in TI 58/59 ROM”. Texas Instruments Software Exchange Newsletter, Kapellen, Belgium 2 (2), Kiadó: TISOFT.  
• (April–June 1980) „Natural logarithm computation scheme / e^x computing scheme / 1/x computing scheme”. Texas Instruments Software Exchange Newsletter, Kapellen, Belgium 2 (3), Kiadó: TISOFT.   (about CORDIC in TI-58/TI-59)
• TI Graphic Products Team. „Transcendental function algorithms”, Texas Instruments, Consumer Products, 1995. április 25.. [2016. március 17-i dátummal az eredetiből archiválva] (Hozzáférés: 2019. március 2.) 
• Arithmetische Algorithmen der Mikrorechentechnik, 1 (német nyelven), Berlin, Germany: VEB Verlag Technik, 219, 261, 271–296. o.. Sablon:EAN. MPN 5539165. License 201.370/4/89 (1989. április 25.). ISBN 3341005153 
• Solving Kepler's equation with CORDIC double iterations. Göttingen, Germany: Institut für Astrophysik, Georg-August-Universität, 109–117. o.. DOI: 10.1093/mnras/staa2441 (2021) 
• Digital Signal Processing in Communication Systems, 1 (1994. április 25.) 
• (1996. április 25.) „On hardware for computing exponential and trigonometric functions”. IEEE Transactions on Computers 45 (3), 328–339. o. DOI:10.1109/12.485571.  
• 6.5 Sine and Cosine Functions, Low Power and Low Complexity Shift-and-Add Based Computations, 1, Linköping Studies in Science and Technology, Department of Electrical Engineering, Linköping University, 244–250. o.. No. 1201 (2008. április 25.). ISBN 978-91-7393-836-5  (x+268 pages)
• (2001. április 25.) „FPGA realization of a CORDIC based FFT processor for biomedical signal processing”. Microprocessors and Microsystems, Kharagpur, West Bengal, India 25 (3), 131–142. o. DOI:10.1016/S0141-9331(01)00106-5.  
• Pseudo-Division Algorithms for Floating-Point Logarithms and Exponentials. University of California, 2002. május 20. [2015. december 25-i dátummal az eredetiből archiválva]. (Hozzáférés: 2016. január 15.)
• Implementation of a CORDIC Algorithm in a Digital Down-Converter, 2008
• (2009. október 6.) „CORDIC Architectures: A Survey”. VLSI Design, Kharagpur, West Bengal, India 2010, 1–19. o, Kiadó: Department of Electronics and Electrical Communication Engineering, Indian Institute of Technology. DOI:10.1155/2010/794891. 794891.  
• Advanced Arithmetic Techniques. quadibloc, 2018 [2018. július 3-i dátummal az eredetiből archiválva]. (Hozzáférés: 2018. július 16.)

További információk

• CORDIC Bibliography Site, 2011. július 1.
• Soft CORDIC IP (verilog HDL code)
• CORDIC Bibliography Site
• BASIC Stamp, CORDIC math implementation
• CORDIC implementation in verilog
• CORDIC Vectoring with Arbitrary Target Value
• PicBasic Pro, Pic18 CORDIC math implementation
• Python CORDIC implementation
• Simple C code for fixed-point CORDIC
• Tutorial and MATLAB Implementation – Using CORDIC to Estimate Phase of a Complex Number
• Descriptions of hardware CORDICs in Arx with testbenches in C++ and VHDL
• An Introduction to the CORDIC algorithm
• 50-th Anniversary of the CORDIC Algorithm
• CORDIC-implementációk: fixed point C code for trigonometric and hyperbolic functions, C code for test and performance verification