Fast Arc Cos algorithm?

Question

I have my own, very fast cos function:

float sine(float x)
{
    const float B = 4/pi;
    const float C = -4/(pi*pi);

    float y = B * x + C * x * abs(x);

    //  const float Q = 0.775;
    const float P = 0.225;

    y = P * (y * abs(y) - y) + y;   // Q * y + P * y * abs(y)


    return y;
}

float cosine(float x)
{
    return sine(x + (pi / 2));
}

But now when I profile, I see that acos() is killing the processor. I don't need instense precision. What is a fast way to calculate acos(x) Thanks.

Answer 1

Got spare memory? A lookup table (with interpolation, if required) is gonna be fastest.

Answer 2

It really depends what you mean by "not intense precision"...

You could do it extremely roughly:

float arccos(float x)
{
    return pi * (-x) / 2;
}

Which is a straight-line function

This is very similar to arcsin:

float arcsin(float x)
{
    return -pi * x;
}

In fact, arc-cosine is just arc-sin flipped and shifted up by π/2.

So you could also write your arccos function as:

float arccos(float x) {
    return(pi * 1.5 - arcsin(x));
}

Answer 3

A simple cubic approximation, the Lagrange polynomial for x ∈ {-1, -½, 0, ½, 1}, is:

double acos(x) {
   return (-0.69813170079773212 * x * x - 0.87266462599716477) * x + 1.5707963267948966;
}

It has a maximum error of about 0.18 rad.

Answer 4

I see approximate routines for sine and cosine that could, as @dan04 says, be done better.

I don't see acos.

Besides, what do you mean "killing the processor"? No matter how fast you make it, it is going to take 100% of processor time if you do nothing else.