標(biāo)題: math.h頭文件下載 [打印本頁(yè)]
作者: das    時(shí)間: 2015-4-18 01:29
標(biāo)題: math.h頭文件下載
math.h單片機(jī)頭文件代碼最后的復(fù)制代碼保存到電腦的方式實(shí)現(xiàn)下載：一共有2個(gè)版本
  1. /* math.h standard header */

  3. /* Copyright 2003-2010 IAR Systems AB. */

  5. #ifndef _MATH

  7. #define _MATH



  11. #ifndef _SYSTEM_BUILD

  13.   #pragma system_include

  15. #endif



  19. #include <ycheck.h>

  21. #include <ymath.h>

  23. #include <xtgmath.h>



  27. _C_STD_BEGIN



  31. #if __AEABI_PORTABILITY_INTERNAL_LEVEL

  33.   #ifndef __AEABI_PORTABLE

  35.     #define __AEABI_PORTABLE

  37.   #endif



  41.   #define HUGE_VAL        _CSTD __aeabi_HUGE_VAL



  45.   #if _DLIB_ADD_C99_SYMBOLS

  47.     #define HUGE_VALF     _CSTD __aeabi_HUGE_VALF

  49.     #define HUGE_VALL     _CSTD __aeabi_HUGE_VALL



  53.     #define INFINITY      _CSTD __aeabi_INFINITY

  55.     #define NAN           _CSTD __aeabi_NAN

  57.   #endif /* _DLIB_ADD_C99_SYMBOLS */

  59. #else /* __AEABI_PORTABILITY_INTERNAL_LEVEL */

  61.   #define HUGE_VAL        (0.Infinity)



  65.   #if _DLIB_ADD_C99_SYMBOLS

  67.     #define HUGE_VALF     ((float) 0.Infinity)

  69.     #define HUGE_VALL     ((long double) 0.Infinity)



  73.     #define INFINITY      ((float) 0.Infinity)

  75.     #define NAN           ((float) 0.NaN)

  77.   #endif /* _DLIB_ADD_C99_SYMBOLS */

  79. #endif /* __AEABI_PORTABILITY_INTERNAL_LEVEL */



  83. #if _DLIB_ADD_C99_SYMBOLS

  85.   typedef float float_t;

  87.   typedef double double_t;

  89. #endif /* _DLIB_ADD_C99_SYMBOLS */





  95. _C_LIB_DECL

  97.                 /* double declarations */

  99. __EFF_NS    __ATTRIBUTES double acos(double);

  101. __EFF_NS    __ATTRIBUTES double asin(double);

  103. __EFF_NS    __ATTRIBUTES double atan(double);

  105. __EFF_NS    __ATTRIBUTES double atan2(double, double);

  107. __EFF_NE    __ATTRIBUTES double ceil(double);

  109. __EFF_NS    __ATTRIBUTES double exp(double);

  111. __EFF_NE    __ATTRIBUTES double fabs(double);

  113. __EFF_NE    __ATTRIBUTES double floor(double);

  115. __EFF_NS    __ATTRIBUTES double fmod(double, double);

  117. __EFF_NENR2 __ATTRIBUTES double frexp(double, int *);

  119. __EFF_NS    __ATTRIBUTES double ldexp(double, int);

  121. __EFF_NENR2 __ATTRIBUTES double modf(double, double *);

  123. __EFF_NS    __ATTRIBUTES double pow(double, double);

  125. __EFF_NS    __ATTRIBUTES double sqrt(double);

  127. __EFF_NS    __ATTRIBUTES double tan(double);

  129. __EFF_NS    __ATTRIBUTES double tanh(double);



  133. __EFF_NS    __ATTRIBUTES double cos(double);

  135. __EFF_NS    __ATTRIBUTES double cosh(double);

  137. __EFF_NS    __ATTRIBUTES double log(double);

  139. __EFF_NS    __ATTRIBUTES double log10(double);

  141. __EFF_NS    __ATTRIBUTES double sin(double);

  143. __EFF_NS    __ATTRIBUTES double sinh(double);



  147. #if _DLIB_ADD_C99_SYMBOLS



  151.                 /* double declarations */

  153.   __EFF_NS    __ATTRIBUTES double acosh(double);

  155.   __EFF_NS    __ATTRIBUTES double asinh(double);

  157.   __EFF_NS    __ATTRIBUTES double atanh(double);

  159.   __EFF_NE    __ATTRIBUTES double cbrt(double);

  161.   __EFF_NE    __ATTRIBUTES double copysign(double, double);

  163.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  165.     __EFF_NS    __ATTRIBUTES double erf(double);

  167.     __EFF_NS    __ATTRIBUTES double erfc(double);

  169.     __EFF_NS    __ATTRIBUTES double expm1(double);

  171.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  173.   __EFF_NS    __ATTRIBUTES double exp2(double);

  175.   __EFF_NE    __ATTRIBUTES double fdim(double, double);

  177.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  179.     __EFF_NS    __ATTRIBUTES double fma(double, double, double);

  181.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  183.   __EFF_NE    __ATTRIBUTES double fmax(double, double);

  185.   __EFF_NE    __ATTRIBUTES double fmin(double, double);

  187.   __EFF_NS    __ATTRIBUTES double hypot(double, double);

  189.   __EFF_NE    __ATTRIBUTES int    ilogb(double);

  191.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  193.     __EFF_NS    __ATTRIBUTES double lgamma(double);

  195.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  197.   #ifdef _LONGLONG

  199.     #pragma language=save

  201.     #pragma language=extended

  203.     __EFF_NS __ATTRIBUTES _Longlong llrint(double);

  205.     __EFF_NS __ATTRIBUTES _Longlong llround(double);

  207.     #pragma language=restore

  209.   #endif /* _LONGLONG */

  211.   __EFF_NS    __ATTRIBUTES double log1p(double);

  213.   __EFF_NS    __ATTRIBUTES double log2(double);

  215.   __EFF_NS    __ATTRIBUTES double logb(double);

  217.   __EFF_NS    __ATTRIBUTES long   lrint(double);

  219.   __EFF_NS    __ATTRIBUTES long   lround(double);

  221.   __EFF_NE    __ATTRIBUTES double nan(const char *);

  223.   __EFF_NS    __ATTRIBUTES double nearbyint(double);

  225.   __EFF_NS    __ATTRIBUTES double nextafter(double, double);

  227.   __EFF_NS    __ATTRIBUTES double nexttoward(double, long double);

  229.   __EFF_NS    __ATTRIBUTES double remainder(double, double);

  231.   __EFF_NS    __ATTRIBUTES double remquo(double, double, int *);

  233.   __EFF_NS    __ATTRIBUTES double rint(double);

  235.   __EFF_NE    __ATTRIBUTES double round(double);

  237.   __EFF_NS    __ATTRIBUTES double scalbn(double, int);

  239.   __EFF_NS    __ATTRIBUTES double scalbln(double, long);

  241.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  243.     __EFF_NS    __ATTRIBUTES double tgamma(double);

  245.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  247.   __EFF_NE    __ATTRIBUTES double trunc(double);



  251.                 /* float declarations */

  253.   __EFF_NS    __ATTRIBUTES float acosf(float);

  255.   __EFF_NS    __ATTRIBUTES float asinf(float);

  257.   __EFF_NS    __ATTRIBUTES float atanf(float);

  259.   __EFF_NS    __ATTRIBUTES float atan2f(float, float);

  261.   __EFF_NE    __ATTRIBUTES float ceilf(float);

  263.   __EFF_NS    __ATTRIBUTES float expf(float);

  265.   __EFF_NE    __ATTRIBUTES float fabsf(float);

  267.   __EFF_NE    __ATTRIBUTES float floorf(float);

  269.   __EFF_NS    __ATTRIBUTES float fmodf(float, float);

  271.   __EFF_NENR2 __ATTRIBUTES float frexpf(float, int *);

  273.   __EFF_NS    __ATTRIBUTES float ldexpf(float, int);

  275.   __EFF_NENR2 __ATTRIBUTES float modff(float, float *);

  277.   __EFF_NS    __ATTRIBUTES float powf(float, float);

  279.   __EFF_NS    __ATTRIBUTES float sqrtf(float);

  281.   __EFF_NS    __ATTRIBUTES float tanf(float);

  283.   __EFF_NS    __ATTRIBUTES float tanhf(float);



  287.   __EFF_NS    __ATTRIBUTES float acoshf(float);

  289.   __EFF_NS    __ATTRIBUTES float asinhf(float);

  291.   __EFF_NS    __ATTRIBUTES float atanhf(float);

  293.   __EFF_NE    __ATTRIBUTES float cbrtf(float);

  295.   __EFF_NE    __ATTRIBUTES float copysignf(float, float);

  297.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  299.     __EFF_NS    __ATTRIBUTES float erff(float);

  301.     __EFF_NS    __ATTRIBUTES float erfcf(float);

  303.     __EFF_NS    __ATTRIBUTES float expm1f(float);

  305.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  307.   __EFF_NS    __ATTRIBUTES float exp2f(float);

  309.   __EFF_NE    __ATTRIBUTES float fdimf(float, float);

  311.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  313.     __EFF_NS    __ATTRIBUTES float fmaf(float, float, float);

  315.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  317.   __EFF_NE    __ATTRIBUTES float fmaxf(float, float);

  319.   __EFF_NE    __ATTRIBUTES float fminf(float, float);

  321.   __EFF_NS    __ATTRIBUTES float hypotf(float, float);

  323.   __EFF_NE    __ATTRIBUTES int   ilogbf(float);

  325.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  327.     __EFF_NS    __ATTRIBUTES float lgammaf(float);

  329.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  331.   #ifdef _LONGLONG

  333.     #pragma language=save

  335.     #pragma language=extended

  337.     __EFF_NS    __ATTRIBUTES _Longlong llrintf(float);

  339.     __EFF_NS    __ATTRIBUTES _Longlong llroundf(float);

  341.     #pragma language=restore

  343.   #endif /* _LONGLONG */

  345.   __EFF_NS    __ATTRIBUTES float log1pf(float);

  347.   __EFF_NS    __ATTRIBUTES float log2f(float);

  349.   __EFF_NS    __ATTRIBUTES float logbf(float);

  351.   __EFF_NS    __ATTRIBUTES long  lrintf(float);

  353.   __EFF_NS    __ATTRIBUTES long  lroundf(float);

  355.   __EFF_NE    __ATTRIBUTES float nanf(const char *);

  357.   __EFF_NS    __ATTRIBUTES float nearbyintf(float);

  359.   __EFF_NS    __ATTRIBUTES float nextafterf(float, float);

  361.   __EFF_NS    __ATTRIBUTES float nexttowardf(float, long double);

  363.   __EFF_NS    __ATTRIBUTES float remainderf(float, float);

  365.   __EFF_NS    __ATTRIBUTES float remquof(float, float, int *);

  367.   __EFF_NS    __ATTRIBUTES float rintf(float);

  369.   __EFF_NE    __ATTRIBUTES float roundf(float);

  371.   __EFF_NS    __ATTRIBUTES float scalbnf(float, int);

  373.   __EFF_NS    __ATTRIBUTES float scalblnf(float, long);

  375.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  377.     __EFF_NS    __ATTRIBUTES float tgammaf(float);

  379.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  381.   __EFF_NE    __ATTRIBUTES float truncf(float);



  385.   __EFF_NS    __ATTRIBUTES float cosf(float);

  387.   __EFF_NS    __ATTRIBUTES float coshf(float);

  389.   __EFF_NS    __ATTRIBUTES float logf(float);

  391.   __EFF_NS    __ATTRIBUTES float log10f(float);

  393.   __EFF_NS    __ATTRIBUTES float sinf(float);

  395.   __EFF_NS    __ATTRIBUTES float sinhf(float);



  399.                 /* long double declarations */

  401.   __EFF_NS    __ATTRIBUTES long double acosl(long double);

  403.   __EFF_NS    __ATTRIBUTES long double asinl(long double);

  405.   __EFF_NS    __ATTRIBUTES long double atanl(long double);

  407.   __EFF_NS    __ATTRIBUTES long double atan2l(long double, long double);

  409.   __EFF_NE    __ATTRIBUTES long double ceill(long double);

  411.   __EFF_NS    __ATTRIBUTES long double expl(long double);

  413.   __EFF_NE    __ATTRIBUTES long double fabsl(long double);

  415.   __EFF_NE    __ATTRIBUTES long double floorl(long double);

  417.   __EFF_NS    __ATTRIBUTES long double fmodl(long double, long double);

  419.   __EFF_NENR2 __ATTRIBUTES long double frexpl(long double, int *);

  421.   __EFF_NS    __ATTRIBUTES long double ldexpl(long double, int);

  423.   __EFF_NENR2 __ATTRIBUTES long double modfl(long double, long double *);

  425.   __EFF_NS    __ATTRIBUTES long double powl(long double, long double);

  427.   __EFF_NS    __ATTRIBUTES long double sqrtl(long double);

  429.   __EFF_NS    __ATTRIBUTES long double tanl(long double);

  431.   __EFF_NS    __ATTRIBUTES long double tanhl(long double);



  435.   __EFF_NS    __ATTRIBUTES long double acoshl(long double);

  437.   __EFF_NS    __ATTRIBUTES long double asinhl(long double);

  439.   __EFF_NS    __ATTRIBUTES long double atanhl(long double);

  441.   __EFF_NE    __ATTRIBUTES long double cbrtl(long double);

  443.   __EFF_NE    __ATTRIBUTES long double copysignl(long double, long double);

  445.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  447.     __EFF_NS    __ATTRIBUTES long double erfl(long double);

  449.     __EFF_NS    __ATTRIBUTES long double erfcl(long double);

  451.     __EFF_NS    __ATTRIBUTES long double expm1l(long double);

  453.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  455.   __EFF_NS    __ATTRIBUTES long double exp2l(long double);

  457.   __EFF_NE    __ATTRIBUTES long double fdiml(long double, long double);

  459.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  461.     __EFF_NS    __ATTRIBUTES long double fmal(long double, long double,

  463.                                               long double);

  465.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  467.   __EFF_NE    __ATTRIBUTES long double fmaxl(long double, long double);

  469.   __EFF_NE    __ATTRIBUTES long double fminl(long double, long double);

  471.   __EFF_NS    __ATTRIBUTES long double hypotl(long double, long double);

  473.   __EFF_NE    __ATTRIBUTES int         ilogbl(long double);

  475.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  477.     __EFF_NS    __ATTRIBUTES long double lgammal(long double);

  479.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  481.   #ifdef _LONGLONG

  483.     #pragma language=save

  485.     #pragma language=extended

  487.     __EFF_NS    __ATTRIBUTES _Longlong llrintl(long double);

  489.     __EFF_NS    __ATTRIBUTES _Longlong llroundl(long double);

  491.     #pragma language=restore

  493.   #endif /* _LONGLONG */

  495.   __EFF_NS    __ATTRIBUTES long double log1pl(long double);

  497.   __EFF_NS    __ATTRIBUTES long double log2l(long double);

  499.   __EFF_NS    __ATTRIBUTES long double logbl(long double);

  501.   __EFF_NS    __ATTRIBUTES long        lrintl(long double);

  503.   __EFF_NS    __ATTRIBUTES long lroundl(long double);

  505.   __EFF_NE    __ATTRIBUTES long double nanl(const char *);

  507.   __EFF_NS    __ATTRIBUTES long double nearbyintl(long double);

  509.   __EFF_NS    __ATTRIBUTES long double nextafterl(long double, long double);

  511.   __EFF_NS    __ATTRIBUTES long double nexttowardl(long double, long double);

  513.   __EFF_NS    __ATTRIBUTES long double remainderl(long double, long double);

  515.   __EFF_NS    __ATTRIBUTES long double remquol(long double, long double, int *);

  517.   __EFF_NS    __ATTRIBUTES long double rintl(long double);

  519.   __EFF_NE    __ATTRIBUTES long double roundl(long double);

  521.   __EFF_NS    __ATTRIBUTES long double scalbnl(long double, int);

  523.   __EFF_NS    __ATTRIBUTES long double scalblnl(long double, long);

  525.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  527.     __EFF_NS    __ATTRIBUTES long double tgammal(long double);

  529.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  531.   __EFF_NE    __ATTRIBUTES long double truncl(long double);



  535.   __EFF_NS    __ATTRIBUTES long double cosl(long double);

  537.   __EFF_NS    __ATTRIBUTES long double coshl(long double);

  539.   __EFF_NS    __ATTRIBUTES long double logl(long double);

  541.   __EFF_NS    __ATTRIBUTES long double log10l(long double);

  543.   __EFF_NS    __ATTRIBUTES long double sinl(long double);

  545.   __EFF_NS    __ATTRIBUTES long double sinhl(long double);

  547. #endif /* _DLIB_ADD_C99_SYMBOLS */



  551. #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH && \

  553.     !defined(_DLIB_DO_NOT_ADD_ACCURATE_FUNCTIONS)

  555.                 /* Accurate versions of certain float functions. */

  557. __EFF_NS __ATTRIBUTES double __iar_tan_accurate(double);

  559. __EFF_NS __ATTRIBUTES double __iar_cos_accurate(double);

  561. __EFF_NS __ATTRIBUTES double __iar_sin_accurate(double);

  563. __EFF_NS __ATTRIBUTES double __iar_pow_accurate(double, double);



  567. __EFF_NS __ATTRIBUTES double __iar_Sin_accurate(double, unsigned int);

  569. __EFF_NS __ATTRIBUTES double __iar_Pow_accurate(double, double, short *pex);

  571. #if _DLIB_ADD_C99_SYMBOLS

  573.   __EFF_NS __ATTRIBUTES float __iar_tan_accuratef(float);

  575.   __EFF_NS __ATTRIBUTES float __iar_cos_accuratef(float);

  577.   __EFF_NS __ATTRIBUTES float __iar_sin_accuratef(float);

  579.   __EFF_NS __ATTRIBUTES float __iar_pow_accuratef(float, float);



  583.   __EFF_NS __ATTRIBUTES float __iar_Sin_accuratef(float, unsigned int);

  585.   __EFF_NS __ATTRIBUTES float __iar_Pow_accuratef(float, float, short *pex);



  589.   __EFF_NS __ATTRIBUTES long double __iar_tan_accuratel(long double);

  591.   __EFF_NS __ATTRIBUTES long double __iar_cos_accuratel(long double);

  593.   __EFF_NS __ATTRIBUTES long double __iar_sin_accuratel(long double);

  595.   __EFF_NS __ATTRIBUTES long double __iar_pow_accuratel(long double,

  597.                                                         long double);



  601.   __EFF_NS __ATTRIBUTES long double __iar_Sin_accuratel(long double,

  603.                                                         unsigned int);

  605.   __EFF_NS __ATTRIBUTES long double __iar_Pow_accuratel(long double,

  607.                                                         long double,

  609.                                                         short *pex);

  611. #endif /* _DLIB_ADD_C99_SYMBOLS */

  613. #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH &&

  615.           !defined(_DLIB_DO_NOT_ADD_ACCURATE_FUNCTIONS) */



  619. #ifndef _DLIB_DO_NOT_ADD_SMALL_FUNCTIONS

  621.                 /* Small versions of certain float functions. */

  623. __EFF_NS __ATTRIBUTES double __iar_cos_small(double);

  625. __EFF_NS __ATTRIBUTES double __iar_exp_small(double);

  627. __EFF_NS __ATTRIBUTES double __iar_log_small(double);

  629. __EFF_NS __ATTRIBUTES double __iar_log10_small(double);

  631. __EFF_NS __ATTRIBUTES double __iar_pow_small(double, double);

  633. __EFF_NS __ATTRIBUTES double __iar_sin_small(double);

  635. __EFF_NS __ATTRIBUTES double __iar_tan_small(double);

  637. #if _DLIB_ADD_C99_SYMBOLS

  639. __EFF_NS __ATTRIBUTES float __iar_cos_smallf(float);

  641. __EFF_NS __ATTRIBUTES float __iar_exp_smallf(float);

  643. __EFF_NS __ATTRIBUTES float __iar_log_smallf(float);

  645. __EFF_NS __ATTRIBUTES float __iar_log10_smallf(float);

  647. __EFF_NS __ATTRIBUTES float __iar_pow_smallf(float, float);

  649. __EFF_NS __ATTRIBUTES float __iar_sin_smallf(float);

  651. __EFF_NS __ATTRIBUTES float __iar_tan_smallf(float);



  655. __EFF_NS __ATTRIBUTES long double __iar_cos_smalll(long double);

  657. __EFF_NS __ATTRIBUTES long double __iar_exp_smalll(long double);

  659. __EFF_NS __ATTRIBUTES long double __iar_log_smalll(long double);

  661. __EFF_NS __ATTRIBUTES long double __iar_log10_smalll(long double);

  663. __EFF_NS __ATTRIBUTES long double __iar_pow_smalll(long double, long double);

  665. __EFF_NS __ATTRIBUTES long double __iar_sin_smalll(long double);

  667. __EFF_NS __ATTRIBUTES long double __iar_tan_smalll(long double);

  669. #endif /* _DLIB_ADD_C99_SYMBOLS */

  671. #endif /* _DLIB_DO_NOT_ADD_SMALL_FUNCTIONS */



  675. _END_C_LIB_DECL



  679. #ifdef __cplusplus

  681.   _EXTERN_CPP

  683.   __EFF_NE    __ATTRIBUTES double abs(double);

  685.   __EFF_NS    __ATTRIBUTES double pow(double, int);



  689.   __EFF_NE    __ATTRIBUTES float abs(float);

  691.   __EFF_NS    __ATTRIBUTES float acos(float);

  693.   __EFF_NS    __ATTRIBUTES float asin(float);

  695.   __EFF_NS    __ATTRIBUTES float atan(float);

  697.   __EFF_NS    __ATTRIBUTES float atan2(float, float);

  699.   __EFF_NE    __ATTRIBUTES float ceil(float);

  701.   __EFF_NS    __ATTRIBUTES float cos(float);

  703.   __EFF_NS    __ATTRIBUTES float cosh(float);

  705.   __EFF_NS    __ATTRIBUTES float exp(float);

  707.   __EFF_NE    __ATTRIBUTES float fabs(float);

  709.   __EFF_NE    __ATTRIBUTES float floor(float);

  711.   __EFF_NS    __ATTRIBUTES float fmod(float, float);

  713.   __EFF_NENR2 __ATTRIBUTES float frexp(float, int *);

  715.   __EFF_NS    __ATTRIBUTES float ldexp(float, int);

  717.   __EFF_NS    __ATTRIBUTES float log(float);

  719.   __EFF_NS    __ATTRIBUTES float log10(float);

  721.   __EFF_NENR2 __ATTRIBUTES float modf(float, float *);

  723.   __EFF_NS    __ATTRIBUTES float pow(float, float);

  725.   __EFF_NS    __ATTRIBUTES float pow(float, int);

  727.   __EFF_NS    __ATTRIBUTES float sin(float);

  729.   __EFF_NS    __ATTRIBUTES float sinh(float);

  731.   __EFF_NS    __ATTRIBUTES float sqrt(float);

  733.   __EFF_NS    __ATTRIBUTES float tan(float);

  735.   __EFF_NS    __ATTRIBUTES float tanh(float);

  737.   __EFF_NS    __ATTRIBUTES float acosh(float);

  739.   __EFF_NS    __ATTRIBUTES float asinh(float);

  741.   __EFF_NS    __ATTRIBUTES float atanh(float);

  743.   __EFF_NE    __ATTRIBUTES float cbrt(float);

  745.   __EFF_NE    __ATTRIBUTES float copysign(float, float);

  747.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  749.     __EFF_NS    __ATTRIBUTES float erf(float);

  751.     __EFF_NS    __ATTRIBUTES float erfc(float);

  753.     __EFF_NS    __ATTRIBUTES float expm1(float);

  755.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  757.   __EFF_NS    __ATTRIBUTES float exp2(float);

  759.   __EFF_NE    __ATTRIBUTES float fdim(float, float);

  761.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  763.     __EFF_NS    __ATTRIBUTES float fma(float, float, float);

  765.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  767.   __EFF_NE    __ATTRIBUTES float fmax(float, float);

  769.   __EFF_NE    __ATTRIBUTES float fmin(float, float);

  771.   __EFF_NS    __ATTRIBUTES float hypot(float, float);

  773.   __EFF_NE    __ATTRIBUTES int   ilogb(float);

  775.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  777.     __EFF_NS    __ATTRIBUTES float lgamma(float);

  779.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */



  783.   #ifdef _LONGLONG

  785.     #pragma language=save

  787.     #pragma language=extended

  789.     __EFF_NS    __ATTRIBUTES _Longlong llrint(float);

  791.     __EFF_NS    __ATTRIBUTES _Longlong llround(float);

  793.     #pragma language=restore

  795.   #endif /* _LONGLONG */



  799.   __EFF_NS    __ATTRIBUTES float log1p(float);

  801.   __EFF_NS    __ATTRIBUTES float log2(float);

  803.   __EFF_NS    __ATTRIBUTES float logb(float);

  805.   __EFF_NS    __ATTRIBUTES long  lrint(float);

  807.   __EFF_NS    __ATTRIBUTES long  lround(float);

  809.   __EFF_NS    __ATTRIBUTES float nearbyint(float);

  811.   __EFF_NS    __ATTRIBUTES float nextafter(float, float);

  813.   __EFF_NS    __ATTRIBUTES float nexttoward(float, long double);

  815.   __EFF_NS    __ATTRIBUTES float remainder(float, float);

  817.   __EFF_NS    __ATTRIBUTES float remquo(float, float, int *);

  819.   __EFF_NS    __ATTRIBUTES float rint(float);

  821.   __EFF_NE    __ATTRIBUTES float round(float);

  823.   __EFF_NS    __ATTRIBUTES float scalbn(float, int);

  825.   __EFF_NS    __ATTRIBUTES float scalbln(float, long);

  827.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  829.     __EFF_NS    __ATTRIBUTES float tgamma(float);

  831.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  833.   __EFF_NE    __ATTRIBUTES float trunc(float);



  837.   __EFF_NE    __ATTRIBUTES long double abs(long double);

  839.   __EFF_NS    __ATTRIBUTES long double acos(long double);

  841.   __EFF_NS    __ATTRIBUTES long double asin(long double);

  843.   __EFF_NS    __ATTRIBUTES long double atan(long double);

  845.   __EFF_NS    __ATTRIBUTES long double atan2(long double, long double);

  847.   __EFF_NE    __ATTRIBUTES long double ceil(long double);

  849.   __EFF_NS    __ATTRIBUTES long double cos(long double);

  851.   __EFF_NS    __ATTRIBUTES long double cosh(long double);

  853.   __EFF_NS    __ATTRIBUTES long double exp(long double);

  855.   __EFF_NE    __ATTRIBUTES long double fabs(long double);

  857.   __EFF_NE    __ATTRIBUTES long double floor(long double);

  859.   __EFF_NS    __ATTRIBUTES long double fmod(long double, long double);

  861.   __EFF_NENR2 __ATTRIBUTES long double frexp(long double, int *);

  863.   __EFF_NS    __ATTRIBUTES long double ldexp(long double, int);

  865.   __EFF_NS    __ATTRIBUTES long double log(long double);

  867.   __EFF_NS    __ATTRIBUTES long double log10(long double);

  869.   __EFF_NENR2 __ATTRIBUTES long double modf(long double, long double *);

  871.   __EFF_NS    __ATTRIBUTES long double pow(long double, long double);

  873.   __EFF_NS    __ATTRIBUTES long double pow(long double, int);

  875.   __EFF_NS    __ATTRIBUTES long double sin(long double);

  877.   __EFF_NS    __ATTRIBUTES long double sinh(long double);

  879.   __EFF_NS    __ATTRIBUTES long double sqrt(long double);

  881.   __EFF_NS    __ATTRIBUTES long double tan(long double);

  883.   __EFF_NS    __ATTRIBUTES long double tanh(long double);

  885.   __EFF_NS    __ATTRIBUTES long double acosh(long double);

  887.   __EFF_NS    __ATTRIBUTES long double asinh(long double);

  889.   __EFF_NS    __ATTRIBUTES long double atanh(long double);

  891.   __EFF_NE    __ATTRIBUTES long double cbrt(long double);

  893.   __EFF_NE    __ATTRIBUTES long double copysign(long double, long double);

  895.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  897.     __EFF_NS    __ATTRIBUTES long double erf(long double);

  899.     __EFF_NS    __ATTRIBUTES long double erfc(long double);

  901.     __EFF_NS    __ATTRIBUTES long double expm1(long double);

  903.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  905.   __EFF_NS    __ATTRIBUTES long double exp2(long double);

  907.   __EFF_NE    __ATTRIBUTES long double fdim(long double, long double);

  909.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  911.     __EFF_NS    __ATTRIBUTES long double fma(long double, long double,

  913.                                              long double);

  915.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  917.   __EFF_NE    __ATTRIBUTES long double fmax(long double, long double);

  919.   __EFF_NE    __ATTRIBUTES long double fmin(long double, long double);

  921.   __EFF_NS    __ATTRIBUTES long double hypot(long double, long double);

  923.   __EFF_NE    __ATTRIBUTES int         ilogb(long double);

  925.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  927.     __EFF_NS    __ATTRIBUTES long double lgamma(long double);

  929.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */



  933.   #ifdef _LONGLONG

  935.     #pragma language=save

  937.     #pragma language=extended

  939.     __EFF_NS    __ATTRIBUTES _Longlong llrint(long double);

  941.     __EFF_NS    __ATTRIBUTES _Longlong llround(long double);

  943.     #pragma language=restore

  945.   #endif /* _LONGLONG */



  949.   __EFF_NS    __ATTRIBUTES long double log1p(long double);

  951.   __EFF_NS    __ATTRIBUTES long double log2(long double);

  953.   __EFF_NS    __ATTRIBUTES long double logb(long double);

  955.   __EFF_NS    __ATTRIBUTES long lrint(long double);

  957.   __EFF_NS    __ATTRIBUTES long lround(long double);

  959.   __EFF_NS    __ATTRIBUTES long double nearbyint(long double);

  961.   __EFF_NS    __ATTRIBUTES long double nextafter(long double, long double);

  963.   __EFF_NS    __ATTRIBUTES long double nexttoward(long double, long double);

  965.   __EFF_NS    __ATTRIBUTES long double remainder(long double, long double);

  967.   __EFF_NS    __ATTRIBUTES long double remquo(long double, long double, int *);

  969.   __EFF_NS    __ATTRIBUTES long double rint(long double);

  971.   __EFF_NE    __ATTRIBUTES long double round(long double);

  973.   __EFF_NS    __ATTRIBUTES long double scalbn(long double, int);

  975.   __EFF_NS    __ATTRIBUTES long double scalbln(long double, long);

  977.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  979.     __EFF_NS    __ATTRIBUTES long double tgamma(long double);

  981.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  983.   __EFF_NE    __ATTRIBUTES long double trunc(long double);



  987.   _END_EXTERN_CPP

  989. #endif /* __cplusplus */





  995. #if defined(__cplusplus) && !defined(_NO_DEFINITIONS_IN_HEADER_FILES)

  997.   _EXTERN_CPP

  999.   /* C++ definitions */



  1003.     #pragma inline=forced

  1005.     inline double abs(double _X)    /* OVERLOADS */

  1007.     {       /* return absolute value */

  1009.       return (fabs(_X));

  1011.     }



  1015.     #pragma inline=forced

  1017.     inline double pow(double _X, int _Y)

  1019.     {       /* raise to integer power */

  1021.       unsigned int _N = _Y;

  1023.       if (_Y < 0)

  1025.         _N = 0 - _N;

  1027.      

  1029.       for (double _Z = 1; ; _X *= _X)

  1031.       {

  1033.         if ((_N & 1) != 0)

  1035.           _Z *= _X;

  1037.         if ((_N >>= 1) == 0)

  1039.           return (_Y < 0 ? (_Z == 0.0 ? HUGE_VAL : (double)(1) / _Z) : _Z);

  1041.       }

  1043.     }



  1047.     #pragma inline=forced

  1049.     inline float abs(float _X)      /* OVERLOADS */

  1051.     {       /* return absolute value */

  1053.       return (_F_FUN(fabs)(_F_CAST _X));

  1055.     }



  1059.     #pragma inline=forced

  1061.     inline float acos(float _X)

  1063.     {       /* return arccosine */

  1065.       return (_F_FUN(acos)(_F_CAST _X));

  1067.     }



  1071.     #pragma inline=forced

  1073.     inline float asin(float _X)

  1075.     {       /* return arcsine */

  1077.       return (_F_FUN(asin)(_F_CAST _X));

  1079.     }



  1083.     #pragma inline=forced

  1085.     inline float atan(float _X)

  1087.     {       /* return arctangent */

  1089.       return (_F_FUN(atan)(_F_CAST _X));

  1091.     }



  1095.     #pragma inline=forced

  1097.     inline float atan2(float _Y, float _X)

  1099.     {       /* return arctangent */

  1101.       return (_F_FUN(atan2)(_F_CAST _Y,_F_CAST  _X));

  1103.     }



  1107.     #pragma inline=forced

  1109.     inline float ceil(float _X)

  1111.     {       /* return ceiling */

  1113.       return (_F_FUN(ceil)(_F_CAST _X));

  1115.     }



  1119.     #pragma inline=forced

  1121.     inline float cos(float _X)

  1123.     {       /* return cosine */

  1125.       return (_F_FUN(cos)(_F_CAST _X));

  1127.     }



  1131.     #pragma inline=forced

  1133.     inline float cosh(float _X)

  1135.     {       /* return hyperbolic cosine */

  1137.       return (_F_FUN(cosh)(_F_CAST _X));

  1139.     }



  1143.     #pragma inline=forced

  1145.     inline float exp(float _X)

  1147.     {       /* return exponential */

  1149.       return (_F_FUN(exp)(_F_CAST _X));

  1151.     }



  1155.     #pragma inline=forced

  1157.     inline float fabs(float _X)

  1159.     {       /* return absolute value */

  1161.       return (_F_FUN(fabs)(_F_CAST _X));

  1163.     }



  1167.     #pragma inline=forced

  1169.     inline float floor(float _X)

  1171.     {       /* return floor */

  1173.       return (_F_FUN(floor)(_F_CAST _X));

  1175.     }



  1179.     #pragma inline=forced

  1181.     inline float fmod(float _X, float _Y)

  1183.     {       /* return modulus */

  1185.       return (_F_FUN(fmod)(_F_CAST _X,_F_CAST  _Y));

  1187.     }



  1191.     #pragma inline=forced

  1193.     inline float frexp(float _X, int *_Y)

  1195.     {       /* unpack exponent */

  1197.       return (_F_FUN(frexp)(_F_CAST _X, _Y));

  1199.     }



  1203.     #pragma inline=forced

  1205.     inline float ldexp(float _X, int _Y)

  1207.     {       /* pack exponent */

  1209.       return (_F_FUN(ldexp)(_F_CAST _X, _Y));

  1211.     }



  1215.     #pragma inline=forced

  1217.     inline float log(float _X)

  1219.     {       /* return natural logarithm */

  1221.       return (_F_FUN(log)(_F_CAST _X));

  1223.     }



  1227.     #pragma inline=forced

  1229.     inline float log10(float _X)

  1231.     {       /* return base-10 logarithm */

  1233.       return (_F_FUN(log10)(_F_CAST _X));

  1235.     }



  1239.     #pragma inline=forced

  1241.     inline float modf(float _X, float *_Y)

  1243.     {       /* unpack fraction */

  1245.       return (_F_FUN(modf)(_F_CAST _X,_F_PTRCAST  _Y));

  1247.     }



  1251.     #pragma inline=forced

  1253.     inline float pow(float _X, float _Y)

  1255.     {       /* raise to power */

  1257.       return (_F_FUN(pow)(_F_CAST _X,_F_CAST  _Y));

  1259.     }



  1263.     #pragma inline=forced

  1265.     inline float pow(float _X, int _Y)

  1267.     {       /* raise to integer power */

  1269.     #ifdef _FLOAT_IS_DOUBLE

  1271.       return (float) pow((double) _X, _Y);

  1273.     #else

  1275.       unsigned int _N = _Y;

  1277.       if (_Y < 0)

  1279.         _N = 0 - _N;



  1283.       for (float _Z = 1; ; _X *= _X)

  1285.       {

  1287.         if ((_N & 1) != 0)

  1289.           _Z *= _X;

  1291.         if ((_N >>= 1) == 0)

  1293.           return _Y < 0 ? (_Z == 0.0F ? (float)HUGE_VAL : (float)(1) / _Z) : _Z;

  1295.       }

  1297.     #endif /* _FLOAT_IS_DOUBLE */

  1299.     }



  1303.     #pragma inline=forced

  1305.     inline float sin(float _X)

  1307.     {       /* return sine */

  1309.       return (_F_FUN(sin)(_F_CAST _X));

  1311.     }



  1315.     #pragma inline=forced

  1317.     inline float sinh(float _X)

  1319.     {       /* return hyperbolic sine */

  1321.       return (_F_FUN(sinh)(_F_CAST _X));

  1323.     }



  1327.     #pragma inline=forced

  1329.     inline float sqrt(float _X)

  1331.     {       /* return square root */

  1333.       return (_F_FUN(sqrt)(_F_CAST _X));

  1335.     }



  1339.     #pragma inline=forced

  1341.     inline float tan(float _X)

  1343.     {       /* return tangent */

  1345.       return (_F_FUN(tan)(_F_CAST _X));

  1347.     }



  1351.     #pragma inline=forced

  1353.     inline float tanh(float _X)

  1355.     {       /* return hyperbolic tangent */

  1357.       return (_F_FUN(tanh)(_F_CAST _X));

  1359.     }



  1363.     #pragma inline=forced

  1365.     inline float acosh(float _Left)

  1367.     {       // return hyperbolic arccosine

  1369.       return (_F_FUN(acosh)(_F_CAST _Left));

  1371.     }



  1375.     #pragma inline=forced

  1377.     inline float asinh(float _Left)

  1379.     {       // return hyperbolic arcsine

  1381.       return (_F_FUN(asinh)(_F_CAST _Left));

  1383.     }



  1387.     #pragma inline=forced

  1389.     inline float atanh(float _Left)

  1391.     {       // return hyperbolic arctangent

  1393.       return (_F_FUN(atanh)(_F_CAST _Left));

  1395.     }



  1399.     #pragma inline=forced

  1401.     inline float cbrt(float _Left)

  1403.     {       // return cube root

  1405.       return (_F_FUN(cbrt)(_F_CAST _Left));

  1407.     }



  1411.     #pragma inline=forced

  1413.     inline float copysign(float _Left, float _Right)

  1415.     {       // return copysign

  1417.       return (_F_FUN(copysign)(_F_CAST _Left, _F_CAST _Right));

  1419.     }



  1423.     #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  1425.       #pragma inline=forced

  1427.       inline float erf(float _Left)

  1429.       {       // return erf

  1431.         return (_F_FUN(erf)(_F_CAST _Left));

  1433.       }



  1437.       #pragma inline=forced

  1439.       inline float erfc(float _Left)

  1441.       {       // return erfc

  1443.         return (_F_FUN(erfc)(_F_CAST _Left));

  1445.       }



  1449.       #pragma inline=forced

  1451.       inline float expm1(float _Left)

  1453.       {       // return expml

  1455.         return (_F_FUN(expm1)(_F_CAST _Left));

  1457.       }

  1459.     #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */



  1463.     #pragma inline=forced

  1465.     inline float exp2(float _Left)

  1467.     {       // return exp2

  1469.       return (_F_FUN(exp2)(_F_CAST _Left));

  1471.     }



  1475.     #pragma inline=forced

  1477.     inline float fdim(float _Left, float _Right)

  1479.     {       // return fdim

  1481.       return (_F_FUN(fdim)(_F_CAST _Left, _F_CAST _Right));

  1483.     }



  1487.     #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  1489.       #pragma inline=forced

  1491.       inline float fma(float _Left, float _Right, float _Addend)

  1493.       {       // return fma

  1495.         return (_F_FUN(fma)(_F_CAST _Left, _F_CAST _Right, _F_CAST _Addend));

  1497.       }

  1499.     #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */



  1503.     #pragma inline=forced

  1505.     inline float fmax(float _Left, float _Right)

  1507.     {       // return fmax

  1509.       return (_F_FUN(fmax)(_F_CAST _Left, _F_CAST _Right));

  1511.     }



  1515.     #pragma inline=forced

  1517.     inline float fmin(float _Left, float _Right)

  1519.     {       // return fmin

  1521.       return (_F_FUN(fmin)(_F_CAST _Left, _F_CAST _Right));

  1523.     }



  1527.     #pragma inline=forced

  1529.     inline float hypot(float _Left, float _Right)

  1531.     {       // return hypot

  1533.       return (_F_FUN(hypot)(_F_CAST _Left, _F_CAST _Right));

  1535.     }



  1539.     #pragma inline=forced

  1541.     inline int ilogb(float _Left)

  1543.     {       // return ilogb

  1545.       return (_F_FUN(ilogb)(_F_CAST _Left));

  1547.     }



  1551.     #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  1553.       #pragma inline=forced

  1555.       inline float lgamma(float _Left)

  1557.       {       // return lgamma

  1559.         return (_F_FUN(lgamma)(_F_CAST _Left));

  1561.       }

  1563.     #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */



  1567.     #ifdef _LONGLONG

  1569.       #pragma language=save

  1571.       #pragma language=extended

  1573.       #pragma inline=forced

  1575.       inline _Longlong llrint(float _Left)

  1577.       {       // return llrint

  1579.         return (_F_FUN(llrint)(_F_CAST _Left));

  1581.       }



  1585.       #pragma inline=forced

  1587.       inline _Longlong llround(float _Left)

  1589.       {       // return llround

  1591.         return (_F_FUN(llround)(_F_CAST _Left));

  1593.       }

  1595.       #pragma language=restore

  1597.     #endif /* _LONGLONG */



  1601.     #pragma inline=forced

  1603.     inline float log1p(float _Left)

  1605.     {       // return loglp

  1607.       return (_F_FUN(log1p)(_F_CAST _Left));

  1609.     }



  1613.     #pragma inline=forced

  1615.     inline float log2(float _Left)

  1617.     {       // return log2

  1619.       return (_F_FUN(log2)(_F_CAST _Left));

  1621.     }



  1625.     #pragma inline=forced

  1627.     inline float logb(float _Left)

  1629.     {       // return logb

  1631.       return (_F_FUN(logb)(_F_CAST _Left));

  1633.     }



  1637.     #pragma inline=forced

  1639.     inline long lrint(float _Left)

  1641.     {       // return lrint

  1643.       return (_F_FUN(lrint)(_F_CAST _Left));

  1645.     }



  1649.     #pragma inline=forced

  1651.     inline long lround(float _Left)

  1653.     {       // return lround

  1655.       return (_F_FUN(lround)(_F_CAST _Left));

  1657.     }



  1661.     #pragma inline=forced

  1663.     inline float nearbyint(float _Left)

  1665.     {       // return nearbyint

  1667.       return (_F_FUN(nearbyint)(_F_CAST _Left));

  1669.     }



  1673.     #pragma inline=forced

  1675.     inline float nextafter(float _Left, float _Right)

  1677.     {       // return nextafter

  1679.       return (_F_FUN(nextafter)(_F_CAST _Left, _F_CAST _Right));

  1681.     }



  1685.     #pragma inline=forced

  1687.     inline float nexttoward(float _Left, long double _Right)

  1689.     {       // return nexttoward

  1691.       return (_F_FUN(nexttoward)(_F_CAST _Left, _F_CAST _Right));

  1693.     }



  1697.     #pragma inline=forced

  1699.     inline float remainder(float _Left, float _Right)

  1701.     {       // return remainder

  1703.       return (_F_FUN(remainder)(_F_CAST _Left, _F_CAST _Right));

  1705.     }



  1709.     #pragma inline=forced

  1711.     inline float remquo(float _Left, float _Right, int *_Pval)

  1713.     {       // return remquo

  1715.       return (_F_FUN(remquo)(_F_CAST _Left, _F_CAST _Right, _Pval));

  1717.     }



  1721.     #pragma inline=forced

  1723.     inline float rint(float _Left)

  1725.     {       // return rint

  1727.       return (_F_FUN(rint)(_F_CAST _Left));

  1729.     }



  1733.     #pragma inline=forced

  1735.     inline float round(float _Left)

  1737.     {       // return round

  1739.       return (_F_FUN(round)(_F_CAST _Left));

  1741.     }



  1745.     #pragma inline=forced

  1747.     inline float scalbn(float _Left, int _Right)

  1749.     {       // return scalbn

  1751.       return (_F_FUN(scalbn)(_F_CAST _Left, _Right));

  1753.     }



  1757.     #pragma inline=forced

  1759.     inline float scalbln(float _Left, long _Right)

  1761.     {       // return scalbln

  1763.       return (_F_FUN(scalbln)(_F_CAST _Left, _Right));

  1765.     }



  1769.     #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  1771.       #pragma inline=forced

  1773.       inline float tgamma(float _Left)

  1775.       {       // return tgamma

  1777.         return (_F_FUN(tgamma)(_F_CAST _Left));

  1779.       }

  1781.     #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */



  1785.     #pragma inline=forced

  1787.     inline float trunc(float _Left)

  1789.     {       // return trunc

  1791.       return (_F_FUN(trunc)(_F_CAST _Left));

  1793.     }



  1797.     #pragma inline=forced

  1799.     inline long double abs(long double _X)  /* OVERLOADS */

  1801.     {       /* return absolute value */

  1803.       return (_L_FUN(fabs)(_L_CAST _X));

  1805.     }



  1809.     #pragma inline=forced

  1811.     inline long double acos(long double _X)

  1813.     {       /* return arccosine */

  1815.       return (_L_FUN(acos)(_L_CAST _X));

  1817.     }



  1821.     #pragma inline=forced

  1823.     inline long double asin(long double _X)

  1825.     {       /* return arcsine */

  1827.       return (_L_FUN(asin)(_L_CAST _X));

  1829.     }



  1833.     #pragma inline=forced

  1835.     inline long double atan(long double _X)

  1837.     {       /* return arctangent */

  1839.       return (_L_FUN(atan)(_L_CAST _X));

  1841.     }



  1845.     #pragma inline=forced

  1847.     inline long double atan2(long double _Y, long double _X)

  1849.     {       /* return arctangent */

  1851.       return (_L_FUN(atan2)(_L_CAST _Y, _L_CAST _X));

  1853.     }



  1857.     #pragma inline=forced

  1859.     inline long double ceil(long double _X)

  1861.     {       /* return ceiling */

  1863.       return (_L_FUN(ceil)(_L_CAST _X));

  1865.     }



  1869.     #pragma inline=forced

  1871.     inline long double cos(long double _X)

  1873.     {       /* return cosine */

  1875.       return (_L_FUN(cos)(_L_CAST _X));

  1877.     }



  1881.     #pragma inline=forced

  1883.     inline long double cosh(long double _X)

  1885.     {       /* return hyperbolic cosine */

  1887.       return (_L_FUN(cosh)(_L_CAST _X));

  1889.     }



  1893.     #pragma inline=forced

  1895.     inline long double exp(long double _X)

  1897.     {       /* return exponential */

  1899.       return (_L_FUN(exp)(_L_CAST _X));

  1901.     }



  1905.     #pragma inline=forced

  1907.     inline long double fabs(long double _X)

  1909.     {       /* return absolute value */

  1911.       return (_L_FUN(fabs)(_L_CAST _X));

  1913.     }



  1917.     #pragma inline=forced

  1919.     inline long double floor(long double _X)

  1921.     {       /* return floor */

  1923.       return (_L_FUN(floor)(_L_CAST _X));

  1925.     }
復(fù)制代碼



作者: das    時(shí)間: 2015-4-18 01:29
這里是另一個(gè)版本
  1.     #pragma inline=forced

  3.     inline long double fmod(long double _X, long double _Y)

  5.     {       /* return modulus */

  7.       return (_L_FUN(fmod)(_L_CAST _X,_L_CAST _Y));

  9.     }



  13.     #pragma inline=forced

  15.     inline long double frexp(long double _X, int *_Y)

  17.     {       /* unpack exponent */

  19.       return (_L_FUN(frexp)(_L_CAST _X, _Y));

  21.     }



  25.     #pragma inline=forced

  27.     inline long double ldexp(long double _X, int _Y)

  29.     {       /* pack exponent */

  31.       return (_L_FUN(ldexp)(_L_CAST _X, _Y));

  33.     }



  37.     #pragma inline=forced

  39.     inline long double log(long double _X)

  41.     {       /* return natural logarithm */

  43.       return (_L_FUN(log)(_L_CAST _X));

  45.     }



  49.     #pragma inline=forced

  51.     inline long double log10(long double _X)

  53.     {       /* return base-10 logarithm */

  55.       return (_L_FUN(log10)(_L_CAST _X));

  57.     }



  61.     #pragma inline=forced

  63.     inline long double modf(long double _X, long double *_Y)

  65.     {       /* unpack fraction */

  67.       return (_L_FUN(modf)(_L_CAST _X, _L_PTRCAST _Y));

  69.     }



  73.     #pragma inline=forced

  75.     inline long double pow(long double _X, long double _Y)

  77.     {       /* raise to power */

  79.       return (_L_FUN(pow)(_L_CAST _X, _L_CAST _Y));

  81.     }



  85.     #pragma inline=forced

  87.     inline long double pow(long double _X, int _Y)

  89.     {       /* raise to integer power */

  91.     #ifdef _LONG_DOUBLE_IS_DOUBLE

  93.       return (long double) pow((double) _X, _Y);

  95.     #else

  97.       unsigned int _N = _Y;

  99.       if (_Y < 0)

  101.         _N = 0 - _N;

  103.      

  105.       for (long double _Z = 1; ; _X *= _X)

  107.       {

  109.         if ((_N & 1) != 0)

  111.           _Z *= _X;

  113.         if ((_N >>= 1) == 0)

  115.           return _Y < 0

  117.             ? (_Z == 0.0L

  119.                ? (long double)HUGE_VAL

  121.                : (long double)(1) / _Z)

  123.             : _Z;

  125.       }

  127.     #endif /* _LONG_DOUBLE_IS_DOUBLE */

  129.     }



  133.     #pragma inline=forced

  135.     inline long double sin(long double _X)

  137.     {       /* return sine */

  139.       return (_L_FUN(sin)(_L_CAST _X));

  141.     }



  145.     #pragma inline=forced

  147.     inline long double sinh(long double _X)

  149.     {       /* return hyperbolic sine */

  151.       return (_L_FUN(sinh)(_L_CAST _X));

  153.     }



  157.     #pragma inline=forced

  159.     inline long double sqrt(long double _X)

  161.     {       /* return square root */

  163.       return (_L_FUN(sqrt)(_L_CAST _X));

  165.     }



  169.     #pragma inline=forced

  171.     inline long double tan(long double _X)

  173.     {       /* return tangent */

  175.       return (_L_FUN(tan)(_L_CAST _X));

  177.     }



  181.     #pragma inline=forced

  183.     inline long double tanh(long double _X)

  185.     {       /* return hyperbolic tangent */

  187.       return (_L_FUN(tanh)(_L_CAST _X));

  189.     }



  193.     #pragma inline=forced

  195.     inline long double acosh(long double _Left)

  197.     {   // return acosh

  199.       return (_F_FUN(acosh)(_L_CAST _Left));

  201.     }



  205.     #pragma inline=forced

  207.     inline long double asinh(long double _Left)

  209.     {   // return asinh

  211.       return (_F_FUN(asinh)(_L_CAST _Left));

  213.     }



  217.     #pragma inline=forced

  219.     inline long double atanh(long double _Left)

  221.     {       // return atanh

  223.       return (_F_FUN(atanh)(_L_CAST _Left));

  225.     }



  229.     #pragma inline=forced

  231.     inline long double cbrt(long double _Left)

  233.     {       // return cbrt

  235.       return (_F_FUN(cbrt)(_L_CAST _Left));

  237.     }



  241.     #pragma inline=forced

  243.     inline long double copysign(long double _Left, long double _Right)

  245.     {       // return copysign

  247.       return (_F_FUN(copysign)(_L_CAST _Left, _L_CAST _Right));

  249.     }



  253.     #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  255.       #pragma inline=forced

  257.       inline long double erf(long double _Left)

  259.       {       // return erf

  261.         return (_F_FUN(erf)(_L_CAST _Left));

  263.       }



  267.       #pragma inline=forced

  269.       inline long double erfc(long double _Left)

  271.       {       // return erfc

  273.         return (_F_FUN(erfc)(_L_CAST _Left));

  275.       }



  279.       #pragma inline=forced

  281.       inline long double expm1(long double _Left)

  283.       {       // return expml

  285.         return (_F_FUN(expm1)(_L_CAST _Left));

  287.       }

  289.     #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */



  293.     #pragma inline=forced

  295.     inline long double exp2(long double _Left)

  297.     {       // return exp2

  299.       return (_F_FUN(exp2)(_L_CAST _Left));

  301.     }



  305.     #pragma inline=forced

  307.     inline long double fdim(long double _Left, long double _Right)

  309.     {       // return fdim

  311.       return (_F_FUN(fdim)(_L_CAST _Left, _L_CAST _Right));

  313.     }



  317.     #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  319.       #pragma inline=forced

  321.       inline long double fma(long double _Left, long double _Right,

  323.                              long double _Addend)

  325.       {       // return fma

  327.         return (_F_FUN(fma)(_L_CAST _Left, _L_CAST _Right, _L_CAST _Addend));

  329.       }

  331.     #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */



  335.     #pragma inline=forced

  337.     inline long double fmax(long double _Left, long double _Right)

  339.     {       // return fmax

  341.       return (_F_FUN(fmax)(_L_CAST _Left, _L_CAST _Right));

  343.     }



  347.     #pragma inline=forced

  349.     inline long double fmin(long double _Left, long double _Right)

  351.     {       // return fmin

  353.       return (_F_FUN(fmin)(_L_CAST _Left, _L_CAST _Right));

  355.     }



  359.     #pragma inline=forced

  361.     inline long double hypot(long double _Left, long double _Right)

  363.     {       // return hypot

  365.       return (_F_FUN(hypot)(_L_CAST _Left, _L_CAST _Right));

  367.     }



  371.     #pragma inline=forced

  373.     inline int ilogb(long double _Left)

  375.     {       // return ilogb

  377.       return (_F_FUN(ilogb)(_L_CAST _Left));

  379.     }



  383.     #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  385.       #pragma inline=forced

  387.       inline long double lgamma(long double _Left)

  389.       {       // return lgamma

  391.         return (_F_FUN(lgamma)(_L_CAST _Left));

  393.       }

  395.     #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */



  399.     #ifdef _LONGLONG

  401.       #pragma language=save

  403.       #pragma language=extended

  405.       #pragma inline=forced

  407.       inline _Longlong llrint(long double _Left)

  409.       {       // return llrint

  411.         return (_F_FUN(llrint)(_L_CAST _Left));

  413.       }



  417.       #pragma inline=forced

  419.       inline _Longlong llround(long double _Left)

  421.       {       // return llround

  423.         return (_F_FUN(llround)(_L_CAST _Left));

  425.       }

  427.       #pragma language=restore

  429.     #endif /* _LONGLONG */



  433.     #pragma inline=forced

  435.     inline long double log1p(long double _Left)

  437.     {       // return loglp

  439.       return (_F_FUN(log1p)(_L_CAST _Left));

  441.     }



  445.     #pragma inline=forced

  447.     inline long double log2(long double _Left)

  449.     {       // return log2

  451.       return (_F_FUN(log2)(_L_CAST _Left));

  453.     }



  457.     #pragma inline=forced

  459.     inline long double logb(long double _Left)

  461.     {       // return logb

  463.       return (_F_FUN(logb)(_L_CAST _Left));

  465.     }



  469.     #pragma inline=forced

  471.     inline long lrint(long double _Left)

  473.     {       // return lrint

  475.       return (_F_FUN(lrint)(_L_CAST _Left));

  477.     }



  481.     #pragma inline=forced

  483.     inline long lround(long double _Left)

  485.     {       // return lround

  487.       return (_F_FUN(lround)(_L_CAST _Left));

  489.     }



  493.     #pragma inline=forced

  495.     inline long double nearbyint(long double _Left)

  497.     {       // return nearbyint

  499.       return (_F_FUN(nearbyint)(_L_CAST _Left));

  501.     }



  505.     #pragma inline=forced

  507.     inline long double nextafter(long double _Left, long double _Right)

  509.     {       // return nextafter

  511.       return (_F_FUN(nextafter)(_L_CAST _Left, _L_CAST _Right));

  513.     }



  517.     #pragma inline=forced

  519.     inline long double nexttoward(long double _Left, long double _Right)

  521.     {       // return nexttoward

  523.       return (_F_FUN(nexttoward)(_L_CAST _Left, _L_CAST _Right));

  525.     }



  529.     #pragma inline=forced

  531.     inline long double remainder(long double _Left, long double _Right)

  533.     {       // return remainder

  535.       return (_F_FUN(remainder)(_L_CAST _Left, _L_CAST _Right));

  537.     }



  541.     #pragma inline=forced

  543.     inline long double remquo(long double _Left, long double _Right,

  545.                               int *_Pval)

  547.     {       // return remquo

  549.       return (_F_FUN(remquo)(_L_CAST _Left, _L_CAST _Right, _Pval));

  551.     }



  555.     #pragma inline=forced

  557.     inline long double rint(long double _Left)

  559.     {       // return rint

  561.       return (_F_FUN(rint)(_L_CAST _Left));

  563.     }



  567.     #pragma inline=forced

  569.     inline long double round(long double _Left)

  571.     {       // return round

  573.       return (_F_FUN(round)(_L_CAST _Left));

  575.     }



  579.     #pragma inline=forced

  581.     inline long double scalbn(long double _Left, int _Right)

  583.     {       // return scalbn

  585.       return (_F_FUN(scalbn)(_L_CAST _Left, _Right));

  587.     }



  591.     #pragma inline=forced

  593.     inline long double scalbln(long double _Left, long _Right)

  595.     {       // return scalbln

  597.       return (_F_FUN(scalbln)(_L_CAST _Left, _Right));

  599.     }



  603.     #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  605.       #pragma inline=forced

  607.       inline long double tgamma(long double _Left)

  609.       {       // return tgamma

  611.         return (_F_FUN(tgamma)(_L_CAST _Left));

  613.       }

  615.     #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */



  619.     #pragma inline=forced

  621.     inline long double trunc(long double _Left)

  623.     {       // return trunc

  625.       return (_F_FUN(trunc)(_L_CAST _Left));

  627.     }



  631.   _END_EXTERN_CPP

  633. #endif /* defined(__cplusplus) && !defined(_NO_DEFINITIONS_IN_HEADER_FILES) */





  639. #if !defined(_NO_DEFINITIONS_IN_HEADER_FILES) && \

  641.     !__AEABI_PORTABILITY_INTERNAL_LEVEL

  643.                 /* double INLINES, FOR C and C++ */



  647. /* C inline definitions */



  651.   #pragma inline=no_body

  653.   double cos(double _X)

  655.   {       /* return cosine */

  657.     return _D_FNAME(Sin)(_X, 1);

  659.   }



  663.   #pragma inline=no_body

  665.   double cosh(double _X)

  667.   {       /* return hyperbolic cosine */

  669.     return _D_FNAME(Cosh)(_X, 1);

  671.   }



  675.   #pragma inline=no_body

  677.   double log(double _X)

  679.   {       /* return natural logarithm */

  681.     return _D_FNAME(Log)(_X, 0);

  683.   }



  687.   #pragma inline=no_body

  689.   double log10(double _X)

  691.   {       /* return base-10 logarithm */

  693.     return _D_FNAME(Log)(_X, 1);

  695.   }



  699.   #pragma inline=no_body

  701.   double sin(double _X)

  703.   {       /* return sine */

  705.     return _D_FNAME(Sin)(_X, 0);

  707.   }



  711.   #pragma inline=no_body

  713.   double sinh(double _X)

  715.   {       /* return hyperbolic sine */

  717.     return _D_FNAME(Sinh)(_X, 1);

  719.   }





  725.                 /* double INLINES, FOR C99 and C++ */

  727.   #if _DLIB_ADD_C99_SYMBOLS

  729.     #pragma inline=no_body

  731.     double log2(double _Left)

  733.     {   /* return base-2 logarithm */

  735.       return (_D_FNAME(Log)(_Left, -1));

  737.     }



  741.     #pragma inline=no_body

  743.     double nan(const char *s)

  745.     {   /* construct a NaN */

  747.       return (0.Nan);

  749.     }



  753.     #pragma inline=no_body

  755.     double nextafter(double x, double y)

  757.     {   /* compute next value after x going toward y */

  759.       return (nexttoward(x, (long double)y));

  761.     }



  765.     #pragma inline=no_body

  767.     double remainder(double x, double y)

  769.     {   /* compute remainder of x/y */

  771.       return (remquo(x, y, 0));

  773.     }



  777.   #endif /* _DLIB_ADD_C99_SYMBOLS */



  781.                 /* float INLINES, FOR C and C++ */

  783.   #if _DLIB_ADD_C99_SYMBOLS

  785.     #pragma inline=no_body

  787.     float cosf(float _X)

  789.     {       /* return cosine */

  791.       return (_F_FNAME(Sin)(_X, 1));

  793.     }



  797.     #pragma inline=no_body

  799.     float coshf(float _X)

  801.     {       /* return hyperbolic cosine */

  803.       return (_F_FNAME(Cosh)(_X, _F_CAST 1.0F));

  805.     }



  809.     #pragma inline=no_body

  811.     float logf(float _X)

  813.     {       /* return natural logarithm */

  815.       return (_F_FNAME(Log)(_X, 0));

  817.     }



  821.     #pragma inline=no_body

  823.     float log2f(float _Left)

  825.     {       /* return base-2 logarithm */

  827.       return (_F_FNAME(Log)(_Left, -1));

  829.     }



  833.     #pragma inline=no_body

  835.     float log10f(float _X)

  837.     {       /* return base-10 logarithm */

  839.       return (_F_FNAME(Log)(_X, 1));

  841.     }



  845.     #pragma inline=no_body

  847.     float nanf(const char *s)

  849.     {   /* construct a NaN */

  851.       return (0.Nan);

  853.     }



  857.     #pragma inline=no_body

  859.     float nextafterf(float x, float y)

  861.     {   /* compute next value after x going toward y */

  863.       return (nexttowardf(x, (long double)y));

  865.     }



  869.     #pragma inline=no_body

  871.     float remainderf(float x, float y)

  873.     {   /* compute remainder of x/y */

  875.       return (remquof(x, y, 0));

  877.     }



  881.     #pragma inline=no_body

  883.     float sinf(float _X)

  885.     {       /* return sine */

  887.       return (_F_FNAME(Sin)(_X, 0));

  889.     }



  893.     #pragma inline=no_body

  895.     float sinhf(float _X)

  897.     {       /* return hyperbolic sine */

  899.       return (_F_FNAME(Sinh)(_X, _F_CAST 1.0F));

  901.     }

  903.   #endif /* _DLIB_ADD_C99_SYMBOLS */



  907.                 /* long double INLINES, FOR C and C++ */

  909.   #if _DLIB_ADD_C99_SYMBOLS

  911.     #pragma inline=no_body

  913.     long double cosl(long double _X)

  915.     {       /* return cosine */

  917.       return (_L_FNAME(Sin)(_X, 1));

  919.     }



  923.     #pragma inline=no_body

  925.     long double coshl(long double _X)

  927.     {       /* return hyperbolic cosine */

  929.       return (_L_FNAME(Cosh)(_X, _L_CAST 1.0L));

  931.     }



  935.     #pragma inline=no_body

  937.     long double logl(long double _X)

  939.     {       /* return natural logarithm */

  941.       return (_L_FNAME(Log)(_X, 0));

  943.     }



  947.     #pragma inline=no_body

  949.     long double log2l(long double _Left)

  951.     {       /* return base-2 logarithm */

  953.       return (_L_FNAME(Log)(_Left, -1));

  955.     }



  959.     #pragma inline=no_body

  961.     long double log10l(long double _X)

  963.     {       /* return base-10 logarithm */

  965.       return (_L_FNAME(Log)(_X, 1));

  967.     }



  971.     #pragma inline=no_body

  973.     long double nanl(const char *s)

  975.     {   /* construct a NaN */

  977.       return (0.Nan);

  979.     }



  983.     #pragma inline=no_body

  985.     long double nextafterl(long double x, long double y)

  987.     {   /* compute next value after x going toward y */

  989.       return (nexttowardl(x, y));

  991.     }



  995.     #pragma inline=no_body

  997.     long double remainderl(long double x, long double y)

  999.     {   /* compute remainder of x/y */

  1001.       return (remquol(x, y, 0));

  1003.     }



  1007.     #pragma inline=no_body

  1009.     long double sinl(long double _X)

  1011.     {       /* return sine */

  1013.       return (_L_FNAME(Sin)(_X, 0));

  1015.     }



  1019.     #pragma inline=no_body

  1021.     long double sinhl(long double _X)

  1023.     {       /* return hyperbolic sine */

  1025.       return (_L_FNAME(Sinh)(_X, _L_CAST 1.0L));

  1027.     }

  1029.   #endif /* _DLIB_ADD_C99_SYMBOLS */



  1033. #endif /* !defined(_NO_DEFINITIONS_IN_HEADER_FILES) && \

  1035.           !__AEABI_PORTABILITY_INTERNAL_LEVEL */



  1039. #if _DLIB_ADD_C99_SYMBOLS



  1043.   /* C99 floating point functionality */



  1047.   #define FP_INFINITE  _INFCODE

  1049.   #define FP_NAN       _NANCODE

  1051.   #define FP_NORMAL    _FINITE

  1053.   #define FP_SUBNORMAL _DENORM

  1055.   #define FP_ZERO      0



  1059.   #define _FP_ILOGBNAN __SIGNED_INT_MAX__

  1061.   #define _FP_ILOGB0   __SIGNED_INT_MIN__



  1065.   #define MATH_ERRNO 1

  1067.   #define MATH_ERREXCEPT 2

  1069.   #ifndef math_errhandling

  1071.     #define math_errhandling MATH_ERRNO

  1073.   #endif



  1077.   #if _DLIB_FAST_FMA

  1079.     #define FP_FAST_FMA  1

  1081.     #define FP_FAST_FMAF 1

  1083.     #define FP_FAST_FMAL 1

  1085.   #endif /* _DLIB_FAST_FMA */



  1089.   #define FP_ILOGB0     _FP_ILOGB0

  1091.   #define FP_ILOGBNAN   _FP_ILOGBNAN



  1095.   /* For generic C99 compare operations */

  1097.   #define _FP_LT 1

  1099.   #define _FP_EQ 2

  1101.   #define _FP_GT 4



  1105.   _C_LIB_DECL

  1107.   __EFF_NS    __ATTRIBUTES int _D_FNAME(Dcomp)(double, double);

  1109.   #ifndef _FLOAT_IS_DOUBLE

  1111.     __EFF_NS    __ATTRIBUTES int _F_FNAME(Dcomp)(float, float);

  1113.   #endif

  1115.   #ifndef _LONG_DOUBLE_IS_DOUBLE

  1117.     __EFF_NS    __ATTRIBUTES int _L_FNAME(Dcomp)(long double, long double);

  1119.   #endif

  1121.   _END_C_LIB_DECL



  1125.   #if _HAS_GENERIC_TEMPLATES

  1127.     _EXTERN_CPP



  1131.     // TEMPLATE FUNCTION _FPCOMP

  1133.     inline int _FPCOMP(float _Left, float _Right)

  1135.     {   // compare _Left and _Right

  1137.       return (_F_FNAME(Dcomp)(_Left, _Right));

  1139.     }



  1143.     inline int _FPCOMP(double _Left, double _Right)

  1145.     {   // compare _Left and _Right

  1147.       return (_D_FNAME(Dcomp)(_Left, _Right));

  1149.     }



  1153.     inline int _FPCOMP(long double _Left, long double _Right)

  1155.     {       // compare _Left and _Right

  1157.       return (_L_FNAME(Dcomp)(_Left, _Right));

  1159.     }



  1163.     template<class _T1, class _T2> inline

  1165.     int _FPCOMP(_T1 _Left, _T2 _Right)

  1167.     {       // compare _Left and _Right

  1169.       typedef typename _Combined_type<

  1171.         float,

  1173.         typename _Real_widened<

  1175.           typename _Real_type<_T1>::_Type,

  1177.           typename _Real_type<_T2>::_Type>::_Type>::_Type _Tw;

  1179.       return (_FPCOMP((_Tw)_Left, (_Tw)_Right));

  1181.     }



  1185.     // FUNCTION fpclassify

  1187.     inline int fpclassify(float _Left)

  1189.     {       // classify argument

  1191.       return (_F_FNAME(Dtest)(_Left));

  1193.     }



  1197.     inline int fpclassify(double _Left)

  1199.     {       // classify argument

  1201.       return (_D_FNAME(Dtest)(_Left));

  1203.     }



  1207.     inline int fpclassify(long double _Left)

  1209.     {       // classify argument

  1211.       return (_L_FNAME(Dtest)(_Left));

  1213.     }



  1217.     // FUNCTION signbit

  1219.     inline bool signbit(float _Left)

  1221.     {       // test sign bit

  1223.       return (_F_FNAME(Dsign)(_Left) != 0);

  1225.     }



  1229.     inline bool signbit(double _Left)

  1231.     {       // test sign bit

  1233.       return (_D_FNAME(Dsign)(_Left) != 0);

  1235.     }



  1239.     inline bool signbit(long double _Left)

  1241.     {       // test sign bit

  1243.       return (_L_FNAME(Dsign)(_Left) != 0);

  1245.     }



  1249.     template<class _Ty> inline

  1251.     bool isfinite(_Ty _Left)

  1253.     {       // test for finite

  1255.       return (fpclassify(_Left) <= 0);

  1257.     }



  1261.     template<class _Ty> inline

  1263.     bool isinf(_Ty _Left)

  1265.     {       // test for infinite

  1267.       return (fpclassify(_Left) == FP_INFINITE);

  1269.     }



  1273.     template<class _Ty> inline

  1275.     bool isnan(_Ty _Left)

  1277.     {       // test for NaN

  1279.       return (fpclassify(_Left) == FP_NAN);

  1281.     }



  1285.     template<class _Ty> inline

  1287.     bool isnormal(_Ty _Left)

  1289.     {       // test for normal

  1291.       return (fpclassify(_Left) == FP_NORMAL);

  1293.     }



  1297.     template<class _Ty1, class _Ty2> inline

  1299.     bool isgreater(_Ty1 _Left, _Ty2 _Right)

  1301.     {       // test for _Left > _Right

  1303.       return ((_FPCOMP(_Left, _Right) & _FP_GT) != 0);

  1305.     }



  1309.     template<class _Ty1, class _Ty2> inline

  1311.     bool isgreaterequal(_Ty1 _Left, _Ty2 _Right)

  1313.     {       // test for _Left >= _Right

  1315.       return ((_FPCOMP(_Left, _Right) & (_FP_EQ | _FP_GT)) != 0);

  1317.     }



  1321.     template<class _Ty1, class _Ty2> inline

  1323.     bool isless(_Ty1 _Left, _Ty2 _Right)

  1325.     {       // test for _Left < _Right

  1327.       return ((_FPCOMP(_Left, _Right) & _FP_LT) != 0);

  1329.     }



  1333.     template<class _Ty1, class _Ty2> inline

  1335.     bool islessequal(_Ty1 _Left, _Ty2 _Right)

  1337.     {       // test for _Left <= _Right

  1339.       return ((_FPCOMP(_Left, _Right) & (_FP_LT | _FP_EQ)) != 0);

  1341.     }



  1345.     template<class _Ty1, class _Ty2> inline

  1347.     bool islessgreater(_Ty1 _Left, _Ty2 _Right)

  1349.     {       // test for _Left != _Right

  1351.       return ((_FPCOMP(_Left, _Right) & (_FP_LT | _FP_GT)) != 0);

  1353.     }



  1357.     template<class _Ty1, class _Ty2> inline

  1359.     bool isunordered(_Ty1 _Left, _Ty2 _Right)

  1361.     {       // test for _Left unorderd w.r.t. _Right

  1363.       return (_FPCOMP(_Left, _Right) == 0);

  1365.     }



  1369.     #define fpclassify(x)                 (_CSTD fpclassify(x))

  1371.     #define signbit(x)                    (_CSTD signbit(x))

  1373.     #define isfinite(x)                   (_CSTD isfinite(x))

  1375.     #define isinf(x)                      (_CSTD isinf(x))

  1377.     #define isnan(x)                      (_CSTD isnan(x))

  1379.     #define isnormal(x)                   (_CSTD isnormal(x))

  1381.     #define isgreater(x, y)               (_CSTD isgreater(x, y))

  1383.     #define isgreaterequal(x, y)          (_CSTD isgreaterequal(x, y))

  1385.     #define isless(x, y)                  (_CSTD isless(x, y))

  1387.     #define islessequal(x, y)             (_CSTD islessequal(x, y))

  1389.     #define islessgreater(x, y)           (_CSTD islessgreater(x, y))

  1391.     #define isunordered(x, y)             (_CSTD isunordered(x, y))



  1395.     _END_EXTERN_CPP



  1399.   #else /* _HAS_GENERIC_TEMPLATES */



  1403.     #define _CARGI(x, fd, ff, fl) __c99_generic(x,,, fd, ff, fl,,,)(x)

  1405.     #define _CARG2I(x, y, fd, ff, fl) __c99_generic(x, y,, fd, ff, fl,,,)(x, y)



  1409.     #define _FPCOMP(x, y) _CARG2I(x, y, _D_FNAME(Dcomp), \

  1411.                                         _F_FNAME(Dcomp), \

  1413.                                         _L_FNAME(Dcomp))

  1415.     #define fpclassify(x) _CARGI(x, _D_FNAME(Dtest), \

  1417.                                     _F_FNAME(Dtest), \

  1419.                                     _L_FNAME(Dtest))

  1421.     #define signbit(x)    _CARGI(x, _D_FNAME(Dsign), \

  1423.                                     _F_FNAME(Dsign), \

  1425.                                     _L_FNAME(Dsign))



  1429.     #define isfinite(x)   (fpclassify(x) <= 0)

  1431.     #define isinf(x)      (fpclassify(x) == FP_INFINITE)

  1433.     #define isnan(x)      (fpclassify(x) == FP_NAN)

  1435.     #define isnormal(x)   (fpclassify(x) == FP_NORMAL)



  1439.     #define isgreater(x, y)       ((_FPCOMP(x, y) & _FP_GT) != 0)

  1441.     #define isgreaterequal(x, y)  ((_FPCOMP(x, y) & (_FP_EQ | _FP_GT)) != 0)

  1443.     #define isless(x, y)          ((_FPCOMP(x, y) & _FP_LT) != 0)

  1445.     #define islessequal(x, y)     ((_FPCOMP(x, y) & (_FP_LT | _FP_EQ)) != 0)

  1447.     #define islessgreater(x, y)   ((_FPCOMP(x, y) & (_FP_LT | _FP_GT)) != 0)

  1449.     #define isunordered(x, y)      (_FPCOMP(x, y) == 0)



  1453.   #endif /* _HAS_GENERIC_TEMPLATES */



  1457.   #pragma inline=no_body

  1459.   int _D_FNAME(Dcomp)(double x, double y)

  1461.   {

  1463.     if (isnan(x) || isnan(y))

  1465.     {

  1467.       return 0;

  1469.     }

  1471.     if (x > y)

  1473.     {

  1475.       return _FP_GT;

  1477.     }

  1479.     if (x < y)

  1481.     {

  1483.       return _FP_LT;

  1485.     }

  1487.     if (x == y)

  1489.     {

  1491.       return _FP_EQ;

  1493.     }

  1495.     return 0;

  1497.   }



  1501.   #ifndef _FLOAT_IS_DOUBLE

  1503.     #pragma inline=no_body

  1505.     int _F_FNAME(Dcomp)(float x, float y)

  1507.     {

  1509.       if (isnan(x) || isnan(y))

  1511.       {

  1513.         return 0;

  1515.       }

  1517.       if (x > y)

  1519.       {

  1521.         return _FP_GT;

  1523.       }

  1525.       if (x < y)

  1527.       {

  1529.         return _FP_LT;

  1531.       }

  1533.       if (x == y)

  1535.       {

  1537.         return _FP_EQ;

  1539.       }

  1541.       return 0;

  1543.     }

  1545.   #endif /* _FLOAT_IS_DOUBLE */



  1549.   #ifndef _LONG_DOUBLE_IS_DOUBLE

  1551.     #pragma inline=no_body

  1553.     int _L_FNAME(Dcomp)(long double x, long double y)

  1555.     {

  1557.       if (isnan(x) || isnan(y))

  1559.       {

  1561.         return 0;

  1563.       }

  1565.       if (x > y)

  1567.       {

  1569.         return _FP_GT;

  1571.       }

  1573.       if (x < y)

  1575.       {

  1577.         return _FP_LT;

  1579.       }

  1581.       if (x == y)

  1583.       {

  1585.         return _FP_EQ;

  1587.       }

  1589.       return 0;

  1591.     }

  1593.   #endif /* _LONG_DOUBLE_IS_DOUBLE */



  1597. #endif /* _DLIB_ADD_C99_SYMBOLS */

  1599. _C_STD_END



  1603.                 /* GENERIC TEMPLATES */

  1605. #if _HAS_GENERIC_TEMPLATES

  1607.   _EXTERN_CPP

  1609.   _C_STD_BEGIN

  1611.         _TGEN_RC(acos)  // real or complex generic overloads

  1613.         _TGEN_RC(acosh)

  1615.         _TGEN_RC(asin)

  1617.         _TGEN_RC(asinh)

  1619.         _TGEN_RC(atan)

  1621.         _TGEN_RC(atanh)

  1623.         _TGEN_RC(cos)

  1625.         _TGEN_RC(cosh)

  1627.         _TGEN_RC(exp)

  1629.         _TGEN_RC0(fabs)

  1631.         _TGEN_RC(log)

  1633.         _TGEN_RC(log10)

  1635.         _TGEN_RC2(pow)

  1637.         _TGEN_RC(sin)

  1639.         _TGEN_RC(sinh)

  1641.         _TGEN_RC(sqrt)

  1643.         _TGEN_RC(tan)

  1645.         _TGEN_RC(tanh)



  1649.         _TGEN_R2(atan2) // real generic overloads

  1651.         _TGEN_R(cbrt)

  1653.         _TGEN_R(ceil)

  1655.         _TGEN_R2(copysign)

  1657.         #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  1659.           _TGEN_R(erf)

  1661.           _TGEN_R(erfc)

  1663.           _TGEN_R(expm1)

  1665.         #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  1667.         _TGEN_R(exp2)

  1669.         _TGEN_R2(fdim)

  1671.         _TGEN_R(floor)

  1673.         #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  1675.           _TGEN_R3(fma)

  1677.         #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  1679.         _TGEN_R2(fmax)

  1681.         _TGEN_R2(fmin)

  1683.         _TGEN_R2(fmod)

  1685.         _TGEN_RX(frexp, int *)

  1687.         _TGEN_R2(hypot)

  1689.         _TGEN_RI(ilogb, int)

  1691.         _TGEN_RX(ldexp, int)

  1693.         #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  1695.           _TGEN_R(lgamma)

  1697.         #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  1699.         #ifdef _LONGLONG

  1701.           #pragma language=save

  1703.           #pragma language=extended

  1705.           _TGEN_RI(llrint, _Longlong)

  1707.           _TGEN_RI(llround, _Longlong)

  1709.           #pragma language=restore

  1711.         #endif /* _LONGLONG */

  1713.         _TGEN_R(log1p)

  1715.         _TGEN_R(log2)

  1717.         _TGEN_R(logb)

  1719.         _TGEN_RI(lrint, long)

  1721.         _TGEN_RI(lround, long)

  1723.         _TGEN_R(nearbyint)

  1725.         _TGEN_R2(nextafter)

  1727.         _TGEN_RX(nexttoward, long double)

  1729.         _TGEN_R2(remainder)

  1731.         _TGEN_R2X(remquo, int *)

  1733.         _TGEN_R(rint)

  1735.         _TGEN_R(round)

  1737.         _TGEN_RX(scalbln, long)

  1739.         _TGEN_RX(scalbn, int)

  1741.         #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  1743.           _TGEN_R(tgamma)

  1745.         #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  1747.         _TGEN_R(trunc)

  1749.   _C_STD_END

  1751.   _END_EXTERN_CPP

  1753. #endif /* _HAS_GENERIC_TEMPLATES */



  1757. #endif /* _MATH */





  1763. #if defined(_STD_USING) && defined(__cplusplus)

  1765.   using _CSTD abs;



  1769.   using _CSTD acos; using _CSTD asin;

  1771.   using _CSTD atan; using _CSTD atan2; using _CSTD ceil;

  1773.   using _CSTD cos; using _CSTD cosh; using _CSTD exp;

  1775.   using _CSTD fabs; using _CSTD floor; using _CSTD fmod;

  1777.   using _CSTD frexp; using _CSTD ldexp; using _CSTD log;

  1779.   using _CSTD log10; using _CSTD modf; using _CSTD pow;

  1781.   using _CSTD sin; using _CSTD sinh; using _CSTD sqrt;

  1783.   using _CSTD tan; using _CSTD tanh;



  1787.   #if _DLIB_ADD_C99_SYMBOLS

  1789.     using _CSTD acosf; using _CSTD asinf;

  1791.     using _CSTD atanf; using _CSTD atan2f; using _CSTD ceilf;

  1793.     using _CSTD cosf; using _CSTD coshf; using _CSTD expf;

  1795.     using _CSTD fabsf; using _CSTD floorf; using _CSTD fmodf;

  1797.     using _CSTD frexpf; using _CSTD ldexpf; using _CSTD logf;

  1799.     using _CSTD log10f; using _CSTD modff; using _CSTD powf;

  1801.     using _CSTD sinf; using _CSTD sinhf; using _CSTD sqrtf;

  1803.     using _CSTD tanf; using _CSTD tanhf;



  1807.     using _CSTD acosl; using _CSTD asinl;

  1809.     using _CSTD atanl; using _CSTD atan2l; using _CSTD ceill;

  1811.     using _CSTD cosl; using _CSTD coshl; using _CSTD expl;

  1813.     using _CSTD fabsl; using _CSTD floorl; using _CSTD fmodl;

  1815.     using _CSTD frexpl; using _CSTD ldexpl; using _CSTD logl;

  1817.     using _CSTD log10l; using _CSTD modfl; using _CSTD powl;

  1819.     using _CSTD sinl; using _CSTD sinhl; using _CSTD sqrtl;

  1821.     using _CSTD tanl; using _CSTD tanhl;



  1825.     using _CSTD acosh; using _CSTD asinh; using _CSTD atanh;

  1827.     using _CSTD cbrt; using _CSTD exp2;

  1829.     using _CSTD hypot; using _CSTD ilogb;

  1831.     using _CSTD log1p; using _CSTD log2; using _CSTD logb;

  1833.     #ifdef _LONGLONG

  1835.       using _CSTD llrint; using _CSTD llround;

  1837.     #endif /* _LONGLONG */

  1839.     using _CSTD lrint; using _CSTD nearbyint;

  1841.     using _CSTD rint; using _CSTD lround;

  1843.     using _CSTD fdim; using _CSTD fmax; using _CSTD fmin;

  1845.     using _CSTD round; using _CSTD trunc;

  1847.     using _CSTD remainder; using _CSTD remquo;

  1849.     using _CSTD copysign; using _CSTD nan; using _CSTD nextafter;

  1851.     using _CSTD scalbn; using _CSTD scalbln; using _CSTD nexttoward;



  1855.     using _CSTD acoshf; using _CSTD asinhf; using _CSTD atanhf;

  1857.     using _CSTD cbrtf; using _CSTD exp2f;

  1859.     using _CSTD hypotf; using _CSTD ilogbf;

  1861.     using _CSTD log1pf; using _CSTD log2f; using _CSTD logbf;

  1863.     #ifdef _LONGLONG

  1865.       using _CSTD llrintf; using _CSTD llroundf;

  1867.     #endif /* _LONGLONG*/

  1869.     using _CSTD lrintf; using _CSTD nearbyintf;

  1871.     using _CSTD rintf; using _CSTD lroundf;

  1873.     using _CSTD fdimf; using _CSTD fmaxf; using _CSTD fminf;

  1875.     using _CSTD roundf; using _CSTD truncf;

  1877.     using _CSTD remainderf; using _CSTD remquof;

  1879.     using _CSTD copysignf; using _CSTD nanf;

  1881.     using _CSTD nextafterf; using _CSTD scalbnf; using _CSTD scalblnf;

  1883.     using _CSTD nexttowardf;



  1887.     using _CSTD acoshl; using _CSTD asinhl; using _CSTD atanhl;

  1889.     using _CSTD cbrtl; using _CSTD exp2l;

  1891.     using _CSTD hypotl; using _CSTD ilogbl;

  1893.     using _CSTD log1pl; using _CSTD log2l; using _CSTD logbl;

  1895.     #ifdef _LONGLONG

  1897.       using _CSTD llrintl; using _CSTD llroundl;

  1899.     #endif /* _LONGLONG */

  1901.     using _CSTD lrintl; using _CSTD nearbyintl;

  1903.     using _CSTD rintl; using _CSTD lroundl;

  1905.     using _CSTD fdiml; using _CSTD fmaxl; using _CSTD fminl;

  1907.     using _CSTD roundl; using _CSTD truncl;

  1909.     using _CSTD remainderl; using _CSTD remquol;

  1911.     using _CSTD copysignl; using _CSTD nanl;

  1913.     using _CSTD nextafterl; using _CSTD scalbnl; using _CSTD scalblnl;

  1915.     using _CSTD nexttowardl;



  1919.     using _CSTD float_t; using _CSTD double_t;



  1923.     #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH

  1925.       using _CSTD erf; using _CSTD erfc;

  1927.       using _CSTD erff; using _CSTD erfcf;

  1929.       using _CSTD erfl; using _CSTD erfcl;

  1931.       using _CSTD expm1; using _CSTD expm1f; using _CSTD expm1l;

  1933.       using _CSTD lgamma; using _CSTD lgammaf; using _CSTD lgammal;

  1935.       using _CSTD tgamma; using _CSTD tgammaf; using _CSTD tgammal;

  1937.       using _CSTD fma; using _CSTD fmaf; using _CSTD fmal;

  1939.     #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH */

  1941.     #if _HAS_GENERIC_TEMPLATES

  1943.       using _CSTD _FPCOMP; using _CSTD fpclassify;

  1945.       using _CSTD signbit; using _CSTD isfinite; using _CSTD isinf;

  1947.       using _CSTD isnan; using _CSTD isnormal;

  1949.       using _CSTD isgreater; using _CSTD isgreaterequal;

  1951.       using _CSTD isless; using _CSTD islessequal; using _CSTD islessgreater;

  1953.       using _CSTD isunordered;

  1955.     #endif /* _HAS_GENERIC_TEMPLATES */

  1957.   #endif /* _DLIB_ADD_C99_SYMBOLS */



  1961.   #if _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH && \

  1963.       !defined(_DLIB_DO_NOT_ADD_ACCURATE_FUNCTIONS)

  1965.     using _CSTD __iar_tan_accurate; using _CSTD __iar_cos_accurate;

  1967.     using _CSTD __iar_sin_accurate; using _CSTD __iar_pow_accurate;

  1969.     using _CSTD __iar_Sin_accurate; using _CSTD __iar_Pow_accurate;

  1971.     #if _DLIB_ADD_C99_SYMBOLS

  1973.       using _CSTD __iar_tan_accuratef; using _CSTD __iar_cos_accuratef;

  1975.       using _CSTD __iar_sin_accuratef; using _CSTD __iar_pow_accuratef;

  1977.       using _CSTD __iar_Sin_accuratef; using _CSTD __iar_Pow_accuratef;

  1979.       using _CSTD __iar_tan_accuratel; using _CSTD __iar_cos_accuratel;

  1981.       using _CSTD __iar_sin_accuratel; using _CSTD __iar_pow_accuratel;

  1983.       using _CSTD __iar_Sin_accuratel; using _CSTD __iar_Pow_accuratel;

  1985.     #endif /* _DLIB_ADD_C99_SYMBOLS */

  1987.   #endif /* _DLIB_ALLOW_LARGE_CONSTANT_TABLES_FOR_MATH &&

  1989.             !defined(_DLIB_DO_NOT_ADD_ACCURATE_FUNCTIONS) */



  1993.   #ifndef _DLIB_DO_NOT_ADD_SMALL_FUNCTIONS

  1995.     using _CSTD __iar_cos_small; using _CSTD __iar_exp_small;

  1997.     using _CSTD __iar_log_small; using _CSTD __iar_log10_small;

  1999.     using _CSTD __iar_pow_small; using _CSTD __iar_sin_small;

  2001.     using _CSTD __iar_tan_small;

  2003.     #if _DLIB_ADD_C99_SYMBOLS

  2005.       using _CSTD __iar_cos_smallf; using _CSTD __iar_exp_smallf;

  2007.       using _CSTD __iar_log_smallf; using _CSTD __iar_log10_smallf;

  2009.       using _CSTD __iar_pow_smallf; using _CSTD __iar_sin_smallf;

  2011.       using _CSTD __iar_tan_smallf;



  2015.       using _CSTD __iar_cos_smalll; using _CSTD __iar_exp_smalll;

  2017.       using _CSTD __iar_log_smalll; using _CSTD __iar_log10_smalll;

  2019.       using _CSTD __iar_pow_smalll; using _CSTD __iar_sin_smalll;

  2021.       using _CSTD __iar_tan_smalll;

  2023.     #endif /* _DLIB_ADD_C99_SYMBOLS */

  2025.   #endif /* _DLIB_DO_NOT_ADD_SMALL_FUNCTIONS */



  2029.   using _CSTD _D_FNAME(Dcomp);

  2031.   using _CSTD _F_FNAME(Dcomp);

  2033.   using _CSTD _L_FNAME(Dcomp);



  2037.   #if __AEABI_PORTABILITY_INTERNAL_LEVEL

  2039.     using _CSTD __aeabi_HUGE_VAL;

  2041.     #if _DLIB_ADD_C99_SYMBOLS

  2043.       using _CSTD __aeabi_HUGE_VALF;

  2045.       using _CSTD __aeabi_HUGE_VALL;

  2047.       using _CSTD __aeabi_INFINITY;

  2049.       using _CSTD __aeabi_NAN;

  2051.     #endif /* _DLIB_ADD_C99_SYMBOLS */

  2053.   #endif



  2057. #endif /* defined(_STD_USING) && defined(__cplusplus) */



  2061. /*

  2063. * Copyright (c) 1992-2009 by P.J. Plauger.  ALL RIGHTS RESERVED.

  2065. * Consult your license regarding permissions and restrictions.

  2067. V5.04:0576 */
復(fù)制代碼
作者: EDDDDDDDDY    時(shí)間: 2018-3-7 14:31
樓主好人




歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1