xtgmath.h

/* xtgmath.h internal header */

#if defined(__cplusplus)

#pragma once

#ifndef _XTGMATH

#define _XTGMATH

#ifndef RC_INVOKED

#include <cstdlib>

#include <xtr1common>

#include <yvals.h>

#pragma pack(push,_CRT_PACKING)

#pragma pack(push,

)

#pragma warning(push,_STL_WARNING_LEVEL)

#pragma warning(push,

)

#pragma warning(disable: _STL_DISABLED_WARNINGS)

#pragma warning(disable:

4455

4494

4619

4643

4702

4984

4988

)

_STL_DISABLE_CLANG_WARNINGS

#pragma push_macro("new")

#undef new

_STD_BEGIN

namespace

std

{

template

class

_Ty1

class

_Ty2

using

_Common_float_type_t

conditional_t

is_same_v

_Ty1

long

double

> ||

is_same_v

_Ty2

long

double

long

double

conditional_t

is_same_v

_Ty1

float

> &&

is_same_v

_Ty2

float

double

>>;

// find type for two-argument math function

_STD_END

}

#define _CRTDEFAULT

#define _CRTSPECIAL _ACRTIMP

#define _GENERIC_MATH1R(FUN, RET, CRTTYPE) \

extern "C" _Check_return_ CRTTYPE RET __cdecl FUN(_In_ double); \

template<class _Ty, \

class = _STD enable_if_t<_STD is_integral_v<_Ty>>> _NODISCARD inline \

RET FUN(_Ty _Left) \

{ \

return (_CSTD FUN(static_cast<double>(_Left))); \

}

#define _GENERIC_MATH1(FUN, CRTTYPE) \

_GENERIC_MATH1R(FUN, double, CRTTYPE)

#define _GENERIC_MATH1X(FUN, ARG2, CRTTYPE) \

extern "C" _Check_return_ CRTTYPE double __cdecl FUN(_In_ double, ARG2); \

template<class _Ty, \

class = _STD enable_if_t<_STD is_integral_v<_Ty>>> _NODISCARD inline \

double FUN(_Ty _Left, ARG2 _Arg2) \

{ \

return (_CSTD FUN(static_cast<double>(_Left), _Arg2)); \

}

#define _GENERIC_MATH2_CALL(FUN, CRTTYPE, CALL_OPT) \

extern "C" _Check_return_ CRTTYPE double CALL_OPT FUN(_In_ double, _In_ double); \

template<class _Ty1, \

class _Ty2, \

class = _STD enable_if_t<_STD is_arithmetic_v<_Ty1> && _STD is_arithmetic_v<_Ty2>>> _NODISCARD inline \

_STD _Common_float_type_t<_Ty1, _Ty2> FUN(_Ty1 _Left, _Ty2 _Right) \

{ \

using _Common = _STD _Common_float_type_t<_Ty1, _Ty2>; \

return (_CSTD FUN(static_cast<_Common>(_Left), static_cast<_Common>(_Right))); \

}

#define _GENERIC_MATH2(FUN, CRTTYPE) \

_GENERIC_MATH2_CALL(FUN, CRTTYPE, __cdecl)

template

class

_Ty1

class

_Ty2

class = _STD enable_if_t<_STD is_arithmetic_v<_Ty1> && _STD is_arithmetic_v<_Ty2>>> _NODISCARD inline

class

= ::

std

enable_if_t

<::

std

is_arithmetic_v

_Ty1

> && ::

std

is_arithmetic_v

_Ty2

>>>

inline

_STD _Common_float_type_t<_Ty1, _Ty2> pow(const _Ty1 _Left, const _Ty2 _Right)

std

_Common_float_type_t

_Ty1

_Ty2

pow

(

const

_Ty1

_Left

const

_Ty2

_Right

)

{

// bring mixed types to a common type

using _Common = _STD _Common_float_type_t<_Ty1, _Ty2>;

using

_Common

= ::

std

_Common_float_type_t

_Ty1

_Ty2

return (_CSTD pow(static_cast<_Common>(_Left), static_cast<_Common>(_Right)));

return

(::

pow

(

static_cast

_Common

_Left

static_cast

_Common

_Right

)));

}

//_GENERIC_MATH1(abs, _CRTDEFAULT) // has integer overloads

_GENERIC_MATH1(acos, _CRTDEFAULT)

extern

"C"

double

__cdecl

acos

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

acos

(

_Ty

_Left

) {

return

(::

acos

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(asin, _CRTDEFAULT)

extern

"C"

double

__cdecl

asin

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

asin

(

_Ty

_Left

) {

return

(::

asin

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(atan, _CRTDEFAULT)

extern

"C"

double

__cdecl

atan

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

atan

(

_Ty

_Left

) {

return

(::

atan

(

static_cast

double

_Left

))); }

_GENERIC_MATH2(atan2, _CRTDEFAULT)

extern

"C"

double

__cdecl

atan2

(

double

);

template

class

_Ty1

class

_Ty2

class

= ::

std

enable_if_t

<::

std

is_arithmetic_v

_Ty1

> && ::

std

is_arithmetic_v

_Ty2

>>>

inline

std

_Common_float_type_t

_Ty1

_Ty2

atan2

(

_Ty1

_Left

_Ty2

_Right

) {

using

_Common

= ::

std

_Common_float_type_t

_Ty1

_Ty2

return

(::

atan2

(

static_cast

_Common

_Left

static_cast

_Common

_Right

))); }

_GENERIC_MATH1(ceil, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

ceil

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

ceil

(

_Ty

_Left

) {

return

(::

ceil

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(cos, _CRTDEFAULT)

extern

"C"

double

__cdecl

cos

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

cos

(

_Ty

_Left

) {

return

(::

cos

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(cosh, _CRTDEFAULT)

extern

"C"

double

__cdecl

cosh

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

cosh

(

_Ty

_Left

) {

return

(::

cosh

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(exp, _CRTDEFAULT)

extern

"C"

double

__cdecl

exp

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

exp

(

_Ty

_Left

) {

return

(::

exp

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(fabs, _CRT_JIT_INTRINSIC)

extern

"C"

double

__cdecl

fabs

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

fabs

(

_Ty

_Left

) {

return

(::

fabs

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(floor, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

floor

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

floor

(

_Ty

_Left

) {

return

(::

floor

(

static_cast

double

_Left

))); }

_GENERIC_MATH2(fmod, _CRTDEFAULT)

extern

"C"

double

__cdecl

fmod

(

double

);

template

class

_Ty1

class

_Ty2

class

= ::

std

enable_if_t

<::

std

is_arithmetic_v

_Ty1

> && ::

std

is_arithmetic_v

_Ty2

>>>

inline

std

_Common_float_type_t

_Ty1

_Ty2

fmod

(

_Ty1

_Left

_Ty2

_Right

) {

using

_Common

= ::

std

_Common_float_type_t

_Ty1

_Ty2

return

(::

fmod

(

static_cast

_Common

_Left

static_cast

_Common

_Right

))); }

_GENERIC_MATH1X(frexp, _Out_ int *, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

frexp

(

double

int

*);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

frexp

(

_Ty

_Left

int

_Arg2

) {

return

(::

frexp

(

static_cast

double

_Left

_Arg2

)); }

_GENERIC_MATH1X(ldexp, _In_ int, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

ldexp

(

double

int

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

ldexp

(

_Ty

_Left

int

_Arg2

) {

return

(::

ldexp

(

static_cast

double

_Left

_Arg2

)); }

_GENERIC_MATH1(log, _CRTDEFAULT)

extern

"C"

double

__cdecl

log

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

log

(

_Ty

_Left

) {

return

(::

log

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(log10, _CRTDEFAULT)

extern

"C"

double

__cdecl

log10

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

log10

(

_Ty

_Left

) {

return

(::

log10

(

static_cast

double

_Left

))); }

//_GENERIC_MATH1(modf, _CRTDEFAULT) // types must match

//_GENERIC_MATH2(pow, _CRTDEFAULT) // hand crafted

_GENERIC_MATH1(sin, _CRTDEFAULT)

extern

"C"

double

__cdecl

sin

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

sin

(

_Ty

_Left

) {

return

(::

sin

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(sinh, _CRTDEFAULT)

extern

"C"

double

__cdecl

sinh

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

sinh

(

_Ty

_Left

) {

return

(::

sinh

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(sqrt, _CRTDEFAULT)

extern

"C"

double

__cdecl

sqrt

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

sqrt

(

_Ty

_Left

) {

return

(::

sqrt

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(tan, _CRTDEFAULT)

extern

"C"

double

__cdecl

tan

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

tan

(

_Ty

_Left

) {

return

(::

tan

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(tanh, _CRTDEFAULT)

extern

"C"

double

__cdecl

tanh

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

tanh

(

_Ty

_Left

) {

return

(::

tanh

(

static_cast

double

_Left

))); }

// C99 MATH FUNCTIONS

// FUNCTION TEMPLATE fma

#if !_HAS_IF_CONSTEXPR

inline

float

_Fma

(

float

_Left

float

_Middle

float

_Right

) {

// call float fma

return (_CSTD fmaf(_Left, _Middle, _Right));

return

(::

fmaf

(

_Left

_Middle

_Right

));

}

inline

double

_Fma

(

double

_Left

double

_Middle

double

_Right

) {

// call double fma

return (_CSTD fma(_Left, _Middle, _Right));

return

(::

fma

(

_Left

_Middle

_Right

));

}

inline

long

double

_Fma

(

long

double

_Left

long

double

_Middle

long

double

_Right

) {

// call long double fma

return (_CSTD fmal(_Left, _Middle, _Right));

return

(::

fmal

(

_Left

_Middle

_Right

));

}

#endif /* ^^^ original code ^^^ */

template

class

_Ty1

class

_Ty2

class

_Ty3

class = _STD enable_if_t<_STD is_arithmetic_v<_Ty1> && _STD is_arithmetic_v<_Ty2>

class

= ::

std

enable_if_t

<::

std

is_arithmetic_v

_Ty1

> && ::

std

is_arithmetic_v

_Ty2

&& _STD is_arithmetic_v<_Ty3>>> _NODISCARD inline

&& ::

std

is_arithmetic_v

_Ty3

>>>

inline

_STD _Common_float_type_t<_Ty1, _STD _Common_float_type_t<_Ty2, _Ty3>>

std

_Common_float_type_t

_Ty1

, ::

std

_Common_float_type_t

_Ty2

_Ty3

fma

(

_Ty1

_Left

_Ty2

_Middle

_Ty3

_Right

) {

// bring mixed types to a common type

using _Common = _STD _Common_float_type_t<_Ty1, _STD _Common_float_type_t<_Ty2, _Ty3>>;

using

_Common

= ::

std

_Common_float_type_t

_Ty1

, ::

std

_Common_float_type_t

_Ty2

_Ty3

>>;

#if _HAS_IF_CONSTEXPR

if constexpr (_STD is_same_v<_Common, float>)

{

return (_CSTD fmaf(static_cast<_Common>(_Left), static_cast<_Common>(_Middle), static_cast<_Common>(_Right)));

}

else if constexpr (_STD is_same_v<_Common, double>)

{

return (_CSTD fma(static_cast<_Common>(_Left), static_cast<_Common>(_Middle), static_cast<_Common>(_Right)));

}

else

{

return (_CSTD fmal(static_cast<_Common>(_Left), static_cast<_Common>(_Middle), static_cast<_Common>(_Right)));

} #else /* vvv original code vvv */

return

(

_Fma

(

static_cast

_Common

_Left

static_cast

_Common

_Middle

static_cast

_Common

_Right

)));

#endif /* ^^^ original code ^^^ */

}

// FUNCTION TEMPLATE remquo

#if !_HAS_IF_CONSTEXPR

inline

float

_Remquo

(

float

_Left

float

_Right

int

_Pquo

) {

// call float remquo

return (_CSTD remquof(_Left, _Right, _Pquo));

return

(::

remquof

(

_Left

_Right

_Pquo

));

}

inline

double

_Remquo

(

double

_Left

double

_Right

int

_Pquo

) {

// call double remquo

return (_CSTD remquo(_Left, _Right, _Pquo));

return

(::

remquo

(

_Left

_Right

_Pquo

));

}

inline

long

double

_Remquo

(

long

double

_Left

long

double

_Right

int

_Pquo

) {

// call long double remquo

return (_CSTD remquol(_Left, _Right, _Pquo));

return

(::

remquol

(

_Left

_Right

_Pquo

));

}

#endif /* ^^^ original code ^^^ */

template

class

_Ty1

class

_Ty2

class = _STD enable_if_t<_STD is_arithmetic_v<_Ty1> && _STD is_arithmetic_v<_Ty2>>> inline

class

= ::

std

enable_if_t

<::

std

is_arithmetic_v

_Ty1

> && ::

std

is_arithmetic_v

_Ty2

>>>

inline

_STD _Common_float_type_t<_Ty1, _Ty2>

std

_Common_float_type_t

_Ty1

_Ty2

remquo

(

_Ty1

_Left

_Ty2

_Right

int

_Pquo

) {

// bring mixed types to a common type

using _Common = _STD _Common_float_type_t<_Ty1, _Ty2>;

using

_Common

= ::

std

_Common_float_type_t

_Ty1

_Ty2

#if _HAS_IF_CONSTEXPR

if constexpr (_STD is_same_v<_Common, float>)

{

return (_CSTD remquof(static_cast<_Common>(_Left), static_cast<_Common>(_Right), _Pquo));

}

else if constexpr (_STD is_same_v<_Common, double>)

{

return (_CSTD remquo(static_cast<_Common>(_Left), static_cast<_Common>(_Right), _Pquo));

}

else

{

return (_CSTD remquol(static_cast<_Common>(_Left), static_cast<_Common>(_Right), _Pquo));

} #else /* vvv original code vvv */

return

(

_Remquo

(

static_cast

_Common

_Left

static_cast

_Common

_Right

_Pquo

));

#endif /* ^^^ original code ^^^ */

}

_GENERIC_MATH1(acosh, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

acosh

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

acosh

(

_Ty

_Left

) {

return

(::

acosh

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(asinh, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

asinh

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

asinh

(

_Ty

_Left

) {

return

(::

asinh

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(atanh, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

atanh

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

atanh

(

_Ty

_Left

) {

return

(::

atanh

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(cbrt, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

cbrt

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

cbrt

(

_Ty

_Left

) {

return

(::

cbrt

(

static_cast

double

_Left

))); }

_GENERIC_MATH2(copysign, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

copysign

(

double

);

template

class

_Ty1

class

_Ty2

class

= ::

std

enable_if_t

<::

std

is_arithmetic_v

_Ty1

> && ::

std

is_arithmetic_v

_Ty2

>>>

inline

std

_Common_float_type_t

_Ty1

_Ty2

copysign

(

_Ty1

_Left

_Ty2

_Right

) {

using

_Common

= ::

std

_Common_float_type_t

_Ty1

_Ty2

return

(::

copysign

(

static_cast

_Common

_Left

static_cast

_Common

_Right

))); }

_GENERIC_MATH1(erf, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

erf

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

erf

(

_Ty

_Left

) {

return

(::

erf

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(erfc, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

erfc

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

erfc

(

_Ty

_Left

) {

return

(::

erfc

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(expm1, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

expm1

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

expm1

(

_Ty

_Left

) {

return

(::

expm1

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(exp2, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

exp2

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

exp2

(

_Ty

_Left

) {

return

(::

exp2

(

static_cast

double

_Left

))); }

_GENERIC_MATH2(fdim, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

fdim

(

double

);

template

class

_Ty1

class

_Ty2

class

= ::

std

enable_if_t

<::

std

is_arithmetic_v

_Ty1

> && ::

std

is_arithmetic_v

_Ty2

>>>

inline

std

_Common_float_type_t

_Ty1

_Ty2

fdim

(

_Ty1

_Left

_Ty2

_Right

) {

using

_Common

= ::

std

_Common_float_type_t

_Ty1

_Ty2

return

(::

fdim

(

static_cast

_Common

_Left

static_cast

_Common

_Right

))); }

//_GENERIC_MATH3(fma, _CRTSPECIAL) // hand crafted

_GENERIC_MATH2(fmax, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

fmax

(

double

);

template

class

_Ty1

class

_Ty2

class

= ::

std

enable_if_t

<::

std

is_arithmetic_v

_Ty1

> && ::

std

is_arithmetic_v

_Ty2

>>>

inline

std

_Common_float_type_t

_Ty1

_Ty2

fmax

(

_Ty1

_Left

_Ty2

_Right

) {

using

_Common

= ::

std

_Common_float_type_t

_Ty1

_Ty2

return

(::

fmax

(

static_cast

_Common

_Left

static_cast

_Common

_Right

))); }

_GENERIC_MATH2(fmin, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

fmin

(

double

);

template

class

_Ty1

class

_Ty2

class

= ::

std

enable_if_t

<::

std

is_arithmetic_v

_Ty1

> && ::

std

is_arithmetic_v

_Ty2

>>>

inline

std

_Common_float_type_t

_Ty1

_Ty2

fmin

(

_Ty1

_Left

_Ty2

_Right

) {

using

_Common

= ::

std

_Common_float_type_t

_Ty1

_Ty2

return

(::

fmin

(

static_cast

_Common

_Left

static_cast

_Common

_Right

))); }

_GENERIC_MATH2(hypot, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

hypot

(

double

);

template

class

_Ty1

class

_Ty2

class

= ::

std

enable_if_t

<::

std

is_arithmetic_v

_Ty1

> && ::

std

is_arithmetic_v

_Ty2

>>>

inline

std

_Common_float_type_t

_Ty1

_Ty2

hypot

(

_Ty1

_Left

_Ty2

_Right

) {

using

_Common

= ::

std

_Common_float_type_t

_Ty1

_Ty2

return

(::

hypot

(

static_cast

_Common

_Left

static_cast

_Common

_Right

))); }

_GENERIC_MATH1R(ilogb, int, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

int

__cdecl

ilogb

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

int

ilogb

(

_Ty

_Left

) {

return

(::

ilogb

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(lgamma, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

lgamma

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

lgamma

(

_Ty

_Left

) {

return

(::

lgamma

(

static_cast

double

_Left

))); }

_GENERIC_MATH1R(llrint, long long, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

long

__cdecl

llrint

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

long

llrint

(

_Ty

_Left

) {

return

(::

llrint

(

static_cast

double

_Left

))); }

_GENERIC_MATH1R(llround, long long, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

long

__cdecl

llround

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

long

llround

(

_Ty

_Left

) {

return

(::

llround

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(log1p, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

log1p

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

log1p

(

_Ty

_Left

) {

return

(::

log1p

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(log2, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

log2

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

log2

(

_Ty

_Left

) {

return

(::

log2

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(logb, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

logb

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

logb

(

_Ty

_Left

) {

return

(::

logb

(

static_cast

double

_Left

))); }

_GENERIC_MATH1R(lrint, long, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

long

__cdecl

lrint

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

long

lrint

(

_Ty

_Left

) {

return

(::

lrint

(

static_cast

double

_Left

))); }

_GENERIC_MATH1R(lround, long, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

long

__cdecl

lround

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

long

lround

(

_Ty

_Left

) {

return

(::

lround

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(nearbyint, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

nearbyint

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

nearbyint

(

_Ty

_Left

) {

return

(::

nearbyint

(

static_cast

double

_Left

))); }

_GENERIC_MATH2(nextafter, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

nextafter

(

double

);

template

class

_Ty1

class

_Ty2

class

= ::

std

enable_if_t

<::

std

is_arithmetic_v

_Ty1

> && ::

std

is_arithmetic_v

_Ty2

>>>

inline

std

_Common_float_type_t

_Ty1

_Ty2

nextafter

(

_Ty1

_Left

_Ty2

_Right

) {

using

_Common

= ::

std

_Common_float_type_t

_Ty1

_Ty2

return

(::

nextafter

(

static_cast

_Common

_Left

static_cast

_Common

_Right

))); }

_GENERIC_MATH1X(nexttoward, _In_ long double, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

nexttoward

(

double

long

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

nexttoward

(

_Ty

_Left

long

double

_Arg2

) {

return

(::

nexttoward

(

static_cast

double

_Left

_Arg2

)); }

_GENERIC_MATH2(remainder, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

remainder

(

double

);

template

class

_Ty1

class

_Ty2

class

= ::

std

enable_if_t

<::

std

is_arithmetic_v

_Ty1

> && ::

std

is_arithmetic_v

_Ty2

>>>

inline

std

_Common_float_type_t

_Ty1

_Ty2

remainder

(

_Ty1

_Left

_Ty2

_Right

) {

using

_Common

= ::

std

_Common_float_type_t

_Ty1

_Ty2

return

(::

remainder

(

static_cast

_Common

_Left

static_cast

_Common

_Right

))); }

//_GENERIC_MATH2X(remquo, _CRTSPECIAL) // hand crafted

_GENERIC_MATH1(rint, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

rint

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

rint

(

_Ty

_Left

) {

return

(::

rint

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(round, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

round

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

round

(

_Ty

_Left

) {

return

(::

round

(

static_cast

double

_Left

))); }

_GENERIC_MATH1X(scalbln, _In_ long, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

scalbln

(

double

long

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

scalbln

(

_Ty

_Left

long

_Arg2

) {

return

(::

scalbln

(

static_cast

double

_Left

_Arg2

)); }

_GENERIC_MATH1X(scalbn, _In_ int, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

scalbn

(

double

int

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

scalbn

(

_Ty

_Left

int

_Arg2

) {

return

(::

scalbn

(

static_cast

double

_Left

_Arg2

)); }

_GENERIC_MATH1(tgamma, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

tgamma

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

tgamma

(

_Ty

_Left

) {

return

(::

tgamma

(

static_cast

double

_Left

))); }

_GENERIC_MATH1(trunc, _CRTSPECIAL)

extern

"C"

__declspec

(dllimport)

double

__cdecl

trunc

(

double

);

template

class

_Ty

class

= ::

std

enable_if_t

<::

std

is_integral_v

_Ty

>>>

inline

double

trunc

(

_Ty

_Left

) {

return

(::

trunc

(

static_cast

double

_Left

))); }

#undef _CRTDEFAULT

#undef _CRTSPECIAL

#undef _GENERIC_MATH1R

#undef _GENERIC_MATH1

#undef _GENERIC_MATH1X

#undef _GENERIC_MATH2_CALL

#undef _GENERIC_MATH2

#pragma pop_macro("new")

_STL_RESTORE_CLANG_WARNINGS

#pragma warning(pop)

#pragma pack(pop) #endif /* RC_INVOKED */ #endif /* _XTGMATH */ #endif /* defined(__cplusplus) */

#pragma pack(pop)