Як використовувати nan та inf у C?

У мене є числовий метод, який може повернути nan або inf, якщо сталася помилка, і для тестування, яке я призначив, я хотів би тимчасово змусити його повернути nan або inf, щоб переконатися, що ситуація правильно обробляється. Чи існує надійний, незалежний від компілятора спосіб створення значень nan та inf у C?

Прогугливши близько 10 хвилин, я зміг знайти лише рішення, залежні від компілятора.

Ви можете перевірити, чи є у вашій реалізації:

#include <math.h>
#ifdef NAN
/* NAN is supported */
#endif
#ifdef INFINITY
/* INFINITY is supported */
#endif

Існування INFINITYгарантовано C99 (або, принаймні, останньою чернеткою), і "розширюється до постійного вираження типу float, що представляє позитивну або беззнакову нескінченність, якщо така є; інакше - до позитивної константи типу float, яка переповнюється під час перекладу".

NAN може бути визначено чи не визначено, і "визначається тоді і тільки тоді, коли реалізація підтримує тихі NaN для типу float. Вона розширюється до постійного виразу типу float, що представляє тихий NaN."

Зверніть увагу, що якщо ви порівнюєте значення з плаваючою комою, виконайте:

a = NAN;

навіть тоді,

a == NAN;

є хибним. Одним із способів перевірити NaN буде:

#include <math.h>
if (isnan(a)) { ... }

Ви також можете зробити: a != aперевірити, чи aNaN.

Існує також isfinite(), isinf(), isnormal()і signbit()макроси в math.hв C99.

C99 також має nanфункції:

#include <math.h>
double nan(const char *tagp);
float nanf(const char *tagp);
long double nanl(const char *tagp);

(Довідка: n1256).

Документи INFINITY Docs NAN

Не існує незалежного від компілятора способу зробити це, оскільки ні стандарти С (ні С ++) не говорять, що математичні типи з плаваючою комою повинні підтримувати NAN або INF.

Редагувати: Я щойно перевірив формулювання стандарту C ++, і там сказано, що ці функції (члени шаблонованого класу numeric_limits):

quiet_NaN() 
signalling_NaN()

поверне подання NAN "за наявності". Це не розширює те, що означає "якщо є", але, мабуть, щось на кшталт "якщо представник FP реалізації підтримує їх". Аналогічно існує функція:

infinity() 

який повертає позитивне повторення INF "за наявності".

Вони обидва визначені в <limits>заголовку - я гадаю, що стандарт C має щось подібне (можливо, також "за наявності"), але у мене немає копії поточного стандарту C99.

Це працює як floatі double:

double NAN = 0.0/0.0;
double POS_INF = 1.0 /0.0;
double NEG_INF = -1.0/0.0;

Редагувати: Як хтось уже говорив, старий стандарт IEEE говорив, що такі значення повинні викликати пастки. Але нові компілятори майже завжди вимикають пастки і повертають задані значення, оскільки перехоплення заважає обробці помилок.

Незалежний від компілятора спосіб, але не незалежний від процесора спосіб отримати їх:

int inf = 0x7F800000;
return *(float*)&inf;

int nan = 0x7F800001;
return *(float*)&nan;

Це має працювати на будь-якому процесорі, який використовує формат плаваючої крапки IEEE 754 (що робить x86).

ОНОВЛЕННЯ: Перевірено та оновлено.

double a_nan = strtod("NaN", NULL);
double a_inf = strtod("Inf", NULL);

<inf.h>

/* IEEE positive infinity.  */

#if __GNUC_PREREQ(3,3)
# define INFINITY   (__builtin_inff())
#else
# define INFINITY   HUGE_VALF
#endif

і

<bits/nan.h>
#ifndef _MATH_H
# error "Never use <bits/nan.h> directly; include <math.h> instead."
#endif


/* IEEE Not A Number.  */

#if __GNUC_PREREQ(3,3)

# define NAN    (__builtin_nanf (""))

#elif defined __GNUC__

# define NAN \
  (__extension__                                  \
   ((union { unsigned __l __attribute__ ((__mode__ (__SI__))); float __d; })  \
    { __l: 0x7fc00000UL }).__d)

#else

# include <endian.h>

# if __BYTE_ORDER == __BIG_ENDIAN
#  define __nan_bytes       { 0x7f, 0xc0, 0, 0 }
# endif
# if __BYTE_ORDER == __LITTLE_ENDIAN
#  define __nan_bytes       { 0, 0, 0xc0, 0x7f }
# endif

static union { unsigned char __c[4]; float __d; } __nan_union
    __attribute_used__ = { __nan_bytes };
# define NAN    (__nan_union.__d)

#endif  /* GCC.  */

Я також здивований, що це не константи часу компіляції. Але я думаю, ви могли б створити ці значення досить легко, просто виконавши інструкцію, яка повертає такий недійсний результат. Поділивши на 0, журнал 0, загар 90, це щось на зразок.

Я зазвичай використовую

#define INFINITY (1e999)

або

const double INFINITY = 1e999

що працює принаймні в контексті IEEE 754, оскільки найвище представницьке подвійне значення приблизно 1e308. 1e309працював би так само добре, як і працював би 1e99999, але трьох дев’яток цілком достатньо і запам’ятовується. Оскільки це або подвійний літерал (у #defineвипадку), або фактичне Infзначення, воно залишатиметься нескінченним, навіть якщо ви використовуєте 128-бітові («довгі подвійні») плаваючі символи.

Ось простий спосіб визначити ці константи, і я впевнений, що це портативно:

const double inf = 1.0/0.0;
const double nan = 0.0/0.0;

Коли я запускаю цей код:

printf("inf  = %f\n", inf);
printf("-inf = %f\n", -inf);
printf("nan  = %f\n", nan);
printf("-nan = %f\n", -nan);

Я отримав:

inf  = inf
-inf = -inf
nan  = -nan
-nan = nan