# Working with angles (is surprisingly hard)

Due to the periodic nature of angles, especially the discontinuity at 2π / 360°, working with them presents some subtle issues. For example, the angles 5° and 355° are "close" to each other, but are numerically quite different. In a geographic (GIS) context, this often surfaces when working with geometries spanning Earth's date-line at -180°/+180° longitude, which often requires multiple code paths to obtain the desired result.

I've recently run into the problem of computing averages and
differences of angles. The difference should increase linearly, it should be 0
if they are equal, negative if the second angle lies to one side of the first,
positive if it's on the other side (whether that's left or right depends on
whether the angles increase in the clockwise direction or in counter-clockwise
direction). Getting that right and coming up with test cases to prove that it's
correct was quite interesting. As Bishop notes in Pattern Recognition and
Machine Learning, it's often simpler to perform operations on angles in
a 2D (x, y) space and then back-transform to angles using the
`atan2()`

function. I've used that for the averaging function; the
difference is calculated using modulo arithmetic.

Here's the Python version of the two functions:

```
def average_angles(angles):
"""Average (mean) of angles
Return the average of an input sequence of angles. The result is between
``0`` and ``2 * math.pi``.
If the average is not defined (e.g. ``average_angles([0, math.pi]))``,
a ``ValueError`` is raised.
"""
x = sum(math.cos(a) for a in angles)
y = sum(math.sin(a) for a in angles)
if x == 0 and y == 0:
raise ValueError(
"The angle average of the inputs is undefined: %r" % angles)
# To get outputs from -pi to +pi, delete everything but math.atan2() here.
return math.fmod(math.atan2(y, x) + 2 * math.pi, 2 * math.pi)
def subtract_angles(lhs, rhs):
"""Return the signed difference between angles lhs and rhs
Return ``(lhs - rhs)``, the value will be within ``[-math.pi, math.pi)``.
Both ``lhs`` and ``rhs`` may either be zero-based (within
``[0, 2*math.pi]``), or ``-pi``-based (within ``[-math.pi, math.pi]``).
"""
return math.fmod((lhs - rhs) + math.pi * 3, 2 * math.pi) - math.pi
```

The code, along with test cases can also be found in this GitHub Gist.
Translation of these functions to other languages should be straight-forward,
`sin()`

/`cos()`

/`fmod()`

/`atan2()`

are pretty ubiquitous.