我该如何制作一个便携式isnan/isinf函数

Question

我一直在使用isinf,isnan函数在Linux平台上工作完美。 但是这在OS-X上不起作用，所以我决定使用std::isinfstd::isnan，它可以在Linux和OS-X上运行。

但英特尔编译器无法识别它，我根据http://software.intel.com/en-us/forums/showthread.php?t=64188

猜测其错误在英特尔编译器现在我只是想避免麻烦和定义自己的isinf，isnan实施。

有谁知道这可以做到吗？

编辑：

我结束了在我的源代码做这做isinf/isnan工作

#include <iostream> 
#include <cmath> 

#ifdef __INTEL_COMPILER 
#include <mathimf.h> 
#endif 

int isnan_local(double x) { 
#ifdef __INTEL_COMPILER 
    return isnan(x); 
#else 
    return std::isnan(x); 
#endif 
} 

int isinf_local(double x) { 
#ifdef __INTEL_COMPILER 
    return isinf(x); 
#else 
    return std::isinf(x); 
#endif 
} 


int myChk(double a){ 
    std::cerr<<"val is: "<<a <<"\t"; 
    if(isnan_local(a)) 
    std::cerr<<"program says isnan"; 
    if(isinf_local(a)) 
    std::cerr<<"program says isinf"; 
    std::cerr<<"\n"; 
    return 0; 
} 

int main(){ 
    double a = 0; 
    myChk(a); 
    myChk(log(a)); 
    myChk(-log(a)); 
    myChk(0/log(a)); 
    myChk(log(a)/log(a)); 

    return 0; 
} 

Answer 1

我还没有试过，但我认为

int isnan(double x) { return x != x; } 
int isinf(double x) { return !isnan(x) && isnan(x - x); } 

会工作。感觉就像isinf应该有更好的方法，但这应该起作用。

Answer 2

好，理想情况下，你会等到英特尔修正了错误或提供了解决:-)

但是，如果你想检测来自IEEE754值NaN和Inf，它映射到一个整数（32或64这取决于它是单精度还是双精度）并检查指数位是否都是1.这表示这两种情况。通过检查尾数的高位来区分NaN和Inf。如果是1，那就是NaN否则Inf。

+/-Inf是由符号位决定的。对于单精度（32位值），符号是高位（b31），指数是下8位（加上23位尾数）。对于双精度，符号仍然是高位，但指数是11位（尾数加52位）。

Wikipedia有所有的血淋淋的细节。

以下代码显示编码如何工作。

#include <stdio.h> 

static void decode (char *s, double x) { 
    long y = *(((long*)(&x))+1); 

    printf("%08x ",y); 
    if ((y & 0x7ff80000L) == 0x7ff80000L) { 
     printf ("NaN (%s)\n", s); 
     return; 
    } 
    if ((y & 0xfff10000L) == 0x7ff00000L) { 
     printf ("+Inf (%s)\n", s); 
     return; 
    } 
    if ((y & 0xfff10000L) == 0xfff00000L) { 
     printf ("-Inf (%s)\n", s); 
     return; 
    } 
    printf ("%e (%s)\n", x, s); 
} 

int main (int argc, char *argv[]) { 
    double dvar; 

    printf ("sizeof double = %d\n", sizeof(double)); 
    printf ("sizeof long = %d\n", sizeof(long)); 

    dvar = 1.79e308; dvar = dvar * 10000; 
    decode ("too big", dvar); 

    dvar = -1.79e308; dvar = dvar * 10000; 
    decode ("too big and negative", dvar); 

    dvar = -1.0; dvar = sqrt(dvar); 
    decode ("imaginary", dvar); 

    dvar = -1.79e308; 
    decode ("normal", dvar); 

    return 0; 
} 

它输出：

sizeof double = 8 
sizeof long = 4 
7ff00000 +Inf (too big) 
fff00000 -Inf (too big and negative) 
fff80000 NaN (imaginary) 
ffefdcf1 -1.790000e+308 (normal) 

只要记住，此代码（而不是方法）取决于你的多头的大小是不是过于便携式很大。但是，如果您必须小心翼翼地获取信息，则您已经进入该领域:-)

另外，我总是发现Harald Schmidt's IEEE754 converter对于浮点分析非常有用。

Answer 3

这个工程在OSX

#include <math.h> 

也这可能是便携式，

int isinf(double x) { return x == x - 1; } 

编辑：

克里斯指出，上述可能无法与大型X

int isinf(double x) { return x == x * 2; } 

Answer 4

此作品在Visual Studio 2008下：

#include <math.h> 
#define isnan(x) _isnan(x) 
#define isinf(x) (!_finite(x)) 
#define fpu_error(x) (isinf(x) || isnan(x)) 

为了安全起见，我推荐使用fpu_error（）。我相信有些数字是用isnan（）提取的，有些用isinf（）提取的，并且你需要两者都是安全的。

下面是一些测试代码：

double zero=0; 
double infinite=1/zero; 
double proper_number=4; 
printf("isinf(infinite)=%d.\n",isinf(infinite)); 
printf("isinf(proper_number)=%d.\n",isinf(proper_number)); 
printf("isnan(infinite)=%d.\n",isnan(infinite)); 
printf("isnan(proper_number)=%d.\n",isnan(proper_number)); 

double num=-4; 
double neg_square_root=sqrt(num); 
printf("isinf(neg_square_root)=%d.\n",isinf(neg_square_root)); 
printf("isinf(proper_number)=%d.\n",isinf(proper_number)); 
printf("isnan(neg_square_root)=%d.\n",isnan(neg_square_root)); 
printf("isnan(proper_number)=%d.\n",isnan(proper_number)); 

这里是输出：

isinf(infinite)=1. 
isinf(proper_number)=0. 
isnan(infinite)=0. 
isnan(proper_number)=0. 
isinf(neg_square_root)=1. 
isinf(proper_number)=0. 
isnan(neg_square_root)=1. 
isnan(proper_number)=0. 

Answer 5

您也可以使用升压此任务：

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

if(boost::math::isnan(...) ....) 

Answer 6

正如brubelsabs所述升报价此功能但是，如报告here，而不是使用

if (boost::math::isnan(number)) 

这应该被用于：

if ((boost::math::isnan)(number)) 

Answer 7

下面的文章有isnan和isinf一些有趣的技巧： http://jacksondunstan.com/articles/983

Answer 8

isnan是C++ 11现在的一部分，包含在GCC++我相信和苹果LLVM。

现在MSVC++ has an _isnan function in <float.h>.

适当#define S和#include S的关系做一个合适的解决办法。

但是，我推荐preventing nan from ever occurring, instead of nan detection。

Answer 9

根据this，无穷很容易检查：

• 标志= 0或1比特指示正/负无穷大。
• exponent =全1位。
• 尾数=全0位。

的NaN是更复杂一些，因为它不具有唯一表示：

• 标志= 0或1。
• exponent =全1位。
• 尾数=除了全部0位以外的任何东西（因为所有的0位都代表无穷大）。

下面是双精度浮点格的代码。单精度可以类似地写成（记得指数是双打和8位单打11位）：

int isinf(double x) 
{ 
    union { uint64 u; double f; } ieee754; 
    ieee754.f = x; 
    return ((unsigned)(ieee754.u >> 32) & 0x7fffffff) == 0x7ff00000 && 
      ((unsigned)ieee754.u == 0); 
} 

int isnan(double x) 
{ 
    union { uint64 u; double f; } ieee754; 
    ieee754.f = x; 
    return ((unsigned)(ieee754.u >> 32) & 0x7fffffff) + 
      ((unsigned)ieee754.u != 0) > 0x7ff00000; 
} 

的实现是非常简单的（我把那些从OpenCV header files）。它采用了工会在一个同等大小的64位无符号整数，则可能需要正确声明：

#if defined _MSC_VER 
    typedef unsigned __int64 uint64; 
#else 
    typedef uint64_t uint64; 
#endif 

Answer 10

没有人似乎已经提到的C99功能fpclassify返回：

一个FP_INFINITE的，FP_NAN，FP_NORMAL，FP_SUBNORMAL，FP_ZERO或实现定义的类型，指定arg的类别。

这适用于visual studio，但我不知道OS-X。

Answer 11

只需使用超级简单符合IEEE 754-1985代码：

static inline bool ISINFINITE(float a)   { return (((U32&) a) & 0x7FFFFFFFU) == 0x7F800000U; } 
static inline bool ISINFINITEPOSITIVE(float a) { return (((U32&) a) & 0xFFFFFFFFU) == 0x7F800000U; } 
static inline bool ISINFINITENEGATIVE(float a) { return (((U32&) a) & 0xFFFFFFFFU) == 0xFF800000U; } 
static inline bool ISNAN(float a)    { return !ISINFINITE(a) && (((U32&) a) & 0x7F800000U) == 0x7F800000U; } 
static inline bool ISVALID(float a)    { return (((U32&) a) & 0x7F800000U) != 0x7F800000U; }