¿Cómo usar nan e inf en C?

Tengo un método numérico que podría devolver nan o inf si hubiera un error, y para las pruebas me gustaría forzarlo temporalmente a devolver nan o inf para asegurar que la situación se maneje correctamente. ¿Existe una forma confiable e independiente del compilador de crear valores de nan e inf en C?

Después de buscar en Google durante unos 10 minutos, solo he podido encontrar soluciones dependientes del compilador.

Puede probar si su implementación lo tiene:

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

La existencia de INFINITYestá garantizada por C99 (o el último borrador al menos), y "se expande a una expresión constante de tipo float que representa infinito positivo o sin signo, si está disponible; de ​​lo contrario, a una constante positiva de tipo float que se desborda en el momento de la traducción".

NAN puede o no estar definido, y "se define si y solo si la implementación admite NaN silenciosos para el tipo float. Se expande a una expresión constante de tipo float que representa un NaN silencioso".

Tenga en cuenta que si está comparando valores de punto flotante y haga lo siguiente:

a = NAN;

incluso entonces,

a == NAN;

Es falso. Una forma de verificar el NaN sería:

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

También puede hacer: a != apara probar si aes NaN.

También hay isfinite(), isinf(), isnormal(), y signbit()macros en math.hen C99.

C99 también tiene nanfunciones:

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

(Referencia: n1256).

Docs INFINITY Docs NAN

No existe una forma independiente del compilador de hacer esto, ya que ni los estándares C (ni los C ++) dicen que los tipos matemáticos de coma flotante deben admitir NAN o INF.

Editar: Acabo de verificar la redacción del estándar C ++, y dice que estas funciones (miembros de la clase de plantilla numeric_limits):

quiet_NaN() 
signalling_NaN()

devolverá las representaciones NAN "si están disponibles". No amplía lo que significa "si está disponible", sino presumiblemente algo como "si el representante de FP de la implementación los admite". Del mismo modo, hay una función:

infinity() 

que devuelve un representante INF positivo "si está disponible".

Ambos están definidos en el <limits>encabezado; supongo que el estándar C tiene algo similar (probablemente también "si está disponible"), pero no tengo una copia del estándar C99 actual.

Esto funciona para ambos floaty double:

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

Editar: Como ya dijo alguien, el antiguo estándar IEEE decía que tales valores deberían generar trampas. Pero los nuevos compiladores casi siempre desactivan las trampas y devuelven los valores dados porque la trampa interfiere con el manejo de errores.

Una forma independiente del compilador, pero no una forma independiente del procesador para obtener estos:

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

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

Esto debería funcionar en cualquier procesador que utilice el formato de punto flotante IEEE 754 (que hace x86).

ACTUALIZACIÓN: Probado y actualizado.

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

y

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

También me sorprende que estas no sean constantes de tiempo de compilación. Pero supongo que podría crear estos valores con bastante facilidad simplemente ejecutando una instrucción que devuelva un resultado tan inválido. Dividiendo por 0, logaritmo de 0, bronceado de 90, ese tipo de cosas.

Yo suelo usar

#define INFINITY (1e999)

o

const double INFINITY = 1e999

que funciona al menos en contextos IEEE 754 porque el valor doble representable más alto es aproximadamente 1e308. 1e309funcionaría igual de bien, 1e99999pero tres nueves son suficientes y memorables. Dado que este es un doble literal (en el #definecaso) o un Infvalor real , seguirá siendo infinito incluso si está utilizando flotantes de 128 bits ("doble largo").

Aquí hay una forma simple de definir esas constantes, y estoy bastante seguro de que es portátil:

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

Cuando ejecuto este código:

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

Yo obtengo:

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