Apakah ada fungsi isnan ()?

PS .: Saya di MinGW (jika itu membuat perbedaan).

Saya menyelesaikan masalah ini dengan menggunakan isnan () dari <math.h>, yang tidak ada di <cmath>dalamnya, yang saya gunakan #includepada awalnya.

Menurut standar IEEE, nilai NaN memiliki properti ganjil yang perbandingannya selalu salah. Artinya, untuk float f, f != fakan benar hanya jika f adalah NaN.

Perhatikan bahwa, seperti yang ditunjukkan beberapa komentar di bawah, tidak semua kompiler menghargai ini ketika mengoptimalkan kode.

Untuk kompiler mana pun yang mengklaim menggunakan IEEE floating point, trik ini harus bekerja. Tetapi saya tidak dapat menjamin bahwa itu akan berhasil dalam praktek. Periksa dengan kompiler Anda, jika ragu.

Tidak ada isnan()fungsi yang tersedia di C ++ Standard Library saat ini. Itu diperkenalkan di C99 dan didefinisikan sebagai makro bukan fungsi. Elemen-elemen pustaka standar yang didefinisikan oleh C99 bukan bagian dari standar C ++ saat ini ISO / IEC 14882: 1998 juga tidak pembaruan ISO / IEC 14882: 2003

Pada tahun 2005 Laporan Teknis 1 diusulkan. TR1 menghadirkan kompatibilitas dengan C99 ke C ++. Terlepas dari kenyataan itu tidak pernah secara resmi diadopsi menjadi standar C ++, banyak ( GCC 4.0+ atau Visual C ++ 9.0+ implementasi C ++ memang menyediakan fitur TR1, semuanya atau hanya beberapa (Visual C ++ 9.0 tidak menyediakan fungsi matematika C99) .

Jika TR1 tersedia, maka cmathsertakan elemen C99 seperti isnan(),, isfinite()dll. Tetapi mereka didefinisikan sebagai fungsi, bukan makro, biasanya di std::tr1::namespace, meskipun banyak implementasi (yaitu GCC 4+ di Linux atau di XCode pada Mac OS X 10.5+) menyuntikkannya langsung ke std::, jadi std::isnandidefinisikan dengan baik.

Selain itu, beberapa implementasi C ++ masih membuat isnan()makro C99 tersedia untuk C ++ (termasuk melalui cmathatau math.h), yang dapat menyebabkan lebih banyak kebingungan dan pengembang mungkin menganggapnya sebagai perilaku standar.

Catatan tentang Viusal C ++, seperti yang disebutkan di atas, tidak menyediakan std::isnankeduanya std::tr1::isnan, tetapi menyediakan fungsi ekstensi _isnan()yang telah tersedia sejak Visual C ++ 6.0

Di XCode, ada yang lebih menyenangkan. Seperti yang disebutkan, GCC 4+ mendefinisikan std::isnan. Untuk versi yang lebih lama dari kompiler dan bentuk perpustakaan XCode, tampaknya (di sini adalah diskusi yang relevan ), belum memiliki kesempatan untuk memeriksa sendiri) dua fungsi didefinisikan, __inline_isnand()pada Intel dan __isnand()pada Power PC.

Solusi pertama: jika Anda menggunakan C ++ 11

Karena ini ditanyakan ada sedikit perkembangan baru: penting untuk mengetahui bahwa itu std::isnan()adalah bagian dari C ++ 11

Ringkasan

Didefinisikan di header <cmath>

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

Menentukan apakah arg floating point number bukan-a-number ( NaN).

Parameter

arg: nilai floating point

Nilai pengembalian

truejika arg adalah NaN, falsejika tidak

Referensi

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

Harap perhatikan bahwa ini tidak kompatibel dengan -fast-math jika Anda menggunakan g ++, lihat saran di bawah ini.

Solusi lain: jika Anda menggunakan alat yang tidak sesuai C ++ 11

Untuk C99, di C, ini diimplementasikan sebagai makro isnan(c)yang mengembalikan nilai int. Jenis xharus mengambang, ganda atau panjang ganda.

Berbagai vendor mungkin atau mungkin tidak termasuk atau tidak fungsi isnan().

Cara yang seharusnya portabel untuk memeriksa NaNadalah dengan menggunakan properti IEEE 754 yang NaNtidak sama dengan dirinya sendiri: yaitu x == xakan salah untuk xmenjadi NaN.

Namun opsi terakhir mungkin tidak berfungsi dengan setiap kompiler dan beberapa pengaturan (terutama pengaturan optimisasi), jadi di pilihan terakhir, Anda selalu dapat memeriksa pola bit ...

Ada juga pustaka header-only yang ada di Boost yang memiliki alat yang rapi untuk menangani tipe data floating point

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

Anda mendapatkan fungsi-fungsi berikut:

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

Jika Anda punya waktu maka lihatlah seluruh toolkit Matematika dari Boost, ia memiliki banyak alat yang berguna dan berkembang dengan cepat.

Juga ketika berhadapan dengan floating point dan non-floating point mungkin ide yang baik untuk melihat Konversi Numerik .

Ada tiga cara "resmi": posix isnanmakro , isnantemplat fungsi c ++ 0x , atau _isnanfungsi visual c ++ .

Sayangnya agak tidak praktis untuk mendeteksi mana yang akan digunakan.

Dan sayangnya, tidak ada cara yang dapat diandalkan untuk mendeteksi apakah Anda memiliki representasi IEEE 754 dengan NaNs. Perpustakaan standar menawarkan cara resmi ( numeric_limits<double>::is_iec559). Tetapi dalam praktiknya kompiler seperti g ++ sekrup itu.

Secara teori orang dapat menggunakan secara sederhana x != x, tetapi kompiler seperti g ++ dan visual c ++ mengacaukannya.

Jadi pada akhirnya, uji untuk bitpatterns NaN tertentu , dengan asumsi (dan semoga menegakkan, di beberapa titik!) Representasi tertentu seperti IEEE 754.

EDIT : sebagai contoh "kompiler seperti g ++ ... mengacaukannya", pertimbangkan

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

Kompilasi dengan g ++ (TDM-2 mingw32) 4.4.1:

C: \ test> ketik "C: \ Program Files \ @commands \ gnuc.bat"
@rem -finput-charset = windows-1252
@ g ++ -O -pedantic -std = c ++ 98 -Wall -Wwrite-string% * -Wno-long-long

C: \ test> gnuc x.cpp

C: \ test> a && echo berfungsi ... || gaung! gagal
bekerja ...

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

C: \ test> a && echo berfungsi ... || gaung! gagal
Pernyataan gagal: a! = B, file x.cpp, baris 6

Aplikasi ini telah meminta Runtime untuk menghentikannya dengan cara yang tidak biasa.
Silakan hubungi tim dukungan aplikasi untuk informasi lebih lanjut.
!gagal

C: \ test> _

Ada std :: isnan jika Anda kompiler mendukung ekstensi c99, tapi saya tidak yakin apakah mingw melakukannya.

Ini adalah fungsi kecil yang seharusnya berfungsi jika kompiler Anda tidak memiliki fungsi standar:

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

Anda dapat menggunakan numeric_limits<float>::quiet_NaN( )definisi di limitsperpustakaan standar untuk mengujinya. Ada konstanta terpisah yang ditentukan untuk 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;
}

Saya tidak tahu apakah ini berfungsi pada semua platform, karena saya hanya diuji dengan g ++ di Linux.

Anda dapat menggunakan isnan()fungsi ini, tetapi Anda harus menyertakan perpustakaan C matematika.

#include <cmath>

Karena fungsi ini adalah bagian dari C99, maka tidak tersedia di mana-mana. Jika vendor Anda tidak menyediakan fungsi, Anda juga dapat menentukan varian Anda sendiri untuk kompatibilitas.

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

Kode berikut menggunakan definisi NAN (semua bit eksponen yang ditetapkan, setidaknya satu bit bit yang ditetapkan) dan mengasumsikan bahwa sizeof (int) = sizeof (float) = 4. Anda dapat mencari NAN di Wikipedia untuk detailnya.

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

pencegahan nan

Jawaban saya untuk pertanyaan ini adalah jangan gunakan cek surut untuknan . Sebaliknya, gunakan pemeriksaan preventif untuk pembagian formulir 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.

nanhasil dari operasi 0.f/0.f, atau 0.0/0.0. nanadalah musuh buruk bagi stabilitas kode Anda yang harus dideteksi dan dicegah dengan sangat hati-hati ¹ . Properti nanyang berbeda dari angka normal:

• nanberacun, (5 * nan= nan)
• nantidak sama dengan apa pun, bahkan tidak sendiri ( nan! = nan)
• nantidak lebih besar dari apa pun ( nan!> 0)
• nantidak kurang dari apa pun ( nan! <0)

2 properti terakhir yang terdaftar adalah kontra-logis dan akan menghasilkan perilaku aneh kode yang bergantung pada perbandingan dengan nanangka (properti ke-3 terakhir juga aneh, tetapi Anda mungkin tidak akan pernah melihat x != x ?dalam kode Anda (kecuali jika Anda memeriksa untuk nan (unreliably))).

Dalam kode saya sendiri, saya perhatikan bahwa nannilai cenderung menghasilkan bug yang sulit ditemukan. (Perhatikan bagaimana ini bukan kasus untuk infatau -inf. ( -inf<0) mengembalikan TRUE, (0 < inf) mengembalikan BENAR, dan bahkan ( -inf< inf) mengembalikan BENAR. Jadi, dalam pengalaman saya, perilaku kode sering masih seperti yang diinginkan).

apa yang harus dilakukan di bawah nan

Apa yang Anda inginkan terjadi di bawah 0.0/0.0 harus ditangani sebagai kasus khusus , tetapi apa yang Anda lakukan harus bergantung pada angka yang Anda harapkan keluar dari kode.

Pada contoh di atas, pada dasarnya hasil ( 0.f/FLT_MIN) adalah 0. Anda mungkin ingin 0.0/0.0menghasilkan HUGEgantinya. Begitu,

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.

Jadi di atas, jika x adalah 0.f, infakan menghasilkan (yang memiliki perilaku cukup baik / tidak rusak seperti yang disebutkan di atas sebenarnya).

Ingat, pembagian integer dengan 0 menyebabkan pengecualian runtime . Jadi Anda harus selalu memeriksa pembagian integer dengan 0. Hanya karena dengan 0.0/0.0tenang mengevaluasi nantidak berarti Anda bisa malas dan tidak memeriksa 0.0/0.0sebelum itu terjadi.

1 _{Pemeriksaan nanvia x != xterkadang tidak dapat diandalkan ( x != xdilucuti oleh beberapa kompiler pengoptimal yang merusak kepatuhan IEEE, khususnya ketika -ffast-mathsakelar diaktifkan).}

Pada C ++ 14 ada beberapa cara untuk menguji apakah angka floating point valueadalah NaN.

Dari cara-cara ini, hanya memeriksa bit representasi angka, bekerja dengan andal, seperti yang disebutkan dalam jawaban asli saya. Khususnya, std::isnandan pemeriksaan yang sering diajukan v != v, tidak bekerja dengan andal dan tidak boleh digunakan, jangan sampai kode Anda berhenti bekerja dengan benar ketika seseorang memutuskan bahwa optimasi floating point diperlukan, dan meminta kompiler untuk melakukan itu. Situasi ini dapat berubah, kompiler bisa mendapatkan lebih banyak menyesuaikan diri, tetapi untuk masalah ini yang belum terjadi dalam 6 tahun sejak jawaban asli.

Selama sekitar 6 tahun, jawaban awal saya adalah solusi yang dipilih untuk pertanyaan ini, yang OK. Tetapi baru-baru ini jawaban yang sangat tervotasikan merekomendasikan v != vtes tidak dapat diandalkan telah dipilih. Oleh karena itu, ini jawaban tambahan yang lebih baru (kami sekarang memiliki standar C ++ 11 dan C ++ 14, dan C ++ 17 di cakrawala).

Cara utama untuk memeriksa NaN-ness, pada C ++ 14, adalah:

• std::isnan(value) )
  adalah cara pustaka standar yang dimaksudkan sejak C ++ 11. isnantampaknya bertentangan dengan makro Posix dengan nama yang sama, tetapi dalam praktiknya itu tidak masalah. Masalah utama adalah bahwa ketika optimasi aritmatika floating point diminta, maka dengan setidaknya satu kompiler utama, yaitu g ++, std::isnan kembali falseuntuk argumen NaN .

• (fpclassify(value) == FP_NAN) )
  Menderita masalah yang sama seperti std::isnan, yaitu, tidak dapat diandalkan.

• (value != value) )
  Direkomendasikan dalam banyak jawaban SO. Menderita masalah yang sama seperti std::isnan, yaitu, tidak dapat diandalkan.

• (value == Fp_info::quiet_NaN()) )
  Ini adalah tes yang dengan perilaku standar tidak boleh mendeteksi NaN, tetapi bahwa dengan perilaku yang dioptimalkan mungkin bisa mendeteksi NaN (karena kode yang dioptimalkan hanya membandingkan representasi bitlevel secara langsung), dan mungkin dikombinasikan dengan cara lain untuk mencakup perilaku standar yang tidak dioptimalkan. , andal bisa mendeteksi NaN. Sayangnya ternyata tidak berfungsi dengan baik.

• (ilogb(value) == FP_ILOGBNAN) )
  Menderita masalah yang sama seperti std::isnan, yaitu, tidak dapat diandalkan.

• isunordered(1.2345, value) )
  Menderita masalah yang sama seperti std::isnan, yaitu, tidak dapat diandalkan.

• is_ieee754_nan( value ) )
  Ini bukan fungsi standar. Ini memeriksa bit sesuai dengan standar IEEE 754. Ini benar-benar dapat diandalkan tetapi kode ini agak bergantung pada sistem.

Dalam kode uji lengkap berikut "sukses" adalah apakah suatu ekspresi melaporkan Nannnes dari nilai tersebut. Untuk sebagian besar ekspresi ukuran keberhasilan ini, tujuan mendeteksi NaN dan hanya NaN, sesuai dengan semantik standar mereka. Untuk (value == Fp_info::quiet_NaN()) )ekspresi, namun, perilaku standar adalah bahwa hal itu tidak bekerja sebagai NaN-detektor.

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

Hasil dengan g ++ (perhatikan lagi bahwa perilaku standar (value == Fp_info::quiet_NaN())adalah bahwa itu tidak berfungsi sebagai detektor NaN, itu hanya sangat menarik di sini):

[C: \ my \ forum \ so \ 282 (deteksi NaN)]
> g ++ --version | temukan "++"
g ++ (x86_64-win32-sjlj-rev1, Dibangun oleh proyek MinGW-W64) 6.3.0

[C: \ my \ forum \ so \ 282 (deteksi NaN)]
> g ++ foo.cpp && a
Klaim kompiler IEEE 754 = true

v = nan, (std :: isnan (value)) = Kesuksesan sejati
u = 3.14, (std :: isnan (value)) = Keberhasilan palsu
w = inf, (std :: isnan (value)) = Keberhasilan palsu

v = nan, ((fpclassify (value) == 0x0100)) = Sukses sejati
u = 3.14, ((fpclassify (value) == 0x0100)) = Keberhasilan palsu
w = inf, ((fpclassify (value) == 0x0100)) = Keberhasilan palsu

v = nan, ((nilai! = nilai)) = Kesuksesan sejati
u = 3,14, ((nilai! = nilai)) = Keberhasilan palsu
w = inf, ((value! = value)) = false Success

v = nan, ((nilai == Fp_info :: quiet_NaN ())) = false GAGAL
u = 3,14, ((nilai == Fp_info :: quiet_NaN ())) = Keberhasilan palsu
w = inf, ((value == Fp_info :: quiet_NaN ())) = Keberhasilan palsu

v = nan, ((ilogb (nilai) == ((int) 0x80000000))) = Sukses sejati
u = 3,14, ((ilogb (nilai) == ((int) 0x80000000))) = Keberhasilan palsu
w = inf, ((ilogb (value) == ((int) 0x80000000)))) Sukses salah

v = nan, (isunordered (1.2345, value)) = true Success
u = 3,14, (isunordered (1.2345, value)) = false Success
w = inf, (isunordered (1.2345, value)) = false Success

v = nan, (is_ieee754_nan (value)) = Kesuksesan sejati
u = 3,14, (is_ieee754_nan (nilai)) = Keberhasilan palsu
w = inf, (is_ieee754_nan (value)) = Keberhasilan palsu

[C: \ my \ forum \ so \ 282 (deteksi NaN)]
> g ++ foo.cpp -fast-math && a
Klaim kompiler IEEE 754 = true

v = nan, (std :: isnan (value)) = false GAGAL
u = 3.14, (std :: isnan (value)) = Keberhasilan palsu
w = inf, (std :: isnan (value)) = Keberhasilan palsu

v = nan, ((fpclassify (value) == 0x0100)) = false GAGAL
u = 3.14, ((fpclassify (value) == 0x0100)) = Keberhasilan palsu
w = inf, ((fpclassify (value) == 0x0100)) = Keberhasilan palsu

v = nan, ((nilai! = nilai)) = false GAGAL
u = 3,14, ((nilai! = nilai)) = Keberhasilan palsu
w = inf, ((value! = value)) = false Success

v = nan, ((value == Fp_info :: quiet_NaN ())) = Sukses sejati
u = 3,14, ((nilai == Fp_info :: quiet_NaN ())) = true FAILED
w = inf, ((value == Fp_info :: quiet_NaN ())) = true FAILED

v = nan, ((ilogb (nilai) == ((int) 0x80000000))) = Sukses sejati
u = 3,14, ((ilogb (nilai) == ((int) 0x80000000))) = Keberhasilan palsu
w = inf, ((ilogb (value) == ((int) 0x80000000)))) Sukses salah

v = nan, (isunordered (1.2345, value)) = false GAGAL
u = 3,14, (isunordered (1.2345, value)) = false Success
w = inf, (isunordered (1.2345, value)) = false Success

v = nan, (is_ieee754_nan (value)) = Kesuksesan sejati
u = 3,14, (is_ieee754_nan (nilai)) = Keberhasilan palsu
w = inf, (is_ieee754_nan (value)) = Keberhasilan palsu

[C: \ my \ forum \ so \ 282 (deteksi NaN)]
> _

Hasil dengan Visual C ++:

[C: \ my \ forum \ so \ 282 (deteksi NaN)]
> cl / nologo- 2> & 1 | temukan "++"
Microsoft (R) C / C ++ Mengoptimalkan Versi Kompiler 19.00.23725 untuk x86

[C: \ my \ forum \ so \ 282 (deteksi NaN)]
> cl foo.cpp / Feb && b
foo.cpp
Klaim kompiler IEEE 754 = true

v = nan, (std :: isnan (value)) = Kesuksesan sejati
u = 3.14, (std :: isnan (value)) = Keberhasilan palsu
w = inf, (std :: isnan (value)) = Keberhasilan palsu

v = nan, ((fpclassify (value) == 2)) = Kesuksesan sejati
u = 3,14, ((fpclassify (value) == 2)) = Keberhasilan palsu
w = inf, ((fpclassify (value) == 2)) = Keberhasilan palsu

v = nan, ((nilai! = nilai)) = Kesuksesan sejati
u = 3,14, ((nilai! = nilai)) = Keberhasilan palsu
w = inf, ((value! = value)) = false Success

v = nan, ((nilai == Fp_info :: quiet_NaN ())) = false GAGAL
u = 3,14, ((nilai == Fp_info :: quiet_NaN ())) = Keberhasilan palsu
w = inf, ((value == Fp_info :: quiet_NaN ())) = Keberhasilan palsu

v = nan, ((ilogb (value) == 0x7fffffff)) = Sukses sejati
u = 3,14, ((ilogb (nilai) == 0x7fffffff)) = Keberhasilan palsu
w = inf, ((ilogb (value) == 0x7fffffff)) = true GAGAL

v = nan, (isunordered (1.2345, value)) = true Success
u = 3,14, (isunordered (1.2345, value)) = false Success
w = inf, (isunordered (1.2345, value)) = false Success

v = nan, (is_ieee754_nan (value)) = Kesuksesan sejati
u = 3,14, (is_ieee754_nan (nilai)) = Keberhasilan palsu
w = inf, (is_ieee754_nan (value)) = Keberhasilan palsu

[C: \ my \ forum \ so \ 282 (deteksi NaN)]
> cl foo.cpp / Feb / fp: cepat && b
foo.cpp
Klaim kompiler IEEE 754 = true

v = nan, (std :: isnan (value)) = Kesuksesan sejati
u = 3.14, (std :: isnan (value)) = Keberhasilan palsu
w = inf, (std :: isnan (value)) = Keberhasilan palsu

v = nan, ((fpclassify (value) == 2)) = Kesuksesan sejati
u = 3,14, ((fpclassify (value) == 2)) = Keberhasilan palsu
w = inf, ((fpclassify (value) == 2)) = Keberhasilan palsu

v = nan, ((nilai! = nilai)) = Kesuksesan sejati
u = 3,14, ((nilai! = nilai)) = Keberhasilan palsu
w = inf, ((value! = value)) = false Success

v = nan, ((nilai == Fp_info :: quiet_NaN ())) = false GAGAL
u = 3,14, ((nilai == Fp_info :: quiet_NaN ())) = Keberhasilan palsu
w = inf, ((value == Fp_info :: quiet_NaN ())) = Keberhasilan palsu

v = nan, ((ilogb (value) == 0x7fffffff)) = Sukses sejati
u = 3,14, ((ilogb (nilai) == 0x7fffffff)) = Keberhasilan palsu
w = inf, ((ilogb (value) == 0x7fffffff)) = true GAGAL

v = nan, (isunordered (1.2345, value)) = true Success
u = 3,14, (isunordered (1.2345, value)) = false Success
w = inf, (isunordered (1.2345, value)) = false Success

v = nan, (is_ieee754_nan (value)) = Kesuksesan sejati
u = 3,14, (is_ieee754_nan (nilai)) = Keberhasilan palsu
w = inf, (is_ieee754_nan (value)) = Keberhasilan palsu

[C: \ my \ forum \ so \ 282 (deteksi NaN)]
> _

Meringkas hasil di atas, hanya pengujian langsung representasi bit-level, menggunakan is_ieee754_nanfungsi yang didefinisikan dalam program pengujian ini, bekerja dengan andal dalam semua kasus dengan g ++ dan Visual C ++.

Tambahan:
Setelah memposting di atas, saya menyadari kemungkinan lain untuk menguji NaN, yang disebutkan dalam jawaban lain di sini, yaitu ((value < 0) == (value >= 0)). Itu ternyata bekerja dengan baik dengan Visual C ++ tetapi gagal dengan -ffast-mathopsi g ++ . Hanya pengujian bitptern secara langsung yang dapat diandalkan.

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

Ini berfungsi jika sizeof(int)4 dan sizeof(long long)8.

Selama waktu berjalan itu hanya perbandingan, coran tidak membutuhkan waktu. Itu hanya mengubah konfigurasi flag perbandingan untuk memeriksa kesetaraan.

Solusi yang mungkin tidak akan bergantung pada representasi IEEE spesifik untuk NaN yang digunakan adalah sebagai berikut:

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

Mempertimbangkan bahwa (x! = X) tidak selalu dijamin untuk NaN (seperti jika menggunakan opsi -fast-matematika), saya telah menggunakan:

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

Angka tidak bisa keduanya <0 dan> = 0, jadi pemeriksaan ini hanya akan berlalu jika angkanya tidak kurang dari, atau lebih besar dari atau sama dengan nol. Yang pada dasarnya tidak ada angka sama sekali, atau NaN.

Anda juga dapat menggunakan ini jika Anda lebih suka:

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

Saya tidak yakin bagaimana ini dipengaruhi oleh -Fast-matematika, jadi jarak tempuh Anda dapat bervariasi.

Bagi saya solusinya bisa makro untuk membuatnya secara eksplisit sejajar dan dengan demikian cukup cepat. Ini juga berfungsi untuk semua tipe float. Itu didasarkan pada kenyataan bahwa satu-satunya kasus ketika nilai tidak sama dengan dirinya sendiri adalah ketika nilai bukan angka.

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

Ini bekerja:

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

keluaran: isnan

Tampaknya bagi saya bahwa pendekatan lintas platform yang terbaik adalah menggunakan gabungan dan menguji pola bit ganda untuk memeriksa NaN.

Saya belum benar-benar menguji solusi ini, dan mungkin ada cara yang lebih efisien untuk bekerja dengan pola bit, tetapi saya pikir itu harus bekerja.

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

Pada x86-64 Anda dapat memiliki metode yang sangat cepat untuk memeriksa NaN dan infinity, yang berfungsi terlepas dari -ffast-mathopsi kompiler. ( f != f, std::isnan, std::isinfSelalu menghasilkan falsedengan -ffast-math).

Pengujian untuk NaN, angka tak terbatas dan terbatas dapat dengan mudah dilakukan dengan memeriksa eksponen maksimum. infinity adalah eksponen maksimum dengan mantissa nol, NaN adalah eksponen maksimum dan mantissa bukan nol. Eksponen disimpan dalam bit berikutnya setelah bit tanda paling atas, sehingga kita bisa meninggalkan shift untuk menyingkirkan bit tanda dan membuat eksponen bit paling atas, tidak ada masking ( operator&) yang diperlukan:

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

The stdversi isinfdan isfinitebeban 2 double/floatkonstanta dari .datasegmen dan dalam skenario kasus terburuk dapat menyebabkan 2 data cache misses. Versi di atas tidak memuat data apa pun, inf_double_shl1dan inf_float_shl1konstanta disandikan sebagai operan langsung ke instruksi perakitan.

Lebih cepat isnan2hanya 2 instruksi perakitan:

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

Menggunakan fakta bahwa ucomisdinstruksi menetapkan flag parity jika ada argumen yang NaN. Ini adalah cara std::isnankerjanya ketika tidak ada -ffast-mathopsi yang ditentukan.

Standar IEEE mengatakan ketika eksponen adalah semua 1s dan mantissa tidak nol, angkanya adalah a NaN. Dobel adalah 1tanda bit, 11bit eksponen dan 52bit mantissa. Lakukan sedikit pemeriksaan.

Seperti komentar di atas menyatakan a! = A tidak akan berfungsi di g ++ dan beberapa kompiler lain, tetapi trik ini seharusnya. Ini mungkin tidak seefisien, tapi masih ada cara:

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

Pada dasarnya, dalam g ++ (saya tidak yakin tentang yang lain) printf mencetak 'nan' pada format% d atau% .f jika variabel bukan integer / float yang valid. Oleh karena itu kode ini memeriksa karakter pertama dari string menjadi 'n' (seperti dalam "nan")

Ini mendeteksi ketidakterbatasan dan juga NaN di Visual Studio dengan mengeceknya dalam batas ganda:

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