Gibt es eine Standardzeichenfunktion (signum, sgn) in C / C ++?

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 eigenen zu schreiben, aber es scheint etwas zu sein, das irgendwo in einer Standardbibliothek sein sollte.

Bearbeiten: Insbesondere suchte ich nach einer Funktion, die an Floats arbeitet.

Überrascht hat noch niemand die typsichere C ++ - Version veröffentlicht:

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

Leistungen:

• Implementiert tatsächlich signum (-1, 0 oder 1). Implementierungen, die hier Copysign verwenden, geben nur -1 oder 1 zurück, was kein Signum ist. Außerdem geben einige Implementierungen hier eher einen Float (oder T) als einen Int zurück, was verschwenderisch erscheint.
• Funktioniert für Ints, Floats, Doubles, Shorts ohne Vorzeichen oder alle benutzerdefinierten Typen, die aus Ganzzahl 0 konstruierbar und bestellbar sind.
• Schnell! copysignist langsam, besonders wenn Sie fördern und dann wieder verengen müssen. Dies ist verzweigungslos und optimiert hervorragend
• Normkonform! Der Bitshift-Hack ist ordentlich, funktioniert aber nur für einige Bit-Darstellungen und nicht, wenn Sie einen vorzeichenlosen Typ haben. Es könnte gegebenenfalls als manuelle Spezialisierung bereitgestellt werden.
• Genau! Durch einfache Vergleiche mit Null kann die interne hochpräzise Darstellung der Maschine (z. B. 80 Bit auf x87) beibehalten und eine vorzeitige Runde auf Null vermieden werden.

Vorsichtsmaßnahmen:

• Da es sich um eine Vorlage handelt, kann das Kompilieren unter bestimmten Umständen länger dauern.
• Anscheinend halten einige Leute die Verwendung einer neuen, etwas esoterischen und sehr langsamen Standardbibliotheksfunktion , die signum nicht einmal wirklich implementiert, für verständlicher.

• Der < 0Teil der Prüfung löst die -Wtype-limitsWarnung des GCC aus, wenn er für einen Typ ohne Vorzeichen instanziiert wird. Sie können dies vermeiden, indem Sie einige Überladungen verwenden:

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

  (Welches ist ein gutes Beispiel für die erste Einschränkung.)

Ich kenne keine Standardfunktion dafür. Hier ist eine interessante Möglichkeit, es zu schreiben:

(x > 0) - (x < 0)

Hier ist eine besser lesbare Möglichkeit:

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

Wenn Sie den ternären Operator mögen, können Sie dies tun:

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

Es gibt eine C99-Mathematikbibliotheksfunktion namens copysign (), die das Vorzeichen von einem Argument und den Absolutwert von dem anderen übernimmt:

result = copysign(1.0, value) // double
result = copysignf(1.0, value) // float
result = copysignl(1.0, value) // long double

gibt Ihnen ein Ergebnis von +/- 1,0, abhängig vom Vorzeichen des Wertes. Beachten Sie, dass Gleitkomma-Nullen vorzeichenbehaftet sind: (+0) ergibt +1 und (-0) ergibt -1.

Es scheint, dass die meisten Antworten die ursprüngliche Frage verfehlt haben.

Gibt es eine Standardzeichenfunktion (signum, sgn) in C / C ++?

Nicht in der Standardbibliothek, aber es gibt copysigneine, die fast auf die gleiche Weise über verwendet werden kann, copysign(1.0, arg)und es gibt eine True-Sign-Funktion in boost, die genauso gut Teil des Standards sein könnte.

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

http://www.boost.org/doc/libs/1_47_0/libs/math/doc/sf_and_dist/html/math_toolkit/utils/sign_functions.html

Anscheinend lautet die Antwort auf die Frage des Originalplakats nein. Es gibt keine Standard- C ++ - sgnFunktion.

Schneller als die oben genannten Lösungen, einschließlich der am besten bewerteten:

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

Gibt es eine Standardzeichenfunktion (signum, sgn) in C / C ++?

Ja, je nach Definition.

C99 und höher hat das signbit()Makro in<math.h>

int signbit(Real-Floating x);
Das signbitMakro gibt genau dann einen Wert ungleich Null zurück, wenn das Vorzeichen seines Argumentwerts negativ ist. C11 §7.12.3.6

Dennoch möchte OP etwas anderes.

Ich möchte eine Funktion, die -1 für negative Zahlen und +1 für positive Zahlen zurückgibt. ... eine Funktion, die an Schwimmern arbeitet.

#define signbit_p1_or_n1(x)  ((signbit(x) ?  -1 : 1)

Tiefer:

Die Stelle ist in folgenden Fällen nicht spezifisch : x = 0.0, -0.0, +NaN, -NaN.

Ein Klassiker signum()kehrt +1auf x>0, -1an x<0und 0auf x==0.

Viele Antworten haben dies bereits behandelt, aber nicht angesprochen x = -0.0, +NaN, -NaN. Viele sind auf eine ganzzahlige Sichtweise ausgerichtet, der normalerweise Not-a-Numbers ( NaN ) und -0,0 fehlen .

Typische Antworten funktionieren wie signnum_typical() Ein -0.0, +NaN, -NaN, sie kehren zurück 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;
}

Stattdessen schlage ich diese Funktionalität vor: Ein -0.0, +NaN, -NaN, es kehrt zurück -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;
}

Es gibt eine Möglichkeit, dies ohne Verzweigung zu tun, aber es ist nicht sehr hübsch.

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

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

Viele andere interessante, übermäßig clevere Sachen auf dieser Seite ...

Wenn Sie nur das Vorzeichen testen möchten, verwenden Sie signbit (gibt true zurück, wenn das Argument ein negatives Vorzeichen hat). Ich bin mir nicht sicher, warum Sie besonders -1 oder +1 zurückgeben möchten. Copysign ist dafür bequemer, aber es klingt so, als würde es auf einigen Plattformen +1 für negative Null zurückgeben, wobei negative Null nur teilweise unterstützt wird, wobei signbit vermutlich true zurückgeben würde.

Im Allgemeinen gibt es in C / C ++ keine Standard-Signum-Funktion, und das Fehlen einer solchen Grundfunktion sagt viel über diese Sprachen aus.

Abgesehen davon glaube ich, dass beide Ansichten der Mehrheit über den richtigen Ansatz zur Definition einer solchen Funktion in gewisser Weise richtig sind, und die "Kontroverse" darüber ist eigentlich kein Argument, wenn man zwei wichtige Vorbehalte berücksichtigt:

• Eine Signum- Funktion sollte ähnlich wie eine abs()Funktion immer den Typ ihres Operanden zurückgeben, da Signum normalerweise zur Multiplikation mit einem Absolutwert verwendet wird, nachdem dieser irgendwie verarbeitet wurde. Daher ist der Hauptanwendungsfall von Signum nicht Vergleiche, sondern Arithmetik, und letztere sollte keine teuren Ganzzahl-zu-Von-Gleitkomma-Konvertierungen beinhalten.

• Gleitkommatypen haben keinen einzigen exakten Nullwert: +0,0 kann als "infinitesimal über Null" und -0,0 als "infinitesimal unter Null" interpretiert werden. Aus diesem Grund müssen Vergleiche mit Null intern mit beiden Werten verglichen werden, und ein Ausdruck wie x == 0.0kann gefährlich sein.

In Bezug auf C denke ich, dass der beste Weg für integrale Typen in der Tat darin besteht, den (x > 0) - (x < 0)Ausdruck zu verwenden, da er verzweigungsfrei übersetzt werden sollte und nur drei grundlegende Operationen erfordert. Definieren Sie am besten Inline-Funktionen, die einen Rückgabetyp erzwingen, der dem Argumenttyp entspricht, und fügen Sie einen C11 hinzu define _Generic, um diese Funktionen einem allgemeinen Namen zuzuordnen.

Mit Gleitkommazahlen, ich denke , Inline - Funktionen basierend auf C11 copysignf(1.0f, x), copysign(1.0, x)und copysignl(1.0l, x)bin der Weg zu gehen, einfach weil sie sind auch sehr wahrscheinlich zu sein , astfrei und zusätzlich erfordert nicht das Ergebnis von integer zurück in eine Floating - Point - Casting Wert. Sie sollten wahrscheinlich deutlich darauf hinweisen, dass Ihre Gleitkommaimplementierungen von signum aufgrund der Besonderheiten von Gleitkomma-Nullwerten, Überlegungen zur Verarbeitungszeit und auch, weil es in der Gleitkomma-Arithmetik oft sehr nützlich ist, das richtige -1 / + zu erhalten, nicht Null zurückgeben 1 Vorzeichen, auch für Nullwerte.

Meine Kopie von C auf den Punkt gebracht zeigt die Existenz einer Standardfunktion namens Copysign, die nützlich sein könnte. Es sieht so aus, als würde Copysign (1.0, -2.0) -1,0 und Copysign (1.0, 2.0) +1.0 zurückgeben.

Ziemlich nah, oder?

Nein, es existiert nicht in c ++, wie in matlab. Ich benutze dafür ein Makro in meinen Programmen.

#define sign(a) ( ( (a) < 0 )  ?  -1   : ( (a) > 0 ) )

Die akzeptierte Antwort mit der folgenden Überladung löst in der Tat keine -Wtype-Limits aus .

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

Für C ++ 11 könnte eine Alternative sein.

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

Für mich löst es keine Warnungen auf GCC 5.3.1 aus.

Etwas abseits des Themas, aber ich benutze dies:

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 - viel nützlicher als "standard" sgn (), da sie in Code wie diesem am häufigsten 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);
}

Es gibt keine Besetzung für vorzeichenlose Typen und kein zusätzliches Minus.

Tatsächlich habe ich diesen 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);
}

Die Frage ist alt, aber es gibt jetzt diese Art von gewünschter Funktion. Ich habe einen Wrapper mit not, left shift und dec hinzugefügt.

Sie können eine Wrapper-Funktion verwenden, die auf dem Signbit von C99 basiert , um das genau gewünschte Verhalten zu erhalten (siehe Code weiter unten).

Gibt zurück, ob das Vorzeichen von x negativ ist.
Dies kann auch auf Unendlichkeiten, NaNs und Nullen angewendet werden (wenn Null ohne Vorzeichen ist, wird dies als positiv betrachtet

#include <math.h>

int signValue(float a) {
    return ((!signbit(a)) << 1) - 1;
}

NB: Ich verwende den Operanden nicht ("!"), Da der Rückgabewert von signbit nicht als 1 angegeben ist (obwohl die Beispiele uns glauben lassen, dass dies immer so wäre), sondern für eine negative Zahl gilt:

Rückgabewert
Ein Wert ungleich Null (true), wenn das Vorzeichen von x negativ ist. und sonst Null (falsch).

Dann multipliziere ich mit zwei mit der Linksverschiebung ("<< 1"), was 2 für eine positive Zahl und 0 für eine negative Zahl ergibt und schließlich um 1 dekrementiert, um 1 und -1 für jeweils positive und negative Zahlen zu erhalten, wie von angefordert OP.

Obwohl die ganzzahlige Lösung in der akzeptierten Antwort ziemlich elegant ist, hat es mich gestört, dass sie NAN für doppelte Typen nicht zurückgeben kann, deshalb habe ich sie leicht modifiziert.

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

Beachten Sie, dass die Rückgabe eines Gleitkomma-NAN im Gegensatz zu einem fest codierten NAN NANin einigen Implementierungen dazu führt , dass das Vorzeichenbit gesetzt wird , sodass die Ausgabe für val = -NANund val = NANunabhängig davon identisch ist (wenn Sie eine " nan" Ausgabe gegenüber einer Ausgabe bevorzugen, die -nanSie setzen können) ein abs(val)vor der Rückkehr ...)

Sie können die boost::math::sign()Methode verwenden, boost/math/special_functions/sign.hppwenn Boost verfügbar ist.

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 keine Nullen als die Hälfte der Zahlen haben, wählt der Zweigprädiktor hier einen der Zweige als den häufigsten aus. Beide Zweige beinhalten nur einfache Operationen.

Alternativ kann auf 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 für das binäre Gleitkommaformat IEEE 754 mit doppelter Genauigkeit: binary64 .

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

Diese Funktion setzt voraus:

• binäre 32- Darstellung von Gleitkommazahlen
• Ein Compiler, der bei Verwendung einer benannten Union eine Ausnahme von der strengen Aliasing- Regel macht

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

Warum ternäre Operatoren verwenden und wenn-sonst, wenn Sie dies einfach tun können

#define sgn(x) x==0 ? 0 : x/abs(x)