Czy w C / C ++ jest standardowa funkcja znaku (signum, sgn)?

Chcę funkcji, która zwraca -1 dla liczb ujemnych i +1 dla liczb dodatnich. http://en.wikipedia.org/wiki/Sign_function Łatwo jest napisać własny, ale wydaje się, że powinien być gdzieś w standardowej bibliotece.

Edycja: W szczególności szukałem funkcji działającej na liczbach zmiennoprzecinkowych.

Zaskoczony, nikt jeszcze nie opublikował bezpiecznej wersji C ++:

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

Korzyści:

• W rzeczywistości implementuje signum (-1, 0 lub 1). Implementacje przy użyciu copysign zwracają tylko -1 lub 1, co nie jest signum. Ponadto niektóre implementacje zwracają liczbę zmiennoprzecinkową (lub T) zamiast int, co wydaje się marnotrawstwem.
• Działa dla liczb całkowitych, liczb zmiennoprzecinkowych, podwójnych, niepodpisanych skrótów lub dowolnych niestandardowych typów możliwych do zbudowania z liczby całkowitej 0 i zamówienia.
• Szybki! copysignjest powolny, szczególnie jeśli musisz się promować, a następnie ponownie zawęzić. Jest to bez rozgałęzień i doskonale optymalizuje
• Zgodny ze standardami! Hack bitshift jest czysty, ale działa tylko w przypadku niektórych reprezentacji bitowych i nie działa, gdy masz typ bez znaku. W razie potrzeby można ją podać jako specjalizację ręczną.
• Dokładny! Proste porównania z zerem mogą zachować wewnętrzną, precyzyjną reprezentację maszyny (np. 80 bitów na x87) i uniknąć przedwczesnego zaokrąglenia do zera.

Ostrzeżenia:

• Jest to szablon, więc w niektórych okolicznościach kompilacja może potrwać dłużej.
• Najwyraźniej niektórzy uważają, że użycie nowej, nieco ezoterycznej i bardzo powolnej standardowej funkcji biblioteki , która nawet nie implementuje signum, jest bardziej zrozumiałe.

• < 0Częścią kontroli wyzwala GCC -Wtype-limitsostrzeżenie, gdy instancja dla typu unsigned. Można tego uniknąć, stosując pewne przeciążenia:

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

  (Co jest dobrym przykładem pierwszego zastrzeżenia).

Nie znam standardowej funkcji do tego. Oto ciekawy sposób, aby to napisać:

(x > 0) - (x < 0)

Oto bardziej czytelny sposób:

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

Jeśli podoba Ci się operator trójskładnikowy, możesz to zrobić:

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

Istnieje funkcja biblioteki matematycznej C99 o nazwie copysign (), która pobiera znak z jednego argumentu, a wartość bezwzględną z drugiego:

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

da wynik +/- 1,0, w zależności od znaku wartości. Zauważ, że zera zmiennoprzecinkowe są podpisane: (+0) da +1, a (-0) da -1.

Wygląda na to, że większość odpowiedzi pominęła pierwotne pytanie.

Czy w C / C ++ jest standardowa funkcja znaku (signum, sgn)?

Nie ma go w standardowej bibliotece, jednak istnieje taki, copysignktóry może być używany prawie w ten sam sposób, copysign(1.0, arg)i jest w nim funkcja prawdziwego znaku boost, która równie dobrze może być częścią standardu.

    #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

Najwyraźniej odpowiedź na pytanie pierwotnego plakatu brzmi „nie”. Nie ma standardowejsgn funkcji C ++ .

Szybsze niż powyższe rozwiązania, w tym najwyżej ocenione:

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

Czy w C / C ++ jest standardowa funkcja znaku (signum, sgn)?

Tak, w zależności od definicji.

C99 i nowsze wersje mają signbit()makro w<math.h>

int signbit(real-floating x);
W signbitmakro zwraca wartość różną od zera, wtedy i tylko wtedy, gdy znak jego wartości argumentu jest ujemna. C11 §7.12.3.6

Jednak OP chce czegoś nieco innego.

Chcę funkcji, która zwraca -1 dla liczb ujemnych i +1 dla liczb dodatnich. ... funkcja działająca na pływakach.

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

Głębiej:

Post nie jest specyficzny w następujących przypadkach: x = 0.0, -0.0, +NaN, -NaN.

Klasyczny signum()powraca +1on x>0, -1on x<0i 0on x==0.

Wiele odpowiedzi już to obejmowało, ale nie zawiera odpowiedzi x = -0.0, +NaN, -NaN. Wiele z nich jest nastawionych na całkowity punkt widzenia, w którym zwykle brakuje Not-a-Numbers ( NaN ) i -0,0 .

Typowe odpowiedzi działają jak signnum_typical() On -0.0, +NaN, -NaN, zwracają 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;
}

Zamiast tego proponuję tę funkcjonalność: On -0.0, +NaN, -NaNzwraca -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;
}

Jest sposób na zrobienie tego bez rozgałęziania, ale nie jest to zbyt ładne.

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

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

Na tej stronie jest też wiele innych interesujących, zbyt sprytnych rzeczy ...

Jeśli wszystko, czego chcesz, to przetestować znak, użyj signbit (zwraca true, jeśli jego argument ma znak ujemny). Nie jestem pewien, dlaczego szczególnie chcesz zwrócić -1 lub +1; copysign jest do tego wygodniejszy, ale wygląda na to, że zwróci +1 dla ujemnego zera na niektórych platformach z jedynie częściowym wsparciem dla ujemnego zera, gdzie signbit prawdopodobnie zwróci prawdę.

Ogólnie rzecz biorąc, w C / C ++ nie ma standardowej funkcji signum, a brak tak fundamentalnej funkcji mówi wiele o tych językach.

Poza tym uważam, że oba poglądy większości na temat właściwego podejścia do zdefiniowania takiej funkcji są w pewnym sensie poprawne, a „kontrowersja” na ten temat jest w rzeczywistości pozbawiona argumentów, gdy weźmie się pod uwagę dwa ważne zastrzeżenia:

• Funkcja signum powinna zawsze zwracać typ swojego argumentu, podobnie jak abs()funkcja, ponieważ signum jest zwykle używane do mnożenia z wartością bezwzględną po tym, jak ta ostatnia zostanie jakoś przetworzona. Dlatego głównym przykładem użycia signum nie są porównania, ale arytmetyka, a ta ostatnia nie powinna obejmować żadnych kosztownych konwersji liczb całkowitych na zmiennoprzecinkowe.

• Typy zmiennoprzecinkowe nie mają pojedynczej dokładnej wartości zerowej: +0,0 można interpretować jako „nieskończenie poniżej zera”, a -0,0 jako „nieskończenie poniżej zera”. To jest powód, dla którego porównania obejmujące zero muszą wewnętrznie sprawdzać obie wartości, a wyrażenie takie x == 0.0może być niebezpieczne.

Jeśli chodzi o C, myślę, że najlepszym rozwiązaniem w przypadku typów integralnych jest rzeczywiście użycie (x > 0) - (x < 0) wyrażenia, ponieważ powinno być przetłumaczone w sposób bezoddziałowy i wymaga tylko trzech podstawowych operacji. Najlepiej zdefiniuj funkcje wbudowane, które wymuszają typ zwracany zgodny z typem argumentu, i dodaj C11, define _Genericaby odwzorować te funkcje na wspólną nazwę.

Jeśli chodzi o wartości zmiennoprzecinkowe, myślę, że funkcje wbudowane oparte na C11 copysignf(1.0f, x), copysign(1.0, x)i copysignl(1.0l, x)są właściwą drogą, po prostu dlatego, że są one również wysoce wolne od rozgałęzień i dodatkowo nie wymagają rzutowania wyniku z liczby całkowitej z powrotem na zmiennoprzecinkowy wartość. Prawdopodobnie powinieneś wyraźnie skomentować, że twoje implementacje zmiennoprzecinkowe signum nie zwrócą zera ze względu na specyfikę wartości zmiennoprzecinkowych zera, względy czasu przetwarzania, a także dlatego, że często jest bardzo przydatne w arytmetyki zmiennoprzecinkowej, aby otrzymać poprawne -1 / + 1 znak, nawet dla wartości zerowych.

Moja kopia C w pigułce ujawnia istnienie standardowej funkcji o nazwie copysign, która może być przydatna. Wygląda na to, że copysign (1.0, -2.0) zwróci -1.0, a copysign (1.0, 2.0) zwróci +1.0.

Całkiem blisko co?

Nie, nie istnieje w c ++, jak w Matlabie. W tym celu używam makra.

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

Przyjęta odpowiedź z poniższym przeciążeniem faktycznie nie wyzwala limitów -Wtype .

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

Dla C ++ 11 może być alternatywą.

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

Dla mnie nie wywołuje żadnych ostrzeżeń w GCC 5.3.1.

Trochę nie na temat, ale używam tego:

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

i znalazłem pierwszą funkcję - tę z dwoma argumentami, która jest znacznie bardziej użyteczna ze „standardowej” funkcji sgn (), ponieważ najczęściej jest używana w takim kodzie:

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

vs.

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

nie ma obsady dla niepodpisanych typów i żadnego dodatkowego minusa.

w rzeczywistości mam ten fragment kodu za pomocą 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);
}

Pytanie jest stare, ale istnieje teraz taka pożądana funkcja. Dodałem owijarkę z not, left shift i dec.

Możesz użyć funkcji otoki opartej na signbit z C99 , aby uzyskać dokładnie pożądane zachowanie (zobacz kod poniżej).

Zwraca, czy znak x jest ujemny.
Można to również zastosować do nieskończoności, NaN i zer (jeśli zero jest bez znaku, jest uważane za dodatnie

#include <math.h>

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

Uwaga: używam operandu nie („!”), Ponieważ wartość zwrotna signbit nie jest określona jako 1 (chociaż przykłady pozwalają sądzić, że zawsze tak będzie), ale prawda dla liczby ujemnej:

Wartość zwracana Wartość
niezerowa (prawda), jeśli znak x jest ujemny; i zero (fałsz) w przeciwnym razie.

Następnie mnożę przez dwa z przesunięciem w lewo („<< 1”), co da nam 2 dla liczby dodatniej i 0 dla liczby ujemnej, a na koniec zmniejszamy o 1, aby uzyskać 1 i -1 odpowiednio dla liczb dodatnich i ujemnych zgodnie z żądaniem OP.

Chociaż całkowite rozwiązanie w przyjętej odpowiedzi jest dość eleganckie, przeszkadzało mi, że nie będzie w stanie zwrócić NAN dla podwójnych typów, więc nieco go zmodyfikowałem.

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

Zauważ, że zwracanie zmiennoprzecinkowej sieci NAN w przeciwieństwie do zakodowanego NANna stałe powoduje, że bit znaku jest ustawiany w niektórych implementacjach , więc wyjście dla val = -NANi val = NANbędzie identyczne bez względu na wszystko (jeśli wolisz nanwyjście " " niż -nanmożesz abs(val)przed powrotem ...)

Możesz użyć boost::math::sign()metody, boost/math/special_functions/sign.hppjeśli dostępne jest wzmocnienie.

Oto implementacja przyjazna dla rozgałęzień:

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

O ile twoje dane nie mają zer jako połowy liczb, tutaj predyktor gałęzi wybierze jedną z gałęzi jako najbardziej powszechną. Oba oddziały wymagają jedynie prostych operacji.

Alternatywnie, w niektórych kompilatorach i architekturach procesorów wersja całkowicie bez rozgałęzień może być szybsza:

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

Działa to w przypadku binarnego zmiennoprzecinkowego formatu podwójnej precyzji IEEE 754: binary64 .

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

Ta funkcja zakłada:

• binarny32 reprezentacja liczb zmiennoprzecinkowych
• kompilator, który robi wyjątek od ścisłej reguły aliasingu podczas używania nazwanego związku

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

Po co używać operatorów trójskładnikowych i if-else, skoro można to po prostu zrobić

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