Самый простой способ проверить, имеют ли два целых числа один и тот же знак?

Question

Какой самый простой способ проверить, имеют ли два целых числа один знак? Есть ли короткий побитовый трюк, чтобы сделать это?

Answer 1

Вот версия, которая работает в C/C++, который не зависит от размеров целочисленных или имеют проблему переполнения (т.е. х * у> = 0 не работает)

bool SameSign(int x, int y) 
{ 
    return (x >= 0)^(y < 0); 
} 

Конечно, вы можете выродок и шаблон:

template <typename valueType> 
bool SameSign(typename valueType x, typename valueType y) 
{ 
    return (x >= 0)^(y < 0); 
} 

Примечание: Так как мы используем исключающее или, мы хотим, чтобы LHS и RHS быть разными, когда знаки совпадают, следовательно, различные проверки от нуля.

Answer 2

если (х * у)> 0 ...

предполагая ненулевой и такие.

Answer 3

Только от верхней части моей головы ...

int mask = 1 << 31; 
(a & mask)^(b & mask) < 0; 

Answer 4

если (а * Ь < 0) знак отличается, другой знак же (или или б равен нулю)

Answer 5

Предполагая, что 32 бит Интс:

bool same = ((x^y) >> 31) != 1; 

Слегка более лаконична:

bool same = !((x^y) >> 31); 

Answer 6

Возвращаясь к моим университетским дням, в большинстве представлений машин, это не самый левый бит целого числа a 1, когда число отрицательно, и 0, когда оно положительно?

Я полагаю, что это скорее зависит от машины.

Answer 7

(integer1 * integer2)> 0

Потому что, когда два числа разделяют знак, результат умножения всегда будет положительным.

Вы также можете сделать это> = 0, если вы хотите лечить 0 как один и тот же знак независимо от того, что.

Answer 8

int same_sign =! ((X >> 31)^(y >> 31));

если (same_sign) ... еще ...

Answer 9

В технической записке, бит-twiddly решения будет гораздо более эффективным, чем умножение, даже на современных архитектурах. Это всего лишь около 3 циклов, которые вы сохраняете, но вы знаете, что они говорят о «копейке» ...

Answer 10

(a^b) >= 0 

оценит 1, если знак такого же, 0 в противном случае.

Answer 11

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

Почти 100% времени целые числа будут храниться как two's compliment, но не рекомендуется делать предположения о внутренних компонентах системы, если вы не используете тип данных, который гарантирует определенный формат хранения.

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

Лично я просто использовал функцию знака выбранного вами языка. Маловероятно, что будут какие-либо проблемы с производительностью с такими расчетами.

Answer 12

Для любого размера междунар с дополнением до двух арифметика:

#define SIGNBIT (~((unsigned int)-1 >> 1)) 
if ((x & SIGNBIT) == (y & SIGNBIT)) 
    // signs are the same 

Answer 13

предполагая 32 бит

если (((х^у) & 0x80000000) == 0)

... ответ, если (x * y> 0) плохо из-за переполнения

Answer 14

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

Похоже, что «простейшая» проверка заключается в сравнении того, как оба значения сравниваются с 0; это довольно общий, если предположить, что типы можно сравнить:

bool compare(T left, T right) 
{ 
    return (left < 0) == (right < 0); 
} 

Если знаки противоположны, вы становитесь ложными. Если знаки совпадают, вы становитесь правдивыми.

Answer 15

Что случилось с

return ((x<0) == (y<0)); 

?

Answer 16

Предполагая, что двойки дополняют арифметику (http://en.wikipedia.org/wiki/Two_complement):

inline bool same_sign(int x, int y) { 
    return (x^y) >= 0; 
} 

Это может занять всего два инструкции и меньше, чем 1ns на современном процессоре с оптимизацией.

не предполагающие двойки дополнение арифметика:

inline bool same_sign(int x, int y) { 
    return (x<0) == (y<0); 
} 

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

Использование умножения - плохая идея, поскольку она уязвима для переполнения.

Answer 17

внеофисный версия C:

int sameSign(int a, int b) { 
    return ~(a^b) & (1<<(sizeof(int)*8-1)); 
} 

C++ шаблон для целочисленных типов:

template <typename T> T sameSign(T a, T b) { 
    return ~(a^b) & (1<<(sizeof(T)*8-1)); 
} 

Answer 18

Лучший способ использования std::signbit следующим образом:

std::signbit(firstNumber) == std::signbit(secondNumber); 

Он также поддерживает другие основные типы (double , float, char и т.д).