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

Question

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 mon propre code, mais il semble que ce soit quelque chose qui devrait se trouver quelque part dans une bibliothèque standard.

Edit : Plus précisément, je cherchais une fonction fonctionnant sur les flottants.

Answer 1

Vous pouvez utiliser boost::math::sign() méthode de boost/math/special_functions/sign.hpp si le boost est disponible.

Answer 2

La question de l'OP était "C/C++" mais voici une solution strictement c++ :

template <typename T>
T sign(T t) 
{
    if( t == 0 )
        return T(0);
    else
        return (t < 0) : T(-1) : T(1);
}

qui ne gère pas le +/- zéro, mais qui utilise les templates de façon agréable pour surcharger tout type pour lequel le compilateur peut comprendre 0, 1 et -1. Si elle est utilisée sur un type pour lequel ce n'est pas vrai, alors le compilateur se plaindra afin que vous n'ayez pas un comportement inattendu. Cela n'aura pas la vitesse de certains des postes précédents, mais sera pratique pour de nombreux cas encore.

Answer 3

Bien que la solution pour les nombres entiers dans la réponse acceptée soit assez élégante, le fait qu'elle ne puisse pas renvoyer NAN pour les types doubles m'a dérangé, aussi 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 d'un NAN en virgule flottante, par opposition à un NAN codé en dur, est une bonne chose. NAN fait en sorte que le bit de signe soit activé dans certaines mises en œuvre donc la sortie pour val = -NAN y val = NAN seront identiques quoi qu'il arrive (si vous préférez une " nan " sur une -nan vous pouvez mettre un abs(val) avant le retour...)

Answer 4

Voici une implémentation favorable 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 ne comportent des zéros dans la moitié des nombres, le prédicteur de branche choisira l'une des branches comme étant la plus commune. Les deux branches n'impliquent que des opérations simples.

Alternativement, sur certains compilateurs et architectures de 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 Format de virgule flottante binaire double précision IEEE 754 : binary64 .

Answer 5

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

Cette fonction suppose :

• binaire32 représentation des nombres à virgule flottante
• un compilateur qui fait un exception concernant l'aliasing strict lors de l'utilisation d'un nommé syndicat