math.h

Go to the documentation of this file.

/***
*math.h - definitions and declarations for math library
*
*       Copyright (c) Microsoft Corporation. All rights reserved.
*
*Purpose:
*       This file contains constant definitions and external subroutine
*       declarations for the math subroutine library.
*       [ANSI/System V]
*
*       [Public]
*
****/

#ifndef _INC_MATH
#define _INC_MATH

#include <crtdefs.h>

/*
 * Currently, all MS C compilers for Win32 platforms default to 8 byte
 * alignment.
 */
#pragma pack(push,_CRT_PACKING)

#ifdef __cplusplus
extern "C" {
#endif  /* __cplusplus */

#ifndef __assembler

/* Definition of _exception struct - this struct is passed to the matherr
 * routine when a floating point exception is detected
 */

#ifndef _EXCEPTION_DEFINED
struct _exception {
        int type;       /* exception type - see below */
        char *name;     /* name of function where error occured */
        double arg1;    /* first argument to function */
        double arg2;    /* second argument (if any) to function */
        double retval;  /* value to be returned by function */
        } ;

#define _EXCEPTION_DEFINED
#endif  /* _EXCEPTION_DEFINED */


/* Definition of a _complex struct to be used by those who use cabs and
 * want type checking on their argument
 */

#ifndef _COMPLEX_DEFINED
struct _complex {
        double x,y; /* real and imaginary parts */
        } ;

#if !__STDC__ && !defined (__cplusplus)
/* Non-ANSI name for compatibility */
#define complex _complex
#endif  /* !__STDC__ && !defined (__cplusplus) */

#define _COMPLEX_DEFINED
#endif  /* _COMPLEX_DEFINED */
#endif  /* __assembler */

typedef float float_t;
typedef double double_t;

/* Constant definitions for the exception type passed in the _exception struct
 */

#define _DOMAIN     1   /* argument domain error */
#define _SING       2   /* argument singularity */
#define _OVERFLOW   3   /* overflow range error */
#define _UNDERFLOW  4   /* underflow range error */
#define _TLOSS      5   /* total loss of precision */
#define _PLOSS      6   /* partial loss of precision */

#define EDOM        33
#define ERANGE      34


/* Definitions of _HUGE and HUGE_VAL - respectively the XENIX and ANSI names
 * for a value returned in case of error by a number of the floating point
 * math routines
 */
#ifndef __assembler
#if !defined (_M_CEE_PURE)
_CRTIMP extern double _HUGE;
#else  /* !defined (_M_CEE_PURE) */
const double _HUGE = System::Double::PositiveInfinity;
#endif  /* !defined (_M_CEE_PURE) */
#endif  /* __assembler */

#define HUGE_VAL _HUGE

#ifndef _HUGE_ENUF
#define _HUGE_ENUF  1e+300  /* _HUGE_ENUF*_HUGE_ENUF must overflow */
#endif /* _HUGE_ENUF */

#define INFINITY   ((float)(_HUGE_ENUF * _HUGE_ENUF))  /* causes warning C4756: overflow in constant arithmetic (by design) */
#define HUGE_VALD  ((double)INFINITY)
#define HUGE_VALF  ((float)INFINITY)
#define HUGE_VALL  ((long double)INFINITY)
#define NAN        ((float)(INFINITY * 0.0F))

#define _DENORM    (-2)
#define _FINITE    (-1)
#define _INFCODE   1
#define _NANCODE   2

#define FP_INFINITE  _INFCODE
#define FP_NAN       _NANCODE
#define FP_NORMAL    _FINITE
#define FP_SUBNORMAL _DENORM
#define FP_ZERO      0

#define _C2          1  /* 0 if not 2's complement */
#define _FP_ILOGB0   (-0x7fffffff - _C2)
#define _FP_ILOGBNAN 0x7fffffff

#define MATH_ERRNO        1
#define MATH_ERREXCEPT    2
#define math_errhandling  (MATH_ERRNO | MATH_ERREXCEPT)

/* MACROS FOR _fperrraise ARGUMENT */
#define _FE_DIVBYZERO 0x04
#define _FE_INEXACT   0x20
#define _FE_INVALID   0x01
#define _FE_OVERFLOW  0x08
#define _FE_UNDERFLOW 0x10

#define _D0_C  3 /* little-endian, small long doubles */
#define _D1_C  2
#define _D2_C  1
#define _D3_C  0

#define _DBIAS 0x3fe
#define _DOFF  4

#define _F0_C  1 /* little-endian */
#define _F1_C  0

#define _FBIAS 0x7e
#define _FOFF  7
#define _FRND  1

#define _L0_C  3 /* little-endian, 64-bit long doubles */
#define _L1_C  2
#define _L2_C  1
#define _L3_C  0

#define _LBIAS 0x3fe
#define _LOFF  4

/* IEEE 754 double properties */
#define _DFRAC  ((unsigned short)((1 << _DOFF) - 1))
#define _DMASK  ((unsigned short)(0x7fff & ~_DFRAC))
#define _DMAX   ((unsigned short)((1 << (15 - _DOFF)) - 1))
#define _DSIGN  ((unsigned short)0x8000)

/* IEEE 754 float properties */
#define _FFRAC  ((unsigned short)((1 << _FOFF) - 1))
#define _FMASK  ((unsigned short)(0x7fff & ~_FFRAC))
#define _FMAX   ((unsigned short)((1 << (15 - _FOFF)) - 1))
#define _FSIGN  ((unsigned short)0x8000)

/* IEEE 754 long double properties */
#define _LFRAC  ((unsigned short)(-1))
#define _LMASK  ((unsigned short)0x7fff)
#define _LMAX   ((unsigned short)0x7fff)
#define _LSIGN  ((unsigned short)0x8000)

#define HUGE_EXP  (int)(_DMAX * 900L / 1000)
#define VHUGE_EXP (int)(_VMAX * 900L / 1000)
#define FHUGE_EXP (int)(_FMAX * 900L / 1000)
#define LHUGE_EXP (int)(_LMAX * 900L / 1000)

#define DSIGN_C(_Val)  (((_double_val *)(char *)&(_Val))->_Sh[_D0_C] & _DSIGN)
#define FSIGN_C(_Val)  (((_float_val *)(char *)&(_Val))->_Sh[_F0_C] & _FSIGN)
#define LSIGN_C(_Val)  (((_ldouble_val *)(char *)&(_Val))->_Sh[_L0_C] & _LSIGN)

void __cdecl _fperrraise(_In_ int _Except);

short _CRTIMP __cdecl _dclass(_In_ double _X);
short _CRTIMP __cdecl _ldclass(_In_ long double _X);
short _CRTIMP __cdecl _fdclass(_In_ float _X);

int _CRTIMP __cdecl _dsign(_In_ double _X);
int _CRTIMP __cdecl _ldsign(_In_ long double _X);
int _CRTIMP __cdecl _fdsign(_In_ float _X);

int _CRTIMP __cdecl _dpcomp(_In_ double _X, _In_ double _Y);
int _CRTIMP __cdecl _ldpcomp(_In_ long double _X, _In_ long double _Y);
int _CRTIMP __cdecl _fdpcomp(_In_ float _X, _In_ float _Y);

short _CRTIMP __cdecl _dtest(_In_ double *_Px);
short _CRTIMP __cdecl _ldtest(_In_ long double *_Px);
short _CRTIMP __cdecl _fdtest(_In_ float *_Px);

short _CRTIMP __cdecl _d_int(_In_ double *_Px, _In_ short _Xexp);
short _CRTIMP __cdecl _ld_int(_In_ long double *_Px, _In_ short _Xexp);
short _CRTIMP __cdecl _fd_int(_In_ float *_Px, _In_ short _Xexp);

short _CRTIMP __cdecl _dscale(_In_ double *_Px, _In_ long _Lexp);
short _CRTIMP __cdecl _ldscale(_In_ long double *_Px, _In_ long _Lexp);
short _CRTIMP __cdecl _fdscale(_In_ float *_Px, _In_ long _Lexp);

short _CRTIMP  __cdecl _dunscale(_In_ short *_Pex, _In_ double *_Px);
short _CRTIMP __cdecl _ldunscale(_In_ short *_Pex, _In_ long double *_Px);
short _CRTIMP __cdecl _fdunscale(_In_ short *_Pex, _In_ float *_Px);

short _CRTIMP __cdecl _dexp(_In_ double *_Px, _In_ double _Y, _In_ long _Eoff);
short _CRTIMP __cdecl _ldexp(_In_ long double *_Px, _In_ long double _Y, _In_ long _Eoff);
short _CRTIMP __cdecl _fdexp(_In_ float *_Px, _In_ float _Y, _In_ long _Eoff);

short _CRTIMP __cdecl _dnorm(_In_ unsigned short *_Ps);
short _CRTIMP __cdecl _fdnorm(_In_ unsigned short *_Ps);

double __cdecl _dpoly(_In_ double _X, _In_ const double *_Tab, _In_ int _N);
long double __cdecl _ldpoly(_In_ long double _X, _In_ const long double *_Tab, _In_ int _N);
float __cdecl _fdpoly(_In_ float _X, _In_ const float *_Tab, _In_ int _N);

double _CRTIMP __cdecl _dlog(_In_ double _X, _In_ int _Baseflag);
long double _CRTIMP __cdecl _ldlog(_In_ long double _X, _In_ int _Baseflag);
float _CRTIMP __cdecl _fdlog(_In_ float _X, _In_ int _Baseflag);

double _CRTIMP __cdecl _dsin(_In_ double _X, _In_ unsigned int _Qoff);
long double _CRTIMP __cdecl _ldsin(_In_ long double _X, _In_ unsigned int _Qoff);
float _CRTIMP __cdecl _fdsin(_In_ float _X, _In_ unsigned int _Qoff);

/* double declarations */
typedef union
{   /* pun floating type as integer array */
    unsigned short _Sh[8];
    double _Val;
} _double_val;

/* float declarations */
typedef union
{   /* pun floating type as integer array */
    unsigned short _Sh[8];
    float _Val;
} _float_val;

/* long double declarations */
typedef union
{   /* pun floating type as integer array */
    unsigned short _Sh[8];
    long double _Val;
} _ldouble_val;

typedef union
{   /* pun float types as integer array */
    unsigned short _Word[8];
    float _Float;
    double _Double;
    long double _Long_double;
} _float_const;

extern const _float_const _Denorm_C,  _Inf_C,  _Nan_C,  _Snan_C, _Hugeval_C;
extern const _float_const _FDenorm_C, _FInf_C, _FNan_C, _FSnan_C;
extern const _float_const _LDenorm_C, _LInf_C, _LNan_C, _LSnan_C;

extern const _float_const _Eps_C,  _Rteps_C;
extern const _float_const _FEps_C, _FRteps_C;
extern const _float_const _LEps_C, _LRteps_C;

extern const double _Zero_C, _Xbig_C;
extern const float _FZero_C, _FXbig_C;
extern const long double _LZero_C, _LXbig_C;

#define _FP_LT  1
#define _FP_EQ  2
#define _FP_GT  4

#ifndef __cplusplus

#define _CLASS_ARG(_Val)                                  (sizeof ((_Val) + (float)0) == sizeof (float) ? 'f' : sizeof ((_Val) + (double)0) == sizeof (double) ? 'd' : 'l')
#define _CLASSIFY(_Val, _FFunc, _DFunc, _LDFunc)          (_CLASS_ARG(_Val) == 'f' ? _FFunc((float)(_Val)) : _CLASS_ARG(_Val) == 'd' ? _DFunc((double)(_Val)) : _LDFunc((long double)(_Val)))
#define _CLASSIFY2(_Val1, _Val2, _FFunc, _DFunc, _LDFunc) (_CLASS_ARG((_Val1) + (_Val2)) == 'f' ? _FFunc((float)(_Val1), (float)(_Val2)) : _CLASS_ARG((_Val1) + (_Val2)) == 'd' ? _DFunc((double)(_Val1), (double)(_Val2)) : _LDFunc((long double)(_Val1), (long double)(_Val2)))

#define fpclassify(_Val)      (_CLASSIFY(_Val, _fdclass, _dclass, _ldclass))
#define _FPCOMPARE(_Val1, _Val2) (_CLASSIFY2(_Val1, _Val2, _fdpcomp, _dpcomp, _ldpcomp))

#define isfinite(_Val)      (fpclassify(_Val) <= 0)
#define isinf(_Val)         (fpclassify(_Val) == FP_INFINITE)
#define isnan(_Val)         (fpclassify(_Val) == FP_NAN)
#define isnormal(_Val)      (fpclassify(_Val) == FP_NORMAL)
#define signbit(_Val)       (_CLASSIFY(_Val, _fdsign, _dsign, _ldsign))

#define isgreater(x, y)      ((_FPCOMPARE(x, y) & _FP_GT) != 0)
#define isgreaterequal(x, y) ((_FPCOMPARE(x, y) & (_FP_EQ | _FP_GT)) != 0)
#define isless(x, y)         ((_FPCOMPARE(x, y) & _FP_LT) != 0)
#define islessequal(x, y)    ((_FPCOMPARE(x, y) & (_FP_LT | _FP_EQ)) != 0)
#define islessgreater(x, y)  ((_FPCOMPARE(x, y) & (_FP_LT | _FP_GT)) != 0)
#define isunordered(x, y)    (_FPCOMPARE(x, y) == 0)

#else /* __cplusplus */

extern "C++" {

inline __nothrow int fpclassify(float _X)
{
    return (_fdtest(&_X));
}

inline __nothrow int fpclassify(double _X)
{
    return (_dtest(&_X));
}

inline __nothrow int fpclassify(long double _X)
{
    return (_ldtest(&_X));
}

inline __nothrow bool signbit(float _X)
{
    return (_fdsign(_X) != 0);
}

inline __nothrow bool signbit(double _X)
{
    return (_dsign(_X) != 0);
}

inline __nothrow bool signbit(long double _X)
{
    return (_ldsign(_X) != 0);
}

inline __nothrow int _fpcomp(float _X, float _Y)
{
    return (_fdpcomp(_X, _Y));
}

inline __nothrow int _fpcomp(double _X, double _Y)
{
    return (_dpcomp(_X, _Y));
}

inline __nothrow int _fpcomp(long double _X, long double _Y)
{
    return (_ldpcomp(_X, _Y));
}

template<class _Trc, class _Tre> struct _Combined_type
{   // determine combined type
    typedef float _Type;    // (real, float) is float
};

template<> struct _Combined_type<float, double>
{   // determine combined type
    typedef double _Type;
};

template<> struct _Combined_type<float, long double>
{   // determine combined type
    typedef long double _Type;
};

template<class _Ty, class _T2> struct _Real_widened
{   // determine widened real type
    typedef long double _Type;  // default is long double
};

template<> struct _Real_widened<float, float>
{   // determine widened real type
    typedef float _Type;
};

template<> struct _Real_widened<float, double>
{   // determine widened real type
    typedef double _Type;
};

template<> struct _Real_widened<double, float>
{   // determine widened real type
    typedef double _Type;
};

template<> struct _Real_widened<double, double>
{   // determine widened real type
    typedef double _Type;
};

template<class _Ty> struct _Real_type
{   // determine equivalent real type
    typedef double _Type;   // default is double
};

template<> struct _Real_type<float>
{   // determine equivalent real type
    typedef float _Type;
};

template<> struct _Real_type<long double>
{   // determine equivalent real type
    typedef long double _Type;
};

template<class _T1, class _T2> inline __nothrow int _fpcomp(_T1 _X, _T2 _Y)
{   // compare _Left and _Right
    typedef typename _Combined_type<float,
        typename _Real_widened<
        typename _Real_type<_T1>::_Type,
        typename _Real_type<_T2>::_Type>::_Type>::_Type _Tw;
    return (_fpcomp((_Tw)_X, (_Tw)_Y));
}

template<class _Ty> inline __nothrow bool isfinite(_Ty _X)
{
    return (fpclassify(_X) <= 0);
}

template<class _Ty> inline __nothrow bool isinf(_Ty _X)
{
    return (fpclassify(_X) == FP_INFINITE);
}

template<class _Ty> inline __nothrow bool isnan(_Ty _X)
{
    return (fpclassify(_X) == FP_NAN);
}

template<class _Ty> inline __nothrow bool isnormal(_Ty _X)
{
    return (fpclassify(_X) == FP_NORMAL);
}

template<class _Ty1, class _Ty2> inline __nothrow bool isgreater(_Ty1 _X, _Ty2 _Y)
{
    return ((_fpcomp(_X, _Y) & _FP_GT) != 0);
}

template<class _Ty1, class _Ty2> inline __nothrow bool isgreaterequal(_Ty1 _X, _Ty2 _Y)
{
    return ((_fpcomp(_X, _Y) & (_FP_EQ | _FP_GT)) != 0);
}

template<class _Ty1, class _Ty2> inline __nothrow bool isless(_Ty1 _X, _Ty2 _Y)
{
    return ((_fpcomp(_X, _Y) & _FP_LT) != 0);
}

template<class _Ty1, class _Ty2> inline __nothrow bool islessequal(_Ty1 _X, _Ty2 _Y)
{
    return ((_fpcomp(_X, _Y) & (_FP_LT | _FP_EQ)) != 0);
}

template<class _Ty1, class _Ty2> inline __nothrow bool islessgreater(_Ty1 _X, _Ty2 _Y)
{
    return ((_fpcomp(_X, _Y) & (_FP_LT | _FP_GT)) != 0);
}

template<class _Ty1, class _Ty2> inline __nothrow bool isunordered(_Ty1 _X, _Ty2 _Y)
{
    return (_fpcomp(_X, _Y) == 0);
}

}  // extern "C++"

#endif /* __cplusplus */

/* Function prototypes */

#if !defined (__assembler)
int       __cdecl abs(_In_ int _X);
long      __cdecl labs(_In_ long _X);
long long __cdecl llabs(_In_ long long _X);

double  __cdecl acos(_In_ double _X);
_CRTIMP double __cdecl acosh(_In_ double _X);
double  __cdecl asin(_In_ double _X);
_CRTIMP double __cdecl asinh(_In_ double _X);
double  __cdecl atan(_In_ double _X);
_CRTIMP double __cdecl atanh(_In_ double _X);
double  __cdecl atan2(_In_ double _Y, _In_ double _X);

_CRTIMP double __cdecl cbrt(_In_ double _X);
_CRTIMP double __cdecl copysign(_In_ double _X, _In_ double _Y);
double  __cdecl cos(_In_ double _X);
double  __cdecl cosh(_In_ double _X);
_CRTIMP double __cdecl erf(_In_ double _X);
_CRTIMP double __cdecl erfc(_In_ double _X);
double  __cdecl exp(_In_ double _X);
_CRTIMP double __cdecl exp2(_In_ double _X);
_CRTIMP double __cdecl expm1(_In_ double _X);
_CRT_JIT_INTRINSIC double  __cdecl fabs(_In_ double _X);
_CRTIMP double __cdecl fdim(_In_ double _X, _In_ double _Y);
_CRTIMP double __cdecl fma(_In_ double _X, _In_ double _Y, _In_ double _Z);
_CRTIMP double __cdecl fmax(_In_ double _X, _In_ double _Y);
_CRTIMP double __cdecl fmin(_In_ double _X, _In_ double _Y);
double  __cdecl fmod(_In_ double _X, _In_ double _Y);
_CRTIMP int __cdecl ilogb(_In_ double _X);
_CRTIMP double __cdecl lgamma(_In_ double _X);
_CRTIMP long long __cdecl llrint(_In_ double _X);
_CRTIMP long long __cdecl llround(_In_ double _X);
double  __cdecl log(_In_ double _X);
double  __cdecl log10(_In_ double _X);
_CRTIMP double __cdecl log1p(_In_ double _X);
_CRTIMP double __cdecl log2(_In_ double _X);
_CRTIMP double __cdecl logb(_In_ double _X);
_CRTIMP long __cdecl lrint(_In_ double _X);
_CRTIMP long __cdecl lround(_In_ double _X);
_CRTIMP double __cdecl nan(_In_ const char *);
_CRTIMP double __cdecl nearbyint(_In_ double _X);
_CRTIMP double __cdecl nextafter(_In_ double _X, _In_ double _Y);
_CRTIMP double __cdecl nexttoward(_In_ double _X, _In_ long double _Y);
double  __cdecl pow(_In_ double _X, _In_ double _Y);
_CRTIMP double __cdecl remainder(_In_ double _X, _In_ double _Y);
_CRTIMP double __cdecl remquo(_In_ double _X, _In_ double _Y, _Out_ int *_Z);
_CRTIMP double __cdecl rint(_In_ double _X);
_CRTIMP double __cdecl round(_In_ double _X);
_CRTIMP double __cdecl scalbln(_In_ double _X, _In_ long _Y);
_CRTIMP double __cdecl scalbn(_In_ double _X, _In_ int _Y);
double  __cdecl sin(_In_ double _X);
double  __cdecl sinh(_In_ double _X);
_CRT_JIT_INTRINSIC  double  __cdecl sqrt(_In_ double _X);
double  __cdecl tan(_In_ double _X);
double  __cdecl tanh(_In_ double _X);
_CRTIMP double __cdecl tgamma(_In_ double _X);
_CRTIMP double __cdecl trunc(_In_ double _X);

_Check_return_ _CRTIMP double  __cdecl atof(_In_z_ const char *_String);
_Check_return_ _CRTIMP double  __cdecl _atof_l(_In_z_ const char *_String, _In_opt_ _locale_t _Locale);

_CRTIMP double  __cdecl _cabs(_In_ struct _complex _Complex_value);
_CRTIMP double  __cdecl ceil(_In_ double _X);

_Check_return_ _CRTIMP double __cdecl _chgsign (_In_ double _X);
_Check_return_ _CRTIMP double __cdecl _copysign (_In_ double _Number, _In_ double _Sign);

_CRTIMP double  __cdecl floor(_In_ double _X);
_CRTIMP double  __cdecl frexp(_In_ double _X, _Out_ int * _Y);
_CRTIMP double  __cdecl _hypot(_In_ double _X, _In_ double _Y);
_CRTIMP double  __cdecl _j0(_In_ double _X );
_CRTIMP double  __cdecl _j1(_In_ double _X );
_CRTIMP double  __cdecl _jn(int _X, _In_ double _Y);
_CRTIMP double  __cdecl ldexp(_In_ double _X, _In_ int _Y);

#if defined (MRTDLL) || defined (_M_CEE_PURE)
int     __CRTDECL _matherr(_Inout_ struct _exception * _Except);
#else  /* defined (MRTDLL) || defined (_M_CEE_PURE) */
int     __cdecl _matherr(_Inout_ struct _exception * _Except);
#endif  /* defined (MRTDLL) || defined (_M_CEE_PURE) */

_CRTIMP double  __cdecl modf(_In_ double _X, _Out_ double * _Y);
_CRTIMP double  __cdecl _y0(_In_ double _X);
_CRTIMP double  __cdecl _y1(_In_ double _X);
_CRTIMP double  __cdecl _yn(_In_ int _X, _In_ double _Y);

__inline double __CRTDECL hypot(_In_ double _X, _In_ double _Y)
{
    return _hypot(_X, _Y);
}


_CRTIMP float __cdecl acoshf(_In_ float _X);
_CRTIMP float __cdecl asinhf(_In_ float _X);
_CRTIMP float __cdecl atanhf(_In_ float _X);
_CRTIMP float __cdecl cbrtf(_In_ float _X);
_CRTIMP float  __cdecl _chgsignf(_In_ float _X);
_CRTIMP float __cdecl copysignf(_In_ float _X, _In_ float _Y);
_CRTIMP float  __cdecl _copysignf(_In_ float _Number, _In_ float _Sign);
_CRTIMP float __cdecl erff(_In_ float _X);
_CRTIMP float __cdecl erfcf(_In_ float _X);
_CRTIMP float __cdecl expm1f(_In_ float _X);
_CRTIMP float __cdecl exp2f(_In_ float _X);
_CRTIMP float __cdecl fdimf(_In_ float _X, _In_ float _Y);
_CRTIMP float __cdecl fmaf(_In_ float _X, _In_ float _Y, _In_ float _Z);
_CRTIMP float __cdecl fmaxf(_In_ float _X, _In_ float _Y);
_CRTIMP float __cdecl fminf(_In_ float _X, _In_ float _Y);
_CRTIMP float  __cdecl _hypotf(_In_ float _X, _In_ float _Y);
_CRTIMP int __cdecl ilogbf(_In_ float _X);
_CRTIMP float __cdecl lgammaf(_In_ float _X);
_CRTIMP long long __cdecl llrintf(_In_ float _X);
_CRTIMP long long __cdecl llroundf(_In_ float _X);
_CRTIMP float __cdecl log1pf(_In_ float _X);
_CRTIMP float __cdecl log2f(_In_ float _X);
_CRTIMP float __cdecl logbf(_In_ float _X);
_CRTIMP long __cdecl lrintf(_In_ float _X);
_CRTIMP long __cdecl lroundf(_In_ float _X);
_CRTIMP float __cdecl nanf(_In_ const char *);
_CRTIMP float __cdecl nearbyintf(_In_ float _X);
_CRTIMP float __cdecl nextafterf(_In_ float _X, _In_ float _Y);
_CRTIMP float __cdecl nexttowardf(_In_ float _X, _In_ long double _Y);
_CRTIMP float __cdecl remainderf(_In_ float _X, _In_ float _Y);
_CRTIMP float __cdecl remquof(_In_ float _X, _In_ float _Y, _Out_ int *_Z);
_CRTIMP float __cdecl rintf(_In_ float _X);
_CRTIMP float __cdecl roundf(_In_ float _X);
_CRTIMP float __cdecl scalblnf(_In_ float _X, _In_ long _Y);
_CRTIMP float __cdecl scalbnf(_In_ float _X, _In_ int _Y);
_CRTIMP float __cdecl tgammaf(_In_ float _X);
_CRTIMP float __cdecl truncf(_In_ float _X);

#if defined (_M_IX86)

_CRTIMP int  __cdecl _set_SSE2_enable(_In_ int _Flag);

#endif  /* defined (_M_IX86) */

#if defined (_M_X64)

_CRTIMP float  __cdecl _logbf(_In_ float _X);
_CRTIMP float  __cdecl _nextafterf(_In_ float _X, _In_ float _Y);
_CRTIMP int    __cdecl _finitef(_In_ float _X);
_CRTIMP int    __cdecl _isnanf(_In_ float _X);
_CRTIMP int    __cdecl _fpclassf(_In_ float _X);

_CRTIMP int  __cdecl _set_FMA3_enable(_In_ int _Flag);

#endif  /* defined (_M_X64) */

#if defined (_M_ARM)

_CRTIMP int    __cdecl _finitef(_In_ float _X);
_CRTIMP float  __cdecl _logbf(_In_ float _X);

#endif  /* defined (_M_ARM) */

#if defined (_M_X64) || defined (_M_ARM)

_CRTIMP float  __cdecl acosf(_In_ float _X);
_CRTIMP float  __cdecl asinf(_In_ float _X);
_CRTIMP float  __cdecl atan2f(_In_ float _Y, _In_ float _X);
_CRTIMP float  __cdecl atanf(_In_ float _X);
_CRTIMP float  __cdecl ceilf(_In_ float _X);
_CRTIMP float  __cdecl cosf(_In_ float _X);
_CRTIMP float  __cdecl coshf(_In_ float _X);
_CRTIMP float  __cdecl expf(_In_ float _X);

#else  /* defined(_M_X64) || defined(_M_ARM) */

__inline float  __CRTDECL acosf(_In_ float _X)
{
    return (float)acos(_X);
}

__inline float  __CRTDECL asinf(_In_ float _X)
{
    return (float)asin(_X);
}

__inline float  __CRTDECL atan2f(_In_ float _Y, _In_ float _X)
{
    return (float)atan2(_Y, _X);
}

__inline float  __CRTDECL atanf(_In_ float _X)
{
    return (float)atan(_X);
}

__inline float  __CRTDECL ceilf(_In_ float _X)
{
    return (float)ceil(_X);
}

__inline float  __CRTDECL cosf(_In_ float _X)
{
    return (float)cos(_X);
}

__inline float  __CRTDECL coshf(_In_ float _X)
{
    return (float)cosh(_X);
}

__inline float  __CRTDECL expf(_In_ float _X)
{
    return (float)exp(_X);
}

#endif  /* defined (_M_X64) || defined (_M_ARM) */

#if defined (_M_ARM)

_CRT_JIT_INTRINSIC _CRTIMP float  __cdecl fabsf(_In_ float  _X);

#else  /* defined (_M_ARM) */

__inline float __CRTDECL fabsf(_In_ float _X)
{
    return (float)fabs(_X);
}

#endif  /* defined (_M_ARM) */

#if defined (_M_X64) || defined (_M_ARM)

_CRTIMP float  __cdecl floorf(_In_ float _X);
_CRTIMP float  __cdecl fmodf(_In_ float _X, _In_ float _Y);

#else /* defined (_M_X64) || defined (_M_ARM) */

__inline float __CRTDECL floorf(_In_ float _X)
{
    return (float)floor(_X);
}

__inline float __CRTDECL fmodf(_In_ float _X, _In_ float _Y)
{
    return (float)fmod(_X, _Y);
}

#endif  /* !defined(_M_X64) && !defined(_M_ARM) */

__inline float __CRTDECL frexpf(_In_ float _X, _Out_ int *_Y)
{
    return (float)frexp(_X, _Y);
}

__inline float __CRTDECL hypotf(_In_ float _X, _In_ float _Y)
{
    return _hypotf(_X, _Y);
}

__inline float __CRTDECL ldexpf(_In_ float _X, _In_ int _Y)
{
    return (float)ldexp(_X, _Y);
}

#if defined (_M_X64) || defined (_M_ARM)

_CRTIMP float  __cdecl log10f(_In_ float _X);
_CRTIMP float  __cdecl logf(_In_ float _X);
_CRTIMP float  __cdecl modff(_In_ float _X, _Out_ float *_Y);
_CRTIMP float  __cdecl powf(_In_ float _X, _In_ float _Y);
_CRTIMP float  __cdecl sinf(_In_ float _X);
_CRTIMP float  __cdecl sinhf(_In_ float _X);
_CRTIMP float  __cdecl sqrtf(_In_ float _X);
_CRTIMP float  __cdecl tanf(_In_ float _X);
_CRTIMP float  __cdecl tanhf(_In_ float _X);

#else /* defined (_M_X64) || defined (_M_ARM) */

__inline float __CRTDECL log10f(_In_ float _X)
{
    return (float)log10(_X);
}

__inline float __CRTDECL logf(_In_ float _X)
{
    return (float)log(_X);
}

__inline float __CRTDECL modff(_In_ float _X, _Out_ float *_Y)
{
    double _F, _I;
    _F = modf(_X, &_I);
    *_Y = (float)_I;
    return (float)_F;
}

__inline float __CRTDECL powf(_In_ float _X, _In_ float _Y)
{
    return (float)pow(_X, _Y);
}

__inline float __CRTDECL sinf(_In_ float _X)
{
    return (float)sin(_X);
}

__inline float __CRTDECL sinhf(_In_ float _X)
{
    return (float)sinh(_X);
}

__inline float __CRTDECL sqrtf(_In_ float _X)
{
    return (float)sqrt(_X);
}

__inline float __CRTDECL tanf(_In_ float _X)
{
    return (float)tan(_X);
}

__inline float __CRTDECL tanhf(_In_ float _X)
{
    return (float)tanh(_X);
}

#endif  /* defined (_M_X64) || defined (_M_ARM) */

_CRTIMP long double __cdecl acoshl(_In_ long double _X);

__inline long double __CRTDECL acosl(_In_ long double _X)
{
    return acos((double)_X);
}

_CRTIMP long double __cdecl asinhl(_In_ long double _X);

__inline long double __CRTDECL asinl(_In_ long double _X)
{
    return asin((double)_X);
}

__inline long double __CRTDECL atan2l(_In_ long double _Y, _In_ long double _X)
{
    return atan2((double)_Y, (double)_X);
}

_CRTIMP long double __cdecl atanhl(_In_ long double _X);

__inline long double __CRTDECL atanl(_In_ long double _X)
{
    return atan((double)_X);
}

_CRTIMP long double __cdecl cbrtl(_In_ long double _X);

__inline long double __CRTDECL ceill(_In_ long double _X)
{
    return ceil((double)_X);
}

__inline long double __CRTDECL _chgsignl(_In_ long double _X)
{
    return _chgsign((double)_X);
}

_CRTIMP long double __cdecl copysignl(_In_ long double _X, _In_ long double _Y);

__inline long double __CRTDECL _copysignl(_In_ long double _X, _In_ long double _Y)
{
    return _copysign((double)_X, (double)_Y);
}

__inline long double __CRTDECL coshl(_In_ long double _X)
{
    return cosh((double)_X);
}

__inline long double __CRTDECL cosl(_In_ long double _X)
{
    return cos((double)_X);
}

_CRTIMP long double __cdecl erfl(_In_ long double _X);
_CRTIMP long double __cdecl erfcl(_In_ long double _X);

__inline long double __CRTDECL expl(_In_ long double _X)
{
    return exp((double)_X);
}

_CRTIMP long double __cdecl exp2l(_In_ long double _X);
_CRTIMP long double __cdecl expm1l(_In_ long double _X);

__inline long double __CRTDECL fabsl(_In_ long double _X)
{
    return fabs((double)_X);
}

_CRTIMP long double __cdecl fdiml(_In_ long double _X, _In_ long double _Y);

__inline long double __CRTDECL floorl(_In_ long double _X)
{
    return floor((double)_X);
}

_CRTIMP long double __cdecl fmal(_In_ long double _X, _In_ long double _Y, _In_ long double _Z);
_CRTIMP long double __cdecl fmaxl(_In_ long double _X, _In_ long double _Y);
_CRTIMP long double __cdecl fminl(_In_ long double _X, _In_ long double _Y);

__inline long double __CRTDECL fmodl(_In_ long double _X, _In_ long double _Y)
{
    return fmod((double)_X, (double)_Y);
}

__inline long double __CRTDECL frexpl(_In_ long double _X, _Out_ int *_Y)
{
    return frexp((double)_X, _Y);
}

_CRTIMP int __cdecl ilogbl(_In_ long double _X);

__inline long double __CRTDECL _hypotl(_In_ long double _X, _In_ long double _Y)
{
    return _hypot((double)_X, (double)_Y);
}

__inline long double __CRTDECL hypotl(_In_ long double _X, _In_ long double _Y)
{
    return _hypot((double)_X, (double)_Y);
}

__inline long double __CRTDECL ldexpl(_In_ long double _X, _In_ int _Y)
{
    return ldexp((double)_X, _Y);
}

_CRTIMP long double __cdecl lgammal(_In_ long double _X);
_CRTIMP long long __cdecl llrintl(_In_ long double _X);
_CRTIMP long long __cdecl llroundl(_In_ long double _X);

__inline long double __CRTDECL logl(_In_ long double _X)
{
    return log((double)_X);
}

__inline long double __CRTDECL log10l(_In_ long double _X)
{
    return log10((double)_X);
}

_CRTIMP long double __cdecl log1pl(_In_ long double _X);
_CRTIMP long double __cdecl log2l(_In_ long double _X);
_CRTIMP long double __cdecl logbl(_In_ long double _X);
_CRTIMP long __cdecl lrintl(_In_ long double _X);
_CRTIMP long __cdecl lroundl(_In_ long double _X);

__inline long double __CRTDECL modfl(_In_ long double _X, _Out_ long double *_Y)
{
    double _F, _I;
    _F = modf((double)_X, &_I);
    *_Y = _I;
    return _F;
}
_CRTIMP long double __cdecl nanl(_In_ const char *);
_CRTIMP long double __cdecl nearbyintl(_In_ long double _X);
_CRTIMP long double __cdecl nextafterl(_In_ long double _X, _In_ long double _Y);
_CRTIMP long double __cdecl nexttowardl(_In_ long double _X, _In_ long double _Y);

__inline long double __CRTDECL powl(_In_ long double _X, _In_ long double _Y)
{
    return pow((double)_X, (double)_Y);
}

_CRTIMP long double __cdecl remainderl(_In_ long double _X, _In_ long double _Y);
_CRTIMP long double __cdecl remquol(_In_ long double _X, _In_ long double _Y, _Out_ int *_Z);
_CRTIMP long double __cdecl rintl(_In_ long double _X);
_CRTIMP long double __cdecl roundl(_In_ long double _X);
_CRTIMP long double __cdecl scalblnl(_In_ long double _X, _In_ long _Y);
_CRTIMP long double __cdecl scalbnl(_In_ long double _X, _In_ int _Y);

__inline long double __CRTDECL sinhl(_In_ long double _X)
{
    return sinh((double)_X);
}

__inline long double __CRTDECL sinl(_In_ long double _X)
{
    return sin((double)_X);
}

__inline long double __CRTDECL sqrtl(_In_ long double _X)
{
    return sqrt((double)_X);
}

__inline long double __CRTDECL tanhl(_In_ long double _X)
{
    return tanh((double)_X);
}

__inline long double __CRTDECL tanl(_In_ long double _X)
{
    return tan((double)_X);
}

_CRTIMP long double __cdecl tgammal(_In_ long double _X);
_CRTIMP long double __cdecl truncl(_In_ long double _X);

#ifndef __cplusplus
#define _matherrl _matherr
#endif /* __cplusplus */
#endif  /* !defined (__assembler) */

#if !__STDC__

/* Non-ANSI names for compatibility */

#define DOMAIN      _DOMAIN
#define SING        _SING
#define OVERFLOW    _OVERFLOW
#define UNDERFLOW   _UNDERFLOW
#define TLOSS       _TLOSS
#define PLOSS       _PLOSS

#define matherr     _matherr

#ifndef __assembler

#if !defined (_M_CEE_PURE)
_CRTIMP extern double HUGE;
#else  /* !defined (_M_CEE_PURE) */
    const double HUGE = _HUGE;
#endif  /* !defined (_M_CEE_PURE) */

_CRT_NONSTDC_DEPRECATE(_j0) _CRTIMP double  __cdecl j0(_In_ double _X);
_CRT_NONSTDC_DEPRECATE(_j1) _CRTIMP double  __cdecl j1(_In_ double _X);
_CRT_NONSTDC_DEPRECATE(_jn) _CRTIMP double  __cdecl jn(_In_ int _X, _In_ double _Y);
_CRT_NONSTDC_DEPRECATE(_y0) _CRTIMP double  __cdecl y0(_In_ double _X);
_CRT_NONSTDC_DEPRECATE(_y1) _CRTIMP double  __cdecl y1(_In_ double _X);
_CRT_NONSTDC_DEPRECATE(_yn) _CRTIMP double  __cdecl yn(_In_ int _X, _In_ double _Y);

#endif  /* __assembler */
#endif  /* !__STDC__ */

#ifdef __cplusplus
}

extern "C++" {

template<class _Ty> inline
        _Ty _Pow_int(_Ty _X, int _Y) throw()
        {unsigned int _N;
        if (_Y >= 0)
                _N = (unsigned int)_Y;
        else
                _N = (unsigned int)(-_Y);
        for (_Ty _Z = _Ty(1); ; _X *= _X)
                {if ((_N & 1) != 0)
                        _Z *= _X;
                if ((_N >>= 1) == 0)
                        return (_Y < 0 ? _Ty(1) / _Z : _Z); }}

inline double __CRTDECL abs(_In_ double _X) throw()
        {return (fabs(_X)); }
inline double __CRTDECL pow(_In_ double _X, _In_ int _Y) throw()
        {return (_Pow_int(_X, _Y)); }
inline float __CRTDECL abs(_In_ float _X) throw()
        {return (fabsf(_X)); }
inline float __CRTDECL acos(_In_ float _X) throw()
        {return (acosf(_X)); }
inline float __CRTDECL acosh(_In_ float _X) throw()
        {return (acoshf(_X)); }
inline float __CRTDECL asin(_In_ float _X) throw()
        {return (asinf(_X)); }
inline float __CRTDECL asinh(_In_ float _X) throw()
        {return (asinhf(_X)); }
inline float __CRTDECL atan(_In_ float _X) throw()
        {return (atanf(_X)); }
inline float __CRTDECL atanh(_In_ float _X) throw()
        {return (atanhf(_X)); }
inline float __CRTDECL atan2(_In_ float _Y, _In_ float _X) throw()
        {return (atan2f(_Y, _X)); }
inline float __CRTDECL cbrt(_In_ float _X) throw()
        {return (cbrtf(_X)); }
inline float __CRTDECL ceil(_In_ float _X) throw()
        {return (ceilf(_X)); }
inline float __CRTDECL copysign(_In_ float _X, _In_ float _Y) throw()
        {return (copysignf(_X, _Y)); }
inline float __CRTDECL cos(_In_ float _X) throw()
        {return (cosf(_X)); }
inline float __CRTDECL cosh(_In_ float _X) throw()
        {return (coshf(_X)); }
inline float __CRTDECL erf(_In_ float _X) throw()
        {return (erff(_X)); }
inline float __CRTDECL erfc(_In_ float _X) throw()
        {return (erfcf(_X)); }
inline float __CRTDECL exp(_In_ float _X) throw()
        {return (expf(_X)); }
inline float __CRTDECL exp2(_In_ float _X) throw()
        {return (exp2f(_X)); }
inline float __CRTDECL expm1(_In_ float _X) throw()
        {return (expm1f(_X)); }
inline float __CRTDECL fabs(_In_ float _X) throw()
        {return (fabsf(_X)); }
inline float __CRTDECL fdim(_In_ float _X, _In_ float _Y) throw()
        {return (fdimf(_X, _Y)); }
inline float __CRTDECL floor(_In_ float _X) throw()
        {return (floorf(_X)); }
inline float __CRTDECL fma(_In_ float _X, _In_ float _Y, _In_ float _Z) throw()
        {return (fmaf(_X, _Y, _Z)); }
inline float __CRTDECL fmax(_In_ float _X, _In_ float _Y) throw()
        {return (fmaxf(_X, _Y)); }
inline float __CRTDECL fmin(_In_ float _X, _In_ float _Y) throw()
        {return (fminf(_X, _Y)); }
inline float __CRTDECL fmod(_In_ float _X, _In_ float _Y) throw()
        {return (fmodf(_X, _Y)); }
inline float __CRTDECL frexp(_In_ float _X, _Out_ int * _Y) throw()
        {return (frexpf(_X, _Y)); }
inline float __CRTDECL hypot(_In_ float _X, _In_ float _Y) throw()
        {return (hypotf(_X, _Y)); }
inline int __CRTDECL ilogb(_In_ float _X) throw()
        {return (ilogbf(_X)); }
inline float __CRTDECL ldexp(_In_ float _X, _In_ int _Y) throw()
        {return (ldexpf(_X, _Y)); }
inline float __CRTDECL lgamma(_In_ float _X) throw()
        {return (lgammaf(_X)); }
inline long long __CRTDECL llrint(_In_ float _X) throw()
        {return (llrintf(_X)); }
inline long long __CRTDECL llround(_In_ float _X) throw()
        {return (llroundf(_X)); }
inline float __CRTDECL log(_In_ float _X) throw()
        {return (logf(_X)); }
inline float __CRTDECL log10(_In_ float _X) throw()
        {return (log10f(_X)); }
inline float __CRTDECL log1p(_In_ float _X) throw()
        {return (log1pf(_X)); }
inline float __CRTDECL log2(_In_ float _X) throw()
        {return (log2f(_X)); }
inline float __CRTDECL logb(_In_ float _X) throw()
        {return (logbf(_X)); }
inline long __CRTDECL lrint(_In_ float _X) throw()
        {return (lrintf(_X)); }
inline long __CRTDECL lround(_In_ float _X) throw()
        {return (lroundf(_X)); }
inline float __CRTDECL modf(_In_ float _X, _Out_ float * _Y) throw()
        {return (modff(_X, _Y)); }
inline float __CRTDECL nearbyint(_In_ float _X) throw()
        {return (nearbyintf(_X)); }
inline float __CRTDECL nextafter(_In_ float _X, _In_ float _Y) throw()
        {return (nextafterf(_X, _Y)); }
inline float __CRTDECL nexttoward(_In_ float _X, _In_ long double _Y) throw()
        {return (nexttowardf(_X, _Y)); }
inline float __CRTDECL pow(_In_ float _X, _In_ float _Y) throw()
        {return (powf(_X, _Y)); }
inline float __CRTDECL pow(_In_ float _X, _In_ int _Y) throw()
        {return (_Pow_int(_X, _Y)); }
inline float __CRTDECL remainder(_In_ float _X, _In_ float _Y) throw()
        {return (remainderf(_X, _Y)); }
inline float __CRTDECL remquo(_In_ float _X, _In_ float _Y, _Out_ int *_Z) throw()
        {return (remquof(_X, _Y, _Z)); }
inline float __CRTDECL rint(_In_ float _X) throw()
        {return (rintf(_X)); }
inline float __CRTDECL round(_In_ float _X) throw()
        {return (roundf(_X)); }
inline float __CRTDECL scalbln(_In_ float _X, _In_ long _Y) throw()
        {return (scalblnf(_X, _Y)); }
inline float __CRTDECL scalbn(_In_ float _X, _In_ int _Y) throw()
        {return (scalbnf(_X, _Y)); }
inline float __CRTDECL sin(_In_ float _X) throw()
        {return (sinf(_X)); }
inline float __CRTDECL sinh(_In_ float _X) throw()
        {return (sinhf(_X)); }
inline float __CRTDECL sqrt(_In_ float _X) throw()
        {return (sqrtf(_X)); }
inline float __CRTDECL tan(_In_ float _X) throw()
        {return (tanf(_X)); }
inline float __CRTDECL tanh(_In_ float _X) throw()
        {return (tanhf(_X)); }
inline float __CRTDECL tgamma(_In_ float _X) throw()
        {return (tgammaf(_X)); }
inline float __CRTDECL trunc(_In_ float _X) throw()
        {return (truncf(_X)); }
inline long double __CRTDECL abs(_In_ long double _X) throw()
        {return (fabsl(_X)); }
inline long double __CRTDECL acos(_In_ long double _X) throw()
        {return (acosl(_X)); }
inline long double __CRTDECL acosh(_In_ long double _X) throw()
        {return (acoshl(_X)); }
inline long double __CRTDECL asin(_In_ long double _X) throw()
        {return (asinl(_X)); }
inline long double __CRTDECL asinh(_In_ long double _X) throw()
        {return (asinhl(_X)); }
inline long double __CRTDECL atan(_In_ long double _X) throw()
        {return (atanl(_X)); }
inline long double __CRTDECL atanh(_In_ long double _X) throw()
        {return (atanhl(_X)); }
inline long double __CRTDECL atan2(_In_ long double _Y, _In_ long double _X) throw()
        {return (atan2l(_Y, _X)); }
inline long double __CRTDECL cbrt(_In_ long double _X) throw()
        {return (cbrtl(_X)); }
inline long double __CRTDECL ceil(_In_ long double _X) throw()
        {return (ceill(_X)); }
inline long double __CRTDECL copysign(_In_ long double _X, _In_ long double _Y) throw()
        {return (copysignl(_X, _Y)); }
inline long double __CRTDECL cos(_In_ long double _X) throw()
        {return (cosl(_X)); }
inline long double __CRTDECL cosh(_In_ long double _X) throw()
        {return (coshl(_X)); }
inline long double __CRTDECL erf(_In_ long double _X) throw()
        {return (erfl(_X)); }
inline long double __CRTDECL erfc(_In_ long double _X) throw()
        {return (erfcl(_X)); }
inline long double __CRTDECL exp(_In_ long double _X) throw()
        {return (expl(_X)); }
inline long double __CRTDECL exp2(_In_ long double _X) throw()
        {return (exp2l(_X)); }
inline long double __CRTDECL expm1(_In_ long double _X) throw()
        {return (expm1l(_X)); }
inline long double __CRTDECL fabs(_In_ long double _X) throw()
        {return (fabsl(_X)); }
inline long double __CRTDECL fdim(_In_ long double _X, _In_ long double _Y) throw()
        {return (fdiml(_X, _Y)); }
inline long double __CRTDECL floor(_In_ long double _X) throw()
        {return (floorl(_X)); }
inline long double __CRTDECL fma(_In_ long double _X, _In_ long double _Y, _In_ long double _Z) throw()
        {return (fmal(_X, _Y, _Z)); }
inline long double __CRTDECL fmax(_In_ long double _X, _In_ long double _Y) throw()
        {return (fmaxl(_X, _Y)); }
inline long double __CRTDECL fmin(_In_ long double _X, _In_ long double _Y) throw()
        {return (fminl(_X, _Y)); }
inline long double __CRTDECL fmod(_In_ long double _X, _In_ long double _Y) throw()
        {return (fmodl(_X, _Y)); }
inline long double __CRTDECL frexp(_In_ long double _X, _Out_ int * _Y) throw()
        {return (frexpl(_X, _Y)); }
inline long double __CRTDECL hypot(_In_ long double _X, _In_ long double _Y) throw()
        {return (hypotl(_X, _Y)); }
inline int __CRTDECL ilogb(_In_ long double _X) throw()
        {return (ilogbl(_X)); }
inline long double __CRTDECL ldexp(_In_ long double _X, _In_ int _Y) throw()
        {return (ldexpl(_X, _Y)); }
inline long double __CRTDECL lgamma(_In_ long double _X) throw()
        {return (lgammal(_X)); }
inline long long __CRTDECL llrint(_In_ long double _X) throw()
        {return (llrintl(_X)); }
inline long long __CRTDECL llround(_In_ long double _X) throw()
        {return (llroundl(_X)); }
inline long double __CRTDECL log(_In_ long double _X) throw()
        {return (logl(_X)); }
inline long double __CRTDECL log10(_In_ long double _X) throw()
        {return (log10l(_X)); }
inline long double __CRTDECL log1p(_In_ long double _X) throw()
        {return (log1pl(_X)); }
inline long double __CRTDECL log2(_In_ long double _X) throw()
        {return (log2l(_X)); }
inline long double __CRTDECL logb(_In_ long double _X) throw()
        {return (logbl(_X)); }
inline long  __CRTDECL lrint(_In_ long double _X) throw()
        {return (lrintl(_X)); }
inline long  __CRTDECL lround(_In_ long double _X) throw()
        {return (lroundl(_X)); }
inline long double __CRTDECL modf(_In_ long double _X, _Out_ long double * _Y) throw()
        {return (modfl(_X, _Y)); }
inline long double __CRTDECL nearbyint(_In_ long double _X) throw()
        {return (nearbyintl(_X)); }
inline long double __CRTDECL nextafter(_In_ long double _X, _In_ long double _Y) throw()
        {return (nextafterl(_X, _Y)); }
inline long double __CRTDECL nexttoward(_In_ long double _X, _In_ long double _Y) throw()
        {return (nexttowardl(_X, _Y)); }
inline long double __CRTDECL pow(_In_ long double _X, _In_ long double _Y) throw()
        {return (powl(_X, _Y)); }
inline long double __CRTDECL pow(_In_ long double _X, _In_ int _Y) throw()
        {return (_Pow_int(_X, _Y)); }
inline long double __CRTDECL remainder(_In_ long double _X, _In_ long double _Y) throw()
        {return (remainderl(_X, _Y)); }
inline long double __CRTDECL remquo(_In_ long double _X, _In_ long double _Y, _Out_ int *_Z) throw()
        {return (remquol(_X, _Y, _Z)); }
inline long double __CRTDECL rint(_In_ long double _X) throw()
        {return (rintl(_X)); }
inline long double __CRTDECL round(_In_ long double _X) throw()
        {return (roundl(_X)); }
inline long double __CRTDECL scalbln(_In_ long double _X, _In_ long _Y) throw()
        {return (scalblnl(_X, _Y)); }
inline long double __CRTDECL scalbn(_In_ long double _X, _In_ int _Y) throw()
        {return (scalbnl(_X, _Y)); }
inline long double __CRTDECL sin(_In_ long double _X) throw()
        {return (sinl(_X)); }
inline long double __CRTDECL sinh(_In_ long double _X) throw()
        {return (sinhl(_X)); }
inline long double __CRTDECL sqrt(_In_ long double _X) throw()
        {return (sqrtl(_X)); }
inline long double __CRTDECL tan(_In_ long double _X) throw()
        {return (tanl(_X)); }
inline long double __CRTDECL tanh(_In_ long double _X) throw()
        {return (tanhl(_X)); }
inline long double __CRTDECL tgamma(_In_ long double _X) throw()
        {return (tgammal(_X)); }
inline long double __CRTDECL trunc(_In_ long double _X) throw()
        {return (truncl(_X)); }

}
#endif  /* __cplusplus */

#pragma pack(pop)

#endif  /* _INC_MATH */

#if defined (_USE_MATH_DEFINES) && !defined (_MATH_DEFINES_DEFINED)
#define _MATH_DEFINES_DEFINED

/* Define _USE_MATH_DEFINES before including math.h to expose these macro
 * definitions for common math constants.  These are placed under an #ifdef
 * since these commonly-defined names are not part of the C/C++ standards.
 */

/* Definitions of useful mathematical constants
 * M_E        - e
 * M_LOG2E    - log2(e)
 * M_LOG10E   - log10(e)
 * M_LN2      - ln(2)
 * M_LN10     - ln(10)
 * M_PI       - pi
 * M_PI_2     - pi/2
 * M_PI_4     - pi/4
 * M_1_PI     - 1/pi
 * M_2_PI     - 2/pi
 * M_2_SQRTPI - 2/sqrt(pi)
 * M_SQRT2    - sqrt(2)
 * M_SQRT1_2  - 1/sqrt(2)
 */

#define M_E        2.71828182845904523536
#define M_LOG2E    1.44269504088896340736
#define M_LOG10E   0.434294481903251827651
#define M_LN2      0.693147180559945309417
#define M_LN10     2.30258509299404568402
#define M_PI       3.14159265358979323846
#define M_PI_2     1.57079632679489661923
#define M_PI_4     0.785398163397448309616
#define M_1_PI     0.318309886183790671538
#define M_2_PI     0.636619772367581343076
#define M_2_SQRTPI 1.12837916709551257390
#define M_SQRT2    1.41421356237309504880
#define M_SQRT1_2  0.707106781186547524401

#endif  /* defined (_USE_MATH_DEFINES) && !defined (_MATH_DEFINES_DEFINED) */