I want a function that returns -1 for negative numbers and +1 for positive numbers. http://en.wikipedia.org/wiki/Sign_function 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.

Surprised no one has posted the type-safe C++ version yet:

```
template <typename T> int sgn(T val) {
return (T(0) < val) - (val < T(0));
}
```

Benefits:

- Actually implements signum (-1, 0, or 1). Implementations here using copysign only return -1 or 1, which is not signum. Also, some implementations here are returning a float (or T) rather than an int, which seems wasteful.
- Works for ints, floats, doubles, unsigned shorts, or any custom types constructible from integer 0 and orderable.
- Fast!
`copysign`

is slow, especially if you need to promote and then narrow again. This is branchless and optimizes excellently - Standards-compliant! The bitshift hack is neat, but only works for some bit representations, and doesn't work when you have an unsigned type. It could be provided as a manual specialization when appropriate.
- Accurate! Simple comparisons with zero can maintain the machine's internal high-precision representation (e.g. 80 bit on x87), and avoid a premature round to zero.

Caveats:

- It's a template so it might take longer to compile in some circumstances.
- Apparently some people think use of a new, somewhat esoteric, and very slow standard library function
*that doesn't even really implement signum*is more understandable. The

`< 0`

part of the check triggers GCC's`-Wtype-limits`

warning when instantiated for an unsigned type. You can avoid this by using some overloads:`template <typename T> inline constexpr int signum(T x, std::false_type is_signed) { return T(0) < x; } template <typename T> inline constexpr int signum(T x, std::true_type is_signed) { return (T(0) < x) - (x < T(0)); } template <typename T> inline constexpr int signum(T x) { return signum(x, std::is_signed<T>()); }`

(Which is a good example of the first caveat.)

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)
```

Licensed under: CC-BY-SA with attribution

Not affiliated with: Stack Overflow