Есть ли функция isnan ()?

PS: я нахожусь в MinGW (если это имеет значение).

Я решил эту проблему с помощью isnan () from <math.h>, которого нет в <cmath>котором я поначалу писал #include.

Согласно стандарту IEEE, значения NaN имеют странное свойство, заключающееся в том, что сравнения с ними всегда ложны. То есть для числа с плавающей запятой 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::пространстве имен, хотя многие реализации (например, GCC 4+ в Linux или в XCode в Mac OS X 10.5+) внедряют их непосредственно std::, так что std::isnanэто четко определено.

Более того, некоторые реализации C ++ все еще делают isnan()макрос C99 доступным для C ++ (включается через cmathили math.h), что может вызвать больше недоразумений, и разработчики могут предположить, что это стандартное поведение.

Замечание о Viusal C ++, как упоминалось выше, не содержит std::isnanни того std::tr1::isnan, ни другого , но предоставляет функцию расширения, определенную как _isnan()доступную с Visual C ++ 6.0.

На XCode еще больше веселья. Как уже упоминалось, GCC 4+ определяет std::isnan. Похоже, что для более старых версий компилятора и библиотеки в форме XCode (здесь уместно обсуждение ) не было возможности проверить себя) определены две функции: __inline_isnand()на Intel и __isnand()на Power PC.

Первое решение: если вы используете 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)

Определяет, является ли данный аргумент числа с плавающей точкой ar-not-a-number ( NaN).

параметры

arg: значение с плавающей точкой

Возвращаемое значение

trueесли аргумент есть NaN, falseиначе

Ссылка

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

Обратите внимание, что это несовместимо с -fast-math, если вы используете g ++, другие предложения приведены ниже.

Другие решения: если вы используете инструменты, не совместимые с C ++ 11

Для C99 в C это реализовано как макрос, isnan(c)который возвращает значение типа int. Тип xдолжен быть float, double или long double.

Различные поставщики могут включать или не включать функцию isnan().

Предположительно переносимый способ проверки NaNсостоит в том, чтобы использовать свойство IEEE 754, NaNкоторое не равно самому себе: то есть x == xбудет ложным для xсуществования NaN.

Однако последний вариант может не работать с каждым компилятором и некоторыми настройками (в частности, настройками оптимизации), поэтому, в крайнем случае, вы всегда можете проверить битовую комбинацию ...

В Boost также есть библиотека только для заголовков, в которой есть удобные инструменты для работы с типами данных с плавающей запятой.

#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, он имеет много полезных инструментов и быстро растет.

Также при работе с плавающими и не плавающими точками было бы неплохо взглянуть на Числовые преобразования .

Существует три «официальных» способа: isnanмакрос posix , isnanшаблон функции c ++ 0x или визуальная _isnanфункция c ++ .

К сожалению, определить, какой из них использовать, довольно непрактично.

И, к сожалению, нет надежного способа определить, есть ли у вас представление IEEE 754 с NaN. Стандартная библиотека предлагает официальный способ ( numeric_limits<double>::is_iec559). Но на практике компиляторы, такие как g ++, облажались.

Теоретически можно было бы просто использовать x != x, но компиляторы, такие как g ++ и visual c ++, облажались.

Итак, в конце, протестируйте для определенных битовых шаблонов NaN , предполагая (и, надеюсь, принудительно применяя, в какой-то момент!) Конкретное представление, такое как IEEE 754.

РЕДАКТИРОВАТЬ : в качестве примера "компиляторы, такие как 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 -Wall -Write-strings% * -Wno-long-long

C: \ test> gnuc x.cpp

C: \ test> & & echo работает ... || эхо! не удалось
работает...

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

C: \ test> & & echo работает ... || эхо! не удалось
Ошибка подтверждения: a! = B, файл x.cpp, строка 6

Это приложение запросило Runtime прекратить его необычным способом.
Пожалуйста, обратитесь в службу поддержки приложения для получения дополнительной информации.
!не смогли

C: \ test> _

Существует std :: isnan, если ваш компилятор поддерживает расширения c99, но я не уверен, что 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;
}

Я не знаю, работает ли это на всех платформах, так как я тестировал только с g ++ на Linux.

Вы можете использовать isnan()функцию, но вам нужно включить математическую библиотеку C.

#include <cmath>

Поскольку эта функция является частью C99, она доступна не везде. Если ваш поставщик не предоставляет эту функцию, вы также можете определить свой собственный вариант совместимости.

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

В следующем коде используется определение NAN (все установленные биты экспоненты, как минимум один набор дробных бит) и предполагается, что sizeof (int) = sizeof (float) = 4. Вы можете найти 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значения имеют тенденцию приводить к трудностям поиска ошибок. (Обратите внимание, что это не относится к случаям infили -inf. ( -inf<0) возвращает TRUE, (0 < inf) возвращает ИСТИНА, и даже ( -inf< inf) возвращает ИСТИНА. Таким образом, по моему опыту, поведение кода часто остается желаемым).

что делать под нан

То, с чем вы хотите столкнуться, 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 _{Проверки на nanvia x != xиногда ненадежны ( x != xотбрасываются некоторыми оптимизирующими компиляторами, которые нарушают соответствие IEEE, особенно когда -ffast-mathкоммутатор включен).}

Начиная с C ++ 14, есть несколько способов проверить, является ли число с плавающей точкой valueNaN.

Из этих способов только проверка битов представления числа работает надежно, как отмечено в моем первоначальном ответе. В частности, std::isnanи часто предлагаемая проверка v != vне работает надежно и не должна использоваться, иначе ваш код перестанет работать правильно, когда кто-то решит, что необходима оптимизация с плавающей запятой, и попросит компилятор сделать это. Эта ситуация может измениться, компиляторы могут получить больше соответствия, но для этой проблемы, которая не возникала в течение 6 лет с момента первоначального ответа.

Около 6 лет моим первоначальным ответом было выбранное решение для этого вопроса, которое было в порядке. Но недавно был выбран ответ с сильным голосом, рекомендующий ненадежный v != vтест. Отсюда и этот дополнительный более актуальный ответ (теперь у нас есть стандарты C ++ 11 и C ++ 14 и C ++ 17 на горизонте).

Основными способами проверки на NaN-ность, начиная с C ++ 14, являются:

• std::isnan(value) )
  это стандартный библиотечный путь начиная с C ++ 11. isnanочевидно, конфликтует с макросом Posix с тем же именем, но на практике это не проблема. Основная проблема заключается в том, что когда запрашивается арифметическая оптимизация с плавающей запятой, то по крайней мере один главный компилятор, а именно g ++, std::isnan возвращает falseаргумент NaN .

• (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()) )выражения стандартное поведение состоит в том, что оно не работает как 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 \ forums \ so \ 282 (обнаружение NaN)]
> g ++ - версия | найти "++"
g ++ (x86_64-win32-sjlj-rev1, построен проектом MinGW-W64) 6.3.0

[C: \ my \ forums \ so \ 282 (обнаружение NaN)]
> g ++ foo.cpp && a
Заявление компилятора IEEE 754 = true

v = nan, (std :: isnan (value)) = истинный успех
u = 3,14, (std :: isnan (значение)) = ложь Успех
w = inf, (std :: isnan (value)) = false Успех

v = nan, ((fpclassify (value) == 0x0100)) = true Успех
u = 3.14, ((fpclassify (value) == 0x0100)) = false Успех
w = inf, ((fpclassify (value) == 0x0100)) = false Успех

v = nan, ((значение! = значение)) = истинный успех
и = 3.14, ((значение! = значение)) = ложь Успех
w = inf, ((значение! = значение)) = ложь Успех

v = nan, ((значение == Fp_info :: quiet_NaN ())) = false FAILED
u = 3.14, ((значение == Fp_info :: quiet_NaN ())) = false Успешно
w = inf, ((значение == Fp_info :: quiet_NaN ())) = false Успех

v = nan, ((ilogb (значение) == ((int) 0x80000000))) = true Успех
u = 3.14, ((ilogb (значение) == ((int) 0x80000000))) = false Успех
w = inf, ((ilogb (значение) == ((int) 0x80000000))) = false Успех

v = nan, (isorordered (1.2345, value)) = истинный успех
U = 3,14, (неупорядочено (1,2345, значение)) = ложь Успех
w = inf, (isorordered (1.2345, value)) = false Успех

v = nan, (is_ieee754_nan (value)) = истинный успех
u = 3,14, (is_ieee754_nan (значение)) = ложь Успех
w = inf, (is_ieee754_nan (value)) = false Успех

[C: \ my \ forums \ so \ 282 (обнаружение NaN)]
> g ++ foo.cpp -ffast-math && a
Заявление компилятора IEEE 754 = true

v = nan, (std :: isnan (value)) = false FAILED
u = 3,14, (std :: isnan (значение)) = ложь Успех
w = inf, (std :: isnan (value)) = false Успех

v = nan, ((fpclassify (value) == 0x0100)) = false FAILED
u = 3.14, ((fpclassify (value) == 0x0100)) = false Успех
w = inf, ((fpclassify (value) == 0x0100)) = false Успех

v = nan, ((value! = value)) = false FAILED
и = 3.14, ((значение! = значение)) = ложь Успех
w = inf, ((значение! = значение)) = ложь Успех

v = nan, ((значение == Fp_info :: quiet_NaN ())) = истинный успех
u = 3.14, ((значение == Fp_info :: quiet_NaN ())) = true FAILED
w = inf, ((значение == Fp_info :: quiet_NaN ())) = true FAILED

v = nan, ((ilogb (значение) == ((int) 0x80000000))) = true Успех
u = 3.14, ((ilogb (значение) == ((int) 0x80000000))) = false Успех
w = inf, ((ilogb (значение) == ((int) 0x80000000))) = false Успех

v = nan, (isorordered (1.2345, value)) = false FAILED
U = 3,14, (неупорядочено (1,2345, значение)) = ложь Успех
w = inf, (isorordered (1.2345, value)) = false Успех

v = nan, (is_ieee754_nan (value)) = истинный успех
u = 3,14, (is_ieee754_nan (значение)) = ложь Успех
w = inf, (is_ieee754_nan (value)) = false Успех

[C: \ my \ forums \ so \ 282 (обнаружение NaN)]
> _

Результаты с Visual C ++:

[C: \ my \ forums \ so \ 282 (обнаружение NaN)]
> cl / nologo- 2> & 1 | найти "++"
Оптимизирующий компилятор Microsoft (R) C / C ++ версии 19.00.23725 для x86

[C: \ my \ forums \ so \ 282 (обнаружение NaN)]
> cl foo.cpp / Feb && b
foo.cpp
Заявление компилятора IEEE 754 = true

v = nan, (std :: isnan (value)) = истинный успех
u = 3,14, (std :: isnan (значение)) = ложь Успех
w = inf, (std :: isnan (value)) = false Успех

v = nan, ((fpclassify (value) == 2)) = true Успех
u = 3.14, ((fpclassify (value) == 2)) = false Успешно
w = inf, ((fpclassify (value) == 2)) = false Успешно

v = nan, ((значение! = значение)) = истинный успех
и = 3.14, ((значение! = значение)) = ложь Успех
w = inf, ((значение! = значение)) = ложь Успех

v = nan, ((значение == Fp_info :: quiet_NaN ())) = false FAILED
u = 3.14, ((значение == Fp_info :: quiet_NaN ())) = false Успешно
w = inf, ((значение == Fp_info :: quiet_NaN ())) = false Успех

v = nan, ((ilogb (значение) == 0x7fffffff)) = истинный успех
u = 3.14, ((ilogb (значение) == 0x7fffffff)) = false Успех
w = inf, ((ilogb (значение) == 0x7fffffff)) = true FAILED

v = nan, (isorordered (1.2345, value)) = истинный успех
U = 3,14, (неупорядочено (1,2345, значение)) = ложь Успех
w = inf, (isorordered (1.2345, value)) = false Успех

v = nan, (is_ieee754_nan (value)) = истинный успех
u = 3,14, (is_ieee754_nan (значение)) = ложь Успех
w = inf, (is_ieee754_nan (value)) = false Успех

[C: \ my \ forums \ so \ 282 (обнаружение NaN)]
> cl foo.cpp / Feb / fp: fast && b
foo.cpp
Заявление компилятора IEEE 754 = true

v = nan, (std :: isnan (value)) = истинный успех
u = 3,14, (std :: isnan (значение)) = ложь Успех
w = inf, (std :: isnan (value)) = false Успех

v = nan, ((fpclassify (value) == 2)) = true Успех
u = 3.14, ((fpclassify (value) == 2)) = false Успешно
w = inf, ((fpclassify (value) == 2)) = false Успешно

v = nan, ((значение! = значение)) = истинный успех
и = 3.14, ((значение! = значение)) = ложь Успех
w = inf, ((значение! = значение)) = ложь Успех

v = nan, ((значение == Fp_info :: quiet_NaN ())) = false FAILED
u = 3.14, ((значение == Fp_info :: quiet_NaN ())) = false Успешно
w = inf, ((значение == Fp_info :: quiet_NaN ())) = false Успех

v = nan, ((ilogb (значение) == 0x7fffffff)) = истинный успех
u = 3.14, ((ilogb (значение) == 0x7fffffff)) = false Успех
w = inf, ((ilogb (значение) == 0x7fffffff)) = true FAILED

v = nan, (isorordered (1.2345, value)) = истинный успех
U = 3,14, (неупорядочено (1,2345, значение)) = ложь Успех
w = inf, (isorordered (1.2345, value)) = false Успех

v = nan, (is_ieee754_nan (value)) = истинный успех
u = 3,14, (is_ieee754_nan (значение)) = ложь Успех
w = inf, (is_ieee754_nan (value)) = false Успех

[C: \ my \ forums \ so \ 282 (обнаружение NaN)]
> _

Подводя итог вышеприведенным результатам, только прямое тестирование представления на битовом уровне с использованием is_ieee754_nanфункции, определенной в этой тестовой программе, надежно работало во всех случаях как с g ++, так и с Visual C ++.

Приложение:
После публикации вышеизложенного я узнал о еще одном возможном тесте на NaN, упомянутом в другом ответе здесь, а именно ((value < 0) == (value >= 0)). Это оказалось нормально работать с Visual C ++, но не с -ffast-mathопцией g ++ . Только прямое бит-тестирование работает надежно.

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.

Во время выполнения это только сравнение, кастинги не занимают время. Он просто изменяет конфигурацию флагов сравнения, чтобы проверить равенство.

Возможное решение, которое не будет зависеть от конкретного представления IEEE для используемого NaN, будет следующим:

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

Учитывая, что (x! = X) не всегда гарантируется для NaN (например, при использовании опции -ffast-math), я использовал:

#define IS_NAN(x) (((x) < 0) == ((x) >= 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 у вас могут быть очень быстрые методы проверки NaN и бесконечности, которые работают независимо от -ffast-mathопции компилятора. ( f != f, std::isnan, std::isinfВсегда дают falseс -ffast-math).

Тестирование на NaN, бесконечность и конечные числа может быть легко выполнено, проверяя максимальный показатель степени. бесконечность - максимальный показатель с нулевой мантиссой, NaN - максимальный показатель и ненулевая мантисса. Экспонента сохраняется в следующих битах после самого верхнего знакового бита, так что мы можем просто сдвинуть влево, чтобы избавиться от знакового бита и сделать экспоненту самыми старшими битами, маскирование ( 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всего 2 инструкции по сборке:

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 гласит, что когда показатель степени равен всем 1s, а мантисса не равна нулю, число равно a 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 печатает 'nan' в форматах% d или% .f, если переменная не является допустимым целым числом / float. Поэтому этот код проверяет, является ли первый символ строки 'n' (как в "nan")

Это обнаруживает бесконечность, а также NaN в Visual Studio, проверяя, что оно в двойных пределах:

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