Esiste una funzione di segno standard (signum, sgn) in C / C ++?

Voglio una funzione che ritorni -1 per i numeri negativi e +1 per i numeri positivi. http://it.wikipedia.org/wiki/Sign_function È abbastanza facile scrivere il mio, ma sembra qualcosa che dovrebbe essere in una libreria standard da qualche parte.

Modifica: In particolare, stavo cercando una funzione che funziona sui float.

Sorpreso nessuno ha ancora pubblicato la versione C ++ sicura dei tipi:

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

Benefici:

• Implementa effettivamente signum (-1, 0 o 1). Le implementazioni qui usando copysign restituiscono solo -1 o 1, che non è signum. Inoltre, alcune implementazioni qui stanno restituendo un float (o T) anziché un int, che sembra dispendioso.
• Funziona con ints, float, double, short senza segno o qualsiasi tipo personalizzato costruibile da intero 0 e ordinabile.
• Veloce! copysignè lento, soprattutto se devi promuovere e poi restringere di nuovo. Questo è senza rami e ottimizza in modo eccellente
• Conforme agli standard! L'hacks bitshift è pulito, ma funziona solo per alcune rappresentazioni di bit e non funziona quando si dispone di un tipo senza segno. Potrebbe essere fornito come specializzazione manuale quando appropriato.
• ! accurate Semplici confronti con zero possono mantenere la rappresentazione interna ad alta precisione della macchina (ad es. 80 bit su x87) ed evitare un giro prematuro a zero.

Avvertenze:

• È un modello quindi potrebbe richiedere più tempo per la compilazione in alcune circostanze.
• Apparentemente alcune persone pensano di usare una nuova funzione di libreria standard, un po 'esoterica e molto lenta, che non implementa nemmeno davvero signum sia più comprensibile l' significato.

• La < 0parte del controllo attiva l' -Wtype-limitsavvertimento di GCC quando viene istanziata per un tipo senza segno. Puoi evitarlo usando alcuni sovraccarichi:

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

  (Che è un buon esempio del primo avvertimento.)

Non conosco una funzione standard per questo. Ecco un modo interessante per scriverlo però:

(x > 0) - (x < 0)

Ecco un modo più leggibile per farlo:

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

Se ti piace l'operatore ternario puoi farlo:

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

Esiste una funzione di libreria matematica C99 chiamata copysign (), che accetta il segno da un argomento e il valore assoluto dall'altro:

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

ti darà un risultato di +/- 1.0, a seconda del segno di valore. Si noti che gli zero in virgola mobile sono firmati: (+0) produrrà +1 e (-0) produrrà -1.

Sembra che la maggior parte delle risposte non abbiano risposto alla domanda originale.

Esiste una funzione di segno standard (signum, sgn) in C / C ++?

Non nella libreria standard, tuttavia esiste un copysignmetodo che può essere utilizzato quasi allo stesso modo tramite copysign(1.0, arg)ed è presente una funzione di accesso reale boost, che potrebbe anche far parte dello 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);

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

Apparentemente, la risposta alla domanda del poster originale è no. Non esiste una funzione C ++ standardsgn .

Esiste una funzione di segno standard (signum, sgn) in C / C ++?

Sì, a seconda della definizione.

C99 e successive ha la signbit()macro in<math.h>

int signbit(reale x);
La signbitmacro restituisce un valore diverso da zero se e solo se il segno del valore dell'argomento è negativo. C11 §7.12.3.6

Eppure OP vuole qualcosa di leggermente diverso.

Voglio una funzione che ritorni -1 per i numeri negativi e +1 per i numeri positivi. ... una funzione che lavora sui galleggianti.

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

Più profondo:

Il post non è specifico nei seguenti casi: x = 0.0, -0.0, +NaN, -NaN .

Un classico signum()ritorna +1su x>0, -1su x<0e0 avantix==0 .

Molte risposte lo hanno già trattato, ma non si rivolgono x = -0.0, +NaN, -NaN. Molti sono orientati a un punto di vista intero che di solito manca di Not-a-Numbers ( NaN ) e -0.0 .

Le risposte tipiche funzionano come signnum_typical() On -0.0, +NaN, -NaN, ritornano 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;
}

Invece, propongo questa funzionalità: On -0.0, +NaN, -NaN, ritorna -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;
}

Più veloce delle soluzioni di cui sopra, inclusa la più votata:

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

C'è un modo per farlo senza ramificarsi, ma non è molto carino.

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

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

Molte altre cose interessanti e troppo intelligenti su quella pagina, anche ...

Se tutto ciò che vuoi è testare il segno, usa signbit (restituisce vero se il suo argomento ha un segno negativo). Non sono sicuro del motivo per cui si desidera che vengano restituiti in particolare -1 o +1; copysign è più conveniente per questo, ma sembra che restituirà +1 per zero negativo su alcune piattaforme con solo il supporto parziale per zero negativo, dove signbit presumibilmente tornerebbe vero.

In generale, non esiste una funzione signum standard in C / C ++ e la mancanza di una funzione così fondamentale ti dice molto su questi linguaggi.

A parte questo, credo che entrambi i punti di vista della maggioranza sul giusto approccio per definire tale funzione siano in un modo corretto, e la "controversia" su di essa è in realtà un non-argomento una volta che si prendono in considerazione due importanti avvertenze:

• Una funzione signum dovrebbe sempre restituire il tipo del suo operando, in modo simile a una abs()funzione, poiché signum viene solitamente utilizzato per la moltiplicazione con un valore assoluto dopo che quest'ultimo è stato in qualche modo elaborato. Pertanto, il principale caso d'uso di signum non è il confronto ma l'aritmetica, e quest'ultimo non dovrebbe comportare costose conversioni da intero a / da virgola mobile.

• I tipi a virgola mobile non presentano un singolo valore zero esatto: +0.0 può essere interpretato come "infinitesimalmente sopra lo zero" e -0,0 come "infinitesimalmente sotto lo zero". Questo è il motivo per cui i confronti che implicano zero devono verificare internamente entrambi i valori e un'espressione simile x == 0.0può essere pericolosa.

Per quanto riguarda C, penso che il modo migliore di procedere con i tipi integrali sia effettivamente usare l' (x > 0) - (x < 0)espressione, poiché dovrebbe essere tradotta in modo privo di diramazioni e richiede solo tre operazioni di base. Definire meglio le funzioni incorporate che impongono un tipo restituito corrispondente al tipo di argomento e aggiungere un C11define _Generic per associare queste funzioni a un nome comune.

Con i valori in virgola mobile, penso che le funzioni inline basate su C11 copysignf(1.0f, x), copysign(1.0, x)e copysignl(1.0l, x)siano la strada da percorrere, semplicemente perché sono anche altamente probabili essere prive di diramazioni e inoltre non richiedono il cast del risultato dall'intero in un punto in virgola mobile valore. Dovresti probabilmente commentare in modo evidente che le tue implementazioni in virgola mobile di signum non restituiranno zero a causa delle peculiarità dei valori di zero in virgola mobile, considerazioni sui tempi di elaborazione e anche perché è spesso molto utile nell'aritmetica in virgola mobile ricevere il corretto -1 / + 1 segno, anche per valori zero.

La mia copia di C in breve rivela l'esistenza di una funzione standard chiamata copysign che potrebbe essere utile. Sembra che copysign (1.0, -2.0) restituisca -1.0 e copysign (1.0, 2.0) restituisca +1.0.

Abbastanza vicino eh?

No, non esiste in c ++, come in matlab. Per questo uso una macro nei miei programmi.

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

La risposta accettata con il sovraccarico di seguito in effetti non attiva -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>());
}

Per C ++ 11 potrebbe essere un'alternativa.

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

Per me non attiva alcun avviso su GCC 5.3.1.

Un po 'fuori tema, ma io uso questo:

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

e ho trovato la prima funzione - quella con due argomenti, molto più utile da "standard" sgn (), perché è spesso usata in codice come questo:

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

vs.

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

non c'è cast per tipi non firmati e nessun segno negativo aggiuntivo.

infatti ho questo pezzo di codice usando 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 domanda è vecchia ma ora esiste questo tipo di funzione desiderata. Ho aggiunto un wrapper con no, spostamento a sinistra e dec.

È possibile utilizzare una funzione wrapper basata su signbit da C99 per ottenere esattamente il comportamento desiderato (vedere il codice più avanti).

Indica se il segno di x è negativo.
Questo può essere applicato anche a infiniti, NaN e zero (se zero è senza segno, è considerato positivo

#include <math.h>

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

NB: Uso l'operando not ("!") Perché il valore restituito di signbit non è specificato come 1 (anche se gli esempi ci fanno pensare che sarebbe sempre così) ma vero per un numero negativo:

Valore di ritorno
Un valore diverso da zero (vero) se il segno di x è negativo; e zero (falso) altrimenti.

Quindi moltiplico per due con lo spostamento a sinistra ("<< 1") che ci darà 2 per un numero positivo e 0 per uno negativo e infine diminuirò di 1 per ottenere 1 e -1 rispettivamente per i numeri positivi e negativi come richiesto da OPERAZIONE.

Mentre la soluzione intera nella risposta accettata è piuttosto elegante, mi dava fastidio che non sarebbe stato in grado di restituire NAN per i doppi tipi, quindi l'ho modificato leggermente.

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

Si noti che la restituzione di un virgola mobile NAN al contrario di un hard coded NANcause il bit del segno da impostare in alcune implementazioni , quindi l'uscita per val = -NANe val = NANstanno per essere identico qualunque cosa (se si preferisce "un nan" uscita nel corso di un -nansi può mettere un abs(val)prima del ritorno ...)

È possibile utilizzare il boost::math::sign()metodo boost/math/special_functions/sign.hppse è disponibile boost.

Ecco un'implementazione intuitiva per le ramificazioni:

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

A meno che i dati non contengano zero come metà dei numeri, qui il predittore di rami sceglierà uno dei rami come il più comune. Entrambe le filiali comportano solo operazioni semplici.

In alternativa, su alcuni compilatori e architetture di CPU una versione completamente senza rami potrebbe essere più veloce:

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

Funziona con il formato a virgola mobile binario IEEE 754 a doppia precisione: binary64 .

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

Questa funzione presuppone:

• binary32rappresentazione di numeri in virgola mobile
• un compilatore che fa un'eccezione alla regola di aliasing rigorosa quando si utilizza un'unione denominata

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

Perché usare operatori ternari e if-else quando puoi semplicemente farlo

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