cómo puedo hacer una función isnan/isinf portátil

Question

He estado usando isinf, isnan funciones en plataformas Linux que funcionó a la perfección. Pero esto no funcionó en OS-X, así que decidí usar std::isinfstd::isnan que funciona tanto en Linux como en OS-X.

Pero el compilador Intel no lo reconoce, y supongo que es un error en el compilador Intel acuerdo con http://software.intel.com/en-us/forums/showthread.php?t=64188

Así que ahora sólo quiero evitar la molestia y definir mi propia isinf, isnan aplicación.

¿Alguien sabe cómo esto podría hacerse?

edición:

que terminé haciendo esto en mi código fuente para hacer isinf/isnan trabajo

#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

no he intentado esto, pero yo creo

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

trabajaría. Se siente como que debería haber una mejor manera para isinf, pero eso debería funcionar.

Answer 2

Bueno, Lo ideal sería esperar a que Intel corrige el error o proporciona una solución :-)

Pero si desea detectar NaN y Inf de los valores IEEE754, asignarlo a un entero (32 o 64 bit dependiendo de si es de precisión simple o doble) y verificar si los bits de exponente son todos 1. Esto indica esos dos casos.

Puede distinguir entre NaN y Inf comprobando el bit de orden superior de la mantisa. Si es 1, eso es NaN de lo contrario Inf.

+/-Inf está dictada por el bit de signo.

Para la precisión simple (valores de 32 bits), el signo es el bit de orden superior (b31), el exponente son los siguientes ocho bits (más una mantisa de 23 bits). Para la precisión doble, el signo sigue siendo el bit de orden superior, pero el exponente es de once bits (más 52 bits para la mantisa).

Wikipedia tiene todos los detalles sangrientos.

El siguiente código muestra cómo funciona la codificación.

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

y se da salida:

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

sólo tener en cuenta que este código (pero no el método) depende en gran medida de los tamaños de los productos largos, que no es excesivamente portátil. Pero, si tiene que manipular un bit para obtener la información, ya ha ingresado ese territorio :-)

Como un lado, siempre he encontrado Harald Schmidt's IEEE754 converter muy útil para el análisis de coma flotante.

Answer 3

esto funciona en OSX

#include <math.h> 

también esto podría ser portátil,

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

edición:

como Chris señaló lo anterior puede fallar con gran x

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

Answer 4

Esto funciona en Visual Studio 2008:

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

Para mayor seguridad, recomiendo usar fpu_error(). Creo que algunos números se recogen con isnan(), y algunos con isinf(), y necesitas ambos para estar seguros.

Aquí hay un código de prueba:

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

Aquí está la salida:

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

También es posible usar impulso para esta tarea:

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

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

Answer 6

Como dijo brubelsabs ofertas Boost esta característica pero, como se informó here, en lugar de usar

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

Esto se debe utilizar:

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

Answer 7

El siguiente artículo tiene algunos trucos interesantes para isnan y isinf: http://jacksondunstan.com/articles/983

Answer 8

isnan es parte de C++ 11 ahora, incluido en GCC++ I creer, y Apple LLVM.

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

apropiadas #define s y s #include debe hacer una solución adecuada.

Sin embargo, recomiendo preventing nan from ever occurring, instead of nan detection.

Answer 9

Según this, infinito es fácil de comprobar:

• signo = 0 o 1 bit que indica el infinito positivo/negativo.
• exponente = todos los 1 bits.
• mantissa = todos los 0 bits.

NaN es un poco más complicado, ya que no tiene una representación única:

• signo = 0 o 1.
• exponente = todos los 1 bits.
• mantissa = cualquier cosa excepto todos los 0 bits (ya que los 0 bits representan infinito).

A continuación se muestra el código para la caja de doble punto de precisión flotante. De precisión simple se puede escribir de manera similar (Recordamos que el exponente es de 11-bits para los dobles y 8-bits para los solteros):

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

La aplicación es bastante sencillo (Tomé los del OpenCV header files). Utiliza una unión más de un entero de 64 bits sin signo de igual tamaño, que puede que tenga que declarar correctamente:

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

Answer 10

Nadie parece haber mencionado el fpclassify función C99 que devuelve:

Uno de FP_INFINITE , FP_NAN, FP_NORMAL, FP_SUBNORMAL, FP_ZERO o tipo definido por la implementación, especificando la categoría de arg.

Esto funciona con Visual Studio, pero no sé acerca de OS-X.

Answer 11

sólo uso que super simple código IEEE 754-1985 compatible:

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