如何在C中使用nan和inf？

Question

我有一个数值方法，如果出现错误，可以返回 nan 或 inf，出于测试目的，我想暂时强制它返回 nan 或 inf 以确保正确处理情况。是否有可靠的、独立于编译器的方法在 C 中创建 nan 和 inf 的值？

经过大约 10 分钟的谷歌搜索后，我只能找到依赖于编译器的解决方案。

Answer 1

您可以测试您的实现是否具有它：

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

C99（或至少是最新草案）保证了INFINITY的存在，并且“扩展为表示正数或无符号的float类型的常量表达式”
无穷大（如果可用）；否则为在转换时溢出的 float 类型的正常量。”

NAN 可以定义也可以不定义，并且“当且仅当实现支持 float 类型的安静 NaN 时才定义。它扩展为代表安静 NaN 的 float 类型常量表达式。”

请注意，如果您正在比较浮点值，并且 do:

a = NAN;

即使这样，

a == NAN;

也是 false。检查 NaN 的一种方法是：

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

您还可以执行以下操作： < code>a != a 来测试 a 是否为 NaN。

还有 isfinite()、isinf()、< C99 中 math.h 中的 code>isnormal() 和 signbit() 宏

也有 nan 函数

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

：(参考：n1256)

。
文档 NAN

Answer 2

没有独立于编译器的方法可以做到这一点，因为 C（或 C++）标准都没有规定浮点数学类型必须支持 NAN 或 INF。

编辑：我刚刚检查了 C++ 标准的措辞，它说这些函数（模板类 numeric_limits 的成员）：

quiet_NaN() 
signalling_NaN()

将返回 NAN 表示“如果可用”。它没有扩展“如果可用”的含义，但大概是“如果实现的 FP 代表支持它们”之类的内容。类似地，有一个函数：

infinity() 

它返回一个正的 INF 表示“如果可用”。

这些都是在 标头中定义的 - 我猜测 C 标准有类似的东西（可能也是“如果可用”），但我没有当前 C99 标准的副本。

Answer 3

这适用于 float 和 double：

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

编辑：
正如有人已经说过的，旧的 IEEE 标准说
这样的价值观应该引发陷阱。但是新的编译器
几乎总是关闭陷阱并返回
给定值，因为捕获会干扰错误
处理。

Answer 4

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

Answer 5

一种独立于编译器的方式，但不是独立于处理器的方式来获取这些：

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

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

这应该适用于任何使用 IEEE 754 浮点格式的处理器（x86 可以）。

更新：已测试并更新。

Answer 6

<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.  */

Answer 7

我通常使用

#define INFINITY (1e999)

or

const double INFINITY = 1e999

，它至少在 IEEE 754 上下文中有效，因为可表示的最高双精度值大约为 1e308。 1e309 的效果与 1e99999 一样好，但三个 9 就足够了并且容易记住。由于这要么是双精度字面量（在 #define 情况下），要么是实际的 Inf 值，因此即使您使用 128 位（“long双”）浮动。

Answer 8

这是定义这些常量的简单方法，我很确定它是可移植的：

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

Answer 9

在 MSVC 中，在 Correct_math.h 中定义了以下内容，该内容包含在 math.h 中：

#ifndef _HUGE_ENUF
    #define _HUGE_ENUF  1e+300  // _HUGE_ENUF*_HUGE_ENUF must overflow
#endif

#define INFINITY   ((float)(_HUGE_ENUF * _HUGE_ENUF))
#define HUGE_VAL   ((double)INFINITY)
#define HUGE_VALF  ((float)INFINITY)
#define HUGE_VALL  ((long double)INFINITY)
#ifndef _UCRT_NEGATIVE_NAN
// This operation creates a negative NAN adding a - to make it positive
#define NAN        (-(float)(INFINITY * 0.0F))
#else
// Keep this for backwards compatibility
#define NAN        ((float)(INFINITY * 0.0F))
#endif

Answer 10

我也很惊讶这些不是编译时间常数。但我想您可以通过简单地执行返回此类无效结果的指令来轻松创建这些值。除以 0、0 的对数、90 的 tan，诸如此类。