C / C ++中是否有标准的符号函数（signum，sgn）？

我想要一个返回负数为-1和正数为+1的函数。 http://en.wikipedia.org/wiki/Sign_function 编写我自己的代码很容易，但是似乎应该将其存储在标准库中。

编辑：具体来说，我正在寻找一个对浮点数起作用的函数。

惊讶的是没有人发布过类型安全的C ++版本：

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

优点：

• 实际实现信号（-1、0或1）。此处使用copysign的实现仅返回-1或1，而不是signum。另外，这里的某些实现返回的是float（或T）而不是int，这似乎很浪费。
• 适用于int，float，double，unsigned short或任何可从整数0构造且可排序的自定义类型。
• 快速！copysign是缓慢的，特别是如果您需要提升然后再次缩小。这是无分支的，并且进行了优化
• 符合标准！位移位技巧很简洁，但仅适用于某些位表示形式，当您使用无符号类型时不起作用。适当时，可以将其作为手动专业提供。
• 准确！简单的零比较可以保持机器内部的高精度表示（例如x87上的80位），并避免过早舍入为零。

注意事项：

• 这是一个模板，因此在某些情况下可能需要更长的时间进行编译。
• 显然，有些人认为使用新的，有些深奥的，非常慢的标准库函数（甚至没有真正实现signum）更容易理解。

• 在为无符号类型实例化时< 0，检查的一部分会触发GCC -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)

有一个名为copysign（）的C99数学库函数，该函数从一个参数获取符号，从另一个参数获取绝对值：

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。

似乎大多数答案都没有回答原始问题。

C / C ++中是否有标准的符号函数（signum，sgn）？

标准库中没有，但是copysign可以通过几乎相同的方式使用它，copysign(1.0, arg)并且在中有一个真正的sign函数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

显然，原始海报问题的答案是“否”。没有标准的 C ++ sgn函数。

比以上解决方案更快，包括评分最高的解决方案：

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

C / C ++中是否有标准的符号函数（signum，sgn）？

是的，取决于定义。

C99及更高版本中包含signbit()宏<math.h>

int signbit（浮动x）；当且仅当其参数值的符号为负时，
该signbit宏才返回非零值。C11§7.12.3.6

但是OP希望有所不同。

我想要一个返回负数为-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;
}

有一种方法可以不分支，但不是很漂亮。

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

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

该页面上还有许多其他有趣的，过于机灵的内容...

如果只想测试符号，请使用符号位（如果其参数为负号，则返回true）。不确定为什么特别希望返回-1或+1；copysign对此更为方便，但听起来在某些平台上它会为负零返回+1，而仅部分支持负零，而其中的符号位可能会返回true。

通常，C / C ++中没有标准的signum函数，并且缺少这样的基本函数会告诉您很多有关这些语言的信息。

除此之外，我相信关于定义这种功能的正确方法的大多数观点都正确，并且一旦考虑到两个重要的警告，关于该功能的“争论”实际上是毫无争议的：

• 与函数类似，signum函数应始终返回其操作数的类型abs()，因为signum通常用于在以某种方式处理绝对值之后与绝对值相乘。因此，signum的主要用例不是比较，而是算术，而算术不应该涉及任何昂贵的整数到浮点数的转换。

• 浮点类型不具有单个精确的零值：+0.0可以解释为“无限地大于零”，而-0.0可以解释为“无限地零以下”。这就是为什么涉及零的比较必须在内部检查两个值的原因，而类似的表达式x == 0.0可能很危险。

关于C，我认为使用整数类型的最佳方法确实是使用(x > 0) - (x < 0)表达式，因为它应该以无分支方式进行转换，并且只需要三个基本操作。最好定义内联函数，以强制执行与参数类型匹配的返回类型，并添加C11 define _Generic以将这些函数映射到通用名称。

随着浮点值，我觉得内联函数基于C11 copysignf(1.0f, x)，copysign(1.0, x)以及copysignl(1.0l, x)是要走的路，只是因为他们也极有可能成为分支免费的，另外不需要从铸造整数回到浮点结果值。您可能应该特别指出，由于浮点零值的特殊性，处理时间的考虑，以及因为在浮点算术中接收正确的-1 / +常常非常有用，因此signum的浮点实现不会返回零。 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-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>());
}

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

问题很老，但是现在有这种所需的功能。我添加了一个包装，没有，左移和十二月。

您可以使用基于C99的符号位的包装函数，以获取确切的所需行为（请参见下面的代码）。

返回x的符号是否为负。
这也可以应用于无限，NaN和零（如果零是无符号的，则视为正数

#include <math.h>

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

注意：我使用的操作数不是（“！”），因为signbit的返回值未指定为1（即使示例让我们认为它总是这样），但对于负数为true：

返回值
如果x的符号为负，则为非零值（true）；否则为false。否则为零（假）。

然后，我乘以2并左移（“ << 1”），这将使我们得到2代表正数，0代表负1，最后减1分别得到正负数的1和-1，分别由OP。

尽管接受的答案中的整数解决方案非常优雅，但令我感到困扰的是，它无法为双精度类型返回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()from的方法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));
}

除非您的数据中的零为数字的一半，否则分支预测器将选择最常见的分支之一。两个分支仅涉及简单的操作。

另外，在某些编译器和CPU体系结构上，完全无分支的版本可能会更快：

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

该函数假定：

• 浮点数的binary32表示形式
• 使用命名联合时对严格别名规则进行例外处理的编译器

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

为什么只需使用三元运算符和if-else即可

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