Is there a standard sign function (signum, sgn) in C/C++?

Question

I want a function that returns -1 for negative numbers and +1 for positive numbers. http://en.wikipedia.org/wiki/Sign%5Ffunction It's easy enough to write my own, but it seems like something that ought to be in a standard library somewhere.

Edit: Specifically, I was looking for a function working on floats.

Answer 1

I don't know of a standard function for it. Here's an interesting way to write it though:

(x > 0) - (x < 0)

Here's a more readable way to do it:

if (x > 0) return 1;
if (x < 0) return -1;
return 0;

If you like the ternary operator you can do this:

(x > 0) ? 1 : ((x < 0) ? -1 : 0)

Answer 2

There's a way to do it without branching, but it's not very pretty.

sign = -(int)((unsigned int)((int)v) >> (sizeof(int) * CHAR_BIT - 1));

http://graphics.stanford.edu/~seander/bithacks.html

Lots of other interesting, overly-clever stuff on that page, too...

Answer 3

Hi

My copy of C in a Nutshell reveals the existence of a standard function called copysign which might be useful. It looks as if copysign(1.0, -2.0) would return -1.0 and copysign(1.0, 2.0) would return +2.0.

Pretty close huh ?

Regards

Mark

Answer 4

There is a C99 math library function called copysign(), which takes the sign from one argument and the absolute value from the other:

result= copysign(1.0,value)

will give you a result of +/- 1.0, depending on the sign of value. Since floating point values are signed, (+0) will yield +1, and (-0) will yield -1.

Answer 5

If all you want is to test the sign, use signbit (returns true if its argument has a negative sign). Not sure why you would particularly want -1 or +1 returned; copysign is more convenient for that, but it sounds like it will return +1 for negative zero on some platforms with only partial support for negative zero, where signbit presumably would return true.

Answer 6

I tend to use the following:

signval = i/abs(i);

That gives +/- 1 although it's likely not very fast.

Answer 7

And just because you can never have enough different ways to compute a simple value ... The book Hacker's Delight by Henry S. Warren, Jr. describes the sign function on page 19. It gives the the comparison predicate version described by Mark Byers as well as a couple of others. With the Microsoft compiler (v14.00.50727.762), both the /O1 and /O2 switches produce less assembly for the following version from the book:

#define sign1(x) (( x >> 31 ) | ( (unsigned int)( -x ) >> 31 ))

Than for the predicate comparison version:

#define sign2(x) (( x > 0 ) - ( x < 0 ))

It took 3.8 seconds to test 2 billion integers on my PC using sign1. It took 5.7 seconds to test the same values using the comparison predicate version (sign2):

I didn't time it, but gcc (v4.0.2) emitted the same number of assembly instructions both both of these versions of the sign function.

I would be hesitant to use the version with the shift operator, though, unless that small speed improvement was terribly critical. It depends on the signed and unsigned right shift behaving appropriately (not to mention the hard coded assumption on integer size).

Answer 8

The OP's question was "C/C++" but here is a strictly c++ solution:

template <typename T>
T sign(T t) 
{
    if( t == 0 )
        return T(0);
    else
        return (t < 0) : T(-1) : T(1);
}

which doesn't handle +/- zero, but uses templates nicely to overload for any type for which the compiler can understand 0, 1, and -1. If it's used on a type for which this isn't true, then the compiler will complain so you don't get unexpected behavior. This wont have the speed of some of the earlier posts, but will be handy for many cases still.