Come usare nan e inf in C?

Ho un metodo numerico che potrebbe restituire nan o inf se ci fosse un errore, e per i test proposti vorrei forzarlo temporaneamente a restituire nan o inf per assicurarmi che la situazione sia gestita correttamente. Esiste un modo affidabile e indipendente dal compilatore per creare valori di nan e inf in C?

Dopo aver cercato su Google per circa 10 minuti, sono stato in grado di trovare solo soluzioni dipendenti dal compilatore.

Puoi verificare se la tua implementazione lo ha:

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

L'esistenza di INFINITYè garantita da C99 (o almeno l'ultima bozza) e "si espande a un'espressione costante di tipo float che rappresenta un infinito positivo o senza segno, se disponibile; altrimenti a una costante positiva di tipo float che trabocca al momento della traduzione".

NAN può o non può essere definito, e "è definito se e solo se l'implementazione supporta NaN silenziosi per il tipo float. Si espande in un'espressione costante di tipo float che rappresenta un NaN silenzioso."

Nota che se stai confrontando valori in virgola mobile e fai:

a = NAN;

anche allora,

a == NAN;

è falso. Un modo per verificare NaN sarebbe:

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

Puoi anche fare: a != aper verificare se aè NaN.

C'è anche isfinite(), isinf(), isnormal(), e signbit()macro in math.hin C99.

C99 ha anche nanfunzioni:

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

(Riferimento: n1256).

Documenti INFINITY Documenti NAN

Non esiste un modo indipendente dal compilatore per eseguire questa operazione, poiché né gli standard C (né C ++) dicono che i tipi matematici in virgola mobile devono supportare NAN o INF.

Modifica: ho appena controllato la dicitura dello standard C ++ e dice che queste funzioni (membri della classe numeric_limits basata su modelli):

quiet_NaN() 
signalling_NaN()

restituirà le rappresentazioni NAN "se disponibili". Non si espande su cosa significhi "se disponibile", ma presumibilmente qualcosa come "se il rappresentante FP dell'implementazione li supporta". Allo stesso modo, c'è una funzione:

infinity() 

che restituisce un rappresentante INF positivo "se disponibile".

Entrambi sono definiti <limits>nell'intestazione: immagino che lo standard C abbia qualcosa di simile (probabilmente anche "se disponibile") ma non ho una copia dell'attuale standard C99.

Funziona per entrambi floate double:

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

Modifica: come qualcuno ha già detto, il vecchio standard IEEE diceva che tali valori dovrebbero sollevare trappole. Ma i nuovi compilatori disattivano quasi sempre i trap e restituiscono i valori dati perché il trapping interferisce con la gestione degli errori.

Un modo indipendente dal compilatore, ma non un modo indipendente dal processore per ottenere questi:

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

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

Questo dovrebbe funzionare su qualsiasi processore che utilizza il formato a virgola mobile IEEE 754 (che fa x86).

AGGIORNAMENTO: testato e aggiornato.

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

e

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

Sono anche sorpreso che queste non siano costanti del tempo di compilazione. Ma suppongo che potresti creare questi valori abbastanza facilmente semplicemente eseguendo un'istruzione che restituisce un risultato così non valido. Dividendo per 0, log di 0, tan di 90, quel genere di cose.

Di solito uso

#define INFINITY (1e999)

o

const double INFINITY = 1e999

che funziona almeno in contesti IEEE 754 perché il valore double più alto rappresentabile è approssimativamente 1e308. 1e309funzionerebbe altrettanto bene, come sarebbe 1e99999, ma tre nove sono sufficienti e memorabili. Poiché questo è un valore letterale doppio (nel #definecaso) o effettivo Inf, rimarrà infinito anche se stai utilizzando float a 128 bit ("doppio lungo").

Ecco un modo semplice per definire quelle costanti e sono abbastanza sicuro che sia portatile:

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

Quando eseguo questo codice:

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

Ottengo:

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