isnan () 함수가 있습니까?

추신 : 나는 MinGW에 있습니다 (차이가있는 경우).

나는이 ()에서 때는 isNaN을 사용하여 해결 한 <math.h>에서 존재하지 않는, <cmath>내가 한, #include처음에 보내고.

IEEE 표준에 따르면 NaN 값은 값과 관련된 비교가 항상 거짓 이라는 이상한 속성을 갖습니다 . 즉, float f의 f != f경우 사실입니다. 만 , f는 NaN의 경우.

아래의 일부 의견에서 지적했듯이 모든 컴파일러가 코드를 최적화 할 때 이것을 존중하지는 않습니다.

IEEE 부동 소수점을 사용한다고 주장하는 컴파일러의 경우이 트릭 이 작동합니다. 그러나 나는 그것을 보장 할 수 없습니다 것입니다 실제로 작동합니다. 의심스러운 경우 컴파일러에 문의하십시오.

isnan()현재 C ++ 표준 라이브러리 에는 사용 가능한 기능 이 없습니다 . C99 에 도입되어 매크로 로 정의되었습니다. 함수가 아닌 . C99로 정의 된 표준 라이브러리 요소는 현재 C ++ 표준 ISO / IEC 14882 : 1998의 일부가 아니며 업데이트 ISO / IEC 14882 : 2003도 아닙니다.

2005 년에는 기술 보고서 ​​1이 제안되었습니다. TR1은 C99와 C ++의 호환성을 제공합니다. 실제로는 C ++ 표준이되기 위해 공식적으로 채택 된 적이 없지만 많은 ( GCC 4.0+ 또는 Visual C ++ 9.0+ C ++ 구현은 TR1 기능을 제공하거나, 전부 또는 일부만 제공합니다 (Visual C ++ 9.0은 C99 수학 함수를 제공하지 않음) .

TR1 사용할 수있는 경우, 다음 cmath과 같은 C99 요소를 포함 isnan(), isfinite()등을하지만, 일반적으로 함수가 아니라 매크로로 정의되어 std::tr1::, 네임 스페이스하지만 그 주사한다 (맥 OS X 10.5에서 엑스 코드 리눅스 또는 즉, GCC 4+) 많은 구현 로 직접 정의 std::되므로 std::isnan잘 정의됩니다.

또한, C의 일부 구현 ++ 여전히 C99 만들 isnan()(를 포함 ++ C 매크로 사용할 수 cmath또는 math.h더 혼란과 개발자들이이 표준 동작입니다 가정 할 수의 원인이 무엇인지,).

Viusal C ++에 대한 참고 사항은 위에서 언급 한 것처럼 std::isnan어느 것도 제공 하지 std::tr1::isnan않지만 _isnan()이후에 사용 가능한 것으로 정의 된 확장 함수를 제공합니다 Visual C ++ 6.0

XCode에는 더 많은 재미가 있습니다. 언급했듯이 GCC 4+는을 정의합니다 std::isnan. 이전 버전의 컴파일러 및 라이브러리 XCode 형식의 경우 Intel 및 Power PC 에 두 가지 기능이 정의 되어있는 것 같습니다 (여기서는 관련 토론이 있습니다 ) .__inline_isnand()__isnand()

첫 번째 해결책 : C ++ 11을 사용하는 경우

이것이 요청 되었기 때문에 약간의 새로운 개발이있었습니다. 그것이 std::isnan()C ++ 11의 일부 임을 아는 것이 중요합니다

개요

헤더에 정의 <cmath>

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

주어진 부동 소수점 숫자 arg가 숫자가 아닌지 판별합니다 (NaN ).

매개 변수

arg: 부동 소수점 값

반환 값

truearg가 인 NaN경우false 경우 그렇지 않은 경우

참고

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

g ++를 사용하는 경우 -fast-math와 호환되지 않습니다. 다른 제안 사항은 아래를 참조하십시오.

다른 솔루션 : 비 C ++ 11 호환 도구를 사용하는 경우

C99의 경우 C에서는 isnan(c)int 값을 반환하는 매크로로 구현됩니다 . 유형은 xfloat, double 또는 long double이어야합니다.

다양한 벤더가 기능을 포함하거나 포함하지 않을 수 있습니다 isnan().

추측하기 쉬운 휴대용 방법 NaN은 IEEE 754 속성을 사용 NaN하지 않는 것입니다. 즉, x == xfalse 인 x것 NaN입니다.

그러나 마지막 옵션은 모든 컴파일러 및 일부 설정 (특히 최적화 설정)에서 작동하지 않을 수 있으므로 최후의 수단으로 항상 비트 패턴을 확인할 수 있습니다 ...

도있다 헤더 전용 라이브러리 부동 소수점 데이터 유형을 처리하는 깔끔한 도구가 부스트에 존재하는

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

다음과 같은 기능이 있습니다.

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

시간이 있다면 Boost의 전체 Math 툴킷을 살펴보면 유용한 도구가 많이 있으며 빠르게 성장하고 있습니다.

또한 부동 소수점과 비 부동 소수점을 다룰 때 Numeric Conversions 를 보는 것이 좋습니다 .

posix isnan매크로 , c ++ 0x isnan함수 템플릿 또는 시각적 c ++ _isnan함수의 세 가지 "공식적인"방법이 있습니다 .

불행히도 어떤 것을 사용할지를 감지하는 것은 비현실적입니다.

불행히도 NaN으로 IEEE 754 표현이 있는지 여부를 감지 할 수있는 확실한 방법은 없습니다. 표준 라이브러리는 공식적인 방법을 제공합니다 (numeric_limits<double>::is_iec559 ). 그러나 실제로 g ++와 같은 컴파일러는 그것을 망칩니다.

이론적으로는 간단하게 사용할 수 x != x있지만 g ++ 및 시각적 c ++와 같은 컴파일러는이를 강화시킵니다.

결국에는 IEEE 754와 같은 특정 표현을 가정하고 특정 시점에서 시행 할 특정 NaN 비트 패턴을 테스트하십시오 .

편집 : "g ++…와 같은 컴파일러와 같은 컴파일러"의 예로서, 고려하십시오

#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) 4.4.1 :

C : \ test> 유형 "C : \ Program Files \ @commands \ gnuc.bat"
@rem -finput-charset = windows-1252
@ g ++ -O -pedantic -std = c ++ 98-벽-쓰기 문자열 % *-롱 롱

C : \ test> gnuc x.cpp

C : \ test> && echo 작동 ... || 에코! 실패
공장...

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

C : \ test> && echo 작동 ... || 에코! 실패
어설 션 실패 : a! = b, 파일 x.cpp, 6 행

이 응용 프로그램은 런타임을 비정상적인 방식으로 종료하도록 요청했습니다.
자세한 내용은 응용 프로그램 지원 팀에 문의하십시오.
!실패한

C : \ test> _

컴파일러가 c99 확장을 지원하면 std :: isnan이 있지만 mingw가 지원하는지 확실하지 않습니다.

컴파일러에 표준 함수가없는 경우 작동해야하는 작은 함수가 있습니다.

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

표준 라이브러리에 numeric_limits<float>::quiet_NaN( )정의 된 것을 사용 limits하여 테스트 할 수 있습니다 . 에 대해 별도의 상수가 정의되어 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;
}

Linux에서 g ++로만 테스트 했으므로 이것이 모든 플랫폼에서 작동하는지 모르겠습니다.

이 isnan()함수 를 사용할 수 있지만 C 수학 라이브러리를 포함해야합니다.

#include <cmath>

이 기능은 C99의 일부이므로 일부 지역에서는 사용할 수 없습니다. 공급 업체가 기능을 제공하지 않으면 호환성을 위해 고유 한 변형을 정의 할 수도 있습니다.

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

다음 코드는 NAN (모든 지수 비트 세트, 하나 이상의 소수 비트 세트)의 정의를 사용하며 sizeof (int) = sizeof (float) = 4라고 가정합니다. 자세한 내용은 Wikipedia에서 NAN을 조회 할 수 있습니다.

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

난 예방

이 질문에 대한 나의 대답은에 대한 소급 확인을 사용하지 않습니다nan . 대신 양식 구분에 대한 예방 점검을 사용하십시오 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.

nan작업 결과 0.f/0.f또는 0.0/0.0. nan감지해야한다 코드의 안정에 무서운 천적이다 방지 매우 신중 ¹ . 그 속성은 nan일반 숫자와 다릅니다.

• nan독성이 있으며 (5 * nan= nan)
• nan아무것도 아니고, 그 자체도 아니다 ( nan! = nan)
• nan무엇보다 크지 않음 ( nan!> 0)
• nan무엇보다 중요하지 않습니다 ( nan! <0)

나열된 마지막 2 개의 속성은 반론 적이며 nan숫자 와의 비교에 의존하는 코드의 이상한 동작을 초래합니다 (마지막 세 번째 속성도 홀수이지만 x != x ?코드에서 볼 수는 없습니다 (확인하지 않는 한) nan (믿을 수 없음))).

내 코드에서는 nan값이 버그를 찾기가 어렵다는 것을 알았 습니다. (이게 얼마나 참고 하지 의 경우 inf나 -inf. ( -inf<0) 반환 TRUE, (0 < inf) TRUE를 반환, 심지어 ( -inf< inf) TRUE를 반환합니다. 그래서, 내 경험, 코드의 동작은 종종 원하는대로 여전히).

난에서해야 할 일

당신이하고 싶은 0.0/0.0 것은 특별한 경우로 처리되어야 하지만, 당신이하는 일은 코드에서 나오는 숫자에 달려 있어야합니다.

위의 예에서 ( 0.f/FLT_MIN) 의 결과는 0기본적으로입니다. 대신 0.0/0.0생성 할 수 있습니다 HUGE. 그래서,

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가 0.f이면 inf결과가 실제로 나타납니다 (실제로 위에서 언급했듯이 아주 좋고 비파괴적인 행동을합니다).

기억 0으로 정수 부문은 런타임 예외가 발생합니다 . 따라서 항상 0으로 정수 나누기를 점검해야합니다. 0.0/0.0조용히 평가 nan한다고해서 게으르고 0.0/0.0발생하기 전에 점검 할 수있는 것은 아닙니다 .

1 _{via 검사 는 때때로 신뢰할 수 없습니다 ( 특히 스위치가 활성화 된 경우 IEEE 준수를 위반하는 일부 최적화 컴파일러에 의해 제거됨 ).nanx != xx != x-ffast-math}

C ++ 14에서 부동 소수점 숫자 value가 NaN 인지 테스트하는 방법에는 여러 가지가 있습니다.

이 방법들 중에서 , 숫자의 표현 비트 만 검사하는 것은 원래의 대답에서 언급했듯이 안정적으로 작동합니다. 특히, std::isnan자주 제안되는 check v != v, 누군가가 부동 소수점 최적화가 필요하다고 결정할 때 코드가 올바르게 작동하지 않도록 컴파일러가 안정적으로 작동하지 않아야하며 사용해서는 안됩니다. 이 상황은 바뀔 수 있고 컴파일러는 더 잘 적응할 수 있지만 원래의 대답 이후 6 년 동안 발생하지 않은이 문제에 대해.

약 6 년 동안 제 원래의 대답은이 질문에 대한 선택된 솔루션이었습니다. 그러나 최근 신뢰할 수없는 v != v테스트를 추천하는 높은 평가를받은 답변 이 선택되었습니다. 따라서이 추가 최신 답변 (현재 C ++ 11 및 C ++ 14 표준과 C ++ 17이 있습니다).

C ++ 14에서 NaN-ness를 확인하는 주요 방법은 다음과 같습니다.

• std::isnan(value) )
  C ++ 11 이후로 의도 된 표준 라이브러리 방식입니다. isnan분명히 같은 이름의 Posix 매크로와 충돌하지만 실제로는 문제가되지 않습니다. 주요 문제는 부동 소수점 산술 최적화가 요청 된 경우 하나 이상의 기본 컴파일러, 즉 g ++를 사용 하여 NaN 인수를 std::isnan 반환false 한다는 것 입니다.

• (fpclassify(value) == FP_NAN) )
  와 같은 문제로 어려움을 겪습니다 std::isnan. 즉, 신뢰할 수 없습니다.

• (value != value) )
  많은 SO 답변에서 권장됩니다. 와 같은 문제로 어려움을 겪습니다 std::isnan. 즉, 신뢰할 수 없습니다.

• (value == Fp_info::quiet_NaN()) )
  이것은 표준 동작을 사용하여 NaN을 감지해서는 안되지만 최적화 된 동작을 사용하면 (비트 레벨 표현을 직접 비교하는 최적화 된 코드로 인해) NaN을 감지 할 수 있으며 다른 방법과 결합하여 최적화되지 않은 표준 동작을 처리 할 수 ​​있습니다 NaN을 안정적으로 감지 할 수 있습니다. 불행히도 그것은 안정적으로 작동하지 않는 것으로 나타났습니다.

• (ilogb(value) == FP_ILOGBNAN) )
  와 같은 문제로 어려움을 겪습니다 std::isnan. 즉, 신뢰할 수 없습니다.

• isunordered(1.2345, value) )
  와 같은 문제로 어려움을 겪습니다 std::isnan. 즉, 신뢰할 수 없습니다.

• is_ieee754_nan( value ) )
  이것은 표준 기능이 아닙니다. IEEE 754 표준에 따라 비트를 확인합니다. 완전히 신뢰할 만하지 만 코드는 시스템에 따라 다릅니다.

다음의 완전한 테스트 코드에서 "성공"은 표현식이 값의 난을보고하는지 여부입니다. 대부분의 표현에서이 성공 척도 인 NaN과 NaN 만 탐지한다는 목표는 표준 시맨틱에 해당합니다. 를 들어 (value == Fp_info::quiet_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 ) );
}

g ++로 결과 (표준 동작은 (value == Fp_info::quiet_NaN())NaN 검출기로 작동하지 않는다는 것입니다. 실제적으로 관심이 많습니다).

[C : \ my \ 포럼 \ so \ 282 (NaN 감지)]
> g ++-버전 | "++"찾기
g ++ (x86_64-win32-sjlj-rev1, MinGW-W64 프로젝트에 의해 빌드 됨) 6.3.0

[C : \ my \ 포럼 \ so \ 282 (NaN 감지)]
> g ++ foo.cpp && a
컴파일러, IEEE 754 = 클레임

v = nan, (std :: isnan (value)) = true 성공
u = 3.14, (std :: isnan (value)) = 거짓 성공
w = inf, (std :: isnan (value)) = 거짓 성공

v = nan, ((fpclassify (value) == 0x0100)) = true 성공
u = 3.14, ((fpclassify (value) == 0x0100)) = 거짓 성공
w = inf, ((fpclassify (value) == 0x0100)) = 거짓 성공

v = nan, ((value! = value)) = true 성공
u = 3.14, ((value! = value)) = 거짓 성공
w = inf, ((value! = value)) = 거짓 성공

v = nan, ((value == Fp_info :: quiet_NaN ())) = 거짓 FAILED
u = 3.14, ((value == Fp_info :: quiet_NaN ())) = 거짓 성공
w = inf, ((value == Fp_info :: quiet_NaN ())) = 거짓 성공

v = nan, ((ilogb (value) == ((int) 0x80000000))) = 진정한 성공
u = 3.14, ((ilogb (value) == ((int) 0x80000000))) = 거짓 성공
w = inf, ((ilogb (value) == ((int) 0x80000000))) = 거짓 성공

v = nan, (isun order (1.2345, value)) = 진정한 성공
u = 3.14, (isun order (1.2345, value)) = 거짓 성공
w = inf, (isun order (1.2345, value)) = 거짓 성공

v = nan, (is_ieee754_nan (value)) = 진정한 성공
u = 3.14, (is_ieee754_nan (value)) = 거짓 성공
w = inf, (is_ieee754_nan (value)) = 거짓 성공

[C : \ my \ 포럼 \ so \ 282 (NaN 감지)]
> g ++ foo.cpp -ffast-math && a
컴파일러, IEEE 754 = 클레임

v = nan, (std :: isnan (value)) = 거짓 실패
u = 3.14, (std :: isnan (value)) = 거짓 성공
w = inf, (std :: isnan (value)) = 거짓 성공

v = nan, ((fpclassify (value) == 0x0100)) = 거짓 실패
u = 3.14, ((fpclassify (value) == 0x0100)) = 거짓 성공
w = inf, ((fpclassify (value) == 0x0100)) = 거짓 성공

v = nan, ((value! = value)) = 거짓 실패
u = 3.14, ((value! = value)) = 거짓 성공
w = inf, ((value! = value)) = 거짓 성공

v = nan, ((value == Fp_info :: quiet_NaN ())) = 진정한 성공
u = 3.14, ((값 == Fp_info :: quiet_NaN ())) = true 실패
w = inf, ((값 == Fp_info :: quiet_NaN ())) = true 실패

v = nan, ((ilogb (value) == ((int) 0x80000000))) = 진정한 성공
u = 3.14, ((ilogb (value) == ((int) 0x80000000))) = 거짓 성공
w = inf, ((ilogb (value) == ((int) 0x80000000))) = 거짓 성공

v = nan, (isun order (1.2345, value)) = 거짓 실패
u = 3.14, (isun order (1.2345, value)) = 거짓 성공
w = inf, (isun order (1.2345, value)) = 거짓 성공

v = nan, (is_ieee754_nan (value)) = 진정한 성공
u = 3.14, (is_ieee754_nan (value)) = 거짓 성공
w = inf, (is_ieee754_nan (value)) = 거짓 성공

[C : \ my \ 포럼 \ so \ 282 (NaN 감지)]
> _

Visual C ++를 사용한 결과 :

[C : \ my \ 포럼 \ so \ 282 (NaN 감지)]
> cl / nologo- 2> & 1 | "++"찾기
x86 용 Microsoft (R) C / C ++ 최적화 컴파일러 버전 19.00.23725

[C : \ my \ 포럼 \ so \ 282 (NaN 감지)]
> cl foo.cpp / 2 월 && b
foo.cpp
컴파일러, IEEE 754 = 클레임

v = nan, (std :: isnan (value)) = true 성공
u = 3.14, (std :: isnan (value)) = 거짓 성공
w = inf, (std :: isnan (value)) = 거짓 성공

v = nan, ((fpclassify (value) == 2)) = 진정한 성공
u = 3.14, ((fpclassify (value) == 2)) = 거짓 성공
w = inf, ((fpclassify (value) == 2)) = 거짓 성공

v = nan, ((value! = value)) = true 성공
u = 3.14, ((value! = value)) = 거짓 성공
w = inf, ((value! = value)) = 거짓 성공

v = nan, ((value == Fp_info :: quiet_NaN ())) = 거짓 FAILED
u = 3.14, ((value == Fp_info :: quiet_NaN ())) = 거짓 성공
w = inf, ((value == Fp_info :: quiet_NaN ())) = 거짓 성공

v = nan, ((ilogb (value) == 0x7fffffff)) = 진정한 성공
u = 3.14, ((ilogb (value) == 0x7fffffff)) = 거짓 성공
w = inf, ((ilogb (value) == 0x7fffffff)) = true 실패

v = nan, (isun order (1.2345, value)) = 진정한 성공
u = 3.14, (isun order (1.2345, value)) = 거짓 성공
w = inf, (isun order (1.2345, value)) = 거짓 성공

v = nan, (is_ieee754_nan (value)) = 진정한 성공
u = 3.14, (is_ieee754_nan (value)) = 거짓 성공
w = inf, (is_ieee754_nan (value)) = 거짓 성공

[C : \ my \ 포럼 \ so \ 282 (NaN 감지)]
> cl foo.cpp / Feb / fp : 빠른 && b
foo.cpp
컴파일러, IEEE 754 = 클레임

v = nan, (std :: isnan (value)) = true 성공
u = 3.14, (std :: isnan (value)) = 거짓 성공
w = inf, (std :: isnan (value)) = 거짓 성공

v = nan, ((fpclassify (value) == 2)) = 진정한 성공
u = 3.14, ((fpclassify (value) == 2)) = 거짓 성공
w = inf, ((fpclassify (value) == 2)) = 거짓 성공

v = nan, ((value! = value)) = true 성공
u = 3.14, ((value! = value)) = 거짓 성공
w = inf, ((value! = value)) = 거짓 성공

v = nan, ((value == Fp_info :: quiet_NaN ())) = 거짓 FAILED
u = 3.14, ((value == Fp_info :: quiet_NaN ())) = 거짓 성공
w = inf, ((value == Fp_info :: quiet_NaN ())) = 거짓 성공

v = nan, ((ilogb (value) == 0x7fffffff)) = 진정한 성공
u = 3.14, ((ilogb (value) == 0x7fffffff)) = 거짓 성공
w = inf, ((ilogb (value) == 0x7fffffff)) = true 실패

v = nan, (isun order (1.2345, value)) = 진정한 성공
u = 3.14, (isun order (1.2345, value)) = 거짓 성공
w = inf, (isun order (1.2345, value)) = 거짓 성공

v = nan, (is_ieee754_nan (value)) = 진정한 성공
u = 3.14, (is_ieee754_nan (value)) = 거짓 성공
w = inf, (is_ieee754_nan (value)) = 거짓 성공

[C : \ my \ 포럼 \ so \ 282 (NaN 감지)]
> _

위의 결과를 종합하면 is_ieee754_nan이 테스트 프로그램에 정의 된 함수를 사용하여 비트 수준 표현의 직접 테스트 만 g ++ 및 Visual C ++ 모두에서 안정적으로 작동했습니다.

부록 :
위의 내용을 게시 한 후 여기 에 또 다른 답변으로 언급 된 NaN을 테스트 할 수있는 또 다른 가능성이 있음을 알게되었습니다 ((value < 0) == (value >= 0)). Visual C ++에서는 잘 작동하지만 g ++의 -ffast-math옵션으로는 실패했습니다 . 직접 비트 패턴 테스트 만 안정적으로 작동합니다.

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

이것은 sizeof(int)4이고 sizeof(long long)8 이면 작동합니다 .

런타임 중에는 캐스팅에 불과하지만 시간이 걸리지 않습니다. 평등을 확인하기 위해 비교 플래그 구성 만 변경합니다.

사용되는 NaN에 대한 특정 IEEE 표현에 의존하지 않는 가능한 솔루션은 다음과 같습니다.

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

Nax에 대해 (x! = x)가 항상 보장되는 것은 아니라는 점을 고려하여 (-ffast-math 옵션을 사용하는 경우와 같이) 다음을 사용했습니다.

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

숫자는 <0과> = 0 일 수 없으므로 실제로이 검사는 숫자가 0보다 작거나 0보다 크지 않은 경우에만 통과합니다. 기본적으로 전혀 숫자가 없거나 NaN입니다.

원하는 경우 이것을 사용할 수도 있습니다.

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

그래도 이것이 -ffast-math의 영향을 받는지 확실하지 않으므로 마일리지가 다를 수 있습니다.

나에게 해결책은 명시 적으로 인라인하여 충분히 빠를 수있는 매크로 일 수 있습니다. 모든 플로트 유형에도 작동합니다. 값이 같지 않은 유일한 경우는 값이 숫자가 아니라는 사실에 근거합니다.

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

이것은 작동합니다 :

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

출력 : isnan

정말 진정한 크로스 플랫폼 접근 방식은 공용체를 사용하고 이중의 비트 패턴을 테스트하여 NaN을 확인하는 것 같습니다.

나는이 솔루션을 철저히 테스트하지 않았으며 비트 패턴을 사용하는보다 효율적인 방법이있을 수 있지만 작동해야한다고 생각합니다.

#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에서는 -ffast-math컴파일러 옵션에 관계없이 NaN 및 무한대를 확인하는 매우 빠른 방법을 사용할 수 있습니다 . ( f != f, std::isnan, std::isinf항상 양보 false로 -ffast-math).

NaN, 무한대 및 유한 수에 대한 테스트는 최대 지수를 확인하여 쉽게 수행 할 수 있습니다. 무한대는 가수가 0 인 최대 지수이고, NaN은 최대 지수이며 0이 아닌 가수입니다. 지수는 최상위 부호 비트 다음에 다음 비트에 저장되므로 부호 비트를 제거하고 지수를 최상위 비트로 만들기 위해 시프트를 왼쪽으로 할 수 있으므로 마스킹 ( operator&)이 필요 하지 않습니다.

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

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

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

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

std의 버전 isinf과 isfinite로드 2 개 double/float에서 상수 .data세그먼트와 최악의 시나리오에 그들은 2 데이터 캐시 미스가 발생할 수 있습니다. 위의 버전은 데이터를로드하지 않습니다, inf_double_shl1그리고 inf_float_shl1상수는 조립 설명서에 즉시 피연산자로 인코딩 된 얻을.

더 빠른 isnan2조립 지침은 두 가지입니다.

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

ucomisd인수가 NaN이면 명령어가 패리티 플래그를 설정 한다는 사실을 사용합니다. 이것은 옵션이 지정 std::isnan되지 않은 경우 작동 하는 방식 -ffast-math입니다.

IEEE 표준에 따르면 지수가 모두 1이고 가수가 0이 아닌 경우 숫자는입니다 NaN. Double은 1부호 비트, 11지수 비트 및 52가수 비트입니다. 조금 확인하십시오.

위의 주석에서 a == a는 g ++ 및 다른 컴파일러에서 작동하지 않지만이 트릭은 작동해야합니다. 효율적이지 않을 수도 있지만 여전히 방법입니다.

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

기본적으로 g ++에서 (다른 사람들에 대해서는 잘 모르겠습니다) printf는 변수가 유효한 정수 / 부동 소수점이 아닌 경우 % d 또는 % .f 형식으로 'nan'을 인쇄합니다. 따라서이 코드는 문자열의 첫 번째 문자가 'n'인지 확인합니다 ( "nan"과 같이).

이것은 무한대와 Visual Studio에서 NaN이 이중 한계 내에 있는지 확인하여 감지합니다.

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