16

Is there a library function or a well-known quick efficient way in Java to normalize an angle to +/- π — e.g. when adding two angles?

What I've got now (based on this answer) is basically the code below...

private static final double TWO_PI = 2 * Math.PI;

double normalize(double theta) {
    double normalized = theta % TWO_PI;
    normalized = (normalized + TWO_PI) % TWO_PI;
    return normalized <= Math.PI ? normalized : normalized - TWO_PI;
}

...but it seems a little complicated and performance-wise I'm not excited about the modulo operator. (Note that I can't guarantee theta isn't some relatively large number, so I don't think there's a pure addition/subtraction solution without looping. I don't actually know how a hand-rolled loop is likely to compare to %.)

Is there a well-tested optimized library function I can use, or a better algorithm, or is this as good as it gets?

Community
  • 1
  • 1
David Moles
  • 48,006
  • 27
  • 136
  • 235
  • You're trying to round to the nearest 90 degree (half pi) or the nearest 180 degree (full pi)? – Kon Jun 15 '14 at 22:23
  • @Kon 180 degree / full pi. – David Moles Jun 15 '14 at 22:23
  • possible duplicate of [Easy way to keeping angles between -179 and 180 degrees](http://stackoverflow.com/questions/2320986/easy-way-to-keeping-angles-between-179-and-180-degrees) – Stefano Sanfilippo Jun 15 '14 at 22:26
  • @StefanoSanfilippo I've read that answer but given that most Java math / geometry libraries are in radians it seems plausible that there's a better answer working in radians than in degrees. – David Moles Jun 15 '14 at 22:32
  • ...and in fact @CupawnTae has provided a [library function answer](http://stackoverflow.com/a/24234924/27358). – David Moles Jun 15 '14 at 23:30

2 Answers2

19

Apache commons has one:

http://commons.apache.org/proper/commons-math/javadocs/api-3.6.1/org/apache/commons/math3/util/MathUtils.html#normalizeAngle(double, double)

normalize an angle between -π and +π

a = MathUtils.normalizeAngle(a, 0.0);

And looking at the source code, you could reproduce it with this (they use their own FastMath.floor but in case you want to do it without an external library):

theta - TWO_PI * Math.floor((theta + Math.PI) / TWO_PI)

Source is here: https://github.com/apache/commons-math/blob/53ec46ba272e23c0c96ada42f26f4e70e96f3115/src/main/java/org/apache/commons/math4/util/MathUtils.java#L107

Note for readers from the future: this method has just (June 2017) been removed from the latest commons-math 4.x codebase. If you're using a version after this, you'll want to use commons-numbers instead (once it's released) - currently:

a = PlaneAngleRadians.normalizeBetweenMinusPiAndPi(a);

or

a = PlaneAngleRadians.normalize(a, 0.0);
Community
  • 1
  • 1
CupawnTae
  • 14,192
  • 3
  • 29
  • 60
18

There is only one 100% foolproof way:

public static double normalizeAngle(double angle) {
    return Math.atan2(Math.sin(angle), Math.cos(angle));
}

Everything else is people trying to be too smart and failing.

cohadar
  • 4,709
  • 2
  • 20
  • 21
  • 9
    This method is probably more accurate (and I think provides a half-closed range, unlike `MathUtils`), but it's also about 40x slower (median ~190ns on my 15" MBP, vs. ~4.9ns using `MathUtils`), which may be more important for some applications. – David Moles Mar 28 '16 at 17:24
  • I agree, atan2 can be slow. But it handles cases with NaN and ±Infinity. – cohadar Mar 29 '16 at 10:09
  • MathUtils handles those as well -- it returns NaN for all three, just as atan2 does. – David Moles Mar 29 '16 at 18:50
  • 1
    This method has weird artifacts at certain angles. I was never able to get it to work 100% foolproof even though it works in theory. – Martin May 08 '18 at 10:21
  • 1
    Foolproof? May be, I don't know. But constraining an arithmetic value within arithmetic bounds by using *three* trigonometric functions seems like overkill to me. A couple of while() statements would be just as safe (coupled with a single if() for fringe cases). – Bogdan Stăncescu Oct 13 '20 at 18:36
  • The range for the result is from -PI to +PI, I would like something from 0 to 2xPI – Noman_1 Apr 20 '21 at 06:29