La differenza più piccola tra 2 angoli

Dati 2 angoli nell'intervallo -PI -> PI attorno a una coordinata, qual è il valore del più piccolo dei 2 angoli tra loro?

Tenendo conto che la differenza tra PI e -PI non è 2 PI ma zero.

Esempio:

Immagina un cerchio, con 2 linee che escono dal centro, ci sono 2 angoli tra quelle linee, l'angolo che formano all'interno, ovvero l'angolo più piccolo , e l'angolo che formano all'esterno, ovvero l'angolo più grande. Entrambi gli angoli quando sommati formano un cerchio completo. Dato che ogni angolo può rientrare in un determinato intervallo, qual è il valore degli angoli più piccoli, tenendo conto del rollover

Questo dà un angolo con segno per tutti gli angoli:

a = targetA - sourceA
a = (a + 180) % 360 - 180

Attenzione in molte lingue l' modulooperazione restituisce un valore con lo stesso segno del dividendo (come C, C ++, C #, JavaScript, elenco completo qui ). Ciò richiede una modfunzione personalizzata in questo modo:

mod = (a, n) -> a - floor(a/n) * n

O così:

mod = (a, n) -> (a % n + n) % n

Se gli angoli si trovano entro [-180, 180] funziona anche:

a = targetA - sourceA
a += (a>180) ? -360 : (a<-180) ? 360 : 0

In modo più dettagliato:

a = targetA - sourceA
a -= 360 if a > 180
a += 360 if a < -180

x è l'angolo target. y è la fonte o l'angolo iniziale:

atan2(sin(x-y), cos(x-y))

Restituisce l'angolo delta firmato. Si noti che, a seconda dell'API, l'ordine dei parametri per la funzione atan2 () potrebbe essere diverso.

Se i tuoi due angoli sono xey, uno degli angoli tra loro è abs (x - y). L'altro angolo è (2 * PI) - abs (x - y). Quindi il valore del più piccolo dei 2 angoli è:

min((2 * PI) - abs(x - y), abs(x - y))

Questo ti dà il valore assoluto dell'angolo e presuppone che gli input siano normalizzati (cioè: all'interno dell'intervallo [0, 2π)).

Se si desidera preservare il segno (ovvero: direzione) dell'angolo e accettare anche angoli al di fuori dell'intervallo, [0, 2π)è possibile generalizzare quanto sopra. Ecco il codice Python per la versione generalizzata:

PI = math.pi
TAU = 2*PI
def smallestSignedAngleBetween(x, y):
    a = (x - y) % TAU
    b = (y - x) % TAU
    return -a if a < b else b

Si noti che l' %operatore non si comporta allo stesso modo in tutte le lingue, in particolare quando sono coinvolti valori negativi, quindi se è necessario il porting di alcune regolazioni dei segni.

Accetto la sfida di fornire la risposta firmata:

def f(x,y):
  import math
  return min(y-x, y-x+2*math.pi, y-x-2*math.pi, key=abs)

Per gli utenti di UnityEngine, il modo più semplice è usare Mathf.DeltaAngle .

Soluzione aritmetica (al contrario di algoritmica):

angle = Pi - abs(abs(a1 - a2) - Pi);

Un codice efficiente in C ++ che funziona con qualsiasi angolo e in entrambi: radianti e gradi è:

inline double getAbsoluteDiff2Angles(const double x, const double y, const double c)
{
    // c can be PI (for radians) or 180.0 (for degrees);
    return c - fabs(fmod(fabs(x - y), 2*c) - c);
}

Non è necessario calcolare le funzioni trigonometriche. Il semplice codice in linguaggio C è:

#include <math.h>
#define PIV2 M_PI+M_PI
#define C360 360.0000000000000000000
double difangrad(double x, double y)
{
double arg;

arg = fmod(y-x, PIV2);
if (arg < 0 )  arg  = arg + PIV2;
if (arg > M_PI) arg  = arg - PIV2;

return (-arg);
}
double difangdeg(double x, double y)
{
double arg;
arg = fmod(y-x, C360);
if (arg < 0 )  arg  = arg + C360;
if (arg > 180) arg  = arg - C360;
return (-arg);
}

sia dif = a - b, in radianti

dif = difangrad(a,b);

sia dif = a - b, in gradi

dif = difangdeg(a,b);

difangdeg(180.000000 , -180.000000) = 0.000000
difangdeg(-180.000000 , 180.000000) = -0.000000
difangdeg(359.000000 , 1.000000) = -2.000000
difangdeg(1.000000 , 359.000000) = 2.000000

Niente peccato, niente cos, niente abbronzatura, .... solo geometria !!!!