Легкий способ удерживания углов между -179 и 180 градусов

Question

Есть ли простой способ преобразования угла (в градусах) между -179 и 180? Я уверен, что я мог бы использовать моды (%) и некоторые если заявления, но это становится уродливым:

//Make angle between 0 and 360 
angle%=360; 

//Make angle between -179 and 180 
if (angle>180) angle-=360; 

Это только кажется, что там должна быть простой математика операция, которая будет делать оба заявления одновременно. На данный момент мне просто нужно создать статический метод для преобразования.

Answer 1

Я немного опоздал на вечеринку, я знаю, но ...

Большинство из этих ответов не являются хорошо, потому что они пытаются быть умным и кратким, а затем надеть» t позаботиться о краевых случаях.

Это немного более подробный, но если вы хотите заставить его работать, просто введите логику, чтобы заставить ее работать. Не пытайтесь быть умными.

 
int normalizeAngle(int angle) 
{ 
    int newAngle = angle; 
    while (newAngle <= -180) newAngle += 360; 
    while (newAngle > 180) newAngle -= 360; 
    return newAngle; 
} 

Это работает и является достаточно чистым и простым, не пытаясь быть фантазией. Обратите внимание, что только один или один из циклов while может быть запущен.

Answer 2

Не так уж и умный, но нет, если.

Угол = (угол + 179)% 360 - 179;

Но я не знаю, как Java обрабатывает по модулю отрицательных чисел. Это работает только тогда, когда -1 по модулю 360 равна 359.

UPDATE

Просто проверили документы и a % b дает значение между -(|b| - 1) и +(|b| - 1) следовательно код разбивается. Для учета отрицательных значений, возвращаемых модульным оператором, необходимо использовать следующее.

angle = ((angle + 179) % 360 + 360) % 360 - 179; 

Но ... нет ... никогда ... не использовать что-то похожее на ваши первоначальные решения, но фиксированные для значений меньших, то -179.

Answer 3

Как насчет

(angle % 360) - 179 

Это будет фактически возвращать разные результаты, чем наивный подход, представленный в этом вопросе, но он будет держать угол между границами указанных. (Я полагаю, это может сделать неправильный ответ, но я оставлю его здесь, если он разрешит аналогичную проблему других лиц).

Answer 4

Может быть, не полезно, но мне всегда нравилось использовать углы без градуса.

Диапазон углов от 0 до 255 может храниться в границах с использованием побитовых операций или для одной байтовой переменной, простой разрешен для переполнения.

Диапазон углов от -128 до 127 не так-то просто с побитовыми операциями, но опять же, для однобайтовой переменной вы можете позволить переполнению.

Я думал, что это отличная идея много лет назад для игр, где вы, вероятно, используете таблицу поиска для углов. В эти дни, не очень хорошо - углы используются по-разному, и все равно плавают.

По-прежнему возможно стоит упомянуть.

Answer 5

Попробуйте это вместо этого!

atan2(sin(angle), cos(angle)) 

atan2 имеет диапазон [- π, π).Это имеет преимущество в том, что загар θ = грех θ/соз θ, и что atan2 достаточно умен, чтобы знать, какой квадрант θ в.

Так как вы хотите градусов, вы хотите, чтобы преобразовать угол и из радиана:

atan2(sin(angle * PI/180.0), cos(angle * PI/180.0)) * 180.0/PI 

Update Моего предыдущий пример был вполне законным, но ограничил диапазон & plusmn; 90 °. atan2 - это желаемое значение -179 ° до 180 °. Сохраняется ниже.

---

Попробуйте это:

asin(sin(angle))) 

Область sin реальная линия, диапазон [-1, 1]. Домен asin составляет [-1, 1], а диапазон - [-PI/2, PI/2]. Поскольку asin является инверсией sin, ваш ввод не изменяется (многое, есть некоторый дрейф, потому что вы используете числа с плавающей запятой). Таким образом, вы возвращаете свое входное значение и получаете желаемый диапазон в качестве побочного эффекта ограниченного диапазона арксина.

Так как вы хотите градусов, вы хотите, чтобы преобразовать свой угол и из радиана:

asin(sin(angle * PI/180.0)) * 180.0/PI 

(Оговорка: тригонометрические функции являются bazillions раза медленнее, чем простой разделяй и вычитать операции, даже если они сделаны в FPU!)

Answer 6

int angle = -394; 

// shortest 
angle %= 360; 
angle = angle < -170 ? angle + 360 : (angle > 180 ? angle - 380 : angle); 

// cleanest 
angle %= 360; 
if (angle < -179) angle += 360; 
else if (angle > 180) angle -= 360; 

Answer 7

Короткий путь, который обрабатывает отрицательные числа является

double mod = x - Math.floor((x + 179.0)/360) * 360; 

Cast по вкусу.

BTW: Похоже, что углы между (180,0, 181,0) не определены. Если не диапазон быть (-180, 180] (без учета включительно]

Answer 8

// reduce the angle 
angle = angle % 360; 

// force it to be the positive remainder, so that 0 <= angle < 360 
angle = (angle + 360) % 360; 

// force into the minimum absolute value residue class, so that -180 < angle <= 180 
if (angle > 180) 
    angle -= 360; 

Answer 9

Ну, еще одно решение, это один только с одним делением и без каких-либо петель.

static double normalizeAngle(double angle) 
{ 
    angle %= 360.0; // [0..360) if angle is positive, (-360..0] if negative 
    if (angle > 180.0) // was positive 
     return angle - 360.0; // was (180..360) => returning (-180..0) 
    if (angle <= -180.0) // was negative 
     return angle + 360.0; // was (-360..180] => returning (0..180] 
    return angle; // (-180..180] 
} 

Answer 10

Это работает как с отрицательными и десятичных чисел и не требует петель, ни тригонометрические функции:

угол - = Math.floor (угол/360 + 0,5) * 360

результат находится в интервале [-180, 180]. Для (-180, 180] интервал, вы можете использовать это вместо:

угол - = Math.ceil (угол/360 - 0,5) * 360

Answer 11

Я знаю, что прошло лет, но до сих пор

.

Это решение не содержит петель, ни вычитание, не по модулю (не позволяет нормализовать интервал радианах). Работает для любого входного сигнала, в том числе и отрицательные значения, большие значения, крайние случаи.

double normalizedAngle = angle - (ceil((angle + M_PI)/(2*M_PI))-1)*2*M_PI; // (-Pi;Pi]: 
double normalizedAngle = angle - (ceil((angle + 180)/360)-1)*360;   // (-180;180]: 

double normalizedAngle = angle - (floor((angle + M_PI)/(2*M_PI)))*2*M_PI; // [-Pi;Pi): 
double normalizedAngle = angle - (floor((angle + 180)/360))*360;   // [-180;180): 

Answer 12

Вот целое только раствор:

int normalize(int angle) 
{ 
    angle %= 360; 
    int fix = angle/180; // Integer division!! 
    return (fix) ? angle - (360 * (fix)) : angle; 
} 

Иногда умение просто веселее, Platinum Azure.

Answer 13

Я сделал формулу для ориентации круговых значений

, чтобы сохранить угол между 0 и 359:

angle + Math.ceil(-angle/360) * 360 

, но чтобы сохранить между -179 до 180 формулы может быть:

angle + Math.ceil((-angle-179)/360) * 360 

это придаст ориентировочный сдвиг около -179, сохраняя фактический угол неповрежденным

Обобщенная формула для ориентации угла сдвига может быть:

angle + Math.ceil((-angle+shift)/360) * 360 

Answer 14

Лучше использовать библиотечные функции. Они обрабатывают особые случаи, такие как NaN и бесконечности.

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

Answer 15

Вот мой вклад. Кажется, он работает для всех углов без проблем с краем. Это быстро. Он может сделать n180 [360000359] = -1 почти мгновенно. Обратите внимание, как функция «Значок» помогает выбрать правильный логический путь и позволяет использовать тот же код для разных углов.

храповик

n180[a_] := 
If[Abs[Mod[a, If[Sign[a] == 0, 360, Sign[a] 360]]] <= 180, 
    Mod[a, If[Sign[a] == 0, 360, Sign[a] 360]], 
    Mod[a, If[Sign[a] == 0, 360, -Sign[a] 360]]]