coverting an angle to a vector and back changes the angle?

Question

So I have the following angle (rad): 3.45575213 Now I convert it via cos & sin to a vector (tDir is zero before):

tDir.x += cos(target->direction);
tDir.y += sin(target->direction);

now I convert it back via:

float newDir = Wrap2PI(atan2(tDir.y, tDir.x));

The wrapping looks like this:

inline float Wrap2PI(float u)
{
    while(u < 0)
        u += PI2;
    while (u >= PI2)
        u -= PI2;
    return u;
}

PI:

const float PI = 3.14159265359f;
const float PI2 = PI*2.0f;

the result is significantly different: 3.45575237

This difference is really big when this calculation is performed 120 times a second, or at least it seems like it, since my objects are rotating clockwise, and this is the only inaccuracy I manage to find in my code. Is there a way to get better results ?

EDIT: Found the problem! It was not the inaccuracy, the vector was sometimes 0,0 ! My bad!

Answer 1

If you want better accuracy than that, you need to use at least doubles, not floats.

Observe:

const float PI = 3.14159265359f;
printf("%0.15f\n", PI);

The output is 3.141592741012573, which demonstrates that the value is only stored accurately to 6 digits after the decimal point. That's a fundamental limitation of the float data type.

If you use doubles you'll do better, and long doubles even better yet. But repeated applications of transcendental functions in floating-point are never going to exactly work out anyway, so you should probably avoid converting except when absolutely necessary. Stick to the most convenient representation for the internal operations and only convert for I/O, for example.

Answer 2

float gives you precision of 6-7 digits. Consider using double.

And anyway, applying trigonometrical functions repeatedly will yield some discrepancy sooner or later.

Answer 3

From a numerical analysis point of view I'don't find it strange that the procedure you posted generates an error of 0.00000024. Trigonometric functions in C/C++ use iterative procedures internally (e.g., Newton-Raphson method) to approximate their results.

However, you could enhance your accuracy either by changing your float to double or long double with-out any performance cost. Nevertheless, if accuracy is #1 factor, you could use an arbitrary precision mathematical library like: GMP. Note however, that use of such packages has an impact on performance (i.e., speed).