Question

I need the most efficient way (in cpu cycles) to determine if two numbers have the same/different sign. But the catch is if either number is zero I need to be able to distinguish it from numbers with same/different signs (ie. zero is treated as a “third” sign). The following code is similar to what I need, but the return values can be anything as long as there are only three distinct return values.

int foo(int x, int y) {
    if (x * y > 0) return 1;
    if (x * y < 0) return -1;
    return 0;
}

For my specific problem, the values are in the range [-6, 6] and X is guaranteed to not be 0. I found a solution to find if two numbers have the same sign, and altered it to get the following solution.

return y? (((x^y) >= 0)? 1 : -1) : 0;

There should be some bitops/comparisons that give faster results than using multiplication, branching, comparisons.

Answer 1

Here is another version (with ugly, non-portable bit manipulation tricks):

int foo(int x, int y) {
    return ((x^y) >> 4) - ((x^(-y)) >> 4);
}

Some explanations:

• ((x^y) >> 4) is -1 if exactly one of x and y is negative, otherwise it is 0.
• ((x^(-y)) >> 4) is -1 if exactly one of x and -y is negative, otherwise it is 0.
• If x > 0 and y > 0, the result will be 0 – (-1) = 1.
• If x < 0 and y < 0, the result will be 0 – (-1) = 1.
• If x > 0 and y = 0, the result will be 0 – 0 = 0.
• If x < 0 and y = 0, the result will be (-1) – (-1) = 0.
• If x > 0 and y < 0, the result will be (-1) – 0 = -1.
• If x < 0 and y > 0, the result will be (-1) – 0 = -1.

Assumes two’s complement arithmetic and assumes that >> shifts with sign-extension.