Why we use CORDIC gain?

Question

I'm studying the cordic. And I found the cordic gain. K=0.607XXX.

From CORDIC, K_i = cos(tan^-1(2^i)).

As I know the K is approched 0.607xxx.when I is going to infinity

this value come up with from all K multiplying.

I understand the reason of exist each k. But I am curioused Where does it used ? Why we use that value K=0.607xx?

Answer 1

The scale factor for the rotation mode of the circular variant of CORDIC can easily be established from first principles. The idea behind CORDIC is to take a point on the unit circle and rotate it, in steps, through the angle u whose sine and cosine we want to determine.

To that end we define a set of incremental angles a₀, ..., a_n-1, such that a_k = atan(0.5^k). We sum these incremental angles appropriately into a partial sum of angles s_k, such than s_n ~= u. Let y_k = cos(s_k) and x_k = sin(s_k). If in a given step k we rotate by a_k, we have

y_k+1 = cos (s_k+1) = cos (s_k + a_k)
x_k+1 = sin (s_k+1) = sin (s_k + a_k)

we can compute x_k+1 and y_k+1 from x_k and y_k as follows:

y_k+1 = y_k * cos (a_k) - x_k * sin (a_k)
x_k+1 = x_k * cos (a_k) + y_k * sin (a_k)

Considering that we may both add and subtract a_k, and that tan(a_k) = sin(a_k)/cos(a_k), we get:

y_k+1 = cos (a_k) * (y_k ∓ x_k * tan(a_k)) = cos (s_k+1)
x_k+1 = cos (a_k) * (x_k ± y_k * tan(a_k)) = sin (s_k+1)

To simplify this computation, we can leave out the multiplication with cos(a_k) in every step, which gives us our CORDIC iteration scheme:

y_k+1 = y ∓ x_k * tan(a_k)
x_k+1 = x ± y_k * tan(a_k)

Because of our choice of a_k, the multiplications with tan(a_k) turn into simple right shifts if we compute in fixed-point arithmetic. Because we left off the factors cos(a_k), we wind up with

y_n ~= cos(u) * (1 / (cos (a₀) * cos (a₁) * ... * cos (a_n))
x_n ~= sin(u) * (1 / (cos (a₀) * cos (a₁) * ... * cos (a_n))

The factor f = cos (a₀) * cos (a₁) * ... * cos (a_n) is 0.607..., as already noted. We incorporate it into the computation by setting the starting values

y₀ = f * cos(0) = f
x₀ = f * sin(0) = 0

Here is C code that shows the entire computation in action, using 16-bit fixed-point arithmetic. Input angles are scaled such that 360 degrees correspond to 2¹⁶, while sine and cosine outputs are scaled such that 1 corresponds to 2¹⁵.

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

/* round (atand (0.5**i) * 65536/360) */
static const short a[15] = 
{
    0x2000, 0x12e4, 0x09fb, 0x0511, 
    0x028b, 0x0146, 0x00a3, 0x0051, 
    0x0029, 0x0014, 0x000a, 0x0005, 
    0x0003, 0x0001, 0x0001
};

#define swap(a,b){a=a^b; b=b^a; a=a^b;}

void cordic (unsigned short u, short *s, short *c)
{
    short x, y, oldx, oldy, q;
    int i;

    x = 0;
    y = 0x4dba;  /* 0.60725 */
    oldx = x;
    oldy = y;

    q = u >> 14;    /* quadrant */
    u = u & 0x3fff; /* reduced angle */
    u = -(short)u;

    i = 0;
    do {
        if ((short)u < 0) {
            x = x + oldy;
            y = y - oldx;
            u = u + a[i];
        } else {
            x = x - oldy;
            y = y + oldx;
            u = u - a[i];
        }
        oldx = x;
        oldy = y;
        i++;
        /* right shift of signed negative number implementation defined in C */
        oldx = (oldx < 0) ? (-((-oldx) >> i)) : (oldx >> i);
        oldy = (oldy < 0) ? (-((-oldy) >> i)) : (oldy >> i);
    } while (i < 15);

    for (i = 0; i < q; i++) {
        swap (x, y);
        y = -y;
    }

    *s = x;
    *c = y;
}

int main (void)
{
    float angle;
    unsigned short u;
    short s, c;

    printf ("angle in degrees [0,360): ");
    scanf ("%f", &angle);
    u = (unsigned short)(angle * 65536.0f / 360.0f + 0.5f);
    cordic (u, &s, &c);
    printf ("sin = % f  (ref: % f)  cos = % f (ref: % f)\n",
            s/32768.0f, sinf(angle/360*2*3.14159265f), 
            c/32768.0f, cosf(angle/360*2*3.14159265f));
    return EXIT_SUCCESS;
}