Existe uma função isnan ()?

PS: Estou no MinGW (se isso faz diferença).

Eu resolvi isso usando isnan () from <math.h>, o qual não existe <cmath>, no qual eu estava #includeinicialmente.

De acordo com o padrão IEEE, os valores de NaN têm a propriedade ímpar de que as comparações que os envolvem são sempre falsas. Ou seja, para um float f, f != fserá verdadeiro apenas se f for NaN.

Observe que, como alguns comentários abaixo apontaram, nem todos os compiladores respeitam isso ao otimizar o código.

Para qualquer compilador que alega usar ponto flutuante IEEE, esse truque deve funcionar. Mas eu não posso garantir que ele vai funcionar na prática. Verifique com seu compilador, em caso de dúvida.

Não há nenhuma isnan()função disponível na biblioteca padrão do C ++ atual. Foi introduzido em C99 e definido como uma macro não uma função. Os elementos da biblioteca padrão definidos por C99 não fazem parte do atual padrão C ++ ISO / IEC 14882: 1998 nem de sua atualização ISO / IEC 14882: 2003.

Em 2005, o Relatório Técnico 1 foi proposto. O TR1 traz compatibilidade com C99 para C ++. Apesar de nunca ter sido oficialmente adotado para se tornar o padrão C ++, muitas implementações ( GCC 4.0+ ou Visual C ++ 9.0+ C ++ fornecem recursos TR1, todos eles ou apenas alguns (o Visual C ++ 9.0 não fornece funções matemáticas C99) .

Se TR1 estiver disponível, ele cmathincluirá elementos C99 como isnan(), isfinite()etc., mas eles serão definidos como funções, não macros, geralmente no std::tr1::espaço para nome, embora muitas implementações (por exemplo, GCC 4+ no Linux ou XCode no Mac OS X 10.5+) os injetem. diretamente para std::, portanto, std::isnanestá bem definido.

Além disso, algumas implementações de C ++ ainda disponibilizam a isnan()macro C99 para C ++ (incluída por cmathou math.h), o que pode causar mais confusões e os desenvolvedores podem assumir que é um comportamento padrão.

Uma observação sobre o Viusal C ++, como mencionado acima, não fornece std::isnannenhum std::tr1::isnan, mas fornece uma função de extensão definida como _isnan()disponível desde o Visual C ++ 6.0

No XCode, há ainda mais diversão. Como mencionado, o GCC 4+ define std::isnan. Para versões mais antigas do compilador e do formulário de biblioteca XCode, parece (aqui está uma discussão relevante ), não tive chance de me verificar) duas funções são definidas, __inline_isnand()na Intel e __isnand()no Power PC.

Primeira solução: se você estiver usando C ++ 11

Como isso foi solicitado, surgiram alguns desenvolvimentos: é importante saber que std::isnan()faz parte do C ++ 11

Sinopse

Definido no cabeçalho <cmath>

bool isnan( float arg ); (since C++11)
bool isnan( double arg ); (since C++11)
bool isnan( long double arg ); (since C++11)

Determina se o número de ponto flutuante arg especificado não é um número ( NaN).

Parâmetros

arg: valor do ponto flutuante

Valor de retorno

truese arg for NaN, falsecaso contrário

Referência

http://en.cppreference.com/w/cpp/numeric/math/isnan

Observe que isso é incompatível com -fast-math se você usa o g ++, veja abaixo outras sugestões.

Outras soluções: se você estiver usando ferramentas não compatíveis com C ++ 11

Para C99, em C, isso é implementado como uma macro isnan(c)que retorna um valor int. O tipo de xdeve ser float, double ou long double.

Vários fornecedores podem incluir ou não uma função isnan().

A maneira supostamente portátil de verificar NaNé usar a propriedade IEEE 754 que NaNnão é igual a si mesma: ou seja x == x, será falsa por xser NaN.

No entanto, a última opção pode não funcionar com todos os compiladores e algumas configurações (particularmente as configurações de otimização); portanto, em último recurso, você sempre pode verificar o padrão de bits ...

Há também uma biblioteca somente de cabeçalho presente no Boost que possui ferramentas legais para lidar com tipos de dados de ponto flutuante

#include <boost/math/special_functions/fpclassify.hpp>

Você obtém as seguintes funções:

template <class T> bool isfinite(T z);
template <class T> bool isinf(T t);
template <class T> bool isnan(T t);
template <class T> bool isnormal(T t);

Se você tiver tempo, consulte o kit de ferramentas de matemática completo do Boost, ele tem muitas ferramentas úteis e está crescendo rapidamente.

Além disso, ao lidar com pontos flutuantes e não flutuantes, pode ser uma boa ideia examinar as conversões numéricas .

Existem três formas "oficiais": posix isnanmacro , c ++ 0x isnanmodelo de função , ou Visual C ++ _isnanfunção .

Infelizmente, é pouco prático detectar qual deles usar.

E, infelizmente, não há maneira confiável de detectar se você possui representação IEEE 754 com NaNs. A biblioteca padrão oferece uma maneira oficial ( numeric_limits<double>::is_iec559). Mas, na prática, compiladores como o g ++ estragam tudo.

Em teoria, pode-se usar simplesmente x != x, mas compiladores como g ++ e visual c ++ estragam tudo.

Portanto, no final, teste os padrões de bit NaN específicos , assumindo (e esperançosamente reforçando, em algum momento!) Uma representação específica, como a IEEE 754.

EDIT : como um exemplo de "compiladores como o g ++… estrague tudo", considere

#include <limits>
#include <assert.h>

void foo( double a, double b )
{
    assert( a != b );
}

int main()
{
    typedef std::numeric_limits<double> Info;
    double const nan1 = Info::quiet_NaN();
    double const nan2 = Info::quiet_NaN();
    foo( nan1, nan2 );
}

Compilando com g ++ (TDM-2 mingw32) 4.4.1:

C: \ test> digite "C: \ Arquivos de Programas \ @commands \ gnuc.bat"
@rem -finput-charset = windows-1252
@ g ++ -O -pedantic -std = c ++ 98 -Wall -Wwrite-strings% * -Wno-long-long

C: \ test> gnuc x.cpp

C: \ test> a && echo funciona ... || eco! falhou
trabalho...

C: \ test> gnuc x.cpp --fast-math

C: \ test> a && echo funciona ... || eco! falhou
Falha na asserção: a! = B, arquivo x.cpp, linha 6

Este aplicativo solicitou que o Runtime o encerrasse de maneira incomum.
Entre em contato com a equipe de suporte do aplicativo para obter mais informações.
! falhou

C: \ teste> _

Existe um std :: isnan se o compilador suportar extensões c99, mas não tenho certeza se o mingw suporta.

Aqui está uma pequena função que deve funcionar se o seu compilador não tiver a função padrão:

bool custom_isnan(double var)
{
    volatile double d = var;
    return d != d;
}

Você pode usar numeric_limits<float>::quiet_NaN( )definido na limitsbiblioteca padrão para testar. Há uma constante separada definida para double.

#include <iostream>
#include <math.h>
#include <limits>

using namespace std;

int main( )
{
   cout << "The quiet NaN for type float is:  "
        << numeric_limits<float>::quiet_NaN( )
        << endl;

   float f_nan = numeric_limits<float>::quiet_NaN();

   if( isnan(f_nan) )
   {
       cout << "Float was Not a Number: " << f_nan << endl;
   }

   return 0;
}

Não sei se isso funciona em todas as plataformas, pois testei apenas com o g ++ no Linux.

Você pode usar a isnan()função, mas precisa incluir a biblioteca de matemática C.

#include <cmath>

Como essa função faz parte do C99, ela não está disponível em todos os lugares. Se o fornecedor não fornecer a função, você também poderá definir sua própria variante para compatibilidade.

inline bool isnan(double x) {
    return x != x;
}

O código a seguir usa a definição de NAN (todos os bits de expoente definidos, pelo menos um conjunto de bits fracionários) e assume que sizeof (int) = sizeof (float) = 4. Você pode procurar NAN na Wikipedia para obter detalhes.

bool IsNan( float value ) { return ((*(UINT*)&value) & 0x7fffffff) > 0x7f800000; }

prevenção nan

Minha resposta a esta pergunta é não usar verificações retroativasnan . Use verificações preventivas para divisões do formulário 0.0/0.0.

#include <float.h>
float x=0.f ;             // I'm gonna divide by x!
if( !x )                  // Wait! Let me check if x is 0
  x = FLT_MIN ;           // oh, since x was 0, i'll just make it really small instead.
float y = 0.f / x ;       // whew, `nan` didn't appear.

nanresultados da operação 0.f/0.f, ou 0.0/0.0. nané um terrível inimigo da estabilidade do seu código que deve ser detectado e evitado com muito cuidado ¹ . As propriedades nandisso são diferentes dos números normais:

• nané tóxico, (5 * nan= nan)
• nannão é igual a nada, nem a si mesmo ( nan! = nan)
• nannão maior que qualquer coisa ( nan!> 0)
• nannão é menos do que qualquer coisa ( nan! <0)

As duas últimas propriedades listadas são contra-lógicas e resultarão em um comportamento ímpar do código que depende de comparações com um nannúmero (a terceira última propriedade também é ímpar, mas você provavelmente nunca verá o x != x ?seu código (a menos que esteja verificando para nan (não confiável))).

No meu próprio código, notei que os nanvalores tendem a produzir bugs difíceis de encontrar. (Observe como esse não é o caso para infou -inf. ( -inf<0) retorna TRUE, (0 < inf) retorna VERDADEIRO e até ( -inf< inf) retorna VERDADEIRO. Portanto, na minha experiência, o comportamento do código geralmente permanece como desejado).

o que fazer sob nan

O que você deseja que aconteça 0.0/0.0 deve ser tratado como um caso especial , mas o que você faz deve depender dos números que você espera que saiam do código.

No exemplo acima, o resultado de ( 0.f/FLT_MIN) será 0basicamente. Você pode 0.0/0.0gerar em seu HUGElugar. Assim,

float x=0.f, y=0.f, z;
if( !x && !y )    // 0.f/0.f case
  z = FLT_MAX ;   // biggest float possible
else
  z = y/x ;       // regular division.

Então, acima, se x fosse 0.f,inf resultaria (que tem um comportamento muito bom / não destrutivo, como mencionado acima, na verdade).

Lembre-se, a divisão inteira por 0 causa uma exceção de tempo de execução . Portanto, você deve sempre verificar a divisão inteira por 0. Só porque 0.0/0.0avaliar discretamente nannão significa que você pode ser preguiçoso e não procurar 0.0/0.0antes que isso aconteça.

1 _{Às vezes, as verificações de nanvia não x != xsão confiáveis ​​( x != xsendo eliminadas por alguns compiladores de otimização que quebram a conformidade com a IEEE, especificamente quando o -ffast-mathcomutador está ativado).}

No C ++ 14, existem várias maneiras de testar se um número de ponto flutuante value é um NaN.

Dessas formas, apenas a verificação dos bits da representação do número funciona de maneira confiável, conforme observado na minha resposta original. Em particular, std::isnane a verificação frequentemente propostav != v , não funciona de maneira confiável e não deve ser usada, para que seu código pare de funcionar corretamente quando alguém decide que a otimização de ponto flutuante é necessária e solicita que o compilador faça isso. Essa situação pode mudar, os compiladores podem ficar mais conformes, mas para esse problema que não aconteceu nos 6 anos desde a resposta original.

Por cerca de 6 anos, minha resposta original foi a solução selecionada para esta pergunta, o que foi bom. Mas, recentemente, uma resposta altamente votada, recomendando o v != vteste não confiável , foi selecionada. Portanto, essa resposta adicional mais atualizada (agora temos os padrões C ++ 11 e C ++ 14 e C ++ 17 no horizonte).

As principais maneiras de verificar o NaN-ness, a partir do C ++ 14, são:

• std::isnan(value) )
  é a maneira de biblioteca padrão pretendida desde C ++ 11. isnanaparentemente entra em conflito com a macro Posix de mesmo nome, mas na prática isso não é um problema. O principal problema é que, quando a otimização aritmética de ponto flutuante é solicitada, pelo menos um compilador principal, ou seja, g ++, std::isnan retorna falsepara o argumento NaN .

• (fpclassify(value) == FP_NAN) )
  Sofre do mesmo problema que std::isnan, ou seja, não é confiável.

• (value != value) )
  Recomendado em muitas respostas SO. Sofre do mesmo problema que std::isnan, ou seja, não é confiável.

• (value == Fp_info::quiet_NaN()) )
  Este é um teste que, com o comportamento padrão, não deve detectar NaNs, mas que, com o comportamento otimizado, pode detectar NaNs (devido ao código otimizado apenas comparando diretamente as representações de nível de bit) e talvez combinado com outra maneira de cobrir o comportamento não otimizado padrão , pode detectar de forma confiável o NaN. Infelizmente, acabou por não funcionar de forma confiável.

• (ilogb(value) == FP_ILOGBNAN) )
  Sofre do mesmo problema que std::isnan, ou seja, não é confiável.

• isunordered(1.2345, value) )
  Sofre do mesmo problema que std::isnan, ou seja, não é confiável.

• is_ieee754_nan( value ) )
  Esta não é uma função padrão. É a verificação dos bits de acordo com o padrão IEEE 754. É completamente confiável mas o código depende um pouco do sistema.

No código de teste completo a seguir, “success” é se uma expressão relata Nan-ness do valor. Para a maioria das expressões, essa medida de sucesso, o objetivo de detectar NaNs e apenas NaNs, corresponde à sua semântica padrão. Para a (value == Fp_info::quiet_NaN()) )expressão, no entanto, o comportamento padrão é que ele não funciona como um detector de NaN.

#include <cmath>        // std::isnan, std::fpclassify
#include <iostream>
#include <iomanip>      // std::setw
#include <limits>
#include <limits.h>     // CHAR_BIT
#include <sstream>
#include <stdint.h>     // uint64_t
using namespace std;

#define TEST( x, expr, expected ) \
    [&](){ \
        const auto value = x; \
        const bool result = expr; \
        ostringstream stream; \
        stream << boolalpha << #x " = " << x << ", (" #expr ") = " << result; \
        cout \
            << setw( 60 ) << stream.str() << "  " \
            << (result == expected? "Success" : "FAILED") \
            << endl; \
    }()

#define TEST_ALL_VARIABLES( expression ) \
    TEST( v, expression, true ); \
    TEST( u, expression, false ); \
    TEST( w, expression, false )

using Fp_info = numeric_limits<double>;

inline auto is_ieee754_nan( double const x )
    -> bool
{
    static constexpr bool   is_claimed_ieee754  = Fp_info::is_iec559;
    static constexpr int    n_bits_per_byte     = CHAR_BIT;
    using Byte = unsigned char;

    static_assert( is_claimed_ieee754, "!" );
    static_assert( n_bits_per_byte == 8, "!" );
    static_assert( sizeof( x ) == sizeof( uint64_t ), "!" );

    #ifdef _MSC_VER
        uint64_t const bits = reinterpret_cast<uint64_t const&>( x );
    #else
        Byte bytes[sizeof(x)];
        memcpy( bytes, &x, sizeof( x ) );
        uint64_t int_value;
        memcpy( &int_value, bytes, sizeof( x ) );
        uint64_t const& bits = int_value;
    #endif

    static constexpr uint64_t   sign_mask       = 0x8000000000000000;
    static constexpr uint64_t   exp_mask        = 0x7FF0000000000000;
    static constexpr uint64_t   mantissa_mask   = 0x000FFFFFFFFFFFFF;

    (void) sign_mask;
    return (bits & exp_mask) == exp_mask and (bits & mantissa_mask) != 0;
}

auto main()
    -> int
{
    double const v = Fp_info::quiet_NaN();
    double const u = 3.14;
    double const w = Fp_info::infinity();

    cout << boolalpha << left;
    cout << "Compiler claims IEEE 754 = " << Fp_info::is_iec559 << endl;
    cout << endl;;
    TEST_ALL_VARIABLES( std::isnan(value) );                    cout << endl;
    TEST_ALL_VARIABLES( (fpclassify(value) == FP_NAN) );        cout << endl;
    TEST_ALL_VARIABLES( (value != value) );                     cout << endl;
    TEST_ALL_VARIABLES( (value == Fp_info::quiet_NaN()) );      cout << endl;
    TEST_ALL_VARIABLES( (ilogb(value) == FP_ILOGBNAN) );        cout << endl;
    TEST_ALL_VARIABLES( isunordered(1.2345, value) );           cout << endl;
    TEST_ALL_VARIABLES( is_ieee754_nan( value ) );
}

Resultados com g ++ (observe novamente que o comportamento padrão de (value == Fp_info::quiet_NaN())é que ele não funciona como um detector de NaN, é apenas um interesse prático aqui):

[C: \ meus \ fóruns \ so \ 282 (detectar NaN)]
> g ++ --versão | encontre "++"
g ++ (x86_64-win32-sjlj-rev1, criado pelo projeto MinGW-W64) 6.3.0

[C: \ meus \ fóruns \ so \ 282 (detectar NaN)]
> g ++ foo.cpp && a
O compilador reivindica IEEE 754 = true

v = nan, (std :: isnan (valor)) = verdadeiro Sucesso
u = 3.14, (std :: isnan (valor)) = false Sucesso
w = inf, (std :: isnan (valor)) = false Sucesso

v = nan, ((fpclassify (value) == 0x0100)) = verdadeiro sucesso
u = 3.14, ((fpclassify (valor) == 0x0100)) = false Sucesso
w = inf, ((fpclassify (value) == 0x0100)) = false Sucesso

v = nan, ((valor! = valor)) = verdadeiro sucesso
u = 3,14, ((valor! = valor)) = falso Sucesso
w = inf, ((valor! = valor)) = falso Sucesso

v = nan, ((valor == Fp_info :: quiet_NaN ())) = false FAILED
u = 3.14, ((valor == Fp_info :: quiet_NaN ())) = false Sucesso
w = inf, ((valor == Fp_info :: quiet_NaN ())) = false Sucesso

v = nan, ((ilogb (value) == ((int) 0x80000000))) = verdadeiro sucesso
u = 3.14, ((ilogb (valor) == ((int) 0x80000000)))) = sucesso falso
w = inf, ((ilogb (value) == ((int) 0x80000000))) = false Sucesso

v = nan, (isunordered (1.2345, value)) = verdadeiro Sucesso
u = 3.14, (sem ordem (1.2345, valor)) = false Sucesso
w = inf, (isunordered (1.2345, value)) = false Sucesso

v = nan, (is_ieee754_nan (valor)) = verdadeiro Sucesso
u = 3.14, (is_ieee754_nan (valor)) = false Sucesso
w = inf, (is_ieee754_nan (value)) = false Sucesso

[C: \ meus \ fóruns \ so \ 282 (detectar NaN)]
> g ++ foo.cpp -ffast-math && a
O compilador reivindica IEEE 754 = true

v = nan, (std :: isnan (valor)) = falso FAILED
u = 3.14, (std :: isnan (valor)) = false Sucesso
w = inf, (std :: isnan (valor)) = false Sucesso

v = nan, ((fpclassify (valor) == 0x0100)) = falso FAILED
u = 3.14, ((fpclassify (valor) == 0x0100)) = false Sucesso
w = inf, ((fpclassify (value) == 0x0100)) = false Sucesso

v = nan, ((valor! = valor)) = falso FAILED
u = 3,14, ((valor! = valor)) = falso Sucesso
w = inf, ((valor! = valor)) = falso Sucesso

v = nan, ((valor == Fp_info :: quiet_NaN ())) = verdadeiro Sucesso
u = 3.14, ((valor == Fp_info :: quiet_NaN ())) = verdadeiro FAILED
w = inf, ((valor == Fp_info :: quiet_NaN ())) = verdadeiro FAILED

v = nan, ((ilogb (value) == ((int) 0x80000000))) = verdadeiro sucesso
u = 3.14, ((ilogb (valor) == ((int) 0x80000000)))) = sucesso falso
w = inf, ((ilogb (value) == ((int) 0x80000000))) = false Sucesso

v = nan, (isunordered (1.2345, value)) = false FAILED
u = 3.14, (sem ordem (1.2345, valor)) = false Sucesso
w = inf, (isunordered (1.2345, value)) = false Sucesso

v = nan, (is_ieee754_nan (valor)) = verdadeiro Sucesso
u = 3.14, (is_ieee754_nan (valor)) = false Sucesso
w = inf, (is_ieee754_nan (value)) = false Sucesso

[C: \ meus \ fóruns \ so \ 282 (detectar NaN)]
> _

Resultados com o Visual C ++:

[C: \ meus \ fóruns \ so \ 282 (detectar NaN)]
> cl / nologo- 2> & 1 | encontre "++"
Microsoft (R) C / C ++ Optimizing Compiler versão 19.00.23725 para x86

[C: \ meus \ fóruns \ so \ 282 (detectar NaN)]
> cl foo.cpp / fev &&b
foo.cpp
O compilador reivindica IEEE 754 = true

v = nan, (std :: isnan (valor)) = verdadeiro Sucesso
u = 3.14, (std :: isnan (valor)) = false Sucesso
w = inf, (std :: isnan (valor)) = false Sucesso

v = nan, ((fpclassify (value) == 2)) = verdadeiro sucesso
u = 3,14, ((fpclassify (valor) == 2)) = falso Sucesso
w = inf, ((fpclassify (value) == 2)) = false Sucesso

v = nan, ((valor! = valor)) = verdadeiro sucesso
u = 3,14, ((valor! = valor)) = falso Sucesso
w = inf, ((valor! = valor)) = falso Sucesso

v = nan, ((valor == Fp_info :: quiet_NaN ())) = false FAILED
u = 3.14, ((valor == Fp_info :: quiet_NaN ())) = false Sucesso
w = inf, ((valor == Fp_info :: quiet_NaN ())) = false Sucesso

v = nan, ((ilogb (valor) == 0x7fffffff)) = verdadeiro sucesso
u = 3.14, ((ilogb (valor) == 0x7fffffff)) = falso Sucesso
w = inf, ((ilogb (valor) == 0x7fffffff)) = verdadeiro FALHOU

v = nan, (isunordered (1.2345, value)) = verdadeiro Sucesso
u = 3.14, (sem ordem (1.2345, valor)) = false Sucesso
w = inf, (isunordered (1.2345, value)) = false Sucesso

v = nan, (is_ieee754_nan (valor)) = verdadeiro Sucesso
u = 3.14, (is_ieee754_nan (valor)) = false Sucesso
w = inf, (is_ieee754_nan (value)) = false Sucesso

[C: \ meus \ fóruns \ so \ 282 (detectar NaN)]
> cl foo.cpp / Feb / fp: fast && b
foo.cpp
O compilador reivindica IEEE 754 = true

v = nan, (std :: isnan (valor)) = verdadeiro Sucesso
u = 3.14, (std :: isnan (valor)) = false Sucesso
w = inf, (std :: isnan (valor)) = false Sucesso

v = nan, ((fpclassify (value) == 2)) = verdadeiro sucesso
u = 3,14, ((fpclassify (valor) == 2)) = falso Sucesso
w = inf, ((fpclassify (value) == 2)) = false Sucesso

v = nan, ((valor! = valor)) = verdadeiro sucesso
u = 3,14, ((valor! = valor)) = falso Sucesso
w = inf, ((valor! = valor)) = falso Sucesso

v = nan, ((valor == Fp_info :: quiet_NaN ())) = false FAILED
u = 3.14, ((valor == Fp_info :: quiet_NaN ())) = false Sucesso
w = inf, ((valor == Fp_info :: quiet_NaN ())) = false Sucesso

v = nan, ((ilogb (valor) == 0x7fffffff)) = verdadeiro sucesso
u = 3.14, ((ilogb (valor) == 0x7fffffff)) = falso Sucesso
w = inf, ((ilogb (valor) == 0x7fffffff)) = verdadeiro FALHOU

v = nan, (isunordered (1.2345, value)) = verdadeiro Sucesso
u = 3.14, (sem ordem (1.2345, valor)) = false Sucesso
w = inf, (isunordered (1.2345, value)) = false Sucesso

v = nan, (is_ieee754_nan (valor)) = verdadeiro Sucesso
u = 3.14, (is_ieee754_nan (valor)) = false Sucesso
w = inf, (is_ieee754_nan (value)) = false Sucesso

[C: \ meus \ fóruns \ so \ 282 (detectar NaN)]
> _

Resumindo os resultados acima, apenas o teste direto da representação no nível de bit, usando a is_ieee754_nanfunção definida neste programa de teste, funcionou de maneira confiável em todos os casos com o g ++ e o Visual C ++.

Adendo:
Depois de postar o texto acima, tomei conhecimento de mais um possível teste para NaN, mencionado em outra resposta aqui, a saber ((value < 0) == (value >= 0)). Isso acabou funcionando bem com o Visual C ++, mas falhou com a -ffast-mathopção do g ++ . Somente testes diretos de bitpattern funcionam de maneira confiável.

inline bool IsNan(float f)
{
    const uint32 u = *(uint32*)&f;
    return (u&0x7F800000) == 0x7F800000 && (u&0x7FFFFF);    // Both NaN and qNan.
}

inline bool IsNan(double d)
{
    const uint64 u = *(uint64*)&d;
    return (u&0x7FF0000000000000ULL) == 0x7FF0000000000000ULL && (u&0xFFFFFFFFFFFFFULL);
}

Isso funciona se sizeof(int)for 4 e sizeof(long long)for 8.

Durante o tempo de execução, é apenas uma comparação, as peças vazadas não levam tempo. Apenas altera a configuração dos sinalizadores de comparação para verificar a igualdade.

Uma possível solução que não dependeria da representação IEEE específica para NaN usada seria a seguinte:

template<class T>
bool isnan( T f ) {
    T _nan =  (T)0.0/(T)0.0;
    return 0 == memcmp( (void*)&f, (void*)&_nan, sizeof(T) );
}

Considerando que (x! = X) nem sempre é garantido para NaN (como se estivesse usando a opção -ffast-math), eu tenho usado:

#define IS_NAN(x) (((x) < 0) == ((x) >= 0))

Os números não podem ser ambos <0 e> = 0; portanto, essa verificação só passa se o número não for menor que, nem maior que ou igual a zero. O que é basicamente nenhum número, ou NaN.

Você também pode usar isso se preferir:

#define IS_NAN(x) (!((x)<0) && !((x)>=0)

Não tenho certeza de como isso é afetado pela matemática -fast, portanto, sua milhagem pode variar.

Quanto a mim, a solução poderia ser uma macro para torná-la explicitamente integrada e, portanto, rápida o suficiente. Também funciona para qualquer tipo de flutuador. Baseia-se no fato de que o único caso em que um valor não é igual é quando o valor não é um número.

#ifndef isnan
  #define isnan(a) (a != a)
#endif

Isso funciona:

#include <iostream>
#include <math.h>
using namespace std;

int main ()
{
  char ch='a';
  double val = nan(&ch);
  if(isnan(val))
     cout << "isnan" << endl;

  return 0;
}

saída: isnan

Parece-me que a melhor abordagem verdadeiramente multiplataforma seria usar uma união e testar o padrão de bits da dupla para verificar NaNs.

Não testei completamente essa solução e pode haver uma maneira mais eficiente de trabalhar com os padrões de bits, mas acho que ela deve funcionar.

#include <stdint.h>
#include <stdio.h>

union NaN
{
    uint64_t bits;
    double num;
};

int main()
{
    //Test if a double is NaN
    double d = 0.0 / 0.0;
    union NaN n;
    n.num = d;
    if((n.bits | 0x800FFFFFFFFFFFFF) == 0xFFFFFFFFFFFFFFFF)
    {
        printf("NaN: %f", d);
    }

    return 0;
}

No x86-64, você pode ter métodos extremamente rápidos para verificar o NaN e o infinito, que funcionam independentemente da -ffast-mathopção do compilador. ( f != f, std::isnan, std::isinfSempre produzir falsecom -ffast-math).

Testes para NaN, infinito e números finitos podem ser feitos facilmente, verificando-se o máximo de expoente. infinito é expoente máximo com mantissa zero, NaN é expoente máximo e mantissa diferente de zero. O expoente é armazenado nos próximos bits após o bit de sinal mais alto, de modo que podemos apenas sair à esquerda para se livrar do bit de sinal e tornar o expoente os bits mais altos, sem mascaramento ( operator&):

static inline uint64_t load_ieee754_rep(double a) {
    uint64_t r;
    static_assert(sizeof r == sizeof a, "Unexpected sizes.");
    std::memcpy(&r, &a, sizeof a); // Generates movq instruction.
    return r;
}

static inline uint32_t load_ieee754_rep(float a) {
    uint32_t r;
    static_assert(sizeof r == sizeof a, "Unexpected sizes.");
    std::memcpy(&r, &a, sizeof a); // Generates movd instruction.
    return r;
}

constexpr uint64_t inf_double_shl1 = UINT64_C(0xffe0000000000000);
constexpr uint32_t inf_float_shl1 = UINT32_C(0xff000000);

// The shift left removes the sign bit. The exponent moves into the topmost bits,
// so that plain unsigned comparison is enough.
static inline bool isnan2(double a)    { return load_ieee754_rep(a) << 1  > inf_double_shl1; }
static inline bool isinf2(double a)    { return load_ieee754_rep(a) << 1 == inf_double_shl1; }
static inline bool isfinite2(double a) { return load_ieee754_rep(a) << 1  < inf_double_shl1; }
static inline bool isnan2(float a)     { return load_ieee754_rep(a) << 1  > inf_float_shl1; }
static inline bool isinf2(float a)     { return load_ieee754_rep(a) << 1 == inf_float_shl1; }
static inline bool isfinite2(float a)  { return load_ieee754_rep(a) << 1  < inf_float_shl1; }

As stdversões isinfe isfinitecarregam 2 double/floatconstantes do .datasegmento e, na pior das hipóteses, podem causar 2 falhas no cache de dados. As versões acima não carregam dados inf_double_shl1e as inf_float_shl1constantes são codificadas como operandos imediatos nas instruções de montagem.

Mais rápido isnan2é apenas 2 instruções de montagem:

bool isnan2(double a) {
    bool r;
    asm(".intel_syntax noprefix"
        "\n\t ucomisd %1, %1"
        "\n\t setp %b0"
        "\n\t .att_syntax prefix"
        : "=g" (r)
        : "x" (a)
        : "cc"
        );
    return r;
}

Usa o fato de que a ucomisdinstrução define sinalizador de paridade se algum argumento for NaN. É assim que std::isnanfunciona quando nenhuma -ffast-mathopção é especificada.

O padrão IEEE diz que quando o expoente é todo se 1a mantissa não é zero, o número é a NaN. Duplo é 1bit de sinal, 11bits de expoente e 52bits de mantissa. Faça uma pequena verificação.

Como os comentários acima afirmam, um! = A não funcionará em g ++ e em alguns outros compiladores, mas esse truque deve. Pode não ser tão eficiente, mas ainda é uma maneira:

bool IsNan(float a)
{
    char s[4];
    sprintf(s, "%.3f", a);
    if (s[0]=='n') return true;
    else return false;
}

Basicamente, em g ++ (não tenho certeza de outros), printf imprime 'nan' nos formatos% d ou% .f, se a variável não for um número inteiro / float válido. Portanto, esse código está verificando se o primeiro caractere da string é 'n' (como em "nan")

Isso detecta o infinito e também o NaN no Visual Studio, verificando se está dentro de limites duplos:

//#include <float.h>
double x, y = -1.1; x = sqrt(y);
if (x >= DBL_MIN && x <= DBL_MAX )
    cout << "DETECTOR-2 of errors FAILS" << endl;
else
    cout << "DETECTOR-2 of errors OK" << endl;