C'de nan ve inf nasıl kullanılır?

Bir hata olduğunda nan veya inf döndürebilen sayısal bir yöntemim var ve test amaçlı olarak, durumun doğru şekilde işlendiğinden emin olmak için onu geçici olarak nan veya inf döndürmeye zorlamak istiyorum. C'de nan ve inf değerlerini oluşturmanın güvenilir, derleyiciden bağımsız bir yolu var mı?

Yaklaşık 10 dakika boyunca googledikten sonra yalnızca derleyiciye bağlı çözümler bulabildim.

Uygulamanızda bulunup bulunmadığını test edebilirsiniz:

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

Varlığı INFINITYC99 (veya en azından en son taslak) ile garanti edilir ve "eğer mevcutsa pozitif veya işaretsiz sonsuzluğu temsil eden sabit bir float tipi ifadesine; aksi takdirde çeviri zamanında taşan pozitif bir float tipi sabitine genişler."

NAN tanımlanabilir veya tanımlanmayabilir ve "ancak ve ancak uygulama kayan tip için sessiz NaN'leri destekliyorsa tanımlanır. Sessiz bir NaN'yi temsil eden sabit bir kayan nokta türü ifadesine genişler."

Kayan nokta değerlerini karşılaştırıyorsanız ve şunları yapın:

a = NAN;

o zaman bile,

a == NAN;

yanlış. NaN'yi kontrol etmenin bir yolu şudur:

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

Ayrıca şunları da yapabilirsiniz: NaN a != aolup olmadığını test etmek için a.

Orada da isfinite(), isinf(), isnormal()ve signbit()makrolar içinde math.hC99.

C99 ayrıca şu nanişlevlere sahiptir :

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

(Referans: n1256).

Docs INFINITY Docs NAN

Bunu yapmanın derleyiciden bağımsız bir yolu yoktur, çünkü ne C (ne de C ++) standartları kayan noktalı matematik türlerinin NAN veya INF'yi desteklemesi gerektiğini söylemektedir.

Düzenleme: Sadece C ++ standardının ifadesini kontrol ettim ve bu işlevlerin (şablonlu sınıf sayısal_sınırlarının üyeleri):

quiet_NaN() 
signalling_NaN()

"varsa" NAN temsillerini döndürecektir. "Varsa" nın ne anlama geldiğini açıklamıyor, ancak muhtemelen "uygulamanın FP temsilcisi onları destekliyorsa" gibi bir şey. Benzer şekilde, bir işlev var:

infinity() 

bu, "varsa" pozitif bir INF temsilcisi döndürür.

Bunların her ikisi de <limits>başlıkta tanımlanmıştır - C standardının benzer bir şeye sahip olduğunu tahmin ediyorum (muhtemelen "varsa" da), ancak mevcut C99 standardının bir kopyasına sahip değilim.

Bu ikisi için çalışır floatve double:

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

Düzenleme: Birisinin daha önce söylediği gibi, eski IEEE standardı bu tür değerlerin tuzakları yükseltmesi gerektiğini söyledi. Ancak yeni derleyiciler hemen hemen her zaman tuzakları kapatır ve verilen değerleri döndürür çünkü yakalama hata işlemeyi engeller.

Derleyiciden bağımsız bir yol, ancak bunları elde etmenin işlemciden bağımsız bir yolu:

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

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

Bu, IEEE 754 kayan nokta biçimini (x86'nın yaptığı) kullanan herhangi bir işlemci üzerinde çalışmalıdır.

GÜNCELLEME: Test edildi ve güncellendi.

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

ve

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

Bunların derleme zamanı sabitleri olmamasına da şaşırdım. Ancak, böyle geçersiz bir sonuç döndüren bir talimatı uygulayarak bu değerleri kolayca yaratabileceğinizi düşünüyorum. 0'a bölme, log 0, bronzluk 90, bu tür bir şey.

Genellikle kullanırım

#define INFINITY (1e999)

veya

const double INFINITY = 1e999

Bu, en azından IEEE 754 bağlamında çalışır, çünkü gösterilebilir en yüksek çift değer kabaca 1e308. 1e309aynen işe yarayacaktı 1e99999, ancak üç dokuz yeterli ve akılda kalıcı. Bu ya bir çift hazır bilgi ( #definedurumda) ya da gerçek bir Infdeğer olduğundan, 128 bitlik (“uzun çift”) kayan değerler kullansanız bile sonsuz kalacaktır.

İşte bu sabitleri tanımlamanın basit bir yolu ve taşınabilir olduğundan oldukça eminim:

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

Bu kodu çalıştırdığımda:

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

Alırım:

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