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.
The type-safe C++ version:
template <typename T> int sgn(T val) {
return (T(0) < val) - (val < T(0));
}
Benefits:
copysign is slow, especially if you need to promote and then narrow again. This is branchless and optimizes excellentlyCaveats:
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.)
T. –
Bandmaster std::copysign seems to result in excellent code for me: 4 instructions (inlined), no branching, entirely using the FPU. The recipe given in this answer, by contrast, generates much worse code (many more instructions, including a multiply, moving back and forth between integer unit and FPU)... –
Fullback copysign on an int it promotes to float/double, and must narrow again on return. Your compiler may optimize that promotion out but I can't find anything suggesting that's guaranteed by the standard. Also to implement signum via copysign you need to manually handle the 0 case - please make sure you include that in any performance comparison. –
Hearth return (T(0) < val) - (val < T(0)); it only requires operator< defined. You can also avoid having two temporaries (and constructors) by assigning T(0) to a temporary explicitly. The compiler can not make this optimization for more complex types T. –
Basketwork operator<. But constexpr functions bodies are required to have only a return statement (+ using/typedef), so you have to choose between constexpr and optimizing expensive constructors; in this case I think constexpr is more useful. –
Hearth bools standard-compliant? –
Spirituous bool are implicitly convertible to int. false converts to zero and true converts to one. –
Lodger true converts to 1, and not just to an implementation-defined non-zero value? –
Spirituous cmov or predication to avoid a branch. On x86 this this can trivially be branchless with setg, as illustrated here: godbolt.org/g/XNst9Z I don't know too much about PowerPC or ARM, but from playing around on godbolt.org it appears to be branchless there also. –
Criollo setg for cmov, compiler would be able to optimize them if they can. godbolt.org/z/sEnqEE –
Biological cmov is required. But your changed version is not correct (notice it's backwards: godbolt.org/z/Gr9sje). Also the ternary operator is not required, the solution in this answer is correct and does not require a branch or cmov: godbolt.org/z/x6r4hn). –
Criollo cmov on x86. –
Criollo setg or cmov) –
Biological setg to eliminate operator <, it probably would also be able to use cmov for similar condition (while both doesn't mean there is no branch) –
Biological cmov and setg (or the equivalent for other cpus). This means that the code above is not guaranteed to be branchless on all architectures. You can check with the different godbolt links, the code is not branchless on AVR, MPS430 and when using Visual-C (even on x86). Without these precisions, my comment is indeed false and misleading. –
Jovitajovitah Also, some implementations here are returning a float (or T) rather than an int, which seems wasteful. NB it's not so wasteful in a fairly typical setting in which the result of the sign function is being used immediately in a floating-point expression, so an int would be converted to a floating point value anyway. –
Misdirection 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)
x==0. –
Homage ?: expressions into non-branching machine code. –
Dualistic x ? (x < 0) ? -1 : 1 : 0 –
Belligerence 1 in C? –
Chief <, > ... shall yield 1 if the specified relation is true and 0 if it is false" –
Granule 0 is "false"; any other value is "true"; however, the relational and equality operators always return 0 or 1 (see Standard 6.5.8 and 6.5.9). -- the value of the expression a * (x == 42) is either 0 or a. –
Elusion !) also returns 0 or 1. !!x is 0 is the value of x is 0, 1 otherwise :) –
Elusion is* functions declared in <ctype.h>. 7.4.1/1 "The functions in this subclause return nonzero (true) if and only if ...", so not all "boolean" C functions return exclusively 0 and 1. –
Elusion copysign for integral x even if I had it available. –
Homage > and < incur a branch! The CPU has to compare the operands, then it has to decide whether to load a 1 or a 0 into a register based on that result. Some platforms might be able to avoid that if they have a 'copy SREG flag into register' function, but that's not going to hold true for all architectures. –
Joashus 0 / 1 in a register based on a compare result, with just a data dependency, not a branch (control dependency). e.g. x86 setcc to set a reg based on a FLAGS condition; MIPS / RISC-V slt (set on less-than), AArch64 CSET (built on top of CSINC with the zero register; AArch64 has a very nice small selection of branchless conditional instructions). There are a few where it's so inconvenient that branchy is preferred; e.g. a comment on another answer mentions MSP430 and AVR. –
Cadre <= where slt isn't usable alone, see How to do less than or equal in Assembly Language(MIPS)?. Anyway, < doesn't inherently incur a branch. –
Cadre (x > 0) - (x < 0) is the best way –
Bielefeld 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) // double
result = copysignf(1.0, value) // float
result = copysignl(1.0, value) // long double
will give you a result of +/- 1.0, depending on the sign of value. Note that floating point zeroes are signed: (+0) will yield +1, and (-0) will yield -1.
copysign seems to result in much better code than any of the suggested alternatives... –
Fullback copysign() on an AVR microcontroller, it adds an amazing 334 bytes to the program size compared to the "hacks" (if not already using anything else from math.h). –
Tolidine It seems that most of the answers missed the original question.
Is there a standard sign function (signum, sgn) in C/C++?
Not in the standard library, however there is copysign which can be used almost the same way via copysign(1.0, arg) and there is a true sign function in boost, which might as well be part of the standard.
#include <boost/math/special_functions/sign.hpp>
//Returns 1 if x > 0, -1 if x < 0, and 0 if x is zero.
template <class T>
inline int sign (const T& z);
Apparently, the answer to the original poster's question is no. There is no standard C++ sgn function.
Is there a standard sign function (signum, sgn) in C/C++?
Yes, depending on definition.
C99 and later has the signbit() macro in <math.h>
int signbit(real-floatingx);
Thesignbitmacro returns a nonzero value if and only if the sign of its argument value is negative. C11 §7.12.3.6
Yet OP wants something a little different.
I want a function that returns -1 for negative numbers and +1 for positive numbers. ... a function working on floats.
#define signbit_p1_or_n1(x) ((signbit(x) ? -1 : 1)
Deeper:
OP's question is not specific in the following x cases: 0.0, -0.0, +NaN, -NaN.
A classic signum() returns +1 on x>0, -1 on x<0 and 0 on x==0.
Many answers have already covered that, but do not address x as -0.0, +NaN, -NaN. Many are geared for an integer point-of-view that usually lacks Not-a-Numbers (NaN) and -0.0.
Typical answers function like signnum_typical() On -0.0, +NaN, -NaN, they return 0.0, 0.0, 0.0.
int signnum_typical(double x) {
if (x > 0.0) return 1;
if (x < 0.0) return -1;
return 0;
}
Instead, I propose this functionality: On -0.0, +NaN, -NaN, it returns -0.0, +NaN, -NaN.
double signnum_c(double x) {
if (x > 0.0) return 1.0;
if (x < 0.0) return -1.0;
return x;
}
Faster than the above solutions, including the highest rated one:
(x < 0) ? -1 : (x > 0)
(x < 0) ? -1 : (x > 0) ? 1 : 0? It might be less terse, but it's more readable. –
Joashus 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...
sign = (v != 0) | -(int)((unsigned int)((int)v) >> (sizeof(int) * CHAR_BIT - 1)); or sign = (v > 0) - (v < 0);. –
Lexine v is an integer type not wider than int –
Angelicangelica 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.
if (x < 0). –
Flameproof In general, there is no standard signum function in C/C++, and the lack of such a fundamental function tells you a lot about these languages.
Apart from that, I believe both majority viewpoints about the right approach to define such a function are in a way correct, and the "controversy" about it is actually a non-argument once you take into account two important caveats:
A signum function should always return the type of its operand, similarly to an abs() function, because signum is usually used for multiplication with an absolute value after the latter has been processed somehow. Therefore, the major use case of signum is not comparisons but arithmetic, and the latter shouldn't involve any expensive integer-to/from-floating-point conversions.
Floating point types do not feature a single exact zero value: +0.0 can be interpreted as "infinitesimally above zero", and -0.0 as "infinitesimally below zero". That's the reason why comparisons involving zero must internally check against both values, and an expression like x == 0.0 can be dangerous.
Regarding C, I think the best way forward with integral types is indeed to use the (x > 0) - (x < 0) expression, as it should be translated in a branch-free fashion, and requires only three basic operations. Best define inline functions that enforce a return type matching the argument type, and add a C11 define _Generic to map these functions to a common name.
With floating point values, I think inline functions based on C11 copysignf(1.0f, x), copysign(1.0, x), and copysignl(1.0l, x) are the way to go, simply because they're also highly likely to be branch-free, and additionally do not require casting the result from integer back into a floating point value. You should probably comment prominently that your floating point implementations of signum will not return zero because of the peculiarities of floating point zero values, processing time considerations, and also because it is often very useful in floating point arithmetic to receive the correct -1/+1 sign, even for zero values.
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 +1.0.
Pretty close huh?
The accepted answer with the overload below does indeed not trigger -Wtype-limits. But it does trigger unused argument warnings (on the is_signed variable). To avoid these the second argument should not be named like so:
template <typename T> inline constexpr
int signum(T x, std::false_type) {
return T(0) < x;
}
template <typename T> inline constexpr
int signum(T x, std::true_type) {
return (T(0) < x) - (x < T(0));
}
template <typename T> inline constexpr
int signum(T x) {
return signum(x, std::is_signed<T>());
}
For C++11 and higher an alternative could be.
template <typename T>
typename std::enable_if<std::is_unsigned<T>::value, int>::type
inline constexpr signum(T const x) {
return T(0) < x;
}
template <typename T>
typename std::enable_if<std::is_signed<T>::value, int>::type
inline constexpr signum(T const x) {
return (T(0) < x) - (x < T(0));
}
For me it does not trigger any warnings on GCC 5.3.1.
-Wunused-parameter warning just use unnamed parameters. –
Mala The question is old but there is now this kind of desired function. I added a wrapper with not, left shift and dec.
You can use a wrapper function based on signbit from C99 in order to get the exact desired behavior (see code further below).
Returns whether the sign of x is negative.
This can be also applied to infinites, NaNs and zeroes (if zero is unsigned, it is considered positive
#include <math.h>
int signValue(float a) {
return ((!signbit(a)) << 1) - 1;
}
NB: I use operand not ("!") because the return value of signbit is not specified to be 1 (even though the examples let us think it would always be this way) but true for a negative number:
Return value
A non-zero value (true) if the sign of x is negative; and zero (false) otherwise.
Then I multiply by two with left shift (" << 1") which will give us 2 for a positive number and 0 for a negative one and finally decrement by 1 to obtain 1 and -1 for respectively positive and negative numbers as requested by OP.
You can use boost::math::sign() method from boost/math/special_functions/sign.hpp if boost is available.
No, it doesn't exist in c++, like in matlab. I use a macro in my programs for this.
#define sign(a) ( ( (a) < 0 ) ? -1 : ( (a) > 0 ) )
#define sign(x) (((x) > 0) - ((x) < 0)) which is good too. –
Cestar Bit off-topic, but I use this:
template<typename T>
constexpr int sgn(const T &a, const T &b) noexcept{
return (a > b) - (a < b);
}
template<typename T>
constexpr int sgn(const T &a) noexcept{
return sgn(a, T(0));
}
and I found first function - the one with two arguments, to be much more useful from "standard" sgn(), because it is most often used in code like this:
int comp(unsigned a, unsigned b){
return sgn( int(a) - int(b) );
}
vs.
int comp(unsigned a, unsigned b){
return sgn(a, b);
}
there is no cast for unsigned types and no additional minus.
in fact i have this piece of code using sgn()
template <class T>
int comp(const T &a, const T &b){
log__("all");
if (a < b)
return -1;
if (a > b)
return +1;
return 0;
}
inline int comp(int const a, int const b){
log__("int");
return a - b;
}
inline int comp(long int const a, long int const b){
log__("long");
return sgn(a, b);
}
Here's a branching-friendly implementation:
inline int signum(const double x) {
if(x == 0) return 0;
return (1 - (static_cast<int>((*reinterpret_cast<const uint64_t*>(&x)) >> 63) << 1));
}
Unless your data has zeros as half of the numbers, here the branch predictor will choose one of the branches as the most common. Both branches only involve simple operations.
Alternatively, on some compilers and CPU architectures a completely branchless version may be faster:
inline int signum(const double x) {
return (x != 0) *
(1 - (static_cast<int>((*reinterpret_cast<const uint64_t*>(&x)) >> 63) << 1));
}
This works for IEEE 754 double-precision binary floating-point format: binary64 .
While the integer solution in the accepted answer is quite elegant it bothered me that it wouldn't be able to return NAN for double types, so I modified it slightly.
template <typename T> double sgn(T val) {
return double((T(0) < val) - (val < T(0)))/(val == val);
}
Note that returning a floating point NAN as opposed to a hard coded NAN causes the sign bit to be set in some implementations, so the output for val = -NAN and val = NAN are going to be identical no matter what (if you prefer a "nan" output over a -nan you can put an abs(val) before the return...)
int sign(float n)
{
union { float f; std::uint32_t i; } u { n };
return 1 - ((u.i >> 31) << 1);
}
This function assumes:
copysign; if you're using static_assert you've got C++11, and might as well really use copysign. –
Hearth double signof(double a) { return (a == 0) ? 0 : (a<0 ? -1 : 1); }
Why use ternary operators and if-else when you can simply do this
#define sgn(x) x==0 ? 0 : x/abs(x)
x == INT_MIN. –
Rathbun © 2022 - 2024 — McMap. All rights reserved.
x==0. According to IEEE 754, negative zero and positive zero should compare as equal. – Barbellatesgn()of your comment is a reasonable view of how to handle zeros. OP only indirectly specified sign of zero with a link. Another reasonable view of the "sign" is to return 1,-1 on +zero,-zero. Sometimes the sign of zero makes a difference. It depends on user's need. Also NaN is a consideration as OP specifiedfloat. – Rathbun