The easiest way to check if two integers have the same sign?

Question

What is the easiest way to check if two integers have the same sign? Is there a short bitwise trick to do this?

Answer 1

Here is a version that works in C / C ++ that does not rely on integer sizes or has an overflow problem (i.e. x * y> = 0 does not work)

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

Of course, you can shout out a pattern too:

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

Note. Since we use an exclusive form, or we want the LHS and RHS to be different when the signs are the same, therefore a different check against zero.

Answer 2

what happened with

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

?

Answer 3

 (a ^ b) >= 0 

will evaluate to 1 if the sign is the same, 0 otherwise.

Answer 4

I would be wary of any bitwise tricks to determine the sign of integers, since then you should make assumptions about how these numbers are represented inside.

Almost 100% of the time, integers will be stored as two compliments , but it is not a good practice to make assumptions about internal components unless you use a data type that guarantees a specific storage format.

In two compliments, you can simply check the last (leftmost) bit in the integer to determine if it is negative, so you can only compare these two bits. This would mean that 0 would have the same sign as a positive number, but this contradicts the sign function implemented in most languages.

Personally, I just use the sign function of your chosen language. It is unlikely that there will be any performance issues with such calculations.

Answer 5

Assuming 32 bit ints:

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

A bit more concise:

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

Answer 6

I am not sure that I consider "bitwise" and "the simplest" synonym. I see many answers suggesting signed 32-bit integers (although it would be foolish to ask unsigned); I'm not sure if they apply to floating point values.

It seems that the “simplest” test would be to compare how both values ​​compare with 0; this is pretty general, assuming types can be compared:

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

If the signs are opposite, you become false. If the signs match, you will get the truth.

Answer 7

(integer1 * integer2)> 0

Because when two integers have a sign, the result of the multiplication will always be positive.

You can also do this> = 0 if you want to treat 0 as the same sign no matter what.

Answer 8

Assuming arithmetic arithmetic ( http://en.wikipedia.org/wiki/Two_complement ):

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

This can take only two instructions and less than 1 ns on a modern processor with optimization.

Do not assume arithmetic arithmetic:

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

This may require one or two additional instructions and do a little more.

Using multiplication is a bad idea because it is vulnerable to overflow.

Answer 9

if (x * y)> 0 ...

assuming nonzero and such.

Answer 10

As a technical note, bit-twiddly solutions will be much more efficient than multiplication even on modern architectures. These are just about three cycles that you save, but you know what they say about the “saved penny” ...

Answer 11

Just from the head ...

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

Answer 12

For any int size with two arithmetic additions:

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

Answer 13

Assume 32 bit

if ((((x ^ y) and 0x80000000) == 0)

... if (x * y> 0) answer is bad due to overflow

Answer 14

non-redistributable version of C:

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

C ++ pattern for integer types:

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

Answer 15

if the sign (a * b <0) is different, otherwise the sign is the same (or a or b is zero)

Answer 16

Returning to my university days, in most representations of machines, is this not the leftmost bit of the integer a 1 when the number is negative, and 0 when it is positive?

I suppose it depends more on the machine.

Answer 17

int same_sign =! ((x → 31) ^ (y → 31));

if (same_sign) ... else ...

Answer 18

It is better to use std :: signbit as follows:

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

It also supports other base types ( double , float , char , etc.).