mingw_math.h File Reference

Go to the source code of this file.

Macros
#define	HUGE_VALF   __INFF
#define	HUGE_VALL   __INFL
#define	INFINITY   HUGE_VALF
#define	NAN   __QNAN
#define	FP_NAN   0x0100
#define	FP_NORMAL   0x0400
#define	FP_INFINITE   (FP_NAN | FP_NORMAL)
#define	FP_ZERO   0x4000
#define	FP_SUBNORMAL   (FP_NORMAL | FP_ZERO)
#define	fpclassify(x)
#define	isfinite(x)   ((fpclassify(x) & FP_NAN) == 0)
#define	isinf(x)   (fpclassify(x) == FP_INFINITE)
#define	isnan(x)
#define	isnormal(x)   (fpclassify(x) == FP_NORMAL)
#define	signbit(x)
#define	FP_ILOGB0   ((int)0x80000000)
#define	FP_ILOGBNAN   ((int)0x80000000)
#define	_nan()   nan("")
#define	_nanf()   nanf("")
#define	_nanl()   nanl("")
#define	isgreater(x, y)   ((__fp_unordered_compare(x, y) & 0x4500) == 0)
#define	isless(x, y)   ((__fp_unordered_compare (y, x) & 0x4500) == 0)
#define	isgreaterequal(x, y)   ((__fp_unordered_compare (x, y) & FP_INFINITE) == 0)
#define	islessequal(x, y)   ((__fp_unordered_compare(y, x) & FP_INFINITE) == 0)
#define	islessgreater(x, y)   ((__fp_unordered_compare(x, y) & FP_SUBNORMAL) == 0)
#define	isunordered(x, y)   ((__fp_unordered_compare(x, y) & 0x4500) == 0x4500)

Typedefs
typedef long double	float_t
typedef long double	double_t

Functions
int __cdecl	__fpclassifyl (long double)
int __cdecl	__fpclassifyf (float)
int __cdecl	__fpclassify (double)
int __cdecl	__isnan (double)
int __cdecl	__isnanf (float)
int __cdecl	__isnanl (long double)
int __cdecl	__signbit (double)
int __cdecl	__signbitf (float)
int __cdecl	__signbitl (long double)
double __cdecl	acosh (double)
float __cdecl	acoshf (float)
long double __cdecl	acoshl (long double)
double __cdecl	asinh (double)
float __cdecl	asinhf (float)
long double __cdecl	asinhl (long double)
double __cdecl	atanh (double)
float __cdecl	atanhf (float)
long double __cdecl	atanhl (long double)
double __cdecl	exp2 (double)
float __cdecl	exp2f (float)
long double __cdecl	exp2l (long double)
double __cdecl	expm1 (double)
float __cdecl	expm1f (float)
long double __cdecl	expm1l (long double)
int __cdecl	ilogb (double)
int __cdecl	ilogbf (float)
int __cdecl	ilogbl (long double)
double __cdecl	log1p (double)
float __cdecl	log1pf (float)
long double __cdecl	log1pl (long double)
double __cdecl	log2 (double)
float __cdecl	log2f (float)
long double __cdecl	log2l (long double)
double __cdecl	logb (double)
float __cdecl	logbf (float)
long double __cdecl	logbl (long double)
double __cdecl	scalbn (double, int)
float __cdecl	scalbnf (float, int)
long double __cdecl	scalbnl (long double, int)
double __cdecl	scalbln (double, long)
float __cdecl	scalblnf (float, long)
long double __cdecl	scalblnl (long double, long)
double __cdecl	cbrt (double)
float __cdecl	cbrtf (float)
long double __cdecl	cbrtl (long double)
double __cdecl	erf (double)
float __cdecl	erff (float)
long double __cdecl	erfl (long double)
double __cdecl	erfc (double)
float __cdecl	erfcf (float)
long double __cdecl	erfcl (long double)
double __cdecl	lgamma (double)
float __cdecl	lgammaf (float)
long double __cdecl	lgammal (long double)
double __cdecl	tgamma (double)
float __cdecl	tgammaf (float)
long double __cdecl	tgammal (long double)
double __cdecl	nearbyint (double)
float __cdecl	nearbyintf (float)
long double __cdecl	nearbyintl (long double)
double __cdecl	rint (double)
float __cdecl	rintf (float)
long double __cdecl	rintl (long double)
long __cdecl	lrint (double)
long __cdecl	lrintf (float)
long __cdecl	lrintl (long double)
__MINGW_EXTENSION long long __cdecl	llrint (double)
__MINGW_EXTENSION long long __cdecl	llrintf (float)
__MINGW_EXTENSION long long __cdecl	llrintl (long double)
double __cdecl	round (double)
float __cdecl	roundf (float)
long double __cdecl	roundl (long double)
long __cdecl	lround (double)
long __cdecl	lroundf (float)
long __cdecl	lroundl (long double)
__MINGW_EXTENSION long long __cdecl	llround (double)
__MINGW_EXTENSION long long __cdecl	llroundf (float)
__MINGW_EXTENSION long long __cdecl	llroundl (long double)
double __cdecl	trunc (double)
float __cdecl	truncf (float)
long double __cdecl	truncl (long double)
double __cdecl	remainder (double, double)
float __cdecl	remainderf (float, float)
long double __cdecl	remainderl (long double, long double)
double __cdecl	remquo (double, double, int *)
float __cdecl	remquof (float, float, int *)
long double __cdecl	remquol (long double, long double, int *)
double __cdecl	copysign (double, double)
float __cdecl	copysignf (float, float)
long double __cdecl	copysignl (long double, long double)
double __cdecl	nan (const char *tagp)
float __cdecl	nanf (const char *tagp)
long double __cdecl	nanl (const char *tagp)
double __cdecl	nextafter (double, double)
float __cdecl	nextafterf (float, float)
long double __cdecl	nextafterl (long double, long double)
double __cdecl	nexttoward (double, long double)
float __cdecl	nexttowardf (float, long double)
long double __cdecl	nexttowardl (long double, long double)
double __cdecl	fdim (double x, double y)
float __cdecl	fdimf (float x, float y)
long double __cdecl	fdiml (long double x, long double y)
double __cdecl	fmax (double, double)
float __cdecl	fmaxf (float, float)
long double __cdecl	fmaxl (long double, long double)
double __cdecl	fmin (double, double)
float __cdecl	fminf (float, float)
long double __cdecl	fminl (long double, long double)
double __cdecl	fma (double, double, double)
float __cdecl	fmaf (float, float, float)
long double __cdecl	fmal (long double, long double, long double)
__CRT_INLINE int __cdecl	__fp_unordered_compare (long double x, long double y)

Variables
const float	__INFF
const long double	__INFL
const double	__QNAN

Macro Definition Documentation

_nan

#define _nan

(

)

nan("")

Definition at line 465 of file mingw_math.h.

_nanf

#define _nanf

(

)

nanf("")

Definition at line 466 of file mingw_math.h.

_nanl

#define _nanl

(

)

nanl("")

Definition at line 467 of file mingw_math.h.

FP_ILOGB0

#define FP_ILOGB0   ((int)0x80000000)

Definition at line 209 of file mingw_math.h.

FP_ILOGBNAN

#define FP_ILOGBNAN   ((int)0x80000000)

Definition at line 210 of file mingw_math.h.

FP_INFINITE

#define FP_INFINITE   (FP_NAN | FP_NORMAL)

Definition at line 52 of file mingw_math.h.

FP_NAN

#define FP_NAN   0x0100

Definition at line 50 of file mingw_math.h.

FP_NORMAL

#define FP_NORMAL   0x0400

Definition at line 51 of file mingw_math.h.

FP_SUBNORMAL

#define FP_SUBNORMAL   (FP_NORMAL | FP_ZERO)

Definition at line 54 of file mingw_math.h.

FP_ZERO

#define FP_ZERO   0x4000

Definition at line 53 of file mingw_math.h.

fpclassify

#define fpclassify

(

x

)

Value:

  (sizeof (x) == sizeof (float) ? __fpclassifyf (x)   \
  : sizeof (x) == sizeof (double) ? __fpclassify (x) \
  : __fpclassifyl (x))

Definition at line 86 of file mingw_math.h.

HUGE_VALF

#define HUGE_VALF   __INFF

Definition at line 17 of file mingw_math.h.

HUGE_VALL

#define HUGE_VALL   __INFL

Definition at line 19 of file mingw_math.h.

INFINITY

#define INFINITY   HUGE_VALF

Definition at line 20 of file mingw_math.h.

isfinite

#define isfinite

(

x

)

((fpclassify(x) & FP_NAN) == 0)

Definition at line 91 of file mingw_math.h.

isgreater

#define isgreater	(		x,
			y
	)		((__fp_unordered_compare(x, y) & 0x4500) == 0)

Definition at line 537 of file mingw_math.h.

isgreaterequal

#define isgreaterequal	(		x,
			y
	)		((__fp_unordered_compare (x, y) & FP_INFINITE) == 0)

Definition at line 539 of file mingw_math.h.

isinf

#define isinf

(

x

)

(fpclassify(x) == FP_INFINITE)

Definition at line 94 of file mingw_math.h.

isless

#define isless	(		x,
			y
	)		((__fp_unordered_compare (y, x) & 0x4500) == 0)

Definition at line 538 of file mingw_math.h.

islessequal

#define islessequal	(		x,
			y
	)		((__fp_unordered_compare(y, x) & FP_INFINITE) == 0)

Definition at line 540 of file mingw_math.h.

islessgreater

#define islessgreater	(		x,
			y
	)		((__fp_unordered_compare(x, y) & FP_SUBNORMAL) == 0)

Definition at line 541 of file mingw_math.h.

isnan

#define isnan

(

x

)

Value:

  (sizeof (x) == sizeof (float) ? __isnanf (x)  \
  : sizeof (x) == sizeof (double) ? __isnan (x) \
  : __isnanl (x))

Definition at line 133 of file mingw_math.h.

isnormal

#define isnormal

(

x

)

(fpclassify(x) == FP_NORMAL)

Definition at line 138 of file mingw_math.h.

isunordered

#define isunordered	(		x,
			y
	)		((__fp_unordered_compare(x, y) & 0x4500) == 0x4500)

Definition at line 542 of file mingw_math.h.

NAN

#define NAN   __QNAN

Definition at line 22 of file mingw_math.h.

signbit

#define signbit

(

x

)

Value:

  (sizeof (x) == sizeof (float) ? __signbitf (x)    \
  : sizeof (x) == sizeof (double) ? __signbit (x)   \
  : __signbitl (x))

Definition at line 164 of file mingw_math.h.

Typedef Documentation

double_t

typedef long double double_t

Definition at line 40 of file mingw_math.h.

float_t

typedef long double float_t

Definition at line 39 of file mingw_math.h.

Function Documentation

__fp_unordered_compare()

__CRT_INLINE int __cdecl __fp_unordered_compare	(	long double	x,
		long double	y
	)

Definition at line 529 of file mingw_math.h.

                                                         {
      unsigned short retval;
      __asm__ __volatile__ ("fucom %%st(1);"
    "fnstsw;": "=a" (retval) : "t" (x), "u" (y));
      return retval;
  }

__fpclassify()

__CRT_INLINE int __cdecl __fpclassify

(

double

x

)

Definition at line 74 of file mingw_math.h.

                                                   {
    unsigned short sw;
    __asm__ __volatile__ ("fxam; fstsw %%ax;" : "=a" (sw): "t" (x));
    return sw & (FP_NAN | FP_NORMAL | FP_ZERO );
  }

__fpclassifyf()

__CRT_INLINE int __cdecl __fpclassifyf

(

float

x

)

Definition at line 79 of file mingw_math.h.

                                                   {
    unsigned short sw;
    __asm__ __volatile__ ("fxam; fstsw %%ax;" : "=a" (sw): "t" (x));
    return sw & (FP_NAN | FP_NORMAL | FP_ZERO );
  }

__fpclassifyl()

__CRT_INLINE int __cdecl __fpclassifyl

(

long double

x

)

Definition at line 69 of file mingw_math.h.

                                                         {
    unsigned short sw;
    __asm__ __volatile__ ("fxam; fstsw %%ax;" : "=a" (sw): "t" (x));
    return sw & (FP_NAN | FP_NORMAL | FP_ZERO );
  }

__isnan()

__CRT_INLINE int __cdecl __isnan

(

double

_x

)

Definition at line 105 of file mingw_math.h.

  {
    unsigned short sw;
    __asm__ __volatile__ ("fxam;"
      "fstsw %%ax": "=a" (sw) : "t" (_x));
    return (sw & (FP_NAN | FP_NORMAL | FP_INFINITE | FP_ZERO | FP_SUBNORMAL))
      == FP_NAN;
  }

__isnanf()

__CRT_INLINE int __cdecl __isnanf

(

float

_x

)

Definition at line 114 of file mingw_math.h.

  {
    unsigned short sw;
    __asm__ __volatile__ ("fxam;"
      "fstsw %%ax": "=a" (sw) : "t" (_x));
    return (sw & (FP_NAN | FP_NORMAL | FP_INFINITE | FP_ZERO | FP_SUBNORMAL))
      == FP_NAN;
  }

__isnanl()

__CRT_INLINE int __cdecl __isnanl

(

long double

_x

)

Definition at line 123 of file mingw_math.h.

  {
    unsigned short sw;
    __asm__ __volatile__ ("fxam;"
      "fstsw %%ax": "=a" (sw) : "t" (_x));
    return (sw & (FP_NAN | FP_NORMAL | FP_INFINITE | FP_ZERO | FP_SUBNORMAL))
      == FP_NAN;
  }

__signbit()

__CRT_INLINE int __cdecl __signbit

(

double

x

)

Definition at line 145 of file mingw_math.h.

                                                {
    unsigned short stw;
    __asm__ __volatile__ ( "fxam; fstsw %%ax;": "=a" (stw) : "t" (x));
    return stw & 0x0200;
  }

__signbitf()

__CRT_INLINE int __cdecl __signbitf

(

float

x

)

Definition at line 151 of file mingw_math.h.

                                                {
    unsigned short stw;
    __asm__ __volatile__ ("fxam; fstsw %%ax;": "=a" (stw) : "t" (x));
    return stw & 0x0200;
  }

__signbitl()

__CRT_INLINE int __cdecl __signbitl

(

long double

x

)

Definition at line 157 of file mingw_math.h.

                                                      {
    unsigned short stw;
    __asm__ __volatile__ ("fxam; fstsw %%ax;": "=a" (stw) : "t" (x));
    return stw & 0x0200;
  }

acosh()

double __cdecl acosh

(

double

x

)

Definition at line 54 of file fun_ieee.c.

{
    // must be x>=1, if not return Nan (Not a Number)
    if(!(x>=1.0)) return sqrt(-1.0);
 
    // return only the positive result (as sqrt does).
    return log(x+sqrt(x*x-1.0));
}

Referenced by rpn_acosh().

acoshf()

float __cdecl acoshf

(

float

)

acoshl()

long double __cdecl acoshl

(

long double

)

asinh()

double __cdecl asinh

(

double

x

)

Definition at line 49 of file fun_ieee.c.

{
    return log(x+sqrt(x*x+1));
}

Referenced by rpn_asinh().

asinhf()

float __cdecl asinhf

(

float

)

asinhl()

long double __cdecl asinhl

(

long double

)

atanh()

double __cdecl atanh

(

double

x

)

Definition at line 63 of file fun_ieee.c.

{
    // must be x>-1, x<1, if not return Nan (Not a Number)
    if(!(x>-1.0 && x<1.0)) return sqrt(-1.0);
 
    return log((1.0+x)/(1.0-x))/2.0;
}

Referenced by rpn_atanh().

atanhf()

float __cdecl atanhf

(

float

)

atanhl()

long double __cdecl atanhl

(

long double

)

cbrt()

double __cdecl cbrt

(

double

)

Referenced by rpn_cbrt().

cbrtf()

float __cdecl cbrtf

(

float

)

cbrtl()

long double __cdecl cbrtl

(

long double

)

copysign()

double __cdecl copysign	(	double	,
		double
	)

copysignf()

float __cdecl copysignf	(	float	,
		float
	)

Referenced by float_32_to_16(), and wined3d_ftoa().

copysignl()

long double __cdecl copysignl	(	long double	,
		long double
	)

erf()

double __cdecl erf

(

double

)

Referenced by create_cab_file(), create_cc_test_files(), extract_cabinet(), extract_cabinet_stream(), ExtractCabinet(), GdipSetLineSigmaBlend(), GdipSetPathGradientSigmaBlend(), HResultFrom(), Init(), SetupIterateCabinetA(), SetupIterateCabinetW(), test_FDICopy(), test_FDICreate(), test_FDIDestroy(), and test_FDIIsCabinet().

erfc()

double __cdecl erfc

(

double

)

erfcf()

float __cdecl erfcf

(

float

)

erfcl()

long double __cdecl erfcl

(

long double

)

erff()

float __cdecl erff

(

float

)

erfl()

long double __cdecl erfl

(

long double

)

exp2()

double __cdecl exp2

(

double

x

)

Definition at line 47 of file exp2.c.

{
  static const double
    max_exp2_arg = 1024.0,  /* 0x4090000000000000 */
    min_exp2_arg = -1074.0, /* 0xc090c80000000000 */
    log2 = 6.931471805599453094178e-01, /* 0x3fe62e42fefa39ef */
    log2_lead = 6.93147167563438415527E-01, /* 0x3fe62e42f8000000 */
    log2_tail = 1.29965068938898869640E-08, /* 0x3e4be8e7bcd5e4f1 */
    one_by_32_lead = 0.03125;
 
  double y, z1, z2, z, hx, tx, y1, y2;
  int m;
  unsigned long long ux, ax;
 
  /*
    Computation of exp2(x).
 
    We compute the values m, z1, and z2 such that
    exp2(x) = 2**m * (z1 + z2),  where exp2(x) is 2**x.
 
    Computations needed in order to obtain m, z1, and z2
    involve three steps.
 
    First, we reduce the argument x to the form
    x = n/32 + remainder,
    where n has the value of an integer and |remainder| <= 1/64.
    The value of n = x * 32 rounded to the nearest integer and
    the remainder = x - n/32.
 
    Second, we approximate exp2(r1 + r2) - 1 where r1 is the leading
    part of the remainder and r2 is the trailing part of the remainder.
 
    Third, we reconstruct exp2(x) so that
    exp2(x) = 2**m * (z1 + z2).
  */
 
 
  GET_BITS_DP64(x, ux);
  ax = ux & (~SIGNBIT_DP64);
 
  if (ax >= 0x4090000000000000) /* abs(x) >= 1024.0 */
    {
      if(ax >= 0x7ff0000000000000)
        {
          /* x is either NaN or infinity */
          if (ux & MANTBITS_DP64)
            /* x is NaN */
            return _handle_error("exp2", OP_EXP, ux|0x0008000000000000, _DOMAIN,
                                0, EDOM, x, 0.0, 1);
          else if (ux & SIGNBIT_DP64)
            /* x is negative infinity; return 0.0 with no flags. */
            return 0.0;
          else
            /* x is positive infinity */
            return x;
        }
      if (x > max_exp2_arg)
        /* Return +infinity with overflow flag */
        return _handle_error("exp2", OP_EXP, PINFBITPATT_DP64, _OVERFLOW,
                            AMD_F_OVERFLOW | AMD_F_INEXACT, ERANGE, x, 0.0, 1);
      else if (x < min_exp2_arg)
        /* x is negative. Return +zero with underflow and inexact flags */
        return _handle_error("exp2", OP_EXP, 0, _UNDERFLOW,
                            AMD_F_UNDERFLOW | AMD_F_INEXACT, ERANGE, x, 0.0, 1);
    }
 
 
  /* Handle small arguments separately */
  if (ax < 0x3fb7154764ee6c2f)   /* abs(x) < 1/(16*log2) */
    {
      if (ax < 0x3c00000000000000)   /* abs(x) < 2^(-63) */
        return 1.0 + x; /* Raises inexact if x is non-zero */
      else
        {
          /* Split x into hx (head) and tx (tail). */
          unsigned long long u;
          hx = x;
          GET_BITS_DP64(hx, u);
          u &= 0xfffffffff8000000;
          PUT_BITS_DP64(u, hx);
          tx = x - hx;
          /* Carefully multiply x by log2. y1 is the most significant
             part of the result, and y2 the least significant part */
          y1 = x * log2_lead;
          y2 = (((hx * log2_lead - y1) + hx * log2_tail) +
                  tx * log2_lead) + tx * log2_tail;
 
          y = y1 + y2;
        z = (9.99564649780173690e-1 +
             (1.61251249355268050e-5 +
              (2.37986978239838493e-2 +
                2.68724774856111190e-7*y)*y)*y)/
            (9.99564649780173692e-1 +
             (-4.99766199765151309e-1 +
              (1.070876894098586184e-1 +
               (-1.189773642681502232e-2 +
             5.9480622371960190616e-4*y)*y)*y)*y);
          z = ((z * y1) + (z * y2)) + 1.0;
        }
    }
  else
    {
      /* Find m, z1 and z2 such that exp2(x) = 2**m * (z1 + z2) */
 
      splitexp(x, log2, 32.0, one_by_32_lead, 0.0, &m, &z1, &z2);
 
      /* Scale (z1 + z2) by 2.0**m */
      if (m > EMIN_DP64 && m < EMAX_DP64)
    z = scaleDouble_1((z1+z2),m);
      else
    z = scaleDouble_2((z1+z2),m);
    }
  return z;
}

Referenced by Test_ofuncs(), and test_SystemFunction003().

exp2f()

float __cdecl exp2f

(

float

)

exp2l()

long double __cdecl exp2l

(

long double

)

expm1()

double __cdecl expm1

(

double

)

expm1f()

float __cdecl expm1f

(

float

)

expm1l()

long double __cdecl expm1l

(

long double

)

fdim()

double __cdecl fdim	(	double	x,
		double	y
	)

fdimf()

float __cdecl fdimf	(	float	x,
		float	y
	)

fdiml()

long double __cdecl fdiml	(	long double	x,
		long double	y
	)

fma()

double __cdecl fma	(	double	x,
		double	y,
		double	z
	)

Definition at line 50 of file stubs.c.

{
    // Simplistic implementation
    return (x * y) + z;
}

fmaf()

float __cdecl fmaf	(	float	x,
		float	y,
		float	z
	)

Definition at line 56 of file stubs.c.

{
    // Simplistic implementation
    return (x * y) + z;
}

fmal()

long double __cdecl fmal	(	long double	,
		long double	,
		long double
	)

fmax()

double __cdecl fmax	(	double	,
		double
	)

fmaxf()

float __cdecl fmaxf	(	float	,
		float
	)

fmaxl()

long double __cdecl fmaxl	(	long double	,
		long double
	)

fmin()

double __cdecl fmin	(	double	,
		double
	)

Referenced by GetMaxValue(), pres_min(), and test_DuplicateHandle().

fminf()

float __cdecl fminf	(	float	,
		float
	)

fminl()

long double __cdecl fminl	(	long double	,
		long double
	)

ilogb()

int __cdecl ilogb

(

double

)

ilogbf()

int __cdecl ilogbf

(

float

)

ilogbl()

int __cdecl ilogbl

(

long double

)

lgamma()

double __cdecl lgamma

(

double

)

lgammaf()

float __cdecl lgammaf

(

float

)

lgammal()

long double __cdecl lgammal

(

long double

)

llrint()

__MINGW_EXTENSION __CRT_INLINE long long __cdecl llrint

(

double

x

)

Definition at line 395 of file mingw_math.h.

  {
    __MINGW_EXTENSION long long retval = 0ll;
    __asm__ __volatile__                                  \
      ("fistpll %0"  : "=m" (retval) : "t" (x) : "st");                   \
      return retval;
  }

llrintf()

__MINGW_EXTENSION __CRT_INLINE long long __cdecl llrintf

(

float

x

)

Definition at line 403 of file mingw_math.h.

  {
    __MINGW_EXTENSION long long retval = 0ll;
    __asm__ __volatile__                                  \
      ("fistpll %0"  : "=m" (retval) : "t" (x) : "st");                   \
      return retval;
  }

llrintl()

__MINGW_EXTENSION __CRT_INLINE long long __cdecl llrintl

(

long double

x

)

Definition at line 411 of file mingw_math.h.

  {
    __MINGW_EXTENSION long long retval = 0ll;
    __asm__ __volatile__                                  \
      ("fistpll %0"  : "=m" (retval) : "t" (x) : "st");                   \
      return retval;
  }

llround()

__MINGW_EXTENSION long long __cdecl llround

(

double

)

llroundf()

__MINGW_EXTENSION long long __cdecl llroundf

(

float

)

llroundl()

__MINGW_EXTENSION long long __cdecl llroundl

(

long double

)

log1p()

double __cdecl log1p

(

double

)

log1pf()

float __cdecl log1pf

(

float

)

log1pl()

long double __cdecl log1pl

(

long double

)

log2()

double __cdecl log2

(

double

x

)

Definition at line 62 of file stubs.c.

{
    // Simplistic implementation: log2(x) = log(x) / log(2)
    return log(x) * M_LOG2E;
}

Referenced by exp2(), log2f(), logbase2(), and pres_log().

log2f()

float __cdecl log2f

(

float

x

)

Definition at line 68 of file stubs.c.

{
    return (float)log2((double)x);
}

log2l()

long double __cdecl log2l

(

long double

)

logb()

__CRT_INLINE double __cdecl logb

(

double

x

)

Definition at line 243 of file mingw_math.h.

  {
    double res = 0.0;
    __asm__ __volatile__ ("fxtract\n\t"
      "fstp %%st" : "=t" (res) : "0" (x));
    return res;
  }

logbf()

__CRT_INLINE float __cdecl logbf

(

float

x

)

Definition at line 251 of file mingw_math.h.

  {
    float res = 0.0F;
    __asm__ __volatile__ ("fxtract\n\t"
      "fstp %%st" : "=t" (res) : "0" (x));
    return res;
  }

logbl()

__CRT_INLINE long double __cdecl logbl

(

long double

x

)

Definition at line 259 of file mingw_math.h.

  {
    long double res = 0.0l;
    __asm__ __volatile__ ("fxtract\n\t"
      "fstp %%st" : "=t" (res) : "0" (x));
    return res;
  }

lrint()

long __cdecl lrint

(

double

x

)

Definition at line 371 of file mingw_math.h.

  {
    long retval = 0;
    __asm__ __volatile__                                  \
      ("fistpl %0"  : "=m" (retval) : "t" (x) : "st");                    \
      return retval;
  }

lrintf()

long __cdecl lrintf

(

float

x

)

Definition at line 379 of file mingw_math.h.

  {
    long retval = 0;
    __asm__ __volatile__                                  \
      ("fistpl %0"  : "=m" (retval) : "t" (x) : "st");                    \
      return retval;
  }

lrintl()

__CRT_INLINE long __cdecl lrintl

(

long double

x

)

Definition at line 387 of file mingw_math.h.

  {
    long retval = 0;
    __asm__ __volatile__                                  \
      ("fistpl %0"  : "=m" (retval) : "t" (x) : "st");                    \
      return retval;
  }

lround()

long __cdecl lround

(

double

)

lroundf()

long __cdecl lroundf

(

float

)

lroundl()

long __cdecl lroundl

(

long double

)

nan()

double __cdecl nan

(

const char *

tagp

)

Referenced by DriveVolume::ObtainInfo(), and trio_nan().

nanf()

float __cdecl nanf

(

const char *

tagp

)

nanl()

long double __cdecl nanl

(

const char *

tagp

)

nearbyint()

double __cdecl nearbyint

(

double

)

nearbyintf()

float __cdecl nearbyintf

(

float

)

nearbyintl()

long double __cdecl nearbyintl

(

long double

)

nextafter()

double __cdecl nextafter	(	double	x,
		double	y
	)

Definition at line 13 of file nextafter.c.

{
    union {double f; uint64_t i;} ux={x}, uy={y};
    uint64_t ax, ay;
    int e;
 
    if (isnan(x) || isnan(y))
        return x + y;
    if (ux.i == uy.i)
        return y;
    ax = ux.i & ~0ULL/2;
    ay = uy.i & ~0ULL/2;
    if (ax == 0) {
        if (ay == 0)
            return y;
        ux.i = (uy.i & 1ULL<<63) | 1;
    } else if (ax > ay || ((ux.i ^ uy.i) & 1ULL<<63))
        ux.i--;
    else
        ux.i++;
    e = ux.i >> 52 & 0x7ff;
    /* raise overflow if ux.f is infinite and x is finite */
    if (e == 0x7ff)
        FORCE_EVAL(x+x);
    /* raise underflow if ux.f is subnormal or zero */
    if (e == 0)
        FORCE_EVAL(x*x + ux.f*ux.f);
    return ux.f;
}

nextafterf()

float __cdecl nextafterf	(	float	x,
		float	y
	)

Definition at line 13 of file nextafterf.c.

{
    union {float f; uint32_t i;} ux={x}, uy={y};
    uint32_t ax, ay, e;
 
    if (isnanf(x) || isnanf(y))
        return x + y;
    if (ux.i == uy.i)
        return y;
    ax = ux.i & 0x7fffffff;
    ay = uy.i & 0x7fffffff;
    if (ax == 0) {
        if (ay == 0)
            return y;
        ux.i = (uy.i & 0x80000000) | 1;
    } else if (ax > ay || ((ux.i ^ uy.i) & 0x80000000))
        ux.i--;
    else
        ux.i++;
    e = ux.i & 0x7f800000;
    /* raise overflow if ux.f is infinite and x is finite */
    if (e == 0x7f800000)
        FORCE_EVAL(x+x);
    /* raise underflow if ux.f is subnormal or zero */
    if (e == 0)
        FORCE_EVAL(x*x + ux.f*ux.f);
    return ux.f;
}

nextafterl()

long double __cdecl nextafterl	(	long double	,
		long double
	)

nexttoward()

double __cdecl nexttoward	(	double	,
		long double
	)

nexttowardf()

float __cdecl nexttowardf	(	float	x,
		long double	y
	)

Definition at line 12 of file nexttowardf.c.

{
    union {float f; uint32_t i;} ux = {x};
    uint32_t e;
 
    if (_isnan(x) || _isnan(y))
        return x + y;
    if (x == y)
        return y;
    if (x == 0) {
        ux.i = 1;
        if (signbit(y))
            ux.i |= 0x80000000;
    } else if (x < y) {
        if (signbit(x))
            ux.i--;
        else
            ux.i++;
    } else {
        if (signbit(x))
            ux.i++;
        else
            ux.i--;
    }
    e = ux.i & 0x7f800000;
    /* raise overflow if ux.f is infinite and x is finite */
    if (e == 0x7f800000)
        FORCE_EVAL(x+x);
    /* raise underflow if ux.f is subnormal or zero */
    if (e == 0)
        FORCE_EVAL(x*x + ux.f*ux.f);
    return ux.f;
}

nexttowardl()

long double __cdecl nexttowardl	(	long double	,
		long double
	)

remainder()

double __cdecl remainder	(	double	x,
		double	y
	)

Definition at line 75 of file remainder.c.

{
  double dx, dy, scale, w, t, v, c, cc;
  int i, ntimes, xexp, yexp;
  unsigned long long u, ux, uy, ax, ay, todd;
  unsigned int sw;
 
  dx = x;
  dy = y;
 
 
  GET_BITS_DP64(dx, ux);
  GET_BITS_DP64(dy, uy);
  ax = ux & ~SIGNBIT_DP64;
  ay = uy & ~SIGNBIT_DP64;
  xexp = (int)((ux & EXPBITS_DP64) >> EXPSHIFTBITS_DP64);
  yexp = (int)((uy & EXPBITS_DP64) >> EXPSHIFTBITS_DP64);
 
  if (xexp < 1 || xexp > BIASEDEMAX_DP64 ||
      yexp < 1 || yexp > BIASEDEMAX_DP64)
    {
      /* x or y is zero, denormalized, NaN or infinity */
      if (xexp > BIASEDEMAX_DP64)
        {
          /* x is NaN or infinity */
          if (ux & MANTBITS_DP64)
            {
              /* x is NaN */
              return _handle_error(_FUNCNAME, _OPERATION, ux|0x0008000000000000, _DOMAIN, 0,
                                  EDOM, x, y, 2);
            }
          else
            {
              /* x is infinity; result is NaN */
              return _handle_error(_FUNCNAME, _OPERATION, INDEFBITPATT_DP64, _DOMAIN,
                                  AMD_F_INVALID, EDOM, x, y, 2);
            }
        }
      else if (yexp > BIASEDEMAX_DP64)
        {
          /* y is NaN or infinity */
          if (uy & MANTBITS_DP64)
            {
              /* y is NaN */
              return _handle_error(_FUNCNAME, _OPERATION, uy|0x0008000000000000, _DOMAIN, 0,
                                  EDOM, x, y, 2);
            }
          else
            {
#ifdef _CRTBLD_C9X
              /* C99 return for y = +-inf is x */
              return x;
#else
              /* y is infinity; result is indefinite */
              return _handle_error(_FUNCNAME, _OPERATION, INDEFBITPATT_DP64, _DOMAIN,
                                  AMD_F_INVALID, EDOM, x, y, 2);
#endif
            }
        }
      else if (ax == 0x0000000000000000)
        {
          /* x is zero */
          if (ay == 0x0000000000000000)
            {
              /* y is zero */
              return _handle_error(_FUNCNAME, _OPERATION, INDEFBITPATT_DP64, _DOMAIN,
                                  AMD_F_INVALID, EDOM, x, y, 2);
            }
          else
            /* C99 return for x = 0 must preserve sign */
            return x;
        }
      else if (ay == 0x0000000000000000)
        {
          /* y is zero */
          return _handle_error(_FUNCNAME, _OPERATION, INDEFBITPATT_DP64, _DOMAIN,
                              AMD_F_INVALID, EDOM, x, y, 2);
        }
 
      /* We've exhausted all other possibilities. One or both of x and
         y must be denormalized */
      if (xexp < 1)
        {
          /* x is denormalized. Figure out its exponent. */
          u = ax;
          while (u < IMPBIT_DP64)
            {
              xexp--;
              u <<= 1;
            }
        }
      if (yexp < 1)
        {
          /* y is denormalized. Figure out its exponent. */
          u = ay;
          while (u < IMPBIT_DP64)
            {
              yexp--;
              u <<= 1;
            }
        }
    }
  else if (ax == ay)
    {
      /* abs(x) == abs(y); return zero with the sign of x */
      PUT_BITS_DP64(ux & SIGNBIT_DP64, dx);
      return dx;
    }
 
  /* Set x = abs(x), y = abs(y) */
  PUT_BITS_DP64(ax, dx);
  PUT_BITS_DP64(ay, dy);
 
  if (ax < ay)
    {
      /* abs(x) < abs(y) */
#if !defined(COMPILING_FMOD)
      if (dx > 0.5*dy)
        dx -= dy;
#endif
      return x < 0.0? -dx : dx;
    }
 
  /* Save the current floating-point status word. We need
     to do this because the remainder function is always
     exact for finite arguments, but our algorithm causes
     the inexact flag to be raised. We therefore need to
     restore the entry status before exiting. */
  sw = get_fpsw_inline();
 
  /* Set ntimes to the number of times we need to do a
     partial remainder. If the exponent of x is an exact multiple
     of 52 larger than the exponent of y, and the mantissa of x is
     less than the mantissa of y, ntimes will be one too large
     but it doesn't matter - it just means that we'll go round
     the loop below one extra time. */
  if (xexp <= yexp)
    ntimes = 0;
  else
    ntimes = (xexp - yexp) / 52;
 
  if (ntimes == 0)
    {
      w = dy;
      scale = 1.0;
    }
  else
    {
      /* Set w = y * 2^(52*ntimes) */
      w = scaleDouble_3(dy, ntimes * 52);
 
      /* Set scale = 2^(-52) */
      PUT_BITS_DP64((unsigned long long)(-52 + EXPBIAS_DP64) << EXPSHIFTBITS_DP64,
                    scale);
    }
 
 
  /* Each time round the loop we compute a partial remainder.
     This is done by subtracting a large multiple of w
     from x each time, where w is a scaled up version of y.
     The subtraction must be performed exactly in quad
     precision, though the result at each stage can
     fit exactly in a double precision number. */
  for (i = 0; i < ntimes; i++)
    {
      /* t is the integer multiple of w that we will subtract.
         We use a truncated value for t.
 
         N.B. w has been chosen so that the integer t will have
         at most 52 significant bits. This is the amount by
         which the exponent of the partial remainder dx gets reduced
         every time around the loop. In theory we could use
         53 bits in t, but the quad precision multiplication
         routine dekker_mul12 does not allow us to do that because
         it loses the last (106th) bit of its quad precision result. */
 
      /* Set dx = dx - w * t, where t is equal to trunc(dx/w). */
      t = (double)(long long)(dx / w);
      /* At this point, t may be one too large due to
         rounding of dx/w */
 
      /* Compute w * t in quad precision */
      dekker_mul12(w, t, &c, &cc);
 
      /* Subtract w * t from dx */
      v = dx - c;
      dx = v + (((dx - v) - c) - cc);
 
      /* If t was one too large, dx will be negative. Add back
         one w */
      /* It might be possible to speed up this loop by finding
         a way to compute correctly truncated t directly from dx and w.
         We would then avoid the need for this check on negative dx. */
      if (dx < 0.0)
        dx += w;
 
      /* Scale w down by 2^(-52) for the next iteration */
      w *= scale;
    }
 
  /* One more time */
  /* Variable todd says whether the integer t is odd or not */
  t = (double)(long long)(dx / w);
  todd = ((long long)(dx / w)) & 1;
  dekker_mul12(w, t, &c, &cc);
  v = dx - c;
  dx = v + (((dx - v) - c) - cc);
  if (dx < 0.0)
    {
      todd = !todd;
      dx += w;
    }
 
  /* At this point, dx lies in the range [0,dy) */
#if !defined(COMPILING_FMOD)
  /* For the fmod function, we're done apart from setting
     the correct sign. */
  /* For the remainder function, we need to adjust dx
     so that it lies in the range (-y/2, y/2] by carefully
     subtracting w (== dy == y) if necessary. The rigmarole
     with todd is to get the correct sign of the result
     when x/y lies exactly half way between two integers,
     when we need to choose the even integer. */
  if (ay < 0x7fd0000000000000)
    {
      if (dx + dx > w || (todd && (dx + dx == w)))
        dx -= w;
    }
  else if (dx > 0.5 * w || (todd && (dx == 0.5 * w)))
    dx -= w;
 
#endif
 
  /* **** N.B. for some reason this breaks the 32 bit version
     of remainder when compiling with optimization. */
  /* Restore the entry status flags */
  set_fpsw_inline(sw);
 
  /* Set the result sign according to input argument x */
  return x < 0.0? -dx : dx;
 
}

Referenced by cut_misaligned_tail(), IDirectSoundBufferImpl_Lock(), layout_recall_range(), positive_remainder(), stripe_next_unit(), TAB_SetItemBounds(), test_RegQueryValueExPerformanceData(), VARIANT_DecScale(), VARIANT_DI_div(), VARIANT_DI_mul(), VARIANT_DI_tostringW(), VARIANT_do_division(), VARIANT_int_addlossy(), VARIANT_int_divbychar(), widGetPosition(), wodGetPosition(), and write_integer().

remainderf()

float __cdecl remainderf	(	float	x,
		float	y
	)

Definition at line 60 of file remainderf.c.

{
  double dx, dy, scale, w, t;
  int i, ntimes, xexp, yexp;
  unsigned long long ux, uy, ax, ay;
 
  unsigned int sw;
 
  dx = x;
  dy = y;
 
 
  GET_BITS_DP64(dx, ux);
  GET_BITS_DP64(dy, uy);
  ax = ux & ~SIGNBIT_DP64;
  ay = uy & ~SIGNBIT_DP64;
  xexp = (int)((ux & EXPBITS_DP64) >> EXPSHIFTBITS_DP64);
  yexp = (int)((uy & EXPBITS_DP64) >> EXPSHIFTBITS_DP64);
 
  if (xexp < 1 || xexp > BIASEDEMAX_DP64 ||
      yexp < 1 || yexp > BIASEDEMAX_DP64)
    {
      /* x or y is zero, NaN or infinity (neither x nor y can be
         denormalized because we promoted from float to double) */
      if (xexp > BIASEDEMAX_DP64)
        {
          /* x is NaN or infinity */
          if (ux & MANTBITS_DP64)
            {
              /* x is NaN */
              unsigned int ufx;
              GET_BITS_SP32(x, ufx);
              return _handle_errorf(_FUNCNAME, _OPERATION, ufx|0x00400000, _DOMAIN, 0,
                                   EDOM, x, y, 2);
            }
          else
            {
              /* x is infinity; result is NaN */
              return _handle_errorf(_FUNCNAME, _OPERATION, INDEFBITPATT_SP32, _DOMAIN,
                                   AMD_F_INVALID, EDOM, x, y, 2);
            }
        }
      else if (yexp > BIASEDEMAX_DP64)
        {
          /* y is NaN or infinity */
          if (uy & MANTBITS_DP64)
            {
              /* y is NaN */
              unsigned int ufy;
              GET_BITS_SP32(y, ufy);
              return _handle_errorf(_FUNCNAME, _OPERATION, ufy|0x00400000, _DOMAIN, 0,
                                   EDOM, x, y, 2);
            }
          else
            {
#ifdef _CRTBLD_C9X
              /* C99 return for y = +-inf is x */
              return x;
#else
              /* y is infinity; result is indefinite */
              return _handle_errorf(_FUNCNAME, _OPERATION, INDEFBITPATT_SP32, _DOMAIN,
                                   AMD_F_INVALID, EDOM, x, y, 2);
#endif
            }
        }
      else if (xexp < 1)
        {
          /* x must be zero (cannot be denormalized) */
          if (yexp < 1)
            {
              /* y must be zero (cannot be denormalized) */
              return _handle_errorf(_FUNCNAME, _OPERATION, INDEFBITPATT_SP32, _DOMAIN,
                                   AMD_F_INVALID, EDOM, x, y, 2);
            }
          else
              /* C99 return for x = 0 must preserve sign */
              return x;
        }
      else
        {
          /* y must be zero */
          return _handle_errorf(_FUNCNAME, _OPERATION, INDEFBITPATT_SP32, _DOMAIN,
                               AMD_F_INVALID, EDOM, x, y, 2);
        }
    }
  else if (ax == ay)
    {
      /* abs(x) == abs(y); return zero with the sign of x */
      PUT_BITS_DP64(ux & SIGNBIT_DP64, dx);
      return (float)dx;
    }
 
  /* Set dx = abs(x), dy = abs(y) */
  PUT_BITS_DP64(ax, dx);
  PUT_BITS_DP64(ay, dy);
 
  if (ax < ay)
    {
      /* abs(x) < abs(y) */
#if !defined(COMPILING_FMOD)
      if (dx > 0.5*dy)
        dx -= dy;
#endif
      return (float)(x < 0.0? -dx : dx);
    }
 
  /* Save the current floating-point status word. We need
     to do this because the remainder function is always
     exact for finite arguments, but our algorithm causes
     the inexact flag to be raised. We therefore need to
     restore the entry status before exiting. */
  sw = get_fpsw_inline();
 
  /* Set ntimes to the number of times we need to do a
     partial remainder. If the exponent of x is an exact multiple
     of 24 larger than the exponent of y, and the mantissa of x is
     less than the mantissa of y, ntimes will be one too large
     but it doesn't matter - it just means that we'll go round
     the loop below one extra time. */
  if (xexp <= yexp)
    {
      ntimes = 0;
      w = dy;
      scale = 1.0;
    }
  else
    {
      ntimes = (xexp - yexp) / 24;
 
      /* Set w = y * 2^(24*ntimes) */
      PUT_BITS_DP64((unsigned long long)(ntimes * 24 + EXPBIAS_DP64) << EXPSHIFTBITS_DP64,
                    scale);
      w = scale * dy;
      /* Set scale = 2^(-24) */
      PUT_BITS_DP64((unsigned long long)(-24 + EXPBIAS_DP64) << EXPSHIFTBITS_DP64,
                    scale);
    }
 
 
  /* Each time round the loop we compute a partial remainder.
     This is done by subtracting a large multiple of w
     from x each time, where w is a scaled up version of y.
     The subtraction can be performed exactly when performed
     in double precision, and the result at each stage can
     fit exactly in a single precision number. */
  for (i = 0; i < ntimes; i++)
    {
      /* t is the integer multiple of w that we will subtract.
         We use a truncated value for t. */
      t = (double)((int)(dx / w));
      dx -= w * t;
      /* Scale w down by 2^(-24) for the next iteration */
      w *= scale;
    }
 
  /* One more time */
#if defined(COMPILING_FMOD)
  t = (double)((int)(dx / w));
  dx -= w * t;
#else
 {
  unsigned int todd;
  /* Variable todd says whether the integer t is odd or not */
  t = (double)((int)(dx / w));
  todd = ((int)(dx / w)) & 1;
  dx -= w * t;
 
  /* At this point, dx lies in the range [0,dy) */
  /* For the remainder function, we need to adjust dx
     so that it lies in the range (-y/2, y/2] by carefully
     subtracting w (== dy == y) if necessary. */
  if (dx > 0.5 * w || ((dx == 0.5 * w) && todd))
    dx -= w;
 }
#endif
 
  /* **** N.B. for some reason this breaks the 32 bit version
     of remainder when compiling with optimization. */
  /* Restore the entry status flags */
  set_fpsw_inline(sw);
 
  /* Set the result sign according to input argument x */
  return (float)(x < 0.0? -dx : dx);
 
}

remainderl()

long double __cdecl remainderl	(	long double	,
		long double
	)

remquo()

double __cdecl remquo	(	double	,
		double	,
		int *
	)

remquof()

float __cdecl remquof	(	float	,
		float	,
		int *
	)

remquol()

long double __cdecl remquol	(	long double	,
		long double	,
		int *
	)

rint()

__CRT_INLINE double __cdecl rint

(

double

x

)

Definition at line 350 of file mingw_math.h.

  {
    double retval = 0.0;
    __asm__ __volatile__ ("frndint;": "=t" (retval) : "0" (x));
    return retval;
  }

rintf()

__CRT_INLINE float __cdecl rintf

(

float

x

)

Definition at line 357 of file mingw_math.h.

  {
    float retval = 0.0;
    __asm__ __volatile__ ("frndint;" : "=t" (retval) : "0" (x) );
    return retval;
  }

rintl()

__CRT_INLINE long double __cdecl rintl

(

long double

x

)

Definition at line 364 of file mingw_math.h.

  {
    long double retval = 0.0l;
    __asm__ __volatile__ ("frndint;" : "=t" (retval) : "0" (x) );
    return retval;
  }

round()

double __cdecl round

(

double

arg

)

Definition at line 10 of file round.c.

{
    if (arg < 0.0)
        return ceil(arg - 0.5);
    else
        return floor(arg + 0.5);
}

roundf()

float __cdecl roundf

(

float

arg

)

Definition at line 10 of file roundf.c.

{
    if (arg < 0.0)
        return ceilf(arg - 0.5);
    else
        return floorf(arg + 0.5);
}

roundl()

long double __cdecl roundl

(

long double

)

scalbln()

double __cdecl scalbln	(	double	,
		long
	)

scalblnf()

float __cdecl scalblnf	(	float	,
		long
	)

scalblnl()

long double __cdecl scalblnl	(	long double	,
		long
	)

scalbn()

double __cdecl scalbn	(	double	x,
		int	n
	)

Definition at line 14 of file scalbn.c.

{
    union {double f; uint64_t i;} u;
    double_t y = x;
 
    if (n > 1023) {
        y *= 0x1p1023;
        n -= 1023;
        if (n > 1023) {
            y *= 0x1p1023;
            n -= 1023;
            if (n > 1023)
                n = 1023;
        }
    } else if (n < -1022) {
        /* make sure final n < -53 to avoid double
           rounding in the subnormal range */
        y *= 0x1p-1022 * 0x1p53;
        n += 1022 - 53;
        if (n < -1022) {
            y *= 0x1p-1022 * 0x1p53;
            n += 1022 - 53;
            if (n < -1022)
                n = -1022;
        }
    }
    u.i = (uint64_t)(0x3ff+n)<<52;
    x = y * u.f;
    return x;
}

scalbnf()

float __cdecl scalbnf	(	float	x,
		int	n
	)

Definition at line 14 of file scalbnf.c.

{
    union {float f; uint32_t i;} u;
    float_t y = x;
 
    if (n > 127) {
        y *= 0x1p127f;
        n -= 127;
        if (n > 127) {
            y *= 0x1p127f;
            n -= 127;
            if (n > 127)
                n = 127;
        }
    } else if (n < -126) {
        y *= 0x1p-126f * 0x1p24f;
        n += 126 - 24;
        if (n < -126) {
            y *= 0x1p-126f * 0x1p24f;
            n += 126 - 24;
            if (n < -126)
                n = -126;
        }
    }
    u.i = (uint32_t)(0x7f+n)<<23;
    x = y * u.f;
    return x;
}

scalbnl()

long double __cdecl scalbnl	(	long double	,
		int
	)

tgamma()

double __cdecl tgamma

(

double

)

tgammaf()

float __cdecl tgammaf

(

float

)

tgammal()

long double __cdecl tgammal

(

long double

)

trunc()

double __cdecl trunc

(

double

)

Referenced by divide_ext().

truncf()

float __cdecl truncf

(

float

)

truncl()

long double __cdecl truncl

(

long double

)

Variable Documentation

__INFF

const float __INFF

extern

__INFL

const long double __INFL

extern

__QNAN

const double __QNAN

extern