A menor diferença entre 2 ângulos

Dados 2 ângulos no intervalo -PI -> PI em torno de uma coordenada, qual é o valor do menor dos 2 ângulos entre eles?

Tendo em conta que a diferença entre PI e -PI não é 2 PI, mas zero.

Exemplo:

Imagine um círculo, com 2 linhas saindo do centro, existem 2 ângulos entre essas linhas, o ângulo que fazem no interior, também conhecido como ângulo menor , e o ângulo que fazem do lado de fora, também conhecido como ângulo maior. Ambos os ângulos, quando somados, formam um círculo completo. Dado que cada ângulo pode caber dentro de um determinado intervalo, qual é o menor valor de ângulos, levando em consideração a rolagem

Isso fornece um ângulo assinado para qualquer ângulo:

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

Cuidado em muitos idiomas: a modulooperação retorna um valor com o mesmo sinal que o dividendo (como C, C ++, C #, JavaScript, lista completa aqui ). Isso requer uma modfunção personalizada da seguinte forma:

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

Ou então:

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

Se os ângulos estão dentro de [-180, 180], isso também funciona:

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

De uma maneira mais detalhada:

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

x é o ângulo alvo. y é a fonte ou o ângulo inicial:

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

Retorna o ângulo delta assinado. Observe que, dependendo da sua API, a ordem dos parâmetros para a função atan2 () pode ser diferente.

Se seus dois ângulos são x e y, então um dos ângulos entre eles é abs (x - y). O outro ângulo é (2 * PI) - abs (x - y). Portanto, o valor do menor dos 2 ângulos é:

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

Isso fornece o valor absoluto do ângulo e assume que as entradas estão normalizadas (ou seja: dentro da faixa [0, 2π)).

Se você deseja preservar o sinal (ou seja: direção) do ângulo e também aceitar ângulos fora do intervalo, [0, 2π)você pode generalizar o que foi descrito acima. Aqui está o código Python para a versão generalizada:

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

Observe que o %operador não se comporta da mesma maneira em todos os idiomas, principalmente quando valores negativos estão envolvidos; portanto, se for necessário portar alguns ajustes de sinal.

Eu enfrento o desafio de fornecer a resposta assinada:

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

Para usuários do UnityEngine, a maneira mais fácil é usar o Mathf.DeltaAngle .

Solução aritmética (em oposição à algorítmica):

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

Um código eficiente em C ++ que funciona para qualquer ângulo e em ambos: radianos e graus é:

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

Não há necessidade de calcular funções trigonométricas. O código simples na linguagem 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);
}

seja dif = a - b, em radianos

dif = difangrad(a,b);

Seja dif = a - b, em graus

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

Sem pecado, sem cos, sem bronzeado, .... apenas geometria !!!!