Wie benutzt man nan und inf in C?

Ich habe eine numerische Methode, die nan oder inf zurückgeben kann, wenn ein Fehler aufgetreten ist, und zu Testzwecken möchte ich sie vorübergehend zwingen, nan oder inf zurückzugeben, um sicherzustellen, dass die Situation korrekt behandelt wird. Gibt es eine zuverlässige, compilerunabhängige Möglichkeit, Werte für nan und inf in C zu erstellen?

Nachdem ich ungefähr 10 Minuten gegoogelt habe, konnte ich nur compilerabhängige Lösungen finden.

Sie können testen, ob Ihre Implementierung es hat:

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

Die Existenz von INFINITYwird durch C99 (oder zumindest den neuesten Entwurf) garantiert und "erweitert sich zu einem konstanten Ausdruck des Typs float, der eine positive oder vorzeichenlose Unendlichkeit darstellt, falls verfügbar; andernfalls zu einer positiven Konstante des Typs float, die zur Übersetzungszeit überläuft."

NAN kann definiert werden oder nicht, und "wird genau dann definiert, wenn die Implementierung leise NaNs für den Float-Typ unterstützt. Sie wird zu einem konstanten Ausdruck des Typs float erweitert, der ein leises NaN darstellt."

Beachten Sie Folgendes, wenn Sie Gleitkommawerte vergleichen, und gehen Sie wie folgt vor:

a = NAN;

sogar dann,

a == NAN;

ist falsch. Eine Möglichkeit, nach NaN zu suchen, wäre:

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

Sie können auch Folgendes tun: um a != azu testen, ob aNaN vorhanden ist.

Es gibt auch isfinite(), isinf(), isnormal(), und signbit()Makros in math.hin C99.

C99 hat auch nanFunktionen:

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

(Referenz: n1256).

Docs INFINITY Docs NAN

Es gibt keine vom Compiler unabhängige Methode, da weder die C- (noch die C ++) Standards besagen, dass die Gleitkomma-Mathe-Typen NAN oder INF unterstützen müssen.

Bearbeiten: Ich habe gerade den Wortlaut des C ++ - Standards überprüft und es heißt, dass diese Funktionen (Mitglieder der Vorlagenklasse numeric_limits):

quiet_NaN() 
signalling_NaN()

Wir werden NAN-Darstellungen "falls verfügbar" zurückgeben. Es wird nicht erweitert, was "falls verfügbar" bedeutet, sondern vermutlich "wenn der FP-Vertreter der Implementierung sie unterstützt". Ebenso gibt es eine Funktion:

infinity() 

Dies gibt einen positiven INF-Repräsentanten "falls verfügbar" zurück.

Diese sind beide in der <limits>Kopfzeile definiert - ich würde vermuten, dass der C-Standard etwas Ähnliches hat (wahrscheinlich auch "falls verfügbar"), aber ich habe keine Kopie des aktuellen C99-Standards.

Dies funktioniert für beide floatund double:

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

Bearbeiten: Wie jemand bereits sagte, sagte der alte IEEE-Standard, dass solche Werte Fallen auslösen sollten. Die neuen Compiler schalten jedoch fast immer die Traps aus und geben die angegebenen Werte zurück, da das Trapping die Fehlerbehandlung beeinträchtigt.

Ein compilerunabhängiger Weg, aber kein prozessorunabhängiger Weg, um diese zu erhalten:

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

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

Dies sollte auf jedem Prozessor funktionieren, der das Gleitkommaformat IEEE 754 verwendet (was x86 tut).

UPDATE: Getestet und aktualisiert.

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

und

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

Ich bin auch überrascht, dass dies keine Kompilierungszeitkonstanten sind. Aber ich nehme an, Sie könnten diese Werte leicht genug erstellen, indem Sie einfach eine Anweisung ausführen, die ein solches ungültiges Ergebnis zurückgibt. Teilen durch 0, log von 0, tan von 90, so etwas.

Ich benutze normalerweise

#define INFINITY (1e999)

oder

const double INFINITY = 1e999

Dies funktioniert zumindest in IEEE 754-Kontexten, da der höchste darstellbare Doppelwert ungefähr ist 1e308. 1e309würde genauso gut funktionieren wie würde 1e99999, aber drei Neunen sind ausreichend und unvergesslich. Da dies entweder ein Doppelliteral (im #defineFall) oder ein tatsächlicher InfWert ist, bleibt es unendlich, selbst wenn Sie 128-Bit-Floats („Long Double“) verwenden.

Hier ist eine einfache Möglichkeit, diese Konstanten zu definieren, und ich bin mir ziemlich sicher, dass sie portabel sind:

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

Wenn ich diesen Code ausführe:

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

Ich bekomme:

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