Existe uma função de sinal padrão (signum, sgn) em C / C ++?

Eu quero uma função que retorne -1 para números negativos e +1 para números positivos. http://en.wikipedia.org/wiki/Sign_function É bastante fácil escrever o meu, mas parece que algo deveria estar em uma biblioteca padrão em algum lugar.

Edit: Especificamente, eu estava procurando uma função trabalhando em carros alegóricos.

Surpreendido, ninguém postou a versão C ++ com segurança de tipo ainda:

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

Benefícios:

• Na verdade, implementa signum (-1, 0 ou 1). As implementações aqui usando copysign retornam apenas -1 ou 1, o que não é signum. Além disso, algumas implementações aqui estão retornando um float (ou T) em vez de um int, o que parece um desperdício.
• Funciona para entradas, carros alegóricos, duplos, curtos não assinados ou quaisquer tipos personalizados construtíveis a partir do número 0 e ordenáveis.
• Rápido! copysigné lento, especialmente se você precisar promover e estreitar novamente. Isso é sem ramificação e otimiza excelentemente
• Em conformidade com os padrões! O truque de deslocamento de bits é puro, mas funciona apenas para algumas representações de bits e não funciona quando você tem um tipo não assinado. Pode ser fornecido como uma especialização manual, quando apropriado.
• Preciso! Comparações simples com zero podem manter a representação interna de alta precisão da máquina (por exemplo, 80 bits em x87) e evitar um arredondamento prematuro para zero.

Ressalvas:

• É um modelo, portanto, pode levar mais tempo para compilar em algumas circunstâncias.
• Aparentemente, algumas pessoas pensam que o uso de uma nova função de biblioteca padrão um tanto esotérica e muito lenta que nem sequer implementa signum é mais compreensível.

• A < 0parte da verificação aciona o -Wtype-limitsaviso do GCC quando instanciada para um tipo não assinado. Você pode evitar isso usando algumas sobrecargas:

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

  (Que é um bom exemplo da primeira advertência.)

Não conheço uma função padrão para isso. Aqui está uma maneira interessante de escrevê-lo:

(x > 0) - (x < 0)

Aqui está uma maneira mais legível de fazer isso:

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

Se você gosta do operador ternário, pode fazer o seguinte:

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

Existe uma função da biblioteca matemática C99 chamada copysign (), que recebe o sinal de um argumento e o valor absoluto do outro:

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

resultará em +/- 1,0, dependendo do sinal do valor. Observe que os zeros de ponto flutuante são assinados: (+0) produzirá +1 e (-0) produzirá -1.

Parece que a maioria das respostas perdeu a pergunta original.

Existe uma função de sinal padrão (signum, sgn) em C / C ++?

Não na biblioteca padrão, no entanto, existe o copysignque pode ser usado quase da mesma maneira via copysign(1.0, arg)e existe uma verdadeira função de sinal boost, que também pode fazer parte do padrão.

    #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

Aparentemente, a resposta para a pergunta do pôster original é não. Não há função C ++ padrãosgn .

Existe uma função de sinal padrão (signum, sgn) em C / C ++?

Sim, dependendo da definição.

C99 e posterior possui a signbit()macro em<math.h>

int signbit(flutuante real x);
A signbitmacro retorna um valor diferente de zero se e somente se o sinal do valor do argumento for negativo. C11 §7.12.3.6

No entanto, o OP quer algo um pouco diferente.

Eu quero uma função que retorne -1 para números negativos e +1 para números positivos. ... uma função trabalhando em carros alegóricos.

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

Mais profundo:

O post não é específico nos seguintes casos: x = 0.0, -0.0, +NaN, -NaN.

Um clássico signum()retorna +1no x>0, -1no x<0e 0no x==0.

Muitas respostas já abordaram isso, mas não abordam x = -0.0, +NaN, -NaN. Muitos são voltados para um ponto de vista inteiro que geralmente não possui números não-números ( NaN ) e -0,0 .

Respostas típicas funcionam como signnum_typical() Ativado -0.0, +NaN, -NaN, elas retornam 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;
}

Em vez disso, proponho esta funcionalidade: Sim -0.0, +NaN, -NaN, ela retorna -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;
}

Mais rápidas que as soluções acima, incluindo a mais alta classificada:

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

Existe uma maneira de fazer isso sem ramificação, mas não é muito bonito.

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

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

Muitas outras coisas interessantes e excessivamente inteligentes nessa página também ...

Se tudo que você deseja é testar o sinal, use signbit (retorna true se o argumento tiver um sinal negativo). Não sabe por que você deseja que -1 ou +1 sejam retornados; copysign é mais conveniente para isso, mas parece que ele retornará +1 para zero negativo em algumas plataformas com apenas suporte parcial para zero negativo, em que presumivelmente o signbit retornaria true.

Em geral, não há função de sinalização padrão no C / C ++, e a falta de uma função fundamental diz muito sobre essas linguagens.

Além disso, acredito que os dois pontos de vista da maioria sobre a abordagem correta para definir uma função estão de certa maneira corretos, e a "controvérsia" sobre ela é na verdade um argumento, uma vez que você leva em consideração duas advertências importantes:

• Uma função signum sempre deve retornar o tipo de seu operando, da mesma forma que uma abs()função, porque signum é geralmente usado para multiplicação com um valor absoluto depois que o último foi processado de alguma forma. Portanto, o principal caso de uso de signum não é comparações, mas aritmética, e o último não deve envolver conversões caras de número inteiro para ponto flutuante.

• Os tipos de ponto flutuante não apresentam um único valor exato de zero: +0,0 pode ser interpretado como "infinitesimalmente acima de zero" e -0,0 como "infinitesimalmente abaixo de zero". Essa é a razão pela qual comparações envolvendo zero devem verificar internamente os dois valores, e uma expressão como x == 0.0pode ser perigosa.

Em relação a C, acho que o melhor caminho a seguir com tipos integrais é realmente usar a (x > 0) - (x < 0)expressão, pois ela deve ser traduzida de forma livre de ramificação e requer apenas três operações básicas. É melhor definir funções embutidas que impõem um tipo de retorno correspondente ao tipo de argumento e adicionar um C11 define _Genericpara mapear essas funções para um nome comum.

Com valores de ponto flutuante, acho funções inline baseado em C11 copysignf(1.0f, x), copysign(1.0, x)e copysignl(1.0l, x)são o caminho a percorrer, simplesmente porque eles são também altamente provável que seja livre de ramo, e, adicionalmente, não necessitam de conversão do resultado de inteiro de volta para um ponto flutuante valor. Provavelmente, você deve comentar com destaque que suas implementações de signum de ponto flutuante não retornarão zero por causa das peculiaridades dos valores de ponto flutuante zero, considerações sobre o tempo de processamento e também porque geralmente é muito útil na aritmética de ponto flutuante receber o -1 / + correto 1 sinal, mesmo para valores zero.

Minha cópia de C em poucas palavras revela a existência de uma função padrão chamada copysign que pode ser útil. Parece que o copysign (1.0, -2.0) retornaria -1.0 e o copysign (1.0, 2.0) retornaria +1.0.

Bem perto né?

Não, ele não existe no c ++, como no matlab. Eu uso uma macro em meus programas para isso.

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

A resposta aceita com a sobrecarga abaixo de fato não aciona -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>());
}

Para C ++ 11, uma alternativa poderia ser.

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

Para mim, ele não dispara nenhum aviso no GCC 5.3.1.

Pouco fora do tópico, mas eu uso isso:

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 eu achei a primeira função - aquela com dois argumentos, para ser muito mais útil a partir de "standard" sgn (), porque é mais frequentemente usada em códigos como este:

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

vs.

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

não há conversão para tipos não assinados e nenhum menos adicional.

na verdade, eu tenho esse pedaço de código 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);
}

A questão é antiga, mas agora existe esse tipo de função desejada. Eu adicionei um invólucro com não, shift esquerdo e dec.

Você pode usar uma função de invólucro baseada no signbit do C99 para obter o comportamento exato desejado (consulte o código mais abaixo).

Retorna se o sinal de x é negativo.
Isso também pode ser aplicado a infinitos, NaNs e zeros (se zero não for assinado, será considerado positivo

#include <math.h>

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

NB: Eu uso o operando não ("!") Porque o valor de retorno do signbit não é especificado como 1 (mesmo que os exemplos pensemos que seria sempre assim), mas verdadeiro para um número negativo:

Valor de retorno
Um valor diferente de zero (true) se o sinal de x for negativo; e zero (falso) caso contrário.

Em seguida, multiplico por dois com o deslocamento à esquerda ("<< 1"), que nos dará 2 para um número positivo e 0 para um número negativo e, finalmente, decrementaremos 1 para obter 1 e -1 para os números respectivamente positivos e negativos, conforme solicitado por OP.

Embora a solução inteira na resposta aceita seja bastante elegante, me incomodou o fato de não poder retornar NAN para tipos duplos, por isso modifiquei-a levemente.

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

Observe que o retorno de uma NAN de ponto flutuante em oposição a um código codificado NANfaz com que o bit de sinal seja definido em algumas implementações ; portanto, a saída val = -NANe a saída val = NANserão idênticas, independentemente do que for (se você preferir uma nansaída " " a uma, -nanvocê pode colocar um abs(val)antes do retorno ...)

Você pode usar o boost::math::sign()método a partir de boost/math/special_functions/sign.hppse o impulso estiver disponível.

Aqui está uma implementação amigável para ramificação:

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 menos que seus dados tenham zeros como metade dos números, aqui o preditor de ramificação escolherá uma das ramificações como a mais comum. Ambas as ramificações envolvem apenas operações simples.

Como alternativa, em alguns compiladores e arquiteturas de CPU, uma versão completamente sem ramificação pode ser mais rápida:

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

Isso funciona para o formato de ponto flutuante binário de precisão dupla IEEE 754: binary64 .

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

Esta função assume:

• representação binary32 de números de ponto flutuante
• um compilador que faz uma exceção sobre a regra estrita de alias ao usar uma união nomeada

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

Por que usar operadores ternários e if-else quando você pode simplesmente fazer isso

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