home *** CD-ROM | disk | FTP | other *** search
/ Programmer Plus 2007 / Programmer-Plus-2007.iso / Programming / Compilers / digital marsC compier / dm / include / math.h < prev    next >
Encoding:
C/C++ Source or Header  |  2001-07-26  |  14.1 KB  |  566 lines
  1.  
  2. /* Copyright (C) 1986-2001 by Digital Mars.
  3.  * All Rights Reserved
  4.  * www.digitalmars.com
  5.  */
  6.  
  7. #if __DMC__ || __RCC__
  8. #pragma once
  9. #endif
  10.  
  11. #ifndef __MATH_H
  12. #define __MATH_H 1
  13.  
  14. #if __cplusplus
  15. extern "C" {
  16. #endif
  17.  
  18. /* Define _CRTAPI1 (for compatibility with the NT SDK) */
  19. #ifndef _CRTAPI1
  20. #define _CRTAPI1 __cdecl
  21. #endif
  22.  
  23. /* Define _CRTAPI2 (for compatibility with the NT SDK) */
  24. #ifndef _CRTAPI2
  25. #define _CRTAPI2 __cdecl
  26. #endif
  27.  
  28. /* Define CRTIMP */
  29. #ifndef _CRTIMP
  30. #if defined(_WIN32) && defined(_DLL)
  31. #define _CRTIMP  __declspec(dllimport)
  32. #else
  33. #define _CRTIMP
  34. #endif
  35. #endif
  36.  
  37. #ifndef FLT_EVAL_METHOD
  38. typedef float float_t;
  39. typedef double double_t;
  40. #define FLT_EVAL_METHOD 0
  41. #endif
  42.  
  43. #define HUGE_VAL    __inf
  44. #define HUGE_VALF    ((float)__inf)
  45. #define HUGE_VALL    ((long double)__inf)
  46.  
  47. #define INFINITY    __inf
  48. #define    NAN        __nan
  49.  
  50. #ifndef __STDC__
  51. #define NANS        __nans
  52. #endif
  53.  
  54. #define    FP_NANS        0
  55. #define FP_NANQ        1
  56. #define    FP_INFINITE    2
  57. #define    FP_NORMAL    3
  58. #define    FP_SUBNORMAL    4
  59. #define    FP_ZERO        5
  60.  
  61. #define FP_NAN        FP_NANQ
  62. #define FP_EMPTY    6
  63. #define FP_UNSUPPORTED    7
  64.  
  65. // Not implemented
  66. //#define FP_ILOGB0
  67. //#define FP_ILOGBNAN
  68.  
  69. #define MATH_ERRNO    1
  70. #define MATH_ERREXCEPT    2
  71. #define math_errhandling (MATH_ERRNO | MATH_ERREXCEPT)
  72.  
  73. unsigned __cdecl __fpclassify_f(float);
  74. unsigned __cdecl __fpclassify_d(double);
  75. unsigned __cdecl __fpclassify_ld(long double);
  76.  
  77. #if __cplusplus
  78. extern "C++" {
  79. inline int fpclassify(float fe)    { return __fpclassify_f(fe); }
  80. inline int fpclassify(double fe){ return __fpclassify_d(fe); }
  81. inline int fpclassify(long double fe)
  82.     { return (sizeof(long double) == sizeof(double))
  83.         ? __fpclassify_d(fe)
  84.         : __fpclassify_ld(fe);
  85.     }
  86.  
  87. inline int signbit(float fe)    { return ((short *)&(fe))[1] & 0x8000; }
  88. inline int signbit(double fe)    { return ((short *)&(fe))[3] & 0x8000; }
  89. inline int signbit(long double fe)
  90.     { return (sizeof(long double) == sizeof(double))
  91.         ? ((short *)&(fe))[3] & 0x8000
  92.         : ((short *)&(fe))[4] & 0x8000;
  93.     }
  94.  
  95. inline int isfinite(float fe)    { return fpclassify(fe) >= FP_NORMAL; }
  96. inline int isfinite(double fe)    { return fpclassify(fe) >= FP_NORMAL; }
  97. inline int isfinite(long double fe) { return fpclassify(fe) >= FP_NORMAL; }
  98.  
  99. inline int isnormal(float fe)    { return fpclassify(fe) == FP_NORMAL; }
  100. inline int isnormal(double fe)    { return fpclassify(fe) == FP_NORMAL; }
  101. inline int isnormal(long double fe) { return fpclassify(fe) == FP_NORMAL; }
  102.  
  103. inline int isnan(float fe)    { return fpclassify(fe) <= FP_NANQ;   }
  104. inline int isnan(double fe)    { return fpclassify(fe) <= FP_NANQ;   }
  105. inline int isnan(long double fe) { return fpclassify(fe) <= FP_NANQ;   }
  106.  
  107. inline int isinf(float fe)    { return fpclassify(fe) == FP_INFINITE; }
  108. inline int isinf(double fe)    { return fpclassify(fe) == FP_INFINITE; }
  109. inline int isinf(long double fe) { return fpclassify(fe) == FP_INFINITE; }
  110.  
  111. }
  112. #else
  113. #define fpclassify(fe)    (sizeof(fe) == sizeof(float) ?            \
  114.                 __fpclassify_f(fe) :            \
  115.                 (sizeof(fe) == sizeof(double) ? __fpclassify_d(fe) : __fpclassify_ld(fe)) \
  116.             )
  117. #if 1
  118. #define signbit __signbit
  119. __inline int __signbit(long double fe)
  120.     { return (sizeof(long double) == sizeof(double))
  121.         ? ((short *)&(fe))[3] & 0x8000
  122.         : ((short *)&(fe))[4] & 0x8000;
  123.     }
  124. #else
  125. #define signbit(fe)    (sizeof(fe) == sizeof(float) ?            \
  126.                 (int)(((short *)&(fe))[1] & 0x8000) :    \
  127.                 (sizeof(fe) == sizeof(double) ? (int)(((short *)&(fe))[3] & 0x8000)  \
  128.                               : (int)(((short *)&(fe))[4] & 0x8000)) \
  129.             )
  130. #endif
  131. #define isfinite(fe)    (fpclassify(fe) >= FP_NORMAL)
  132. #define isnormal(fe)    (fpclassify(fe) == FP_NORMAL)
  133. #define isnan(fe)    (fpclassify(fe) <= FP_NANQ)
  134. #define isinf(fe)    (fpclassify(fe) == FP_INFINITE)
  135. #endif
  136.  
  137.  
  138. #if __OS2__ && __INTSIZE == 4
  139. #define __CLIB    __stdcall
  140. #else
  141. #define __CLIB    __cdecl
  142. #endif
  143.  
  144. double    __CLIB acos(double);
  145. float    __CLIB acosf(float);
  146. #define acosl    acos
  147.  
  148. double    __CLIB asin(double);
  149. float    __CLIB asinf(float);
  150. #define asinl    asin
  151. #define _asinl    asinl
  152.  
  153. double    __CLIB atan(double);
  154. float    __CLIB atanf(float);
  155. #define atanl    atan
  156. #define _atanl    atanl
  157.  
  158. double    __CLIB atan2(double,double);
  159. float    __CLIB atan2f(float,float);
  160. #define atan2l    atan2
  161. #define _atan2l    atan2l
  162.  
  163. float        __CLIB cosf(float);
  164. double        __CLIB cos(double);
  165. long double    __CLIB cosl(long double);
  166. float        __CLIB _inline_cosf(float);
  167. double        __CLIB _inline_cos(double);
  168. long double    __CLIB _inline_cosl(long double);
  169. #if __INLINE_8087 && __I86__ >= 3
  170. #define cos(d)  _inline_cos(d)
  171. #define cosf(f) _inline_cosf(f)
  172. #define cosl(d) _inline_cosl(d)
  173. #elif !_WIN32
  174. #define cosl(d) cos(d)
  175. #endif
  176. #define _cosl    cosl
  177.  
  178. float        __CLIB sinf(float);
  179. double        __CLIB sin(double);
  180. long double    __CLIB sinl(long double);
  181. float        __CLIB _inline_sinf(float);
  182. double        __CLIB _inline_sin(double);
  183. long double    __CLIB _inline_sinl(long double);
  184. #if __INLINE_8087 && __I86__ >= 3
  185. #define sin(d)  _inline_sin(d)
  186. #define sinf(f) _inline_sinf(f)
  187. #define sinl(d) _inline_sinl(d)
  188. #elif !_WIN32
  189. #define sinl(d) sin(d)
  190. #endif
  191. #define _sinl    sinl
  192.  
  193. double    __CLIB tan(double);
  194. float    __CLIB tanf(float);
  195. #define tanl    tan
  196. #define _tanl    tan
  197.  
  198. double __CLIB acosh(double x);
  199. float __CLIB acoshf(float x);
  200. long double __CLIB acoshl(long double x);
  201.  
  202. double __CLIB asinh(double x);
  203. float __CLIB asinhf(float x);
  204. long double __CLIB asinhl(long double x);
  205.  
  206. double __CLIB atanh(double x);
  207. float __CLIB atanhf(float x);
  208. long double __CLIB atanhl(long double x);
  209.  
  210.  
  211. double    __CLIB cosh(double);
  212. float    __CLIB coshf(float);
  213. #define coshl    cosh
  214. #define _coshl    cosh
  215.  
  216. double    __CLIB sinh(double);
  217. float    __CLIB sinhf(float);
  218. #define sinhl    sinh
  219. #define _sinhl    sinh
  220.  
  221. double    __CLIB tanh(double);
  222. float    __CLIB tanhf(float);
  223. #define tanhl    tanh
  224. #define _tanhl    tanh
  225.  
  226. double    __CLIB exp(double);
  227. float    __CLIB expf(float);
  228. long double __CLIB expl(long double);
  229. #define expl    exp
  230. #define _expl    expl
  231.  
  232. double    __CLIB exp2(double);
  233. float    __CLIB exp2f(float);
  234. long double __CLIB exp2l(long double);
  235.  
  236. double    __CLIB expm1(double);
  237. float    __CLIB expm1f(float);
  238. #define expm1l    expm1
  239.  
  240. double    __CLIB frexp(double,int *);
  241. float    __CLIB frexpf(float,int *);
  242. #define frexpl    frexp
  243. #define _frexpl    frexp
  244.  
  245. int __CLIB ilogb(double);
  246. int __CLIB ilogbf(float);
  247. int __CLIB ilogbl(long double);
  248.  
  249. double    __CLIB ldexp(double,int);
  250. float    __CLIB ldexpf(float,int);
  251. #if _WIN32
  252. long double    __CLIB ldexpl(long double, int);
  253. #define _ldexpl    ldexpl
  254. #else
  255. #define ldexpl    ldexp
  256. #define _ldexpl    ldexp
  257. #endif
  258.  
  259. double    __CLIB log(double);
  260. float    __CLIB logf(float);
  261. #define logl    log
  262. #define _logl    log
  263.  
  264. double    __CLIB log10(double);
  265. float    __CLIB log10f(float);
  266. #define log10l    log10
  267. #define _log10l    log10
  268.  
  269. double    __CLIB log1p(double);
  270. float    __CLIB log1pf(float);
  271. #if _WIN32
  272. long double    __CLIB log1pl(long double);
  273. #else
  274. #define log1pl    log1p
  275. #endif
  276.  
  277. double    __CLIB log2(double);
  278. float    __CLIB log2f(float);
  279. long double __CLIB log2l(long double);
  280.  
  281. double    __CLIB logb(double);
  282. float    __CLIB logbf(float);
  283. long double __CLIB logbl(long double);
  284. #define logbl        logb
  285.  
  286. double    __CLIB modf(double,double *);
  287. float    __CLIB modff(float,float *);
  288. #define modfl    modf
  289. #define _modfl    modf
  290.  
  291. double    __CLIB scalbn(double, int);
  292. float    __CLIB scalbnf(float, int);
  293. long double __CLIB scalbnl(long double, int);
  294.  
  295. double    __CLIB scalbln(double, long);
  296. float    __CLIB scalblnf(float, long);
  297. long double __CLIB scalblnl(long double, long);
  298.  
  299. double    __CLIB cbrt(double, int);
  300. float    __CLIB cbrtf(float, int);
  301. long double __CLIB cbrtl(long double, int);
  302.  
  303. float        __CLIB fabsf(float);
  304. double        __CLIB fabs(double);
  305. long double    __CLIB fabsl(long double);
  306. float        __CLIB _inline_fabsf(float);
  307. double        __CLIB _inline_fabs(double);
  308. long double    __CLIB _inline_fabsl(long double);
  309. #define fabs(d)  _inline_fabs(d)
  310. #define fabsf(f) _inline_fabsf(f)
  311. #define fabsl(d) _inline_fabsl(d)
  312. #define _fabsl    fabsl
  313.  
  314. float    __CLIB hypotf(float, float);
  315. double    __CLIB hypot(double,double);
  316. long double __CLIB hypotl(long double, long double);
  317.  
  318. double    __CLIB pow(double,double);
  319. float    __CLIB powf(float,float);
  320. #define powl    pow
  321. #define _powl    pow
  322.  
  323. float        __CLIB sqrtf(float);
  324. double        __CLIB sqrt(double);
  325. long double    __CLIB sqrtl(long double);
  326. float        __CLIB _inline_sqrtf(float);
  327. double        __CLIB _inline_sqrt(double);
  328. long double    __CLIB _inline_sqrtl(long double);
  329. #if __INLINE_8087
  330. #define sqrt(d)  _inline_sqrt(d)
  331. #define sqrtf(f) _inline_sqrtf(f)
  332. #define sqrtl(d) _inline_sqrtl(d)
  333. #elif !_WIN32
  334. #define sqrtl(d) sqrt(d)
  335. #endif
  336.  
  337. double __CLIB erf(double x);
  338. float __CLIB erff(float x);
  339. long double __CLIB erfl(long double x);
  340.  
  341. double __CLIB erfc(double x);
  342. float __CLIB erfcf(float x);
  343. long double __CLIB erfcl(long double x);
  344.  
  345. double __CLIB lgamma(double x);
  346. float __CLIB lgammaf(float x);
  347. long double __CLIB lgammal(long double x);
  348.  
  349. double __CLIB tgamma(double x);
  350. float __CLIB tgammaf(float x);
  351. long double __CLIB tgammal(long double x);
  352.  
  353. float        __CLIB ceilf(float);
  354. double        __CLIB ceil(double);
  355. long double    __CLIB ceill(long double);
  356. #define _ceill ceil
  357.  
  358. float        __CLIB floorf(float);
  359. double        __CLIB floor(double);
  360. long double    __CLIB floorl(long double);
  361. #define _floorl    floor
  362.  
  363. double __cdecl nearbyint(double);
  364. float __cdecl nearbyintf(float);
  365. long double __cdecl nearbyintl(long double);
  366. #if !_WIN32
  367. #define nearbyintl    nearbyint
  368. #endif
  369.  
  370. float        __cdecl rintf(float);
  371. double        __cdecl rint(double);
  372. long double    __cdecl rintl(long double);
  373. float        __cdecl _inline_rintf(float);
  374. double        __cdecl _inline_rint(double);
  375. long double    __cdecl _inline_rintl(long double);
  376. #if __INLINE_8087
  377. #define rint(d)  _inline_rint(d)
  378. #define rintf(f) _inline_rintf(f)
  379. #define rintl(d) _inline_rintl(d)
  380. #elif !_WIN32
  381. #define rintl(d) rint(d)
  382. #endif
  383.  
  384. long int __cdecl lrint(double x);
  385. long int __cdecl lrintf(float x);
  386. long int __cdecl lrintl(long double x);
  387.  
  388. #if _WIN32
  389. long long int __cdecl llrint(double x);
  390. long long int __cdecl llrintf(float x);
  391. long long int __cdecl llrintl(long double x);
  392. #endif
  393.  
  394. double __cdecl round(double );
  395. float __cdecl roundf(float );
  396. long double __cdecl roundl(long double );
  397. #if !_WIN32
  398. #define roundl        round
  399. #endif
  400.  
  401. long int __cdecl lround(double x);
  402. long int __cdecl lroundf(float x);
  403. long int __cdecl lroundl(long double x);
  404.  
  405. #if _WIN32
  406. long long int __cdecl llround(double x);
  407. long long int __cdecl llroundf(float x);
  408. long long int __cdecl llroundl(long double x);
  409. #endif
  410.  
  411. double __cdecl trunc(double);
  412. float __cdecl truncf(float);
  413. long double __cdecl truncl(long double);
  414. #if !_WIN32
  415. #define truncl        trunc
  416. #endif
  417.  
  418. double    __CLIB fmod(double,double);
  419. float    __CLIB fmodf(float,float);
  420. #define fmodl    fmod
  421. #define _fmodl    fmod
  422.  
  423. double __cdecl remainder(double ,double);
  424. float __cdecl remainderf(float ,float);
  425. long double __cdecl remainderl(long double ,long double);
  426. #define remainderl    remainder
  427.  
  428. double __cdecl remquo(double ,double ,int *);
  429. float __cdecl remquof(float ,float ,int *);
  430. long double __cdecl remquol(long double ,long double ,int *);
  431. #define remquol        remquo
  432.  
  433. double        __cdecl copysign(double, double);
  434. float        __cdecl copysignf(float, float);
  435. long double    __cdecl copysignl(long double, long double);
  436. #if !_WIN32
  437. #define copysignl    copysign
  438. #endif
  439.  
  440. double __cdecl nan(const char *);
  441. float __cdecl nanf(const char *);
  442. long double __cdecl nanl(const char *);
  443. #define nanl        nan
  444.  
  445. double __cdecl nextafter(double, double);
  446. float __cdecl nextafterf(float, float);
  447. long double __cdecl nextafterl(long double, long double);
  448. #define nextafterl    nextafter
  449.  
  450. double __cdecl nexttoward(double, double);
  451. float __cdecl nexttowardf(float, float);
  452. long double __cdecl nexttowardl(long double, long double);
  453.  
  454. double __cdecl fdim(double, double);
  455. float __cdecl fdimf(float, float);
  456. long double __cdecl fdiml(long double, long double);
  457.  
  458. double __cdecl fmax(double, double);
  459. float __cdecl fmaxf(float, float);
  460. long double __cdecl fmaxl(long double, long double);
  461.  
  462. double __cdecl fmin(double, double);
  463. float __cdecl fminf(float, float);
  464. long double __cdecl fminl(long double, long double);
  465.  
  466. double __cdecl fma(double, double, double);
  467. float __cdecl fmaf(float, float, float);
  468. long double __cdecl fmal(long double, long double, long double);
  469.  
  470.  
  471. #define isgreater(x,y)        !((x) !>  (y))
  472. #define isgreaterequal(x,y)    !((x) !>= (y))
  473. #define isless(x,y)        !((x) !<  (y))
  474. #define islessequal(x,y)    !((x) !<= (y))
  475. #define islessgreater(x,y)    !((x) !<> (y))
  476. #define isunordered(x,y)    ((x) !<>= (y))
  477.  
  478. #ifndef __STDC__
  479.  
  480. #define _matherrl _matherr
  481.  
  482. #if 0 // obsolete
  483. #define PI        3.14159265358979323846
  484. #define LOG2        0.30102999566398119521
  485. #define LN2        0.6931471805599453094172321
  486. #define LOG2T        3.32192809488736234787
  487. #define LOG2E        1.4426950408889634074
  488. #endif
  489.  
  490. #define M_LOG2T        3.32192809488736234787
  491. #define M_LOG2        0.30102999566398119521
  492. #define    M_LOG2E        1.4426950408889634074
  493. #define    M_LN2        0.6931471805599453094172321
  494. #define    M_PI        3.14159265358979323846
  495. #define    M_E        2.7182818284590452354
  496. #define    M_LOG10E    0.43429448190325182765
  497. #define    M_LN10        2.30258509299404568402
  498. #define    M_PI_2        1.57079632679489661923
  499. #define    M_PI_4        0.78539816339744830962
  500. #define    M_1_PI        0.31830988618379067154
  501. #define    M_2_PI        0.63661977236758134308
  502. #define    M_2_SQRTPI    1.12837916709551257390
  503. #define    M_SQRT2        1.41421356237309504880
  504. #define    M_SQRT1_2    0.70710678118654752440
  505.  
  506. #ifndef _EXCEPTION_DEFINED
  507.  
  508. struct _exception
  509. {    int type;
  510.     char *name;
  511.     double arg1;
  512.     double arg2;
  513.     double retval;
  514. };
  515.  
  516. #if !__STDC__
  517. #define exception _exception
  518. #endif
  519.  
  520. #define _exceptionl _exception
  521.  
  522. #define _EXCEPTION_DEFINED
  523. #endif 
  524.  
  525.  
  526. #define _DOMAIN        1
  527. #define _SING        2
  528. #define    _OVERFLOW    3
  529. #define _UNDERFLOW    4
  530. #define _TLOSS        5
  531. #define _PLOSS        6
  532.  
  533. #define EDOM            33
  534. #define ERANGE          34
  535.  
  536. #ifndef __STDC__
  537. #define DOMAIN        _DOMAIN
  538. #define SING        _SING
  539. #define    OVERFLOW    _OVERFLOW
  540. #define UNDERFLOW    _UNDERFLOW
  541. #define TLOSS        _TLOSS
  542. #define PLOSS        _PLOSS
  543. #define DIVIDE_BY_ZERO  7
  544. #endif
  545.  
  546. int    __CLIB matherr(struct exception *);
  547. double    __CLIB atof(const char *);
  548. #define _atold atof
  549. #define _matherr matherr
  550. double    __CLIB poly(double,int,double []);
  551. #define polyl poly
  552. double _poly87(double, int, double []);
  553.  
  554. #if __INLINE_8087
  555. #define poly _poly87
  556. #endif
  557.  
  558.  
  559. #endif
  560.  
  561. #if __cplusplus
  562. }
  563. #endif
  564.  
  565. #endif
  566.