Gibt es eine Standard-Vorzeichenfunktion (signum, sgn) in C/C++?

Question

Ich möchte eine Funktion, die -1 für negative Zahlen und +1 für positive Zahlen zurückgibt. http://en.wikipedia.org/wiki/Sign_function Es ist einfach genug, meine eigene zu schreiben, aber es scheint etwas zu sein, das irgendwo in einer Standardbibliothek sein sollte.

Edit: Ich habe speziell nach einer Funktion gesucht, die mit Floats arbeitet.

Answer 1

Ein bisschen off-topic, aber ich benutze das:

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));
}

und ich fand die erste Funktion - die mit zwei Argumenten - sehr viel nützlicher als die "Standard"-Funktion sgn(), weil sie am häufigsten in Code wie diesem verwendet wird:

int comp(unsigned a, unsigned b){
   return sgn( int(a) - int(b) );
}

vs.

int comp(unsigned a, unsigned b){
   return sgn(a, b);
}

gibt es keinen Cast für vorzeichenlose Typen und kein zusätzliches Minus.

In der Tat habe ich dieses Stück Code mit 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);
}

Answer 2

Hier ist eine verzweigungsfreundliche Implementierung:

inline int signum(const double x) {
    if(x == 0) return 0;
    return (1 - (static_cast<int>((*reinterpret_cast<const uint64_t*>(&x)) >> 63) << 1));
}

Sofern Ihre Daten nicht zur Hälfte aus Nullen bestehen, wählt der Zweigprädiktor einen der Zweige als den häufigsten aus. Beide Zweige beinhalten nur einfache Operationen.

Alternativ dazu kann bei einigen Compilern und CPU-Architekturen eine vollständig verzweigungslose Version schneller sein:

inline int signum(const double x) {
    return (x != 0) * 
        (1 - (static_cast<int>((*reinterpret_cast<const uint64_t*>(&x)) >> 63) << 1));
}

Dies funktioniert bei IEEE 754 doppeltgenaues binäres Gleitkommaformat: binary64 .

Answer 3

Während die Integer-Lösung in der akzeptierten Antwort recht elegant ist, störte es mich, dass sie nicht in der Lage ist, NAN für Double-Typen zurückzugeben, also habe ich sie leicht verändert.

template <typename T> double sgn(T val) {
    return double((T(0) < val) - (val < T(0)))/(val == val);
}

Beachten Sie, dass die Rückgabe einer Fließkomma-NAN im Gegensatz zu einer hart kodierten NAN bewirkt, dass das Vorzeichenbit in einige Implementierungen , so dass die Ausgabe für val = -NAN y val = NAN werden auf jeden Fall identisch sein (wenn Sie eine " nan " Ausgabe über eine -nan können Sie eine abs(val) vor der Rückkehr...)

Answer 4

int sign(float n)
{     
  union { float f; std::uint32_t i; } u { n };
  return 1 - ((u.i >> 31) << 1);
}

Diese Funktion setzt voraus:

• binär32 Darstellung von Gleitkommazahlen
• einen Compiler, der eine Ausnahme über das strenge Aliasing Regel bei Verwendung einer namens Gewerkschaft

Answer 5

double signof(double a) { return (a == 0) ? 0 : (a<0 ? -1 : 1); }