Czy istnieje funkcja isnan ()?

PS .: Jestem w MinGW (jeśli to robi różnicę).

Miałem to rozwiązane za pomocą isnan () from <math.h>, który nie istnieje, w <cmath>którym byłem #includepoczątkowo.

Zgodnie ze standardem IEEE wartości NaN mają dziwną właściwość polegającą na tym, że porównania z nimi związane są zawsze fałszywe. To znaczy, dla liczby zmiennoprzecinkowej f f != fbędzie prawdą tylko wtedy, gdy f jest NaN.

Zauważ, że jak zauważyły ​​niektóre komentarze poniżej, nie wszystkie kompilatory przestrzegają tego podczas optymalizacji kodu.

Dla każdego kompilatora, który twierdzi, że używa zmiennoprzecinkowego IEEE, ta sztuczka powinna działać. Ale nie mogę zagwarantować, że to będzie działać w praktyce. W razie wątpliwości skontaktuj się ze swoim kompilatorem.

W isnan()obecnej bibliotece standardowej C ++ nie jest dostępna żadna funkcja. Został wprowadzony w C99 i zdefiniowany jako makro a nie funkcja. Elementy standardowej biblioteki zdefiniowane przez C99 nie są częścią aktualnego standardu C ++ ISO / IEC 14882: 1998 ani jego aktualizacji ISO / IEC 14882: 2003.

W 2005 r. Zaproponowano sprawozdanie techniczne 1. TR1 zapewnia zgodność z C99 do C ++. Pomimo tego, że nigdy nie zostało oficjalnie przyjęte jako standard C ++, wiele ( implementacje GCC 4.0+ lub Visual C ++ 9.0+ C ++ zapewniają funkcje TR1, wszystkie lub tylko niektóre (Visual C ++ 9.0 nie zapewnia funkcji matematycznych C99) .

Jeśli TR1 jest dostępna, a następnie cmathzawiera elementy, takie jak C99 isnan(), isfinite()itp ale są one zdefiniowane jako funkcje, niewymienione makr, zazwyczaj w std::tr1::przestrzeni nazw, chociaż wiele implementacji (tj GCC 4+ w systemie Linux lub w Xcode na Mac OS X 10.5+) wstrzyknąć bezpośrednio do std::, więc std::isnanjest dobrze zdefiniowane.

Co więcej, niektóre implementacje C ++ wciąż udostępniają isnan()makro C99 dla C ++ (zawarte przez cmathlub math.h), co może powodować więcej zamieszania, a programiści mogą założyć, że jest to standardowe zachowanie.

Uwaga na temat Viusal C ++, jak wspomniano powyżej, nie zapewnia std::isnanżadnej z nich std::tr1::isnan, ale zapewnia funkcję rozszerzenia zdefiniowaną jako _isnan()dostępna od wersji Visual C ++ 6.0

Na XCode jest jeszcze więcej zabawy. Jak wspomniano, GCC 4+ definiuje std::isnan. Wydaje się, że w starszych wersjach kompilatora i biblioteki XCode (tutaj jest odpowiednia dyskusja ), nie miałem okazji się sprawdzić) zdefiniowano dwie funkcje, __inline_isnand()na Intel i __isnand()Power PC.

Pierwsze rozwiązanie: jeśli używasz C ++ 11

Ponieważ o to zapytano, pojawiło się trochę nowych rozwiązań: ważne jest, aby wiedzieć, że std::isnan()jest to część C ++ 11

Streszczenie

Zdefiniowane w nagłówku <cmath>

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

Określa, czy podana liczba zmiennoprzecinkowa arg nie jest liczbą ( NaN).

Parametry

arg: wartość zmiennoprzecinkowa

Zwracana wartość

truejeśli arg jest NaN, w falseprzeciwnym razie

Odniesienie

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

Pamiętaj, że jest to niezgodne z opcją -fast-matematyki, jeśli używasz g ++, zobacz inne sugestie poniżej.

Inne rozwiązania: jeśli używasz narzędzi niezgodnych z C ++ 11

W przypadku C99 w C jest to zaimplementowane jako makro, isnan(c)które zwraca wartość int. Typ xpowinien być zmiennoprzecinkowy, podwójny lub długi podwójny.

Różni dostawcy mogą, ale nie muszą zawierać funkcji isnan().

Niby przenośny sposób na sprawdzenie NaNto użycie właściwości IEEE 754, która NaNnie jest sobie równa: tj. x == xBędzie fałszywa za xbycie NaN.

Jednak ostatnia opcja może nie działać z każdym kompilatorem i niektórymi ustawieniami (szczególnie ustawieniami optymalizacji), więc w ostateczności zawsze możesz sprawdzić wzorzec bitowy ...

W programie Boost dostępna jest także biblioteka tylko z nagłówkami, która zawiera zgrabne narzędzia do obsługi typów danych zmiennoprzecinkowych

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

Otrzymasz następujące funkcje:

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

Jeśli masz czas, zapoznaj się z całym zestawem narzędzi matematycznych z Boost, ma wiele przydatnych narzędzi i szybko rośnie.

Również w przypadku punktów zmiennoprzecinkowych i nieprzemiennych dobrym pomysłem może być przyjrzenie się konwersji liczbowej .

Istnieją trzy „oficjalne” sposoby: isnanmakro posix , isnanszablon funkcji c ++ 0x lub wizualna _isnanfunkcja c ++ .

Niestety wykrycie, którego z nich użyć, jest raczej niepraktyczne.

I niestety nie ma niezawodnego sposobu na wykrycie, czy masz reprezentację IEEE 754 z NaN. Standardowa biblioteka oferuje taki oficjalny sposób ( numeric_limits<double>::is_iec559). Ale w praktyce kompilatory takie jak g ++ to psują.

Teoretycznie można użyć po prostu x != x, ale kompilatory takie jak g ++ i visual c ++ to psują.

W końcu przetestuj określone bity wzorcowe NaN , zakładając (i mam nadzieję, że w pewnym momencie wymuszę !) Określoną reprezentację, taką jak IEEE 754.

EDYCJA : jako przykład „kompilatorów takich jak g ++… spieprz to”, rozważ

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

Kompilacja z g ++ (TDM-2 mingw32) 4.4.1:

C: \ test> wpisz „C: \ Program Files \ @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> echo && działa ... || echo! nie powiodło się
Pracuje...

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

C: \ test> echo && działa ... || echo! nie powiodło się
Asercja nie powiodła się: a! = B, plik x.cpp, wiersz 6

Ta aplikacja poprosiła środowisko wykonawcze o zakończenie go w nietypowy sposób.
Skontaktuj się z zespołem pomocy technicznej aplikacji, aby uzyskać więcej informacji.
! nie powiodło się

C: \ test> _

Istnieje std :: isnan, jeśli kompilator obsługuje rozszerzenia c99, ale nie jestem pewien, czy mingw to robi.

Oto mała funkcja, która powinna działać, jeśli twój kompilator nie ma standardowej funkcji:

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

Możesz użyć numeric_limits<float>::quiet_NaN( )zdefiniowanego w limitsstandardowej bibliotece do testowania. Zdefiniowano osobną stałą 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;
}

Nie wiem, czy to działa na wszystkich platformach, ponieważ testowałem tylko z g ++ w systemie Linux.

Możesz użyć tej isnan()funkcji, ale musisz dołączyć bibliotekę matematyki C.

#include <cmath>

Ponieważ ta funkcja jest częścią C99, nie jest dostępna wszędzie. Jeśli twój dostawca nie dostarcza tej funkcji, możesz również zdefiniować własny wariant dla kompatybilności.

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

Poniższy kod wykorzystuje definicję NAN (zestaw wszystkich bitów wykładniczych, przynajmniej jeden zestaw bitów ułamkowych) i zakłada, że ​​sizeof (int) = sizeof (float) = 4. Szczegółowe informacje można znaleźć w Wikipedii w NAN.

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

zapobieganie nanom

Moja odpowiedź na to pytanie nienan polega na sprawdzaniu z mocą wsteczną . Zamiast tego użyj kontroli zapobiegawczej dla podziałów formularza 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.

nanwynika z operacji 0.f/0.flub 0.0/0.0. nanjest straszną przeszkodą dla stabilności twojego kodu, którą trzeba bardzo ostrożnie wykryć ¹ . Ich właściwości nanróżnią się od normalnych liczb:

• nanjest toksyczny, (5 * nan= nan)
• nannie jest niczym, nawet sam ( nan! = nan)
• nannie większy niż cokolwiek ( nan!> 0)
• nanjest nie mniej niż cokolwiek ( nan! <0)

Dwie ostatnie wymienione właściwości są przeciwne logice i spowodują dziwne zachowanie kodu, który opiera się na porównaniach z nanliczbą (trzecia ostatnia właściwość jest również nieparzysta, ale prawdopodobnie nigdy nie zobaczyszx != x ? w swoim kodzie (chyba że sprawdzasz dla nan (niewiarygodnie))).

W swoim własnym kodzie zauważyłem, że nanwartości często powodują błędy, które można znaleźć. (Zauważ, że tak nie jest w przypadku influb -inf. ( -inf<0) zwraca TRUE, (0 < inf) zwraca PRAWDA, a nawet ( -inf< inf) zwraca PRAWDA. Tak więc, z mojego doświadczenia, zachowanie kodu często jest nadal pożądane).

co robić pod nan

To, co chcesz się wydarzyć, 0.0/0.0 musi być traktowane jako szczególny przypadek , ale to, co robisz, musi zależeć od liczb, których oczekujesz od kodu.

W powyższym przykładzie wynikiem ( 0.f/FLT_MIN) będzie w 0zasadzie. Zamiast tego możesz chcieć 0.0/0.0wygenerować HUGE. Więc,

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.

Tak więc powyżej, gdyby x było 0.f,inf spowodowałoby (które ma całkiem dobre / nieniszczące zachowanie, jak wspomniano powyżej).

Pamiętaj, dzielenie liczb całkowitych przez 0 powoduje wyjątek czasu wykonywania . Dlatego zawsze musisz sprawdzać dzielenie liczb całkowitych przez 0. To, że 0.0/0.0cicho ocenia nan, nie oznacza, że ​​możesz być leniwy i nie sprawdzać, 0.0/0.0zanim to nastąpi.

1 _{Czeki przez nanvia x != xsą czasami niewiarygodne ( x != xsą usuwane przez niektóre optymalizujące kompilatory, które łamią zgodność z IEEE, szczególnie gdy -ffast-mathprzełącznik jest włączony).}

Począwszy od C ++ 14 istnieje wiele sposobów sprawdzenia, czy liczba zmiennoprzecinkowa valuejest NaN.

Spośród tych sposobów tylko sprawdzanie bitów reprezentacji liczby działa niezawodnie, jak zauważono w mojej pierwotnej odpowiedzi. W szczególności std::isnani często proponowana kontrola v != vnie działa niezawodnie i nie powinna być używana, aby Twój kod nie przestał działać poprawnie, gdy ktoś zdecyduje, że potrzebna jest optymalizacja zmiennoprzecinkowa, i poprosi kompilator o zrobienie tego. Ta sytuacja może się zmienić, kompilatory mogą uzyskać większą zgodność, ale w przypadku tego problemu, który nie pojawił się przez 6 lat od pierwotnej odpowiedzi.

Przez około 6 lat moją pierwotną odpowiedzią było wybrane rozwiązanie tego pytania, które było OK. Ale ostatnio wybrano bardzo pozytywną odpowiedź zalecającą niewiarygodny v != vtest. Stąd ta dodatkowa, bardziej aktualna odpowiedź (teraz mamy standardy C ++ 11 i C ++ 14 oraz C ++ 17 na horyzoncie).

Główne sposoby sprawdzania obecności NaN od C ++ 14 to:

• std::isnan(value) )
  jest zamierzonym standardowym sposobem biblioteki od C ++ 11. isnannajwyraźniej jest w konflikcie z makrem Posix o tej samej nazwie, ale w praktyce nie stanowi to problemu. Główny problem polega na tym, że gdy wymagana jest optymalizacja arytmetyczna zmiennoprzecinkowa, wówczas co najmniej jeden główny kompilator, mianowicie g ++, std::isnan zwraca falseargument NaN .

• (fpclassify(value) == FP_NAN) )
  Cierpi na ten sam problem, co std::isnannp. Nie jest wiarygodny.

• (value != value) )
  Zalecane w wielu odpowiedziach SO. Cierpi na ten sam problem, co std::isnannp. Nie jest wiarygodny.

• (value == Fp_info::quiet_NaN()) )
  Jest to test, który przy standardowym zachowaniu nie powinien wykrywać NaN, ale że przy zoptymalizowanym zachowaniu może wykryć NaN (ze względu na zoptymalizowany kod bezpośrednio porównujący reprezentacje poziomu bitów) i być może w połączeniu z innym sposobem na pokrycie standardowego niezoptymalizowanego zachowania , mógł niezawodnie wykryć NaN. Niestety okazało się, że nie działa niezawodnie.

• (ilogb(value) == FP_ILOGBNAN) )
  Cierpi na ten sam problem, co std::isnannp. Nie jest wiarygodny.

• isunordered(1.2345, value) )
  Cierpi na ten sam problem, co std::isnannp. Nie jest wiarygodny.

• is_ieee754_nan( value ) )
  To nie jest standardowa funkcja. Sprawdza bity zgodnie ze standardem IEEE 754. Jest całkowicie niezawodny, ale kod jest w pewnym stopniu zależny od systemu.

W poniższym kompletnym kodzie testowym „sukces” określa, czy wyrażenie zgłasza Nanowość wartości. Dla większości wyrażeń ta miara sukcesu, cel wykrycia NaN i tylko NaN, odpowiada ich standardowej semantyce. Jednak w przypadku (value == Fp_info::quiet_NaN()) )wyrażenia standardowe zachowanie polega na tym, że nie działa ono jako detektor 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 ) );
}

Wyniki z g ++ (zauważ, że standardowe zachowanie (value == Fp_info::quiet_NaN())jest takie, że nie działa jako detektor NaN, jest to po prostu bardzo praktyczne zainteresowanie tutaj):

[C: \ my \ forums \ so \ 282 (wykryj NaN)]
> g ++ --wersja | znajdź „++”
g ++ (x86_64-win32-sjlj-rev1, zbudowany przez projekt MinGW-W64) 6.3.0

[C: \ my \ forums \ so \ 282 (wykryj NaN)]
> g ++ foo.cpp && a
Kompilator twierdzi, że IEEE 754 = true

v = nan, (std :: isnan (wartość)) = true Sukces
u = 3,14, (std :: isnan (wartość)) = false Sukces
w = inf, (std :: isnan (wartość)) = false Sukces

v = nan, ((fpclassify (wartość) == 0x0100)) = true Sukces
u = 3,14, ((fpclassify (wartość) == 0x0100)) = fałszywy sukces
w = inf, ((fpclassify (wartość) == 0x0100)) = false Sukces

v = nan, ((wartość! = wartość)) = true Sukces
u = 3,14, ((wartość! = wartość)) = false Sukces
w = inf, ((wartość! = wartość)) = false Sukces

v = nan, ((wartość == Fp_info :: quiet_NaN ())) = false FAILED
u = 3,14, ((wartość == Fp_info :: quiet_NaN ())) = false Sukces
w = inf, ((wartość == Fp_info :: quiet_NaN ())) = false Sukces

v = nan, ((ilogb (wartość) == ((int) 0x80000000))) = true Sukces
u = 3,14, ((ilogb (wartość) == ((int) 0x80000000))) = false Sukces
w = inf, ((ilogb (wartość) == ((int) 0x80000000))) = false Sukces

v = nan, (isunordered (1.2345, wartość)) = true Sukces
u = 3,14, (isunordered (1,2345, wartość)) = false Sukces
w = inf, (isunordered (1.2345, wartość)) = false Sukces

v = nan, (is_ieee754_nan (wartość)) = true Sukces
u = 3,14, (is_ieee754_nan (wartość)) = false Sukces
w = inf, (is_ieee754_nan (wartość)) = false Sukces

[C: \ my \ forums \ so \ 282 (wykryj NaN)]
> g ++ foo.cpp -ffast-math && a
Kompilator twierdzi, że IEEE 754 = true

v = nan, (std :: isnan (wartość)) = false FAILED
u = 3,14, (std :: isnan (wartość)) = false Sukces
w = inf, (std :: isnan (wartość)) = false Sukces

v = nan, ((fpclifyify (wartość) == 0x0100)) = false FAILED
u = 3,14, ((fpclassify (wartość) == 0x0100)) = fałszywy sukces
w = inf, ((fpclassify (wartość) == 0x0100)) = false Sukces

v = nan, ((wartość! = wartość)) = false FAILED
u = 3,14, ((wartość! = wartość)) = false Sukces
w = inf, ((wartość! = wartość)) = false Sukces

v = nan, ((wartość == Fp_info :: quiet_NaN ())) = true Sukces
u = 3,14, ((wartość == Fp_info :: quiet_NaN ())) = true FAILED
w = inf, ((wartość == Fp_info :: quiet_NaN ())) = true FAILED

v = nan, ((ilogb (wartość) == ((int) 0x80000000))) = true Sukces
u = 3,14, ((ilogb (wartość) == ((int) 0x80000000))) = false Sukces
w = inf, ((ilogb (wartość) == ((int) 0x80000000))) = false Sukces

v = nan, (isunordered (1.2345, wartość)) = false FAILED
u = 3,14, (isunordered (1,2345, wartość)) = false Sukces
w = inf, (isunordered (1.2345, wartość)) = false Sukces

v = nan, (is_ieee754_nan (wartość)) = true Sukces
u = 3,14, (is_ieee754_nan (wartość)) = false Sukces
w = inf, (is_ieee754_nan (wartość)) = false Sukces

[C: \ my \ forums \ so \ 282 (wykryj NaN)]
> _

Wyniki z Visual C ++:

[C: \ my \ forums \ so \ 282 (wykryj NaN)]
> cl / nologo- 2> i 1 | znajdź „++”
Microsoft (R) C / C ++ Optimization Compiler Version 19.00.23725 dla x86

[C: \ my \ forums \ so \ 282 (wykryj NaN)]
> cl foo.cpp / Feb && b
foo.cpp
Kompilator twierdzi, że IEEE 754 = true

v = nan, (std :: isnan (wartość)) = true Sukces
u = 3,14, (std :: isnan (wartość)) = false Sukces
w = inf, (std :: isnan (wartość)) = false Sukces

v = nan, ((fpclassify (wartość) == 2)) = true Sukces
u = 3,14, ((fpclassify (wartość) == 2)) = fałszywy sukces
w = inf, ((fpclassify (wartość) == 2)) = false Sukces

v = nan, ((wartość! = wartość)) = true Sukces
u = 3,14, ((wartość! = wartość)) = false Sukces
w = inf, ((wartość! = wartość)) = false Sukces

v = nan, ((wartość == Fp_info :: quiet_NaN ())) = false FAILED
u = 3,14, ((wartość == Fp_info :: quiet_NaN ())) = false Sukces
w = inf, ((wartość == Fp_info :: quiet_NaN ())) = false Sukces

v = nan, ((ilogb (wartość) == 0x7fffffff)) = true Sukces
u = 3,14, ((ilogb (wartość) == 0x7fffffff)) = fałszywy sukces
w = inf, ((ilogb (wartość) == 0x7fffffff)) = true FAILED

v = nan, (isunordered (1.2345, wartość)) = true Sukces
u = 3,14, (isunordered (1,2345, wartość)) = false Sukces
w = inf, (isunordered (1.2345, wartość)) = false Sukces

v = nan, (is_ieee754_nan (wartość)) = true Sukces
u = 3,14, (is_ieee754_nan (wartość)) = false Sukces
w = inf, (is_ieee754_nan (wartość)) = false Sukces

[C: \ my \ forums \ so \ 282 (wykryj NaN)]
> cl foo.cpp / Feb / fp: fast && b
foo.cpp
Kompilator twierdzi, że IEEE 754 = true

v = nan, (std :: isnan (wartość)) = true Sukces
u = 3,14, (std :: isnan (wartość)) = false Sukces
w = inf, (std :: isnan (wartość)) = false Sukces

v = nan, ((fpclassify (wartość) == 2)) = true Sukces
u = 3,14, ((fpclassify (wartość) == 2)) = fałszywy sukces
w = inf, ((fpclassify (wartość) == 2)) = false Sukces

v = nan, ((wartość! = wartość)) = true Sukces
u = 3,14, ((wartość! = wartość)) = false Sukces
w = inf, ((wartość! = wartość)) = false Sukces

v = nan, ((wartość == Fp_info :: quiet_NaN ())) = false FAILED
u = 3,14, ((wartość == Fp_info :: quiet_NaN ())) = false Sukces
w = inf, ((wartość == Fp_info :: quiet_NaN ())) = false Sukces

v = nan, ((ilogb (wartość) == 0x7fffffff)) = true Sukces
u = 3,14, ((ilogb (wartość) == 0x7fffffff)) = fałszywy sukces
w = inf, ((ilogb (wartość) == 0x7fffffff)) = true FAILED

v = nan, (isunordered (1.2345, wartość)) = true Sukces
u = 3,14, (isunordered (1,2345, wartość)) = false Sukces
w = inf, (isunordered (1.2345, wartość)) = false Sukces

v = nan, (is_ieee754_nan (wartość)) = true Sukces
u = 3,14, (is_ieee754_nan (wartość)) = false Sukces
w = inf, (is_ieee754_nan (wartość)) = false Sukces

[C: \ my \ forums \ so \ 282 (wykryj NaN)]
> _

Podsumowując powyższe wyniki, tylko bezpośrednie testowanie reprezentacji na poziomie bitów przy użyciu is_ieee754_nanfunkcji zdefiniowanej w tym programie testowym działało niezawodnie we wszystkich przypadkach zarówno z g ++, jak i Visual C ++.

Dodatek:
Po opublikowaniu powyższego dowiedziałem się o jeszcze jednym możliwym teście na NaN, wymienionym w innej odpowiedzi tutaj, mianowicie ((value < 0) == (value >= 0)). Okazało się, że działa dobrze z Visual C ++, ale zawiodło z -ffast-mathopcją g ++ . Tylko bezpośrednie testowanie bitatternów działa niezawodnie.

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

Działa sizeof(int)to, jeśli ma 4 i sizeof(long long)8.

W czasie wykonywania jest to tylko porównanie, casting nie zajmuje żadnego czasu. Po prostu zmienia konfigurację flag porównania, aby sprawdzić równość.

Możliwe rozwiązanie, które nie zależy od konkretnej reprezentacji IEEE dla NaN, byłoby następujące:

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

Biorąc pod uwagę, że (x! = X) nie zawsze jest gwarantowane dla NaN (np. Jeśli korzystam z opcji -ffast-matematyki), używałem:

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

Liczby nie mogą być jednocześnie <0 i> = 0, więc tak naprawdę to sprawdzenie jest pomyślne tylko wtedy, gdy liczba nie jest ani mniejsza, ani większa od lub równa zero. Który w zasadzie nie jest liczbą, ani NaN.

Możesz również użyć tego, jeśli wolisz:

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

Nie jestem jednak pewien, jak wpływa na to matematyka, więc przebieg może się różnić.

Jeśli chodzi o mnie, rozwiązaniem może być makro, które uczyni je wyraźnie wbudowanym, a zatem wystarczająco szybkim. Działa również dla każdego typu pływaka. Opiera się na fakcie, że jedynym przypadkiem, gdy wartość nie jest równa samej sobie, jest to, że wartość nie jest liczbą.

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

To działa:

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

wyjście: isnan

Wydaje mi się, że najlepszym prawdziwie wieloplatformowym podejściem byłoby użycie unii i przetestowanie wzorca bitowego podwójnego w celu sprawdzenia NaN.

Nie przetestowałem dokładnie tego rozwiązania i może istnieć bardziej wydajny sposób pracy z wzorcami bitów, ale myślę, że powinien on działać.

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

Na x86-64 możesz mieć niezwykle szybkie metody sprawdzania NaN i nieskończoności, które działają niezależnie od -ffast-mathopcji kompilatora. ( f != f, std::isnan, std::isinfZawsze dają falsesię -ffast-math).

Testowanie NaN, liczb nieskończoności i skończonych można łatwo wykonać, sprawdzając maksymalny wykładnik potęgi. nieskończoność to maksymalny wykładnik z zerową mantysą, NaN to maksymalny wykładnik i niezerowa mantysa. Wykładnik jest przechowywany w następnych bitach po bicie najwyższego znaku, dzięki czemu możemy po prostu w lewo przesunąć, aby pozbyć się bitu znaku i uczynić wykładnik najwyższymi bitami, nie operator&jest konieczne maskowanie ( ):

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

Te stdwersje isinfi isfiniteobciążenia 2 double/floatstałe z .datasegmentu aw najgorszym przypadku mogą one powodować 2 tęskni pamięci podręcznej danych. Powyższe wersje nie ładują żadnych danych, inf_double_shl1a inf_float_shl1stałe są kodowane jako bezpośrednie operandy w instrukcjach montażu.

Szybsze isnan2są tylko 2 instrukcje montażu:

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

Wykorzystuje fakt, że ucomisdinstrukcja ustawia flagę parzystości, jeśli dowolnym argumentem jest NaN. Tak std::isnandziała, gdy nie -ffast-mathokreślono żadnych opcji.

Standard IEEE mówi, że gdy wykładnikiem są wszystkie 1s, a mantysa nie jest równa zero, liczba jest a NaN. Double to 1bit znaku, 11bity wykładnikowe i 52bity mantysy. Sprawdź trochę.

Jak wspomniano powyżej, a! = A nie będzie działać w g ++ i niektórych innych kompilatorach, ale ta sztuczka powinna. To może nie być tak wydajne, ale wciąż jest sposób:

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

Zasadniczo, w g ++ (nie jestem pewien co do innych) printf wypisuje „nan” w formatach% d lub% .f, jeśli zmienna nie jest poprawną liczbą całkowitą / zmiennoprzecinkową. Dlatego ten kod sprawdza, czy pierwszym znakiem ciągu jest „n” (jak w „nan”)

To wykrywa nieskończoność, a także NaN w Visual Studio, sprawdzając, czy jest w podwójnych granicach:

//#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;