An alternative way to normalize angles to (-pi, pi]

[luckykk273]

Hi,
In norm_angle, the % operator is used to do modulo on floating numbers to normalize angles to (-pi, pi].
I know norm_angle is well tested in test_norm_angle in test/test_rotations.py.
From my point of view, it'd be better not using % operator for two reasons:

1. In document of math.fmod, it is mentioned:

function fmod is generally preferred when working with floats, while Python’s x % y is preferred when working with integers.

2. More general for other programming language
   In other language(e.g. C/C++), it is not allowed to use % operator for floating numbers.

Here is the modified version I have already tested:

def norm_angle(a):
    """Normalize angle to (-pi, pi].

    Parameters
    ----------
    a : float or array-like, shape (n,)
        Angle(s) in radians

    Returns
    -------
    a_norm : float or array-like, shape (n,)
        Normalized angle(s) in radians
    """
    a = np.asarray(a)
    two_pi = 2.0 * np.pi
    return (a - (np.ceil((a + np.pi) / two_pi) - 1.0) * two_pi)  # (-Pi, Pi]
    # return (a - np.floor((a + np.pi) / two_pi) * two_pi)  # [-Pi, Pi)

The above mentioned is my suggestion and you could take into consieration. Thank you!

[AlexanderFabisch]

Hi @luckykk273 , thanks for the advice. Would you be willing to open a pull request?

edit: btw. there is numpy.fmod. I would suggest to use it then.

[luckykk273]

Hi @AlexanderFabisch,
Thank you for your reply and suggestions. As far as I know, the % operator and numpy.fmod behave differently.
As mentioned in the documentation for math.fmod:

Python’s x % y returns a result with the sign of y instead, and may not be exactly computable for float arguments.

However, in the numpy.fmod documentation, it states:

For fmod, the sign of the result is the sign of the dividend, while for remainder, the sign of the result is the sign of the divisor.

I also attempted to replace the % operator with numpy.fmod directly as follow:

>>> a = 7.143741
>>> (np.pi - np.asarray(a)) % (2.0 * np.pi)  # return a result with the sign of (2.0 * np.pi)
2.281036960769379
>>> np.fmod(np.pi - np.asarray(a), 2.0 * np.pi)  # the sign of the result is the sign of (np.pi - np.asarray(a))
-4.002148346410207
>>> -((np.pi - np.asarray(a)) % (2.0 * np.pi) - np.pi)
0.8605556928204141
>>> -(np.fmod(np.pi - np.asarray(a), 2.0 * np.pi) - np.pi)
7.143741

but it didn't pass the test in test_norm_angle. If you don't mind using numpy.ceil, I can directly submit a pull request. If you prefer to use numpy.fmod, I need to reconsider the implementation approach and make the necessary changes before submitting the pull request. Thank you!

[AlexanderFabisch]

OK, please open a PR with ceil and I will have a closer look.