Comment utiliser nan et inf en C?

J'ai une méthode numérique qui pourrait retourner nan ou inf s'il y avait une erreur, et pour les tests intentionnels, j'aimerais la forcer temporairement à retourner nan ou inf pour m'assurer que la situation est gérée correctement. Existe-t-il un moyen fiable et indépendant du compilateur de créer des valeurs de nan et inf en C?

Après avoir cherché sur Google pendant environ 10 minutes, je n'ai pu trouver que des solutions dépendantes du compilateur.

Vous pouvez tester si votre implémentation l'a:

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

L'existence de INFINITYest garantie par C99 (ou le dernier brouillon au moins), et "se développe en une expression constante de type float représentant l'infini positif ou non signé, si disponible; sinon, en une constante positive de type float qui déborde au moment de la traduction."

NAN peut ou non être défini et "est défini si et seulement si l'implémentation prend en charge les NaN silencieux pour le type float. Il se développe en une expression constante de type float représentant un NaN silencieux."

Notez que si vous comparez des valeurs à virgule flottante, et faites:

a = NAN;

même à ce moment là,

a == NAN;

c'est faux. Une façon de vérifier NaN serait:

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

Vous pouvez également faire: a != apour tester si aest NaN.

Il y a aussi isfinite(), isinf(), isnormal()et signbit()macros math.hdans C99.

C99 a également des nanfonctions:

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

(Référence: n1256).

Docs INFINITY Docs NAN

Il n'y a pas de moyen indépendant du compilateur de faire cela, car ni les normes C (ni C ++) ne disent que les types mathématiques à virgule flottante doivent prendre en charge NAN ou INF.

Edit: Je viens de vérifier le libellé du standard C ++, et il dit que ces fonctions (membres de la classe modèle numeric_limits):

quiet_NaN() 
signalling_NaN()

renverra les représentations NAN "si disponibles". Il ne développe pas ce que signifie «si disponible», mais probablement quelque chose comme «si le représentant FP de l'implémentation les soutient». De même, il existe une fonction:

infinity() 

qui renvoie un représentant INF positif "si disponible".

Ceux-ci sont tous deux définis dans l'en- <limits>tête - je suppose que le standard C a quelque chose de similaire (probablement aussi "si disponible") mais je n'ai pas de copie du standard C99 actuel.

Cela fonctionne à la fois pour floatet double:

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

Edit: Comme quelqu'un l'a déjà dit, l'ancienne norme IEEE disait que de telles valeurs devraient lever des pièges. Mais les nouveaux compilateurs désactivent presque toujours les traps et renvoient les valeurs données car le trapping interfère avec la gestion des erreurs.

Un moyen indépendant du compilateur, mais pas un moyen indépendant du processeur pour les obtenir:

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

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

Cela devrait fonctionner sur n'importe quel processeur utilisant le format à virgule flottante IEEE 754 (ce que fait x86).

MISE À JOUR: Testé et mis à jour.

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

et

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

Je suis également surpris qu'il ne s'agisse pas de constantes de temps de compilation. Mais je suppose que vous pouvez créer ces valeurs assez facilement en exécutant simplement une instruction qui renvoie un résultat aussi invalide. Diviser par 0, log de 0, bronzage de 90, ce genre de chose.

J'utilise habituellement

#define INFINITY (1e999)

ou

const double INFINITY = 1e999

qui fonctionne au moins dans les contextes IEEE 754 car la valeur double représentable la plus élevée est à peu près 1e308. 1e309fonctionnerait aussi bien, comme le ferait 1e99999, mais trois neuf sont suffisants et mémorables. Puisqu'il s'agit d'un double littéral (dans le #definecas) ou d'une Infvaleur réelle , il restera infini même si vous utilisez des flottants de 128 bits («long double»).

Voici un moyen simple de définir ces constantes, et je suis presque sûr que c'est portable:

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

Quand j'exécute ce code:

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

Je reçois:

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