Existe-t-il une fonction de signe standard (signum, sgn) en C / C ++?

Je veux une fonction qui renvoie -1 pour les nombres négatifs et +1 pour les nombres positifs. http://en.wikipedia.org/wiki/Sign_function Il est assez facile d'écrire le mien, mais il semble que quelque chose devrait se trouver quelque part dans une bibliothèque standard.

Edit: Plus précisément, je cherchais une fonction travaillant sur les flotteurs.

Surpris, personne n'a encore publié la version C ++ de type sécurisé:

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

Avantages:

• Implémente en fait le signum (-1, 0 ou 1). Les implémentations ici utilisant copysign ne renvoient que -1 ou 1, ce qui n'est pas le signe. De plus, certaines implémentations renvoient ici un float (ou T) plutôt qu'un int, ce qui semble inutile.
• Fonctionne pour les entiers, les flottants, les doubles, les shorts non signés ou tout type personnalisé pouvant être construit à partir de l'entier 0 et pouvant être commandé.
• Vite! copysignest lent, surtout si vous devez promouvoir puis rétrécir à nouveau. Ceci est sans branche et optimise parfaitement
• Conforme aux normes! Le hack bitshift est soigné, mais ne fonctionne que pour certaines représentations de bits, et ne fonctionne pas lorsque vous avez un type non signé. Il pourrait être fourni en tant que spécialisation manuelle le cas échéant.
• Précis! Des comparaisons simples avec zéro peuvent maintenir la représentation interne de haute précision de la machine (par exemple 80 bits sur x87) et éviter un arrondi prématuré à zéro.

Mises en garde:

• C'est un modèle, il peut donc prendre plus de temps à compiler dans certaines circonstances.
• Apparemment, certaines personnes pensent que l'utilisation d'une nouvelle fonction de bibliothèque standard quelque peu ésotérique et très lente qui n'implémente même pas vraiment signum est plus compréhensible.

• La < 0partie de la vérification déclenche l' -Wtype-limitsavertissement de GCC lorsqu'il est instancié pour un type non signé. Vous pouvez éviter cela en utilisant certaines surcharges:

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

  (Ce qui est un bon exemple de la première mise en garde.)

Je ne connais pas de fonction standard pour cela. Voici une façon intéressante de l'écrire:

(x > 0) - (x < 0)

Voici une façon plus lisible de le faire:

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

Si vous aimez l'opérateur ternaire, vous pouvez le faire:

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

Il existe une fonction de bibliothèque mathématique C99 appelée copysign (), qui prend le signe d'un argument et la valeur absolue de l'autre:

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

vous donnera un résultat de +/- 1.0, selon le signe de la valeur. Notez que les zéros à virgule flottante sont signés: (+0) donnera +1 et (-0) donnera -1.

Il semble que la plupart des réponses aient manqué la question initiale.

Existe-t-il une fonction de signe standard (signum, sgn) en C / C ++?

Pas dans la bibliothèque standard, mais il en existe copysignqui peuvent être utilisés presque de la même manière via copysign(1.0, arg)et il existe une véritable fonction de signe dans boost, qui pourrait tout aussi bien faire partie de la norme.

    #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

Apparemment, la réponse à la question de l'affiche originale est non. Il n'y a pas de fonction C ++ standardsgn .

Existe-t-il une fonction de signe standard (signum, sgn) en C / C ++?

Oui, selon la définition.

C99 et versions ultérieures ont la signbit()macro dans<math.h>

int signbit(flottant réel x);
La signbitmacro renvoie une valeur non nulle si et seulement si le signe de sa valeur d'argument est négatif. C11 §7.12.3.6

Pourtant, OP veut quelque chose d'un peu différent.

Je veux une fonction qui renvoie -1 pour les nombres négatifs et +1 pour les nombres positifs. ... une fonction travaillant sur les flotteurs.

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

Plus profond:

Le poste n'est pas spécifique dans les cas suivants: x = 0.0, -0.0, +NaN, -NaN.

Un classique des signum()retours +1sur x>0, -1sur x<0et 0sur x==0.

De nombreuses réponses ont déjà couvert ce point, mais n'en traitent pas x = -0.0, +NaN, -NaN. Beaucoup sont adaptés à un point de vue entier qui manque généralement de Not-a-Numbers ( NaN ) et -0.0 .

Les réponses typiques fonctionnent comme signnum_typical() On -0.0, +NaN, -NaN, elles reviennent 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;
}

Au lieu de cela, je propose cette fonctionnalité: Oui -0.0, +NaN, -NaN, elle revient -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;
}

Plus rapide que les solutions ci-dessus, y compris la meilleure note:

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

Il y a un moyen de le faire sans ramification, mais ce n'est pas très joli.

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

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

Beaucoup d'autres choses intéressantes et trop intelligentes sur cette page aussi ...

Si tout ce que vous voulez est de tester le signe, utilisez signbit (retourne vrai si son argument a un signe négatif). Je ne sais pas pourquoi vous voudriez particulièrement que -1 ou +1 soit retourné; copysign est plus pratique pour cela, mais il semble qu'il renverra +1 pour zéro négatif sur certaines plates-formes avec seulement un support partiel pour zéro négatif, où signbit retournerait vraisemblablement vrai.

En général, il n'y a pas de fonction de signalisation standard en C / C ++, et l'absence d'une telle fonction fondamentale en dit long sur ces langages.

En dehors de cela, je pense que les deux points de vue majoritaires sur la bonne approche pour définir une telle fonction sont en quelque sorte corrects, et la "controverse" à ce sujet est en fait un non-argument une fois que vous prenez en compte deux mises en garde importantes:

• Une fonction signum doit toujours retourner le type de son opérande, de la même manière qu'une abs()fonction, car signum est généralement utilisé pour la multiplication avec une valeur absolue après que cette dernière a été traitée d'une manière ou d'une autre. Par conséquent, le cas d'utilisation majeur de signum n'est pas les comparaisons mais l'arithmétique, et cette dernière ne devrait pas impliquer de conversions entières en virgule flottante coûteuses.

• Les types à virgule flottante ne comportent pas une seule valeur zéro exacte: +0,0 peut être interprété comme "infinitésimalement supérieur à zéro" et -0,0 comme "infinitésimalement inférieur à zéro". C'est la raison pour laquelle les comparaisons impliquant zéro doivent vérifier en interne par rapport aux deux valeurs, et une expression comme x == 0.0peut être dangereuse.

En ce qui concerne C, je pense que la meilleure façon de progresser avec les types intégraux est en effet d'utiliser l' (x > 0) - (x < 0)expression, car elle doit être traduite sans branchement et ne nécessite que trois opérations de base. Définissez au mieux les fonctions en ligne qui appliquent un type de retour correspondant au type d'argument et ajoutez un C11 define _Genericpour mapper ces fonctions à un nom commun.

Avec les valeurs à virgule flottante, je pense que les fonctions en ligne basées sur C11 copysignf(1.0f, x), copysign(1.0, x)et copysignl(1.0l, x)sont la voie à suivre, simplement parce qu'elles sont également très susceptibles d'être sans branche, et en outre ne nécessitent pas de transtyper le résultat de l'entier en virgule flottante valeur. Vous devriez probablement indiquer clairement que vos implémentations en virgule flottante de signum ne retourneront pas zéro en raison des particularités des valeurs nulles en virgule flottante, des considérations de temps de traitement, et aussi parce qu'il est souvent très utile dans l'arithmétique en virgule flottante de recevoir le bon -1 / + 1 signe, même pour des valeurs nulles.

Ma copie de C en bref révèle l'existence d'une fonction standard appelée copysign qui pourrait être utile. Il semble que copysign (1.0, -2.0) renvoie -1.0 et copysign (1.0, 2.0) renvoie +1.0.

Assez proche hein?

Non, il n'existe pas en c ++, comme dans matlab. J'utilise une macro dans mes programmes pour cela.

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

La réponse acceptée avec la surcharge ci-dessous ne déclenche en effet pas -Wtype-limits .

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

Pour C ++ 11, une alternative pourrait être.

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

Pour moi, cela ne déclenche aucun avertissement sur GCC 5.3.1.

Peu hors sujet, mais j'utilise ceci:

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

et j'ai trouvé la première fonction - celle avec deux arguments, beaucoup plus utile dans sgn () "standard", car elle est le plus souvent utilisée dans du code comme celui-ci:

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

contre.

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

il n'y a pas de transtypage pour les types non signés et aucun inconvénient supplémentaire.

en fait, j'ai ce morceau de code en utilisant 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);
}

La question est ancienne mais il existe désormais ce type de fonction souhaitée. J'ai ajouté un wrapper avec not, shift gauche et dec.

Vous pouvez utiliser une fonction wrapper basée sur signbit de C99 afin d'obtenir le comportement souhaité exact (voir le code ci-dessous).

Renvoie si le signe de x est négatif.
Cela peut également être appliqué aux infinis, aux NaN et aux zéros (si zéro n'est pas signé, il est considéré comme positif

#include <math.h>

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

NB: J'utilise l'opérande non ("!") Car la valeur de retour de signbit n'est pas spécifiée à 1 (même si les exemples laissent penser que ce serait toujours ainsi) mais vrai pour un nombre négatif:

Valeur de retour
Une valeur non nulle (vraie) si le signe de x est négatif; et zéro (faux) sinon.

Ensuite, je multiplie par deux avec le décalage vers la gauche ("<< 1") qui nous donnera 2 pour un nombre positif et 0 pour un nombre négatif et enfin décrémenter de 1 pour obtenir 1 et -1 pour les nombres respectivement positifs et négatifs comme demandé par OP.

Bien que la solution entière dans la réponse acceptée soit assez élégante, cela m'a dérangé de ne pas pouvoir renvoyer NAN pour les types doubles, donc je l'ai légèrement modifiée.

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

Notez que le retour à virgule flottante NAN par opposition à une pré - programmée NANcause le bit de signe à régler dans certaines implémentations , de sorte que la sortie pour val = -NANet val = NANvont être identiques , peu importe ce que (si vous préférez une « nan» sortie sur une , -nanvous pouvez mettre un abs(val)avant le retour ...)

Vous pouvez utiliser la boost::math::sign()méthode à partir du moment boost/math/special_functions/sign.hppoù le boost est disponible.

Voici une implémentation adaptée aux branchements:

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

À moins que vos données aient des zéros comme la moitié des nombres, ici le prédicteur de branche choisira l'une des branches comme la plus courante. Les deux branches impliquent uniquement des opérations simples.

Alternativement, sur certains compilateurs et architectures CPU, une version complètement sans branche peut être plus rapide:

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

Cela fonctionne pour le format à virgule flottante binaire double précision IEEE 754: binaire64 .

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

Cette fonction suppose:

• représentation binaire32 des nombres à virgule flottante
• un compilateur qui crée une exception concernant la règle d' alias stricte lors de l'utilisation d'une union nommée

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

Pourquoi utiliser des opérateurs ternaires et if-else quand vous pouvez simplement le faire

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