Fix fixed-point conversion precision to avoid overflow

[jserv]

The commit previous implementation used ((angle * TWIN_ANGLE_360) >> 15) which
caused two critical issues:

1. Integer Overflow:
   The multiplication 9092 * 4096 results in 37,240,832, exceeding the
   16-bit signed integer limit (32,767). It occurs when CORDIC iteration
   reaches maximum angle accumulation.
2. Precision Error for Negative Values:
   Right shift (>>) rounds towards negative infinity (floor division),
   while the original floating-point cast truncates towards zero.
   This causes precision errors for ~87.5% of negative angle values
   (all non-multiples of 8).
   Examples:
   • Original: (int)(-7 / 32768.0 * 4096) = 0
   • Right shift: -7 >> 3 = -1 (WRONG)
   • Integer division: -7 / 8 = 0 (CORRECT)

This commit simplifies the expression by factoring out constants:

• Original: angle * TWIN_ANGLE_360 / 32768
• Since TWIN_ANGLE_360 = 2^12 and 32768 = 2^15
• Simplified: angle * 2^12 / 2^15 = angle / 8

This uses integer division (/) instead of right shift (>>) to match the
original truncate-towards-zero behavior guaranteed by C99, preserving
exact precision for all angle values in CORDIC's [-9092, 9092] range.

[weihsinyeh]

Does this commit also aim to fix the incorrect casting of the variable angle from twin_angle_t to double?

[jserv]

Does this commit also aim to fix the incorrect casting of the variable angle from twin_angle_t to double?

Yes, intentionally.

[weihsinyeh]

Then, why didn't you write this purpose on this commit log ?

[jouae]

Since TWIN_ANGLE_360=4096 = 2^12by simple simplification, the original expression can be represented as

$$\frac{\text{angle} * 4096}{32768} = \text{angle} * 2^{12} *2^{-15} = \text{angle} * 2^{-3}$$

which is equivalent to

+/* Fixed-point conversion: angle * TWIN_ANGLE_360 / 32768 */
+    return (twin_angle_t) (angle >> 3);

[jouae]

When the value range of angle is $[-9092,9092]$, using the original expression:

(angle * TWIN_ANGLE_360) >> 15

with TWIN_ANGLE_360 = 4096 can cause overflow. The maximum possible result of the multiplication is:

$$9092 * 4096 = 37,249,024$$

This value exceeds the limits of 16-bit, it may result in integer overflow and unpredictable behavior.

To avoid this issue, the multiplication and division can be replaced with a simple bit shift:

angle >> 3