Существует ли стандартная функция знака (signum, sgn) в C / C ++?

Я хочу функцию, которая возвращает -1 для отрицательных чисел и +1 для положительных чисел. http://en.wikipedia.org/wiki/Sign_function Достаточно легко написать мою собственную, но это похоже на то, что должно быть где-то в стандартной библиотеке.

Редактировать: В частности, я искал функцию, работающую на поплавках.

Удивило, что никто еще не опубликовал типобезопасную версию C ++:

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

Льготы:

• На самом деле реализует signum (-1, 0 или 1). Реализации здесь, использующие copysign, только возвращают -1 или 1, что не является signum. Кроме того, некоторые реализации здесь возвращают float (или T), а не int, что кажется расточительным.
• Работает для целых чисел, чисел с плавающей запятой, двойных чисел, шорт без знака или любых пользовательских типов, которые могут быть созданы из целого числа 0 и могут быть заказаны.
• Быстрый! copysignмедленный, особенно если вам нужно продвинуться, а затем снова сузить. Это не имеет ответвлений и отлично оптимизирует
• Соответствующий стандартам! Хак с бит-сдвигом аккуратен, но работает только для некоторых битовых представлений и не работает, когда у вас тип без знака. Это может быть предоставлено в качестве ручной специализации, когда это необходимо.
• Точная! Простые сравнения с нулем могут поддерживать внутреннее высокоточное представление машины (например, 80 бит на x87) и избежать преждевременного округления до нуля.

Предостережения:

• Это шаблон, поэтому в некоторых случаях сборка может занять больше времени.
• Очевидно, некоторые люди считают более понятным использование новой, несколько эзотерической и очень медленной стандартной библиотечной функции , которая даже не реализует Signum .

• < 0Часть проверки триггеров ССЗ -Wtype-limitsпредупреждение , когда экземпляр для неподписанных типа. Вы можете избежать этого, используя некоторые перегрузки:

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

  (Что является хорошим примером первого предупреждения.)

Я не знаю стандартной функции для этого. Вот интересный способ написать это:

(x > 0) - (x < 0)

Вот более читаемый способ сделать это:

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

Если вам нравится троичный оператор, вы можете сделать это:

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

Существует функция математической библиотеки C99, называемая copysign (), которая принимает знак одного аргумента и абсолютное значение другого:

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

даст вам результат +/- 1,0, в зависимости от знака значения. Обратите внимание, что нули с плавающей точкой подписаны: (+0) даст +1, а (-0) даст -1.

Кажется, что большинство ответов пропустили оригинальный вопрос.

Существует ли стандартная функция знака (signum, sgn) в C / C ++?

Не в стандартной библиотеке, однако, есть то, copysignчто можно использовать почти так же, как через, copysign(1.0, arg)и есть функция истинного знака boost, которая также может быть частью стандарта.

    #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

Судя по всему, ответ на вопрос автора оригинала - нет. Там нет стандартнойsgn функции C ++ .

Существует ли стандартная функция знака (signum, sgn) в C / C ++?

Да, в зависимости от определения.

C99 и позже имеет signbit()макрос в<math.h>

int signbit(реальный плавающий x);
В signbitмакрокоманде возвращает значение от нуля тогда и только тогда , когда знак его аргумент отрицательного значения. C11 §7.12.3.6

И все же ОП хочет что-то немного другое.

Я хочу функцию, которая возвращает -1 для отрицательных чисел и +1 для положительных чисел. ... функция, работающая на поплавках.

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

Глубже:

Сообщение не является специфичным в следующих случаях: x = 0.0, -0.0, +NaN, -NaN.

Классический signum()возвращается +1на x>0, -1на x<0и 0на x==0.

Многие ответы уже охватили это, но не обращаются x = -0.0, +NaN, -NaN. Многие из них ориентированы на целочисленную точку зрения, в которой обычно отсутствуют номера-числа ( NaN ) и -0,0 .

Типичные ответы работают как signnum_typical() On -0.0, +NaN, -NaN, они возвращаются 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;
}

Вместо этого я предлагаю эту функциональность: -0.0, +NaN, -NaNон возвращается -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;
}

Быстрее, чем вышеперечисленные решения, в том числе с самым высоким рейтингом:

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

Есть способ сделать это без ветвления, но это не очень красиво.

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

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

Много других интересных, слишком умных вещей на этой странице тоже ...

Если все, что вам нужно, это проверить знак, используйте signbit (возвращает true, если его аргумент имеет отрицательный знак). Не уверен, почему вы хотели бы вернуть -1 или +1; copysign более удобен для этого, но, похоже, он вернет +1 для отрицательного нуля на некоторых платформах с частичной поддержкой отрицательного нуля, где signbit предположительно вернул бы true.

В общем, в C / C ++ нет стандартной функции signum, и отсутствие такой фундаментальной функции многое говорит вам об этих языках.

Кроме того, я полагаю, что обе точки зрения большинства о правильном подходе к определению такой функции в некотором смысле правильны, и «спор» об этом фактически не является аргументом, если принять во внимание два важных предостережения:

• Функция signum всегда должна возвращать тип своего операнда, аналогично abs()функции, потому что signum обычно используется для умножения с абсолютным значением после того, как последний был каким-либо образом обработан. Следовательно, основным вариантом использования signum являются не сравнения, а арифметика, и последний не должен включать какие-либо дорогостоящие преобразования целых чисел в / из плавающей запятой.

• Типы с плавающей запятой не имеют единственного точного нулевого значения: +0.0 можно интерпретировать как «бесконечно меньше нуля», а -0.0 - «бесконечно меньше нуля». По этой причине сравнения, включающие ноль, должны внутренне сверяться с обоими значениями, и такое выражение x == 0.0может быть опасным.

Что касается C, я думаю, что лучший способ продвижения вперед с интегральными типами - это действительно использовать (x > 0) - (x < 0)выражение, так как оно должно переводиться без ветвления и требует только трех основных операций. Лучше всего определить встроенные функции, которые обеспечивают возвращаемый тип, соответствующий типу аргумента, и добавить C11 define _Genericдля сопоставления этих функций общему имени.

С плавающей точкой, я думаю , что встроенные функции , основанные на С11 copysignf(1.0f, x), copysign(1.0, x)и copysignl(1.0l, x)это путь, просто потому , что они также весьма вероятно, будет отделение свободной, и , кроме того , не требуют заливки результат целочисленного обратно в плавающей точкой ценность. Вы, вероятно, должны заметить, что ваши реализации signum с плавающей запятой не будут возвращать ноль из-за особенностей нулевых значений с плавающей запятой, соображений времени обработки, а также потому, что это часто очень полезно в арифметике с плавающей запятой для получения правильного -1 / + 1 знак, даже для нулевых значений.

Моя копия C в двух словах показывает существование стандартной функции copysign, которая может быть полезна. Похоже, что copysign (1.0, -2.0) вернет -1.0, а copysign (1.0, 2.0) вернет +1.0.

Довольно близко, а?

Нет, его нет в c ++, как в matlab. Я использую макрос в моих программах для этого.

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

Принятый ответ с приведенной ниже перегрузкой действительно не вызывает -Wtype-limit .

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

Для C ++ 11 альтернативой может быть.

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

Для меня это не вызывает никаких предупреждений на GCC 5.3.1.

Немного не по теме, но я использую это:

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

и я обнаружил, что первая функция - с двумя аргументами - гораздо более полезна из «стандартного» sgn (), потому что она чаще всего используется в коде, подобном следующему:

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

против

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

здесь нет броска для неподписанных типов и дополнительного минуса.

на самом деле у меня есть этот кусок кода с помощью 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);
}

Вопрос старый, но теперь есть такая желаемая функция. Я добавил обертку с not, left shift и dec.

Вы можете использовать функцию-оболочку на основе signbit из C99 , чтобы получить точное желаемое поведение (см. Код ниже).

Возвращает, является ли знак х отрицательным.
Это также может быть применено к бесконечности, NaN и нулям (если ноль без знака, он считается положительным

#include <math.h>

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

NB: я использую операнд не ("!"), Потому что возвращаемое значение signbit не указано равным 1 (хотя примеры позволяют нам думать, что так будет всегда), но верно для отрицательного числа:

Возвращаемое значение
Ненулевое значение (true), если знак x отрицательный; и ноль (ложь) в противном случае.

Затем я умножаю на два с левым смещением («<< 1»), что даст нам 2 для положительного числа и 0 для отрицательного и, наконец, уменьшу на 1, чтобы получить 1 и -1 для соответственно положительных и отрицательных чисел, как этого требует ОП.

Хотя целочисленное решение в принятом ответе довольно элегантно, меня беспокоило, что оно не сможет вернуть NAN для двойных типов, поэтому я немного его изменил.

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

Обратите внимание , что возвращение с плавающей точкой NAN , в отличии от жестких закодированных NANпричин знакового бита быть установлены в некоторых реализациях , поэтому выход для val = -NANи val = NANсобираешься не может быть одинаковым независимо от того , что (если вы предпочитаете « nan» выход больше -nanвы можете положить abs(val)перед возвращением ...)

Вы можете использовать boost::math::sign()метод, boost/math/special_functions/sign.hppесли буст доступен.

Вот реализация для ветвления:

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

Если ваши данные не имеют нулей в качестве половины чисел, здесь предиктор ветвлений выберет одну из ветвей в качестве наиболее распространенной. Обе ветви включают только простые операции.

В качестве альтернативы, на некоторых компиляторах и архитектурах ЦП версия без ответвлений может быть быстрее:

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

Это работает для двоичного формата с плавающей точкой двойной точности IEEE 754: binary64 .

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

Эта функция предполагает:

• двоичное32 представление чисел с плавающей точкой
• компилятор, который делает исключение из правила строгого псевдонима при использовании именованного объединения

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

Зачем использовать троичные операторы и если-иначе, когда вы можете просто сделать это

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