Como usar nan e inf em C?

Eu tenho um método numérico que poderia retornar nan ou inf se houvesse um erro e, para fins de teste, gostaria de forçá-lo temporariamente a retornar nan ou inf para garantir que a situação esteja sendo tratada corretamente. Existe uma maneira confiável e independente do compilador para criar valores de nan e inf em C?

Depois de pesquisar no Google por cerca de 10 minutos, só consegui encontrar soluções dependentes do compilador.

Você pode testar se sua implementação tem:

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

A existência de INFINITYé garantida por C99 (ou pelo menos o rascunho mais recente) e "se expande para uma expressão constante do tipo float representando infinito positivo ou sem sinal, se disponível; do contrário, para uma constante positiva do tipo float que transborda no momento da tradução".

NAN pode ou não ser definido, e "é definido se e somente se a implementação suportar NaNs silenciosos para o tipo float. Ele se expande para uma expressão constante do tipo float representando um NaN silencioso."

Observe que se você estiver comparando valores de ponto flutuante, faça:

a = NAN;

mesmo assim,

a == NAN;

é falso. Uma maneira de verificar o NaN seria:

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

Você também pode fazer: a != apara testar se aé NaN.

Há também isfinite(), isinf(), isnormal(), e signbit()macros no math.hno C99.

C99 também tem nanfunções:

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

(Referência: n1256).

Docs INFINITY Docs NAN

Não há uma maneira independente do compilador de fazer isso, pois nem os padrões C (nem os C ++) dizem que os tipos matemáticos de ponto flutuante devem oferecer suporte a NAN ou INF.

Edit: Acabei de verificar o texto do padrão C ++, e ele diz que essas funções (membros da classe modelada numeric_limits):

quiet_NaN() 
signalling_NaN()

retornará representações NAN "se disponíveis". Não expande o que significa "se disponível", mas provavelmente algo como "se o representante de FP da implementação os apoiar". Da mesma forma, existe uma função:

infinity() 

que retorna um rep INF positivo "se disponível".

Ambos estão definidos no <limits>cabeçalho - acho que o padrão C tem algo semelhante (provavelmente também "se disponível"), mas não tenho uma cópia do padrão C99 atual.

Isso funciona para ambos floate double:

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

Edit: Como alguém já disse, o antigo padrão IEEE dizia que tais valores deveriam gerar armadilhas. Mas os novos compiladores quase sempre desligam as armadilhas e retornam os valores fornecidos porque a armadilha interfere no tratamento de erros.

Uma maneira independente do compilador, mas não uma maneira independente do processador de obter estes:

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

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

Isso deve funcionar em qualquer processador que use o formato de ponto flutuante IEEE 754 (o que o x86 faz).

ATUALIZAÇÃO: Testado e atualizado.

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

Também estou surpreso que não sejam constantes de tempo de compilação. Mas suponho que você possa criar esses valores com bastante facilidade simplesmente executando uma instrução que retorne um resultado inválido. Dividindo por 0, log de 0, tan de 90, esse tipo de coisa.

Eu costumo usar

#define INFINITY (1e999)

ou

const double INFINITY = 1e999

que funciona pelo menos em contextos IEEE 754 porque o valor duplo mais alto representável é aproximadamente 1e308. 1e309funcionaria tão bem quanto 1e99999, mas três noves é suficiente e memorável. Uma vez que este é um literal duplo (no #definecaso) ou um Infvalor real , ele permanecerá infinito mesmo se você estiver usando floats de 128 bits (“long double”).

Esta é uma maneira simples de definir essas constantes, e tenho certeza de que é portátil:

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

Quando executo este código:

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

Eu recebo:

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