Standard-Weise zu normalisieren, die einen Winkel von +/- π Bogenmaß in Java

Gibt es eine library-Funktion oder ein bekannter eine schnelle effiziente Art und Weise in Java zu normalisieren, die einen Winkel von +/- π — z.B. beim hinzufügen von zwei Winkeln?

Was ich haben jetzt (basierend auf diese Antwort) ist im Grunde den code unten...

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;
}

...aber es scheint ein wenig kompliziert und performance-wise, ich bin nicht begeistert von der modulo-operator. (Beachten Sie, dass ich nicht garantieren kann theta nicht eine relativ große Zahl, so ich glaube nicht, dass es eine Reine addition/Subtraktion Lösung ohne Schleife. Ich weiß wirklich nicht, wie eine hand-gerollte Schleife ist wahrscheinlich, um vergleichen zu %.)

Gibt es eine gut getestet optimierte Bibliothek-Funktion, die ich verwenden kann, oder einen besseren Algorithmus, oder ist das so gut wie es geht?

Sie versuchen zu Runden auf den nächsten 90 Grad (halbe pi) oder die nächste 180 Grad (volle pi)?
180 Grad / full pi.
möglich, Duplikat der Einfache Möglichkeit zu halten, der Winkel zwischen -179 und 180 Grad
Ich habe gelesen, dass die Antwort aber so, dass die meisten Java-Mathematik / geometrie-Bibliotheken sind in radians scheint es plausibel, dass es eine bessere Antwort arbeiten im Bogenmaß als in Grad.
...und in der Tat @CupawnTae hat eine "Mediathek" - Funktion Antwort.

InformationsquelleAutor David Moles | 2014-06-15

java radians

16

Apache commons hat eine:

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

normalisieren, die einen Winkel zwischen -π und +π

a = MathUtils.normalizeAngle(a, 0.0);

Suchen und am source-code, Sie konnte es reproduzieren mit diesem (Sie verwenden Ihre eigene FastMath.floor aber in Fall, dass Sie wollen, es zu tun, ohne eine externe Bibliothek):
```
theta - TWO_PI * Math.floor((theta + Math.PI) / TWO_PI)
```
Quelle ist hier: https://github.com/apache/commons-math/blob/53ec46ba272e23c0c96ada42f26f4e70e96f3115/src/main/java/org/apache/commons/math4/util/MathUtils.java#L107

Hinweis für Leser aus der Zukunft: diese Methode hat gerade (Juni 2017) entfernt wurde aus der aktuellen commons-math 4.x-Codebasis. Wenn Sie eine version nach dieser, werden Sie wollen, verwenden Sie commons-zahlen statt (sobald es erschienen ist) - aktuell:
```
a = PlaneAngleRadians.normalizeBetweenMinusPiAndPi(a);
```
oder
```
a = PlaneAngleRadians.normalize(a, 0.0);
```
InformationsquelleAutor CupawnTae
7

Gibt es nur eine 100% narrensichere Weg:
```
public static double normalizeAngle(double angle) {
    return Math.atan2(Math.sin(angle), Math.cos(angle));
}   
```
Alles andere ist Menschen, die versuchen, zu schlau zu sein und zu Versagen.
- Diese Methode ist wahrscheinlich genauer (und ich denke, dass stellt einen halb-geschlossenen Bereich, im Gegensatz zu MathUtils), aber es ist auch über 40x langsamer (median ~190ns auf meinem 15" MBP vs. ~4.9 ns mit MathUtils), die wichtiger sein kann für einige Anwendungen.
- Ich bin damit einverstanden, atan2 kann langsam sein. Aber es Griffe Fälle mit NaN und ±Infinity.
- MathUtils behandelt diejenigen, die als gut-es gibt NaN für alle drei, genau wie atan2 tut.
- Diese Methode hat komische Artefakte bei bestimmten Winkeln. Ich war nie in der Lage, um es zu 100% narrensicher, obwohl es funktioniert in der Theorie.
InformationsquelleAutor cohadar

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.