İsnan () işlevi var mı?

Not: MinGW'deyim (bu bir fark yaratırsa ).

Bunu , ilk başta <math.h>içinde bulunduğum <cmath>, içinde bulunmadığım isnan () kullanarak çözmüştüm #include.

IEEE standardına göre, NaN değerleri, bunları içeren karşılaştırmalar her zaman yanlış olan garip özelliğe sahiptir . Yani, bir f şamandırası için, sadece f NaN ise f != fdoğrudur .

Aşağıdaki bazı yorumların belirttiği gibi, kod optimize ederken tüm derleyiciler buna saygı duymaz.

IEEE kayan noktalı kullanmak iddia herhangi bir derleyici için bu hile gerektiğini çalışır. Ama bunun garanti edemez olacak pratikte çalışır. Şüpheniz varsa derleyicinize danışın.

isnan()Geçerli C ++ Standart Kitaplığında kullanılabilir işlev yoktur . C99'da tanıtıldı ve bir işlev değil bir makro olarak tanımlandı . C99 tarafından tanımlanan standart kütüphanenin unsurları, mevcut C ++ standardı ISO / IEC 14882: 1998'in bir parçası değildir ve ISO / IEC 14882: 2003 güncellemesidir.

2005 yılında Teknik Rapor 1 önerilmiştir. TR1, C99 ile C ++ 'a uyumluluk getirir. C ++ standardı olmanın resmen kabul edilmemesine rağmen, çoğu ( GCC 4.0+ veya Visual C ++ 9.0+ C ++ uygulamaları hepsi veya sadece TR1 özellikleri sağlar (Visual C ++ 9.0 C99 matematik işlevleri sağlamaz) .

TR1 varsa, o zaman cmathgibi C99 unsurları içerir isnan(), isfinite()vb ancak genellikle işlevler değil makrolar olarak tanımlanır std::tr1::, ad olsa onlara iğne (Mac OS X 10.5+ üzerindeki XCode Linux üzerinde veya içinde yani GCC 4+) birçok uygulamaları doğrudan std::, yani std::isnaniyi tanımlanmış.

Dahası, bazı C ++ uygulamaları hala C99 isnan()makrosunu C ++ için kullanılabilir ( cmathveya aracılığıyla math.h), daha fazla karışıklığa neden olabilir ve geliştiriciler bunun standart bir davranış olduğunu varsayabilir.

Yukarıda da belirtildiği gibi Viusal C hakkında not ++, bu sağlamaz std::isnande std::tr1::isnan, ancak olarak tanımlanmış bir uzantı fonksiyonu sağlar _isnan()çünkü mevcut olmuştur ki Visual C ++ 6.0

XCode'da daha da eğlenceli. Belirtildiği gibi, GCC4+ tanımlamaktadır std::isnan. Derleyici ve kütüphane formunun eski sürümleri için XCode, Intel ve Power PC'de iki işlev tanımlanmış gibi görünüyor (burada ilgili tartışma var ), kendimi kontrol etme şansım olmadı .__inline_isnand()__isnand()

İlk çözüm: C ++ 11 kullanıyorsanız

Bu sorulduğundan beri biraz yeni gelişmeler oldu: std::isnan()C ++ 11'in bir parçası olduğunu bilmek önemlidir

özet

Üstbilgide tanımlandı <cmath>

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

Verilen kayan nokta sayısı bağımsız değişkeninin bir sayı ( NaN) olup olmadığını belirler .

Parametreler

arg: kayan nokta değeri

Geri dönüş değeri

truearg ise NaN, falseaksi takdirde

Referans

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

G ++ kullanıyorsanız bunun -fast-math ile uyumsuz olduğunu lütfen unutmayın, diğer öneriler için aşağıya bakın.

Diğer çözümler: C ++ 11 uyumlu olmayan araçlar kullanıyorsanız

C99 için, C'de, bu isnan(c)bir int değeri döndüren bir makro olarak uygulanır . Tipi xfloat, çift veya uzun çift olacaktır.

Çeşitli satıcılar bir işlev içerebilir veya içermeyebilir isnan().

Sözde taşınabilir olan kontrol etmenin yolu, kendisine eşit olmayan NaNIEEE 754 özelliğini kullanmaktır NaN: yani varlık x == xyanlıştır .xNaN

Ancak son seçenek her derleyici ve bazı ayarlarla (özellikle optimizasyon ayarları) çalışmayabilir, bu nedenle son çare olarak her zaman bit desenini kontrol edebilirsiniz ...

Ayrıca, Boost'ta kayan nokta veri türleriyle başa çıkmak için düzgün araçlara sahip yalnızca başlık içeren bir kütüphane de vardır.

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

Aşağıdaki işlevleri alırsınız:

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

Zamanınız varsa Boost'un tüm Matematik araç setine bir göz atın, birçok yararlı araç vardır ve hızla büyüyor.

Ayrıca, kayan ve kayan noktalarla uğraşırken Sayısal Dönüşümlere bakmak iyi bir fikir olabilir .

Üç "resmi" yol vardır: posix isnanmakrosu , c ++ 0x isnanişlev şablonu veya görsel c ++ _isnanişlevi .

Ne yazık ki hangilerinin kullanılacağını belirlemek oldukça pratik değildir.

Ne yazık ki, NaN'lerle IEEE 754 temsilciliğiniz olup olmadığını tespit etmenin güvenilir bir yolu yoktur. Standart kütüphane böyle bir görevli sunmaktadır ( numeric_limits<double>::is_iec559). Ama pratikte g ++ gibi derleyiciler bunu berbat ediyor.

Teoride basitçe kullanılabilir x != x, ancak g ++ ve visual c ++ gibi derleyiciler bunu berbat eder.

Sonuç olarak , IEEE 754 gibi belirli bir temsili varsayarak (ve umarım bir noktada zorlayarak!) Belirli NaN bit desenlerini test edin .

EDIT : "g ++… gibi vidalar derleyiciler" bir örnek olarak, düşünün

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

G ++ (TDM-2 mingw32) ile derleme 4.4.1:

C: \ test> "C: \ Program Files \ @commands \ gnuc.bat" yazın
@rem -finput-charset = windows-1252
@ g ++ -O -pedantic -std = c ++ 98 -Duvar -Yazı-dizeleri% * -Wno-long-long

C: \ test> gnuc x.cpp

C: \ test> a && echo çalışıyor ... || echo! başarısız
İşler...

C: \ test> gnuc x.cpp - hızlı matematik

C: \ test> a && echo çalışıyor ... || echo! başarısız
Onaylama başarısız oldu: a! = B, dosya x.cpp, satır 6

Bu uygulama Runtime'dan alışılmadık bir şekilde sonlandırmasını istedi.
Daha fazla bilgi için lütfen uygulamanın destek ekibiyle iletişime geçin.
!başarısız oldu

C: \ test> _

Derleyici c99 uzantılarını destekliyorsa bir std :: isnan var, ancak mingw'un desteklediğinden emin değilim.

Derleyiciniz standart işleve sahip değilse çalışması gereken küçük bir işlev şunlardır:

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

Test etmek numeric_limits<float>::quiet_NaN( )için limitsstandart kitaplıkta tanımlanan kullanabilirsiniz . İçin ayrı bir sabit tanımlanmıştır 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;
}

Sadece Linux'ta g ++ ile test ettiğim için bunun tüm platformlarda çalışıp çalışmadığını bilmiyorum.

isnan()İşlevi kullanabilirsiniz , ancak C matematik kitaplığını da eklemeniz gerekir.

#include <cmath>

Bu işlev C99'un bir parçası olduğundan, her yerde kullanılamaz. Satıcınız işlevi sağlamazsa, uyumluluk için kendi değişkeninizi de tanımlayabilirsiniz.

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

Aşağıdaki kod, NAN tanımını (tüm üs bitleri kümesi, en az bir kesirli bit kümesi) kullanır ve sizeof (int) = sizeof (float) = 4 olduğunu varsayar. Ayrıntılar için Wikipedia'da NAN'a bakabilirsiniz.

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

nan önleme

Bu soruya cevabım geriye dönük kontroller kullanmamaknan . Kullanım önleyici formun bölümler için çek 0.0/0.0yerine.

#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.

nanoperasyondan elde edilen sonuçlar 0.f/0.fveya 0.0/0.0. çok dikkatli bir nanşekilde tespit edilmesi ve önlenmesi gereken kodunuzun kararlılığına korkunç bir düşmanıdır ¹ . Bunun özellikleri nannormal sayılardan farklıdır:

• nanzehirlidir, (5 * nan= nan)
• nanhiçbir şeye eşit değil, kendisi bile değil ( nan! = nan)
• nanhiçbir şeyden büyük değil ( nan!> 0)
• nanhiçbir şeyden daha az değildir ( nan! <0)

Listelenen son 2 özellik karşı-mantıklıdır ve bir nansayı ile karşılaştırmaya dayanan kodun garip davranışı ile sonuçlanır (son 3 özellik de tuhaftır, ancak muhtemelen x != x ?kodunuzda görmeyeceksiniz (kontrol etmediğiniz sürece) nan için (güvenilmez))).

Kendi kodumda, nandeğerlerin bulmak zor hataları üretme eğiliminde olduğunu fark ettim . (Bunun veya durumunun nasıl olmadığına dikkat edin . ( <0) döndürür , (0 < ) TRUE döndürür ve hatta (inf-inf-infTRUEinf-inf < inf) TRUE döndürür. Bu nedenle, tecrübelerime göre, kodun davranışı genellikle hala istenildiği gibidir.

nan altında ne yapmalı

Altında ne olmak istiyorsun 0.0/0.0 özel bir durum olarak ele alınmalıdır , ancak yaptığınız şey koddan çıkmayı beklediğiniz sayılara bağlı olmalıdır.

Yukarıdaki örnekte, ( 0.f/FLT_MIN) sonucu 0temel olarak olacaktır . Bunun yerine 0.0/0.0oluşturmak isteyebilirsiniz HUGE. Yani,

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.

X olsaydı Yani yukarıda, 0.f, inf(aslında yukarıda belirtildiği gibi oldukça iyi / tahribatsız davranışa sahip olan) neden olur.

Unutmayın, 0'a tamsayı bölme bir çalışma zamanı istisnasına neden olur . Bu nedenle, her zaman 0 ile tamsayı bölünmesini kontrol etmelisiniz. Sadece 0.0/0.0sessizce değerlendirmek, nantembel olabileceğiniz anlamına gelmez ve 0.0/0.0gerçekleşmeden önce kontrol edemeyeceğiniz anlamına gelmez .

1 _{Geçiş kontrolleri bazen güvenilir değildir ( özellikle anahtar etkinleştirildiğinde IEEE uyumluluğunu bozan bazı optimize edici derleyiciler tarafından çıkarılır ).nanx != xx != x-ffast-math}

C ++ 14'ten itibaren bir kayan nokta sayısının test edilip edilmediğini test etmenin birkaç yolu vardır. value NaN .

Bu yollardan, sadece sayının temsilinin bitlerinin kontrol edilmesi, orijinal cevabımda belirtildiği gibi güvenilir bir şekilde çalışır. Özellikle std::isnanve sıkça önerilen çekv != v , güvenilir bir şekilde çalışmaz ve kullanılmamalıdır, eğer birisi kayan nokta optimizasyonunun gerekli olduğuna karar verdiğinde kodunuz düzgün çalışmayı durdurmaz ve derleyiciden bunu yapmasını ister. Bu durum değişebilir, derleyiciler daha uygun olabilir, ancak bu sorunun orijinal cevabından bu yana 6 yıl içinde gerçekleşmedi.

Yaklaşık 6 yıl boyunca asıl cevabım bu soru için seçilen çözümdü, ki bu iyiydi. Ancak son zamanlarda, güvenilir olmayan v != vtesti öneren oldukça güncel bir cevap seçildi. Dolayısıyla bu ek daha güncel cevap (artık C ++ 11 ve C ++ 14 standartlarına ve ufukta C ++ 17'ye sahibiz).

C ++ 14'ten itibaren NaN-ness'i kontrol etmenin ana yolları şunlardır:

• std::isnan(value) )
  C ++ 11'den beri istenen standart kütüphane yoludur. isnanGörünüşe göre aynı adı taşıyan Posix makrosu ile çelişiyor, ancak pratikte bu bir sorun değil. Ana sorun, kayan nokta aritmetik optimizasyonu istendiğinde, en az bir ana derleyici, yani g ++ ile NaN argümanı için std::isnan geri falsedönmesidir .

• (fpclassify(value) == FP_NAN) )
std::isnanYani, aynı problemden muzdarip değildir, yani güvenilir değildir.

• (value != value) )
  Birçok SO cevabında önerilir. std::isnanYani, aynı problemden muzdarip değildir, yani güvenilir değildir.

• (value == Fp_info::quiet_NaN()) )
  Bu, standart davranışı olan NaN'leri algılamaması gereken bir testtir, ancak optimize edilmiş davranışla NaN'leri algılayabilir (optimize edilmiş kod sadece bit seviyesi sunumlarını doğrudan karşılaştırarak) ve belki de standart optimize edilmemiş davranışı kapsayacak başka bir yolla birleştirilebilir. , NaN'yi güvenilir bir şekilde tespit edebilir. Ne yazık ki güvenilir bir şekilde çalışmadığı ortaya çıktı.

• (ilogb(value) == FP_ILOGBNAN) )
std::isnanYani, aynı problemden muzdarip değildir, yani güvenilir değildir.

• isunordered(1.2345, value) )
std::isnanYani, aynı problemden muzdarip değildir, yani güvenilir değildir.

• is_ieee754_nan( value ) )
  Bu standart bir işlev değil. Uçları IEEE 754 standardına göre kontrol ediyor. Tamamen güvenilirdir ancak kod bir şekilde sisteme bağlıdır.

Aşağıdaki tam test kodunda “başarı” ifadenin değerin Naneliğini rapor edip etmediğidir. Çoğu ifade için bu başarı ölçüsü, NaN'leri ve sadece NaN'leri tespit etme amacı, standart anlamlarına karşılık gelir. İçin (value == Fp_info::quiet_NaN()) )ekspresyon Ancak standart davranışı, NaN-dedektörü olarak çalışmaz olmasıdır.

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

G ++ ile elde edilen sonuçlar (bunun standart davranışının (value == Fp_info::quiet_NaN())bir NaN-detektörü olarak çalışmadığına dikkat edin, buradaki pratik ilgi çok fazladır):

[C: \ my \ forumlar \ so \ 282 (NaN algıla)]
> g ++ - sürüm | "++" bul
g ++ (x86_64-win32-sjlj-rev1, MinGW-W64 projesi tarafından oluşturulmuştur) 6.3.0

[C: \ my \ forumlar \ so \ 282 (NaN algıla)]
> g ++ foo.cpp && a
Derleyici hak talepleri IEEE 754 = doğru

v = nan, (std :: isnan (değer)) = gerçek Başarı
u = 3.14, (std :: isnan (değer)) = yanlış Başarı
w = inf, (std :: isnan (değer)) = yanlış Başarı

v = nan, ((fpclassify (değer) == 0x0100)) = gerçek Başarı
u = 3.14, ((fpclassify (değer) == 0x0100)) = yanlış Başarı
w = inf, ((fpclassify (değer) == 0x0100)) = yanlış Başarı

v = nan, ((değer! = değer)) = gerçek Başarı
u = 3.14, ((değer! = değer)) = yanlış Başarı
w = inf, ((değer! = değer)) = yanlış Başarı

v = nan, ((değer == Fp_info :: quiet_NaN ())) = yanlış FAILED
u = 3.14, ((value == Fp_info :: quiet_NaN ())) = yanlış Başarı
w = inf, ((value == Fp_info :: quiet_NaN ())) = yanlış Başarı

v = nan, ((ilogb (değer) == ((int) 0x80000000))) = gerçek Başarı
u = 3.14, ((ilogb (değer) == ((int) 0x80000000))) = yanlış Başarı
w = inf, ((ilogb (değer) == ((int) 0x80000000))) = yanlış Başarı

v = nan, (değersiz (1.2345, değer)) = gerçek Başarı
u = 3.14, (değersiz (1.2345, değer)) = yanlış Başarı
w = inf, (isunordered (1.2345, değer)) = yanlış Başarı

v = nan, (is_ieee754_nan (değer)) = gerçek Başarı
u = 3.14, (is_ieee754_nan (değer)) = yanlış Başarı
w = inf, (is_ieee754_nan (değer)) = yanlış Başarı

[C: \ my \ forumlar \ so \ 282 (NaN algıla)]
> g ++ foo.cpp -ffast-math && a
Derleyici hak talepleri IEEE 754 = doğru

v = nan, (std :: isnan (değer)) = yanlış FAILED
u = 3.14, (std :: isnan (değer)) = yanlış Başarı
w = inf, (std :: isnan (değer)) = yanlış Başarı

v = nan, ((fpclassify (değer) == 0x0100)) = yanlış FAILED
u = 3.14, ((fpclassify (değer) == 0x0100)) = yanlış Başarı
w = inf, ((fpclassify (değer) == 0x0100)) = yanlış Başarı

v = nan, ((değer! = değer)) = yanlış FAILED
u = 3.14, ((değer! = değer)) = yanlış Başarı
w = inf, ((değer! = değer)) = yanlış Başarı

v = nan, ((value == Fp_info :: quiet_NaN ())) = gerçek Başarı
u = 3.14, ((value == Fp_info :: quiet_NaN ())) = doğru BAŞARISIZ
w = inf, ((value == Fp_info :: quiet_NaN ())) = doğru BAŞARISIZ

v = nan, ((ilogb (değer) == ((int) 0x80000000))) = gerçek Başarı
u = 3.14, ((ilogb (değer) == ((int) 0x80000000))) = yanlış Başarı
w = inf, ((ilogb (değer) == ((int) 0x80000000))) = yanlış Başarı

v = nan, (ayrıştırılmadı (1.2345, değer)) = yanlış FAILED
u = 3.14, (değersiz (1.2345, değer)) = yanlış Başarı
w = inf, (isunordered (1.2345, değer)) = yanlış Başarı

v = nan, (is_ieee754_nan (değer)) = gerçek Başarı
u = 3.14, (is_ieee754_nan (değer)) = yanlış Başarı
w = inf, (is_ieee754_nan (değer)) = yanlış Başarı

[C: \ my \ forumlar \ so \ 282 (NaN algıla)]
> _

Visual C ++ ile sonuçlar:

[C: \ my \ forumlar \ so \ 282 (NaN algıla)]
> cl / nologo- 2> & 1 | "++" bul
X86 için Microsoft (R) C / C ++ Optimize Edici Derleyici Sürümü 19.00.23725

[C: \ my \ forumlar \ so \ 282 (NaN algıla)]
> cl foo.cpp / Şub && b
foo.cpp
Derleyici hak talepleri IEEE 754 = doğru

v = nan, (std :: isnan (değer)) = gerçek Başarı
u = 3.14, (std :: isnan (değer)) = yanlış Başarı
w = inf, (std :: isnan (değer)) = yanlış Başarı

v = nan, ((fpclassify (değer) == 2)) = gerçek Başarı
u = 3.14, ((fpclassify (değer) == 2)) = yanlış Başarı
w = inf, ((fpclassify (değer) == 2)) = yanlış Başarı

v = nan, ((değer! = değer)) = gerçek Başarı
u = 3.14, ((değer! = değer)) = yanlış Başarı
w = inf, ((değer! = değer)) = yanlış Başarı

v = nan, ((değer == Fp_info :: quiet_NaN ())) = yanlış FAILED
u = 3.14, ((value == Fp_info :: quiet_NaN ())) = yanlış Başarı
w = inf, ((value == Fp_info :: quiet_NaN ())) = yanlış Başarı

v = nan, ((ilogb (değer) == 0x7fffffff)) = gerçek Başarı
u = 3.14, ((ilogb (değer) == 0x7fffffff)) = yanlış Başarı
w = inf, ((ilogb (değer) == 0x7fffffff)) = gerçek BAŞARISIZ

v = nan, (değersiz (1.2345, değer)) = gerçek Başarı
u = 3.14, (değersiz (1.2345, değer)) = yanlış Başarı
w = inf, (isunordered (1.2345, değer)) = yanlış Başarı

v = nan, (is_ieee754_nan (değer)) = gerçek Başarı
u = 3.14, (is_ieee754_nan (değer)) = yanlış Başarı
w = inf, (is_ieee754_nan (değer)) = yanlış Başarı

[C: \ my \ forumlar \ so \ 282 (NaN algıla)]
> cl foo.cpp / Şub / fp: hızlı && b
foo.cpp
Derleyici hak talepleri IEEE 754 = doğru

v = nan, (std :: isnan (değer)) = gerçek Başarı
u = 3.14, (std :: isnan (değer)) = yanlış Başarı
w = inf, (std :: isnan (değer)) = yanlış Başarı

v = nan, ((fpclassify (değer) == 2)) = gerçek Başarı
u = 3.14, ((fpclassify (değer) == 2)) = yanlış Başarı
w = inf, ((fpclassify (değer) == 2)) = yanlış Başarı

v = nan, ((değer! = değer)) = gerçek Başarı
u = 3.14, ((değer! = değer)) = yanlış Başarı
w = inf, ((değer! = değer)) = yanlış Başarı

v = nan, ((değer == Fp_info :: quiet_NaN ())) = yanlış FAILED
u = 3.14, ((value == Fp_info :: quiet_NaN ())) = yanlış Başarı
w = inf, ((value == Fp_info :: quiet_NaN ())) = yanlış Başarı

v = nan, ((ilogb (değer) == 0x7fffffff)) = gerçek Başarı
u = 3.14, ((ilogb (değer) == 0x7fffffff)) = yanlış Başarı
w = inf, ((ilogb (değer) == 0x7fffffff)) = gerçek BAŞARISIZ

v = nan, (değersiz (1.2345, değer)) = gerçek Başarı
u = 3.14, (değersiz (1.2345, değer)) = yanlış Başarı
w = inf, (isunordered (1.2345, değer)) = yanlış Başarı

v = nan, (is_ieee754_nan (değer)) = gerçek Başarı
u = 3.14, (is_ieee754_nan (değer)) = yanlış Başarı
w = inf, (is_ieee754_nan (değer)) = yanlış Başarı

[C: \ my \ forumlar \ so \ 282 (NaN algıla)]
> _

Yukarıdaki sonuçları özetlemek gerekirse is_ieee754_nan, bu test programında tanımlanan işlevi kullanarak sadece bit seviyesi gösteriminin doğrudan test edilmesi, hem g ++ hem de Visual C ++ ile her durumda güvenilir bir şekilde çalıştı.

Zeyilname:
Yukarıdakileri gönderdikten sonra, buradaki başka bir cevapta bahsedilen NaN'yi test etmek için bir başka ihtimal olduğunun farkına vardım ((value < 0) == (value >= 0)). Bu Visual C ++ ile iyi çalıştığı ortaya çıktı ama g ++ 'ın -ffast-mathseçeneği ile başarısız oldu . Sadece doğrudan bitpattern testi güvenilir bir şekilde çalışır.

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

Bu sizeof(int), 4 ve sizeof(long long)8 ise çalışır .

Çalışma süresi boyunca sadece karşılaştırmadır, dökümler zaman almaz. Eşitliği kontrol etmek için karşılaştırma bayrakları yapılandırmasını değiştirir.

Kullanılan NaN için spesifik IEEE temsiline bağlı olmayacak olası bir çözüm aşağıdaki gibi olacaktır:

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

NaN için (x! = X) her zaman garanti edilmediğini göz önünde bulundurarak (örneğin, -ffast-math seçeneği kullanılıyorsa):

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

Sayılar hem <0 hem de> = 0 olamaz, bu nedenle bu denetim yalnızca sayı sıfırdan küçük, sıfırdan büyük veya ona eşitse geçer. Hangi temelde hiçbir sayı veya NaN.

İsterseniz bunu da kullanabilirsiniz:

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

Bunun -ffast-math'dan nasıl etkilendiğinden emin değilim, bu yüzden kilometreniz değişebilir.

Bana gelince, çözüm onu ​​açıkça satır içi ve böylece yeterince hızlı hale getirmek için bir makro olabilir. Ayrıca herhangi bir şamandıra tipi için de çalışır. Bir değerin kendisine eşit olmadığı tek durumun değerin bir sayı olmadığı gerçeğine dayanmasıdır.

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

Bu çalışıyor:

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

çıktı: isnan

Bana göre en iyi gerçek çapraz platform yaklaşımı bir birlik kullanmak ve NaN'leri kontrol etmek için çiftin bit modelini test etmek olacaktır.

Bu çözümü tam olarak test etmedim ve bit desenleriyle çalışmanın daha verimli bir yolu olabilir, ancak bence işe yarayacak.

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

X86-64'te, -ffast-mathderleyici seçeneğinden bağımsız olarak çalışan NaN ve sonsuzluğu kontrol etmek için son derece hızlı yöntemlere sahip olabilirsiniz . ( f != f, std::isnan, std::isinfHer zaman verim falseile -ffast-math).

NaN, sonsuzluk ve sonlu sayılar için testler, maksimum üs kontrolü yapılarak kolayca yapılabilir. sonsuzluk sıfır mantis ile maksimum üs, NaN maksimum üs ve sıfır olmayan mantistir. Üs, en üstteki işaret bitinden sonra sonraki bitlerde saklanır, böylece işaret bitinden kurtulmak ve üssü en üst bitler yapmak için vardiyayı bırakabiliriz, maskeleme ( operator&) gerekmez:

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

stdSürümleri isinfve isfiniteyük 2 double/floatila sabitleri .datasegmenti ve en kötü ihtimalle onlar 2 veri önbellek isabetsizlik neden olabilir. Yukarıdaki sürümler herhangi bir veri yüklemez inf_double_shl1ve inf_float_shl1sabitler montaj talimatlarına derhal işlenen olarak kodlanır.

Daha hızlı isnan2sadece 2 montaj talimatıdır:

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

ucomisdHerhangi bir argüman NaN ise komutun parite bayrağını ayarlamasını kullanır . std::isnanHiçbir -ffast-mathseçenek belirtilmediğinde bu şekilde çalışır .

IEEE standardı, üs tümüyle 1s ve mantis sıfır olmadığında, sayının a olduğunu belirtir NaN. İkili 1işaret biti, 11üs bitleri ve 52mantis bitleridir. Biraz kontrol et.

Yukarıdaki yorumlarda olduğu gibi a! = A, g ++ ve diğer bazı derleyicilerde çalışmaz, ancak bu hile gerekir. O kadar verimli olmayabilir, ama yine de bir yoludur:

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

Temel olarak, g ++ 'da (diğerlerinden emin değilim) printf, değişken geçerli bir tamsayı / float değilse% d veya% .f formatlarında' nan 'basar. Bu nedenle, bu kod dizenin ilk karakterinin 'n' olup olmadığını kontrol eder ("nan" de olduğu gibi)

Bu, Visual Studio'da sonsuzluğu ve ayrıca NaN'yi çift sınırlar içinde olduğunu kontrol ederek algılar:

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