Perbedaan terkecil antara 2 Sudut

Diketahui 2 sudut dalam rentang -PI -> PI di sekitar koordinat, berapakah nilai terkecil dari 2 sudut di antara keduanya?

Memperhatikan bahwa perbedaan antara PI dan -PI bukanlah 2 PI melainkan nol.

Contoh:

Bayangkan sebuah lingkaran, dengan 2 garis keluar dari tengah, ada 2 sudut di antara garis-garis itu, sudut yang dibuat di dalam alias sudut yang lebih kecil , dan sudut yang dibuat di luar alias sudut yang lebih besar. Kedua sudut jika dijumlahkan membuat lingkaran penuh. Mengingat bahwa setiap sudut bisa muat dalam kisaran tertentu, berapa nilai sudut yang lebih kecil, dengan mempertimbangkan rollover

Ini memberikan sudut yang ditandatangani untuk setiap sudut:

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

Hati-hati dalam banyak bahasa, modulooperasi mengembalikan nilai dengan tanda yang sama dengan dividen (seperti C, C ++, C #, JavaScript, daftar lengkap di sini ). Ini membutuhkan modfungsi khusus seperti:

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

Atau lebih:

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

Jika sudut berada dalam [-180, 180] ini juga berfungsi:

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

Dengan cara yang lebih bertele-tele:

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

x adalah sudut target. y adalah sumber atau sudut awal:

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

Ini mengembalikan sudut delta yang ditandatangani. Perhatikan bahwa bergantung pada API Anda, urutan parameter untuk fungsi atan2 () mungkin berbeda.

Jika kedua sudut Anda adalah x dan y, maka salah satu sudut di antaranya adalah abs (x - y). Sudut lainnya adalah (2 * PI) - abs (x - y). Jadi nilai terkecil dari 2 sudut tersebut adalah:

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

Ini memberi Anda nilai absolut dari sudut, dan ini mengasumsikan input dinormalisasi (yaitu: dalam kisaran [0, 2π)).

Jika Anda ingin mempertahankan tanda (yaitu: arah) dari sudut dan juga menerima sudut di luar jangkauan, [0, 2π)Anda dapat menggeneralisasikan hal di atas. Berikut kode Python untuk versi umum:

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

Perhatikan bahwa %operator tidak berperilaku sama di semua bahasa, terutama ketika nilai negatif terlibat, jadi jika porting beberapa penyesuaian tanda mungkin diperlukan.

Saya menerima tantangan untuk memberikan jawaban yang ditandatangani:

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

Untuk pengguna UnityEngine, cara termudah adalah dengan menggunakan Mathf.DeltaAngle .

Solusi aritmatika (sebagai lawan algoritmik):

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

Kode efisien dalam C ++ yang berfungsi untuk semua sudut dan di kedua: radian dan derajat adalah:

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

Metode sederhana, yang saya gunakan di C ++ adalah:

double deltaOrientation = angle1 - angle2;
double delta =  remainder(deltaOrientation, 2*M_PI);

Tidak perlu menghitung fungsi trigonometri. Kode sederhana dalam bahasa C adalah:

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

misalkan dif = a - b, dalam radian

dif = difangrad(a,b);

biarkan dif = a - b, dalam derajat

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

Tanpa dosa, tanpa cos, tanpa tan, .... hanya geometri !!!!