Gibt es eine isnan () Funktion?

PS.: Ich bin in MinGW (wenn das einen Unterschied macht).

Ich hatte dies gelöst, indem ich isnan () von verwendete <math.h>, das nicht existiert, in <cmath>dem ich #includezuerst war.

Gemäß dem IEEE-Standard haben NaN-Werte die ungerade Eigenschaft, dass Vergleiche, an denen sie beteiligt sind, immer falsch sind. Das heißt, für einen Float f ist nur dann f != fwahr , wenn f NaN ist.

Beachten Sie, dass, wie einige Kommentare unten gezeigt haben, dies nicht alle Compiler bei der Optimierung von Code berücksichtigen.

Für jeden Compiler, die IEEE - Gleitkomma verwenden behauptet, dieser Trick sollte funktionieren. Aber ich kann nicht garantieren , dass es wird in der Praxis funktionieren. Fragen Sie im Zweifelsfall Ihren Compiler.

isnan()In der aktuellen C ++ - Standardbibliothek ist keine Funktion verfügbar. Es wurde in C99 eingeführt und als Makro und nicht als Funktion definiert. Von C99 definierte Elemente der Standardbibliothek sind weder Teil des aktuellen C ++ - Standards ISO / IEC 14882: 1998 noch dessen Aktualisierung ISO / IEC 14882: 2003.

Im Jahr 2005 wurde der technische Bericht 1 vorgeschlagen. Der TR1 bringt Kompatibilität mit C99 zu C ++. Trotz der Tatsache, dass es nie offiziell als C ++ - Standard übernommen wurde, bieten viele ( GCC 4.0+ oder Visual C ++ 9.0+ C ++ - Implementierungen TR1-Funktionen, alle oder nur einige (Visual C ++ 9.0 bietet keine C99-Mathematikfunktionen). .

Wenn TR1 verfügbar ist, dann cmathschließt C99 Elemente wie isnan(), isfinite()usw. , aber sie sind als Funktionen definiert, keine Makros, in der Regel in std::tr1::Namespace, obwohl viele Implementierungen (dh GCC 4+ auf Linux oder in XCode auf Mac OS X 10.5 und höher) inject sie direkt zu std::, std::isnanist also gut definiert.

Darüber hinaus stellen einige Implementierungen von C ++ das C99- isnan()Makro weiterhin für C ++ zur Verfügung (enthalten durch cmathoder math.h), was zu weiteren Verwirrungen führen kann und Entwickler möglicherweise davon ausgehen, dass es sich um ein Standardverhalten handelt.

Ein Hinweis zu Viusal C ++, wie oben erwähnt, bietet std::isnanweder eine std::tr1::isnan, noch eine Erweiterungsfunktion, _isnan()die seit Visual C ++ 6.0 verfügbar ist

Auf XCode macht es noch mehr Spaß. Wie bereits erwähnt, definiert GCC 4+ std::isnan. Für ältere Versionen des Compilers und der Bibliothek von XCode scheinen (hier ist eine relevante Diskussion ), ich hatte keine Gelegenheit, mich selbst zu überprüfen) zwei Funktionen definiert worden, __inline_isnand()auf Intel und __isnand()auf Power PC.

Erste Lösung: Wenn Sie C ++ 11 verwenden

Da dies gefragt wurde, gab es einige neue Entwicklungen: Es ist wichtig zu wissen, dass dies std::isnan()Teil von C ++ 11 ist

Zusammenfassung

In der Kopfzeile definiert <cmath>

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

Bestimmt, ob die angegebene Gleitkommazahl arg keine Zahl ist ( NaN).

Parameter

arg: Gleitkommawert

Rückgabewert

truewenn arg ist NaN, falsesonst

Referenz

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

Bitte beachten Sie, dass dies nicht mit -fast-math kompatibel ist, wenn Sie g ++ verwenden. Weitere Vorschläge finden Sie weiter unten.

Andere Lösungen: Wenn Sie nicht C ++ 11-kompatible Tools verwenden

Für C99 wird dies in C als Makro implementiert isnan(c), das einen int-Wert zurückgibt. Die Art xmuss schwimmend, doppelt oder lang doppelt sein.

Verschiedene Anbieter können eine Funktion enthalten oder nicht isnan().

Die vermeintlich tragbare Methode zur Überprüfung NaNbesteht darin, die IEEE 754-Eigenschaft zu verwenden, NaNdie nicht gleich sich selbst ist: dh x == xfür das xSein falsch ist NaN.

Die letzte Option funktioniert jedoch möglicherweise nicht mit jedem Compiler und einigen Einstellungen (insbesondere Optimierungseinstellungen), sodass Sie als letztes Mittel immer das Bitmuster überprüfen können ...

In Boost gibt es auch eine Bibliothek nur für Header , die über nützliche Tools für den Umgang mit Gleitkomma-Datentypen verfügt

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

Sie erhalten folgende Funktionen:

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

Wenn Sie Zeit haben, schauen Sie sich das gesamte Math-Toolkit von Boost an. Es enthält viele nützliche Tools und wächst schnell.

Auch beim Umgang mit Gleitkomma- und Nicht-Gleitkommawerten ist es möglicherweise eine gute Idee, sich die numerischen Konvertierungen anzusehen .

Es gibt drei "offizielle" Möglichkeiten: posix isnan Makro , C ++ 0x- isnanFunktionsvorlage oder visuelle C ++ - _isnanFunktion .

Leider ist es ziemlich unpraktisch zu erkennen, welche davon verwendet werden sollen.

Und leider gibt es keine zuverlässige Möglichkeit, festzustellen, ob Sie eine IEEE 754-Darstellung mit NaNs haben. Die Standardbibliothek bietet einen offiziellen solchen Weg (numeric_limits<double>::is_iec559 ). Aber in der Praxis vermasseln Compiler wie g ++ das.

Theoretisch könnte man einfach verwenden x != x , aber Compiler wie g ++ und Visual C ++ vermasseln das.

Testen Sie also am Ende das Spezifische NaN-Bitmuster , indem Sie eine bestimmte Darstellung wie IEEE 754 annehmen (und hoffentlich irgendwann durchsetzen!).

BEARBEITEN : Als Beispiel für "Compiler wie g ++ ... vermasseln Sie das" betrachten Sie

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

Kompilieren mit g ++ (TDM-2 mingw32) 4.4.1:

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

C: \ test> gnuc x.cpp

C: \ test> ein && Echo funktioniert ... || Echo! fehlgeschlagen
funktioniert ...

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

C: \ test> ein && Echo funktioniert ... || Echo! fehlgeschlagen
Behauptung fehlgeschlagen: a! = B, Datei x.cpp, Zeile 6

Diese Anwendung hat die Runtime aufgefordert, sie auf ungewöhnliche Weise zu beenden.
Bitte wenden Sie sich an das Support-Team der Anwendung, um weitere Informationen zu erhalten.
!gescheitert

C: \ test> _

Es gibt ein std :: isnan, wenn Ihr Compiler c99-Erweiterungen unterstützt, aber ich bin mir nicht sicher, ob mingw dies tut.

Hier ist eine kleine Funktion, die funktionieren sollte, wenn Ihr Compiler nicht über die Standardfunktion verfügt:

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

Sie können numeric_limits<float>::quiet_NaN( )in der limitsStandardbibliothek definierte verwenden, um mit zu testen. Es ist eine separate Konstante für definiert 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;
}

Ich weiß nicht, ob dies auf allen Plattformen funktioniert, da ich nur mit g ++ unter Linux getestet habe.

Sie können die isnan()Funktion verwenden, müssen jedoch die C-Mathematikbibliothek einschließen.

#include <cmath>

Da diese Funktion Teil von C99 ist, ist sie nicht überall verfügbar. Wenn Ihr Anbieter die Funktion nicht bereitstellt, können Sie aus Kompatibilitätsgründen auch Ihre eigene Variante definieren.

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

Der folgende Code verwendet die Definition von NAN (alle Exponentenbits gesetzt, mindestens ein Teilbit gesetzt) ​​und geht davon aus, dass sizeof (int) = sizeof (float) = 4. Sie können NAN in Wikipedia nach Details suchen.

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

Nanoprävention

Meine Antwort auf diese Frage lautet: Verwenden Sie keine rückwirkenden Prüfungen fürnan . Verwenden Sie stattdessen vorbeugende Überprüfungen für Unterteilungen des Formulars 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.

nanErgebnisse aus der Operation 0.f/0.f, oder 0.0/0.0. nanist eine schreckliche Nemesis für die Stabilität Ihres Codes, die sehr sorgfältig erkannt und verhindert werden muss ¹ . Die Eigenschaften davon nanunterscheiden sich von normalen Zahlen:

• nanist giftig, (5 * nan= nan)
• nanist nichts gleich, nicht einmal sich selbst ( nan! = nan)
• nannicht größer als alles ( nan!> 0)
• nanist nicht weniger als alles ( nan! <0)

Die letzten beiden aufgelisteten Eigenschaften sind gegenlogisch und führen zu einem merkwürdigen Verhalten des Codes, das auf Vergleichen mit einer nanZahl beruht (die drittletzte Eigenschaft ist ebenfalls ungerade, aber Sie werden sie wahrscheinlich nie x != x ?in Ihrem Code sehen (es sei denn, Sie überprüfen) für nan (unzuverlässig))).

In meinem eigenen Code habe ich festgestellt, dass nanWerte dazu neigen, schwer zu findende Fehler zu erzeugen. (Beachten Sie, dass dies bei oder nicht der Fall ist . ( <0) gibt zurück , (0 < ) gibt TRUE zurück und sogar ( < ) gibt TRUE zurück. Nach meiner Erfahrung ist das Verhalten des Codes daher häufig immer noch wie gewünscht.)inf-inf-infTRUEinf-infinf

was unter nan zu tun ist

Was unter passieren soll, 0.0/0.0 muss als Sonderfall behandelt werden , aber was Sie tun, muss von den Zahlen abhängen, von denen Sie erwarten, dass sie aus dem Code hervorgehen.

Im obigen Beispiel ist das Ergebnis von ( 0.f/FLT_MIN) im 0Grunde genommen. Möglicherweise möchten Sie stattdessen 0.0/0.0generieren HUGE. Damit,

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.

Wenn x oben wäre 0.f, infwürde sich dies ergeben (was ein ziemlich gutes / zerstörungsfreies Verhalten aufweist, wie oben tatsächlich erwähnt).

Denken Sie daran, dass die Ganzzahldivision durch 0 eine Laufzeitausnahme verursacht . Sie müssen also immer nach einer ganzzahligen Division durch 0 suchen. Nur weil 0.0/0.0leise ausgewertet wird, nanheißt das nicht, dass Sie faul sein können und nicht nachsehen müssen, 0.0/0.0bevor dies geschieht.

1 _{Überprüfungen auf nanVia x != xsind manchmal unzuverlässig ( x != xwerden von einigen optimierenden Compilern entfernt, die die IEEE-Konformität verletzen, insbesondere wenn der -ffast-mathSwitch aktiviert ist).}

Ab C ++ 14 gibt es verschiedene Möglichkeiten, um zu testen, ob eine Gleitkommazahl valueeine NaN ist.

Von diesen Möglichkeiten funktioniert nur die Überprüfung der Bits der Zahlendarstellung zuverlässig, wie in meiner ursprünglichen Antwort angegeben. Insbesondere std::isnanund die häufig vorgeschlagene Überprüfung v != vfunktionieren nicht zuverlässig und sollten nicht verwendet werden, damit Ihr Code nicht nicht mehr ordnungsgemäß funktioniert, wenn jemand entscheidet, dass eine Gleitkommaoptimierung erforderlich ist, und den Compiler dazu auffordert. Diese Situation kann sich ändern, Compiler können konformer werden, aber für dieses Problem ist dies in den 6 Jahren seit der ursprünglichen Antwort nicht aufgetreten.

Für ungefähr 6 Jahre war meine ursprüngliche Antwort die ausgewählte Lösung für diese Frage, die in Ordnung war. Vor kurzem wurde jedoch eine hoch gelobte Antwort ausgewählt, die den unzuverlässigen v != vTest empfiehlt . Daher diese zusätzliche aktuellere Antwort (wir haben jetzt die Standards C ++ 11 und C ++ 14 sowie C ++ 17 am Horizont).

Die wichtigsten Möglichkeiten zur Überprüfung der NaN-Fähigkeit ab C ++ 14 sind:

• std::isnan(value) )
  ist die beabsichtigte Standardbibliothek seit C ++ 11. isnanAnscheinend widerspricht es dem gleichnamigen Posix-Makro, aber in der Praxis ist das kein Problem. Das Hauptproblem besteht darin, dass, wenn eine Gleitkomma-Arithmetikoptimierung angefordert wird, mindestens ein Hauptcompiler, nämlich g ++, für das NaN-Argument std::isnan zurückgibtfalse .

• (fpclassify(value) == FP_NAN) )
  Leidet unter dem gleichen Problem std::isnan, dh ist nicht zuverlässig.

• (value != value) )
  Empfohlen in vielen SO-Antworten. Leidet unter dem gleichen Problem std::isnan, dh ist nicht zuverlässig.

• (value == Fp_info::quiet_NaN()) )
  Dies ist ein Test, der mit Standardverhalten keine NaNs erkennen sollte, der jedoch mit dem optimierten Verhalten möglicherweise NaNs erkennen könnte (aufgrund des optimierten Codes, der nur die Bitlevel-Darstellungen direkt vergleicht) und möglicherweise mit einer anderen Methode kombiniert wird, um das nicht optimierte Standardverhalten abzudecken konnte NaN zuverlässig nachweisen. Leider stellte sich heraus, dass es nicht zuverlässig funktionierte.

• (ilogb(value) == FP_ILOGBNAN) )
  Leidet unter dem gleichen Problem std::isnan, dh ist nicht zuverlässig.

• isunordered(1.2345, value) )
  Leidet unter dem gleichen Problem std::isnan, dh ist nicht zuverlässig.

• is_ieee754_nan( value ) )
  Dies ist keine Standardfunktion. Es überprüft die Bits gemäß dem IEEE 754-Standard. Es ist absolut zuverlässig, aber der Code ist etwas systemabhängig.

Im folgenden vollständigen Testcode ist „Erfolg“, ob ein Ausdruck die Nan-Ness des Werts meldet. Für die meisten Ausdrücke entspricht dieses Erfolgsmaß, das Ziel, NaNs und nur NaNs zu erkennen, ihrer Standardsemantik. Für den (value == Fp_info::quiet_NaN()) )Ausdruck ist das Standardverhalten jedoch, dass er nicht als NaN-Detektor funktioniert.

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

Ergebnisse mit g ++ (beachten Sie erneut, dass das Standardverhalten von (value == Fp_info::quiet_NaN())ist, dass es nicht als NaN-Detektor funktioniert, es ist hier nur sehr von praktischem Interesse):

[C: \ my \ forums \ so \ 282 (NaN erkennen)]
> g ++ --version | finde "++"
g ++ (x86_64-win32-sjlj-rev1, erstellt vom MinGW-W64-Projekt) 6.3.0

[C: \ my \ forums \ so \ 282 (NaN erkennen)]
> g ++ foo.cpp && a
Der Compiler behauptet, IEEE 754 = true

v = nan, (std :: isnan (Wert)) = wahrer Erfolg
u = 3,14, (std :: isnan (Wert)) = false Erfolg
w = inf, (std :: isnan (Wert)) = false Erfolg

v = nan, ((fpclassify (value) == 0x0100)) = true Erfolg
u = 3,14, ((fpclassify (Wert) == 0x0100)) = false Erfolg
w = inf, ((fpclassify (value) == 0x0100)) = false Erfolg

v = nan, ((Wert! = Wert)) = wahrer Erfolg
u = 3,14, ((Wert! = Wert)) = falsch Erfolg
w = inf, ((Wert! = Wert)) = false Erfolg

v = nan, ((Wert == Fp_info :: quiet_NaN ())) = false FAILED
u = 3.14, ((Wert == Fp_info :: quiet_NaN ())) = false Erfolg
w = inf, ((value == Fp_info :: quiet_NaN ())) = false Erfolg

v = nan, ((ilogb (Wert) == ((int) 0x80000000))) = wahr Erfolg
u = 3,14, ((ilogb (Wert) == ((int) 0x80000000))) = false Erfolg
w = inf, ((ilogb (Wert) == ((int) 0x80000000))) = false Erfolg

v = nan, (ungeordnet (1,2345, Wert)) = wahr Erfolg
u = 3,14, (ungeordnet (1,2345, Wert)) = falsch Erfolg
w = inf, (isunordered (1.2345, value)) = false Erfolg

v = nan, (is_ieee754_nan (Wert)) = true Erfolg
u = 3,14, (is_ieee754_nan (Wert)) = false Erfolg
w = inf, (is_ieee754_nan (Wert)) = false Erfolg

[C: \ my \ forums \ so \ 282 (NaN erkennen)]
> g ++ foo.cpp -ffast-math && a
Der Compiler behauptet, IEEE 754 = true

v = nan, (std :: isnan (Wert)) = false FAILED
u = 3,14, (std :: isnan (Wert)) = false Erfolg
w = inf, (std :: isnan (Wert)) = false Erfolg

v = nan, ((fpclassify (value) == 0x0100)) = false FAILED
u = 3,14, ((fpclassify (Wert) == 0x0100)) = false Erfolg
w = inf, ((fpclassify (value) == 0x0100)) = false Erfolg

v = nan, ((Wert! = Wert)) = false FAILED
u = 3,14, ((Wert! = Wert)) = falsch Erfolg
w = inf, ((Wert! = Wert)) = false Erfolg

v = nan, ((value == Fp_info :: quiet_NaN ())) = true Erfolg
u = 3.14, ((Wert == Fp_info :: quiet_NaN ())) = true FAILED
w = inf, ((value == Fp_info :: quiet_NaN ())) = true FAILED

v = nan, ((ilogb (Wert) == ((int) 0x80000000))) = wahr Erfolg
u = 3,14, ((ilogb (Wert) == ((int) 0x80000000))) = false Erfolg
w = inf, ((ilogb (Wert) == ((int) 0x80000000))) = false Erfolg

v = nan, (ungeordnet (1,2345, Wert)) = false FAILED
u = 3,14, (ungeordnet (1,2345, Wert)) = falsch Erfolg
w = inf, (isunordered (1.2345, value)) = false Erfolg

v = nan, (is_ieee754_nan (Wert)) = true Erfolg
u = 3,14, (is_ieee754_nan (Wert)) = false Erfolg
w = inf, (is_ieee754_nan (Wert)) = false Erfolg

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

Ergebnisse mit Visual C ++:

[C: \ my \ forums \ so \ 282 (NaN erkennen)]
> cl / nologo- 2> & 1 | finde "++"
Microsoft (R) C / C ++ - Optimierungscompiler Version 19.00.23725 für x86

[C: \ my \ forums \ so \ 282 (NaN erkennen)]
> cl foo.cpp / Feb && b
foo.cpp
Der Compiler behauptet, IEEE 754 = true

v = nan, (std :: isnan (Wert)) = wahrer Erfolg
u = 3,14, (std :: isnan (Wert)) = false Erfolg
w = inf, (std :: isnan (Wert)) = false Erfolg

v = nan, ((fpclassify (value) == 2)) = true Success
u = 3,14, ((fpclassify (Wert) == 2)) = false Erfolg
w = inf, ((fpclassify (value) == 2)) = false Erfolg

v = nan, ((Wert! = Wert)) = wahrer Erfolg
u = 3,14, ((Wert! = Wert)) = falsch Erfolg
w = inf, ((Wert! = Wert)) = false Erfolg

v = nan, ((Wert == Fp_info :: quiet_NaN ())) = false FAILED
u = 3.14, ((Wert == Fp_info :: quiet_NaN ())) = false Erfolg
w = inf, ((value == Fp_info :: quiet_NaN ())) = false Erfolg

v = nan, ((ilogb (Wert) == 0x7fffffff)) = wahr Erfolg
u = 3,14, ((ilogb (Wert) == 0x7fffffff)) = false Erfolg
w = inf, ((ilogb (Wert) == 0x7fffffff)) = true FAILED

v = nan, (ungeordnet (1,2345, Wert)) = wahr Erfolg
u = 3,14, (ungeordnet (1,2345, Wert)) = falsch Erfolg
w = inf, (isunordered (1.2345, value)) = false Erfolg

v = nan, (is_ieee754_nan (Wert)) = true Erfolg
u = 3,14, (is_ieee754_nan (Wert)) = false Erfolg
w = inf, (is_ieee754_nan (Wert)) = false Erfolg

[C: \ my \ forums \ so \ 282 (NaN erkennen)]
> cl foo.cpp / Feb / fp: schnell && b
foo.cpp
Der Compiler behauptet, IEEE 754 = true

v = nan, (std :: isnan (Wert)) = wahrer Erfolg
u = 3,14, (std :: isnan (Wert)) = false Erfolg
w = inf, (std :: isnan (Wert)) = false Erfolg

v = nan, ((fpclassify (value) == 2)) = true Success
u = 3,14, ((fpclassify (Wert) == 2)) = false Erfolg
w = inf, ((fpclassify (value) == 2)) = false Erfolg

v = nan, ((Wert! = Wert)) = wahrer Erfolg
u = 3,14, ((Wert! = Wert)) = falsch Erfolg
w = inf, ((Wert! = Wert)) = false Erfolg

v = nan, ((Wert == Fp_info :: quiet_NaN ())) = false FAILED
u = 3.14, ((Wert == Fp_info :: quiet_NaN ())) = false Erfolg
w = inf, ((value == Fp_info :: quiet_NaN ())) = false Erfolg

v = nan, ((ilogb (Wert) == 0x7fffffff)) = wahr Erfolg
u = 3,14, ((ilogb (Wert) == 0x7fffffff)) = false Erfolg
w = inf, ((ilogb (Wert) == 0x7fffffff)) = true FAILED

v = nan, (ungeordnet (1,2345, Wert)) = wahr Erfolg
u = 3,14, (ungeordnet (1,2345, Wert)) = falsch Erfolg
w = inf, (isunordered (1.2345, value)) = false Erfolg

v = nan, (is_ieee754_nan (Wert)) = true Erfolg
u = 3,14, (is_ieee754_nan (Wert)) = false Erfolg
w = inf, (is_ieee754_nan (Wert)) = false Erfolg

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

Zusammenfassend lässt sich sagen, dass nur das direkte Testen der Darstellung auf Bitebene mit der is_ieee754_nanin diesem Testprogramm definierten Funktion in allen Fällen sowohl mit g ++ als auch mit Visual C ++ zuverlässig funktionierte.

Nachtrag:
Nachdem ich das oben Gesagte veröffentlicht hatte, wurde mir ein weiterer möglicher Test für NaN bewusst, der in einer anderen Antwort hier erwähnt wurde, nämlich ((value < 0) == (value >= 0)). Das hat mit Visual C ++ gut funktioniert, ist aber mit der -ffast-mathOption von g ++ fehlgeschlagen . Nur direkte Bitmusterprüfungen funktionieren zuverlässig.

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

Dies funktioniert, wenn sizeof(int)4 und sizeof(long long)8 ist.

Während der Laufzeit ist es nur ein Vergleich, Gussteile brauchen keine Zeit. Es wird lediglich die Konfiguration der Vergleichsflags geändert, um die Gleichheit zu überprüfen.

Eine mögliche Lösung, die nicht von der spezifischen IEEE-Darstellung für verwendetes NaN abhängt, wäre die folgende:

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

In Anbetracht dessen, dass (x! = X) für NaN nicht immer garantiert ist (z. B. wenn die Option -ffast-math verwendet wird), habe ich Folgendes verwendet:

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

Zahlen können nicht sowohl <0 als auch> = 0 sein, daher besteht diese Prüfung nur dann, wenn die Zahl weder kleiner noch größer oder gleich Null ist. Welches ist im Grunde überhaupt keine Zahl oder NaN.

Sie können dies auch verwenden, wenn Sie Folgendes bevorzugen:

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

Ich bin mir nicht sicher, wie sich dies auf -ffast-math auswirkt, daher kann Ihr Kilometerstand variieren.

Für mich könnte die Lösung ein Makro sein, um es explizit inline und damit schnell genug zu machen. Es funktioniert auch für jeden Float-Typ. Es basiert auf der Tatsache, dass der einzige Fall, in dem ein Wert nicht gleich ist, der ist, wenn der Wert keine Zahl ist.

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

Das funktioniert:

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

Ausgabe: isnan

Es scheint mir, dass der beste wirklich plattformübergreifende Ansatz darin besteht, eine Union zu verwenden und das Bitmuster des Double zu testen, um nach NaNs zu suchen.

Ich habe diese Lösung nicht gründlich getestet, und es gibt möglicherweise eine effizientere Möglichkeit, mit den Bitmustern zu arbeiten, aber ich denke, dass sie funktionieren sollte.

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

Unter x86-64 können Sie extrem schnelle Methoden zum Überprüfen auf NaN und unendlich verwenden, die unabhängig von der -ffast-mathCompileroption funktionieren . ( f != f, std::isnan, std::isinfErgeben immer falsemit -ffast-math).

Das Testen auf NaN, unendlich und endliche Zahlen kann leicht durchgeführt werden, indem nach dem maximalen Exponenten gesucht wird. unendlich ist maximaler Exponent mit Mantisse Null, NaN ist maximaler Exponent und Mantisse ungleich Null. Der Exponent wird in den nächsten Bits nach dem obersten Vorzeichenbit gespeichert, so dass wir die Verschiebung nach links verschieben können, um das Vorzeichenbit zu entfernen und den Exponenten zu den obersten Bits zu machen. Es ist keine Maskierung ( operator&) erforderlich:

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

Die stdVersionen von isinfund isfiniteLaden von 2 double/floatKonstanten aus dem .dataSegment und im schlimmsten Fall können sie 2 Datencache-Fehler verursachen. Die obigen Versionen laden keine Daten inf_double_shl1und inf_float_shl1Konstanten werden als unmittelbare Operanden in die Montageanweisungen codiert.

Schneller isnan2sind nur 2 Montageanleitungen:

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

Verwendet die Tatsache, dass der ucomisdBefehl das Paritätsflag setzt, wenn ein Argument NaN ist. So std::isnanfunktioniert es, wenn keine -ffast-mathOptionen angegeben sind.

Der IEEE-Standard sagt, wenn der Exponent alle 1s ist und die Mantisse nicht Null ist, ist die Zahl a NaN. Double ist 1Vorzeichenbit, 11Exponentenbit und 52Mantissenbit. Mach ein bisschen nach.

Wie oben erwähnt, funktioniert a! = A in g ++ und einigen anderen Compilern nicht, aber dieser Trick sollte. Es mag nicht so effizient sein, aber es ist immer noch ein Weg:

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

Grundsätzlich druckt printf in g ++ (bei anderen bin ich mir allerdings nicht sicher) 'nan' in den Formaten% d oder% .f, wenn die Variable keine gültige Ganzzahl / float ist. Daher prüft dieser Code, ob das erste Zeichen der Zeichenfolge 'n' ist (wie in "nan").

Dies erkennt Unendlichkeit und auch NaN in Visual Studio, indem überprüft wird, ob es innerhalb doppelter Grenzen liegt:

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