newlib/libc/include/math.h

   1 #ifndef  _MATH_H_
   2
   3 #define  _MATH_H_
   4
   5 #include <sys/reent.h>
   6 #include <sys/cdefs.h>
   7 #include <machine/ieeefp.h>
   8 #include "_ansi.h"
   9
  10 _BEGIN_STD_C
  11
  12 /* Natural log of 2 */
  13 #define _M_LN2        0.693147180559945309417
  14
  15 #if __GNUC_PREREQ (3, 3)
  16  /* gcc >= 3.3 implicitly defines builtins for HUGE_VALx values.  */
  17
  18 # ifndef HUGE_VAL
  19 #  define HUGE_VAL (__builtin_huge_val())
  20 # endif
  21
  22 # ifndef HUGE_VALF
  23 #  define HUGE_VALF (__builtin_huge_valf())
  24 # endif
  25
  26 # ifndef HUGE_VALL
  27 #  define HUGE_VALL (__builtin_huge_vall())
  28 # endif
  29
  30 # ifndef INFINITY
  31 #  define INFINITY (__builtin_inff())
  32 # endif
  33
  34 # ifndef NAN
  35 #  define NAN (__builtin_nanf(""))
  36 # endif
  37
  38 #else /* !gcc >= 3.3  */
  39
  40  /*      No builtins.  Use fixed defines instead.  (All 3 HUGE plus the INFINITY
  41   * and NAN macros are required to be constant expressions.  Using a variable--
  42   * even a static const--does not meet this requirement, as it cannot be
  43   * evaluated at translation time.)
  44   *      The infinities are done using numbers that are far in excess of
  45   * something that would be expected to be encountered in a floating-point
  46   * implementation.  (A more certain way uses values from float.h, but that is
  47   * avoided because system includes are not supposed to include each other.)
  48   *      This method might produce warnings from some compilers.  (It does in
  49   * newer GCCs, but not for ones that would hit this #else.)  If this happens,
  50   * please report details to the Newlib mailing list.  */
  51
  52  #ifndef HUGE_VAL
  53   #define HUGE_VAL (1.0e999999999)
  54  #endif
  55
  56  #ifndef HUGE_VALF
  57   #define HUGE_VALF (1.0e999999999F)
  58  #endif
  59
  60  #if !defined(HUGE_VALL)  &&  defined(_HAVE_LONG_DOUBLE)
  61   #define HUGE_VALL (1.0e999999999L)
  62  #endif
  63
  64  #if !defined(INFINITY)
  65   #define INFINITY (HUGE_VALF)
  66  #endif
  67
  68  #if !defined(NAN)
  69   #if defined(__GNUC__)  &&  defined(__cplusplus)
  70     /* Exception:  older g++ versions warn about the divide by 0 used in the
  71      * normal case (even though older gccs do not).  This trick suppresses the
  72      * warning, but causes errors for plain gcc, so is only used in the one
  73      * special case.  */
  74     static const union { __ULong __i[1]; float __d; } __Nanf = {0x7FC00000};
  75     #define NAN (__Nanf.__d)
  76   #else
  77     #define NAN (0.0F/0.0F)
  78   #endif
  79  #endif
  80
  81 #endif /* !gcc >= 3.3  */
  82
  83 /* Reentrant ANSI C functions.  */
  84
  85 #ifndef __math_68881
  86 extern double atan (double);
  87 extern double cos (double);
  88 extern double sin (double);
  89 extern double tan (double);
  90 extern double tanh (double);
  91 extern double frexp (double, int *);
  92 extern double modf (double, double *);
  93 extern double ceil (double);
  94 extern double fabs (double);
  95 extern double floor (double);
  96 #endif /* ! defined (__math_68881) */
  97
  98 /* Non reentrant ANSI C functions.  */
  99
 100 #ifndef _REENT_ONLY
 101 #ifndef __math_68881
 102 extern double acos (double);
 103 extern double asin (double);
 104 extern double atan2 (double, double);
 105 extern double cosh (double);
 106 extern double sinh (double);
 107 extern double exp (double);
 108 extern double ldexp (double, int);
 109 extern double log (double);
 110 extern double log10 (double);
 111 extern double pow (double, double);
 112 extern double sqrt (double);
 113 extern double fmod (double, double);
 114 #endif /* ! defined (__math_68881) */
 115 #endif /* ! defined (_REENT_ONLY) */
 116
 117 #if __MISC_VISIBLE
 118 extern int finite (double);
 119 extern int finitef (float);
 120 extern int finitel (long double);
 121 extern int isinff (float);
 122 extern int isnanf (float);
 123 #ifdef __CYGWIN__ /* not implemented in newlib yet */
 124 extern int isinfl (long double);
 125 extern int isnanl (long double);
 126 #endif
 127 #if !defined(__cplusplus) || __cplusplus < 201103L
 128 extern int isinf (double);
 129 #endif
 130 #endif /* __MISC_VISIBLE */
 131 #if (__MISC_VISIBLE || (__XSI_VISIBLE && __XSI_VISIBLE < 600)) \
 132   && (!defined(__cplusplus) || __cplusplus < 201103L)
 133 extern int isnan (double);
 134 #endif
 135
 136 #if __ISO_C_VISIBLE >= 1999
 137 /* ISO C99 types and macros. */
 138
 139 /* FIXME:  FLT_EVAL_METHOD should somehow be gotten from float.h (which is hard,
 140  * considering that the standard says the includes it defines should not
 141  * include other includes that it defines) and that value used.  (This can be
 142  * solved, but autoconf has a bug which makes the solution more difficult, so
 143  * it has been skipped for now.)  */
 144 #if !defined(FLT_EVAL_METHOD) && defined(__FLT_EVAL_METHOD__)
 145   #define FLT_EVAL_METHOD __FLT_EVAL_METHOD__
 146   #define __TMP_FLT_EVAL_METHOD
 147 #endif /* FLT_EVAL_METHOD */
 148 #if defined FLT_EVAL_METHOD
 149   #if FLT_EVAL_METHOD == 0
 150     typedef float  float_t;
 151     typedef double double_t;
 152    #elif FLT_EVAL_METHOD == 1
 153     typedef double float_t;
 154     typedef double double_t;
 155    #elif FLT_EVAL_METHOD == 2
 156     typedef long double float_t;
 157     typedef long double double_t;
 158    #else
 159     /* Implementation-defined.  Assume float_t and double_t have been
 160      * defined previously for this configuration (e.g. config.h). */
 161   #endif
 162 #else
 163     /* Assume basic definitions.  */
 164     typedef float  float_t;
 165     typedef double double_t;
 166 #endif
 167 #if defined(__TMP_FLT_EVAL_METHOD)
 168   #undef FLT_EVAL_METHOD
 169 #endif
 170
 171 #define FP_NAN         0
 172 #define FP_INFINITE    1
 173 #define FP_ZERO        2
 174 #define FP_SUBNORMAL   3
 175 #define FP_NORMAL      4
 176
 177 #ifndef FP_ILOGB0
 178 # define FP_ILOGB0 (-__INT_MAX__)
 179 #endif
 180 #ifndef FP_ILOGBNAN
 181 # define FP_ILOGBNAN __INT_MAX__
 182 #endif
 183
 184 #ifndef MATH_ERRNO
 185 # define MATH_ERRNO 1
 186 #endif
 187 #ifndef MATH_ERREXCEPT
 188 # define MATH_ERREXCEPT 2
 189 #endif
 190 #ifndef math_errhandling
 191 # ifdef _IEEE_LIBM
 192 #  define _MATH_ERRHANDLING_ERRNO 0
 193 # else
 194 #  define _MATH_ERRHANDLING_ERRNO MATH_ERRNO
 195 # endif
 196 # ifdef _SUPPORTS_ERREXCEPT
 197 #  define _MATH_ERRHANDLING_ERREXCEPT MATH_ERREXCEPT
 198 # else
 199 #  define _MATH_ERRHANDLING_ERREXCEPT 0
 200 # endif
 201 # define math_errhandling (_MATH_ERRHANDLING_ERRNO | _MATH_ERRHANDLING_ERREXCEPT)
 202 #endif
 203
 204 extern int __isinff (float);
 205 extern int __isinfd (double);
 206 extern int __isnanf (float);
 207 extern int __isnand (double);
 208 extern int __fpclassifyf (float);
 209 extern int __fpclassifyd (double);
 210 extern int __signbitf (float);
 211 extern int __signbitd (double);
 212
 213 /* Note: isinf and isnan were once functions in newlib that took double
 214  *       arguments.  C99 specifies that these names are reserved for macros
 215  *       supporting multiple floating point types.  Thus, they are
 216  *       now defined as macros.  Implementations of the old functions
 217  *       taking double arguments still exist for compatibility purposes
 218  *       (prototypes for them are earlier in this header).  */
 219
 220 #if __GNUC_PREREQ (4, 4)
 221   #define fpclassify(__x) (__builtin_fpclassify (FP_NAN, FP_INFINITE, \
 222                                                  FP_NORMAL, FP_SUBNORMAL, \
 223                                                  FP_ZERO, __x))
 224   #ifndef isfinite
 225     #define isfinite(__x)       (__builtin_isfinite (__x))
 226   #endif
 227   #ifndef isinf
 228     #define isinf(__x) (__builtin_isinf_sign (__x))
 229   #endif
 230   #ifndef isnan
 231     #define isnan(__x) (__builtin_isnan (__x))
 232   #endif
 233   #define isnormal(__x) (__builtin_isnormal (__x))
 234 #else
 235   #define fpclassify(__x) \
 236           ((sizeof(__x) == sizeof(float))  ? __fpclassifyf(__x) : \
 237           __fpclassifyd(__x))
 238   #ifndef isfinite
 239     #define isfinite(__y) \
 240             (__extension__ ({int __cy = fpclassify(__y); \
 241                              __cy != FP_INFINITE && __cy != FP_NAN;}))
 242   #endif
 243   #ifndef isinf
 244     #define isinf(__x) (fpclassify(__x) == FP_INFINITE)
 245   #endif
 246   #ifndef isnan
 247     #define isnan(__x) (fpclassify(__x) == FP_NAN)
 248   #endif
 249   #define isnormal(__x) (fpclassify(__x) == FP_NORMAL)
 250 #endif
 251
 252 #if __GNUC_PREREQ (4, 0)
 253   #if defined(_HAVE_LONG_DOUBLE)
 254     #define signbit(__x) \
 255             ((sizeof(__x) == sizeof(float))  ? __builtin_signbitf(__x) : \
 256              (sizeof(__x) == sizeof(double)) ? __builtin_signbit (__x) : \
 257                                                __builtin_signbitl(__x))
 258   #else
 259     #define signbit(__x) \
 260             ((sizeof(__x) == sizeof(float))  ? __builtin_signbitf(__x) : \
 261                                                __builtin_signbit (__x))
 262   #endif
 263 #else
 264   #define signbit(__x) \
 265           ((sizeof(__x) == sizeof(float))  ?  __signbitf(__x) : \
 266                   __signbitd(__x))
 267 #endif
 268
 269 #if __GNUC_PREREQ (2, 97)
 270 #define isgreater(__x,__y)      (__builtin_isgreater (__x, __y))
 271 #define isgreaterequal(__x,__y) (__builtin_isgreaterequal (__x, __y))
 272 #define isless(__x,__y)         (__builtin_isless (__x, __y))
 273 #define islessequal(__x,__y)    (__builtin_islessequal (__x, __y))
 274 #define islessgreater(__x,__y)  (__builtin_islessgreater (__x, __y))
 275 #define isunordered(__x,__y)    (__builtin_isunordered (__x, __y))
 276 #else
 277 #define isgreater(x,y) \
 278           (__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); \
 279                            !isunordered(__x,__y) && (__x > __y);}))
 280 #define isgreaterequal(x,y) \
 281           (__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); \
 282                            !isunordered(__x,__y) && (__x >= __y);}))
 283 #define isless(x,y) \
 284           (__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); \
 285                            !isunordered(__x,__y) && (__x < __y);}))
 286 #define islessequal(x,y) \
 287           (__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); \
 288                            !isunordered(__x,__y) && (__x <= __y);}))
 289 #define islessgreater(x,y) \
 290           (__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); \
 291                            !isunordered(__x,__y) && (__x < __y || __x > __y);}))
 292
 293 #define isunordered(a,b) \
 294           (__extension__ ({__typeof__(a) __a = (a); __typeof__(b) __b = (b); \
 295                            fpclassify(__a) == FP_NAN || fpclassify(__b) == FP_NAN;}))
 296 #endif
 297
 298 /* Non ANSI double precision functions.  */
 299
 300 extern double infinity (void);
 301 extern double nan (const char *);
 302 extern double copysign (double, double);
 303 extern double logb (double);
 304 extern int ilogb (double);
 305
 306 extern double asinh (double);
 307 extern double cbrt (double);
 308 extern double nextafter (double, double);
 309 extern double rint (double);
 310 extern double scalbn (double, int);
 311
 312 extern double exp2 (double);
 313 extern double scalbln (double, long int);
 314 extern double tgamma (double);
 315 extern double nearbyint (double);
 316 extern long int lrint (double);
 317 extern long long int llrint (double);
 318 extern double round (double);
 319 extern long int lround (double);
 320 extern long long int llround (double);
 321 extern double trunc (double);
 322 extern double remquo (double, double, int *);
 323 extern double fdim (double, double);
 324 extern double fmax (double, double);
 325 extern double fmin (double, double);
 326 extern double fma (double, double, double);
 327
 328 #ifndef __math_68881
 329 extern double log1p (double);
 330 extern double expm1 (double);
 331 #endif /* ! defined (__math_68881) */
 332
 333 #ifndef _REENT_ONLY
 334 extern double acosh (double);
 335 extern double atanh (double);
 336 extern double remainder (double, double);
 337 extern double gamma (double);
 338 extern double lgamma (double);
 339 extern double erf (double);
 340 extern double erfc (double);
 341 extern double log2 (double);
 342 #if !defined(__cplusplus)
 343 #define log2(x) (log (x) / _M_LN2)
 344 #endif
 345
 346 #ifndef __math_68881
 347 extern double hypot (double, double);
 348 #endif
 349
 350 #endif /* ! defined (_REENT_ONLY) */
 351
 352 /* Single precision versions of ANSI functions.  */
 353
 354 extern float atanf (float);
 355 extern float cosf (float);
 356 extern float sinf (float);
 357 extern float tanf (float);
 358 extern float tanhf (float);
 359 extern float frexpf (float, int *);
 360 extern float modff (float, float *);
 361 extern float ceilf (float);
 362 extern float fabsf (float);
 363 extern float floorf (float);
 364
 365 #ifndef _REENT_ONLY
 366 extern float acosf (float);
 367 extern float asinf (float);
 368 extern float atan2f (float, float);
 369 extern float coshf (float);
 370 extern float sinhf (float);
 371 extern float expf (float);
 372 extern float ldexpf (float, int);
 373 extern float logf (float);
 374 extern float log10f (float);
 375 extern float powf (float, float);
 376 extern float sqrtf (float);
 377 extern float fmodf (float, float);
 378 #endif /* ! defined (_REENT_ONLY) */
 379
 380 /* Other single precision functions.  */
 381
 382 extern float exp2f (float);
 383 extern float scalblnf (float, long int);
 384 extern float tgammaf (float);
 385 extern float nearbyintf (float);
 386 extern long int lrintf (float);
 387 extern long long int llrintf (float);
 388 extern float roundf (float);
 389 extern long int lroundf (float);
 390 extern long long int llroundf (float);
 391 extern float truncf (float);
 392 extern float remquof (float, float, int *);
 393 extern float fdimf (float, float);
 394 extern float fmaxf (float, float);
 395 extern float fminf (float, float);
 396 extern float fmaf (float, float, float);
 397
 398 extern float infinityf (void);
 399 extern float nanf (const char *);
 400 extern float copysignf (float, float);
 401 extern float logbf (float);
 402 extern int ilogbf (float);
 403
 404 extern float asinhf (float);
 405 extern float cbrtf (float);
 406 extern float nextafterf (float, float);
 407 extern float rintf (float);
 408 extern float scalbnf (float, int);
 409 extern float log1pf (float);
 410 extern float expm1f (float);
 411
 412 #ifndef _REENT_ONLY
 413 extern float acoshf (float);
 414 extern float atanhf (float);
 415 extern float remainderf (float, float);
 416 extern float gammaf (float);
 417 extern float lgammaf (float);
 418 extern float erff (float);
 419 extern float erfcf (float);
 420 extern float log2f (float);
 421 extern float hypotf (float, float);
 422 #endif /* ! defined (_REENT_ONLY) */
 423
 424 /* Newlib doesn't fully support long double math functions so far.
 425    On platforms where long double equals double the long double functions
 426    simply call the double functions.  On Cygwin the long double functions
 427    are implemented independently from newlib to be able to use optimized
 428    assembler functions despite using the Microsoft x86_64 ABI. */
 429 #if defined (_LDBL_EQ_DBL) || defined (__CYGWIN__)
 430 /* Reentrant ANSI C functions.  */
 431 #ifndef __math_68881
 432 extern long double atanl (long double);
 433 extern long double cosl (long double);
 434 extern long double sinl (long double);
 435 extern long double tanl (long double);
 436 extern long double tanhl (long double);
 437 extern long double frexpl (long double, int *);
 438 extern long double modfl (long double, long double *);
 439 extern long double ceill (long double);
 440 extern long double fabsl (long double);
 441 extern long double floorl (long double);
 442 extern long double log1pl (long double);
 443 extern long double expm1l (long double);
 444 #endif /* ! defined (__math_68881) */
 445 /* Non reentrant ANSI C functions.  */
 446 #ifndef _REENT_ONLY
 447 #ifndef __math_68881
 448 extern long double acosl (long double);
 449 extern long double asinl (long double);
 450 extern long double atan2l (long double, long double);
 451 extern long double coshl (long double);
 452 extern long double sinhl (long double);
 453 extern long double expl (long double);
 454 extern long double ldexpl (long double, int);
 455 extern long double logl (long double);
 456 extern long double log10l (long double);
 457 extern long double powl (long double, long double);
 458 extern long double sqrtl (long double);
 459 extern long double fmodl (long double, long double);
 460 extern long double hypotl (long double, long double);
 461 #endif /* ! defined (__math_68881) */
 462 #endif /* ! defined (_REENT_ONLY) */
 463 extern long double copysignl (long double, long double);
 464 extern long double nanl (const char *);
 465 extern int ilogbl (long double);
 466 extern long double asinhl (long double);
 467 extern long double cbrtl (long double);
 468 extern long double nextafterl (long double, long double);
 469 extern float nexttowardf (float, long double);
 470 extern double nexttoward (double, long double);
 471 extern long double nexttowardl (long double, long double);
 472 extern long double logbl (long double);
 473 extern long double log2l (long double);
 474 extern long double rintl (long double);
 475 extern long double scalbnl (long double, int);
 476 extern long double exp2l (long double);
 477 extern long double scalblnl (long double, long);
 478 extern long double tgammal (long double);
 479 extern long double nearbyintl (long double);
 480 extern long int lrintl (long double);
 481 extern long long int llrintl (long double);
 482 extern long double roundl (long double);
 483 extern long lroundl (long double);
 484 extern long long int llroundl (long double);
 485 extern long double truncl (long double);
 486 extern long double remquol (long double, long double, int *);
 487 extern long double fdiml (long double, long double);
 488 extern long double fmaxl (long double, long double);
 489 extern long double fminl (long double, long double);
 490 extern long double fmal (long double, long double, long double);
 491 #ifndef _REENT_ONLY
 492 extern long double acoshl (long double);
 493 extern long double atanhl (long double);
 494 extern long double remainderl (long double, long double);
 495 extern long double lgammal (long double);
 496 extern long double erfl (long double);
 497 extern long double erfcl (long double);
 498 #endif /* ! defined (_REENT_ONLY) */
 499 #else /* !_LDBL_EQ_DBL && !__CYGWIN__ */
 500 extern long double hypotl (long double, long double);
 501 extern long double sqrtl (long double);
 502 #ifdef __i386__
 503 /* Other long double precision functions.  */
 504 extern _LONG_DOUBLE rintl (_LONG_DOUBLE);
 505 extern long int lrintl (_LONG_DOUBLE);
 506 extern long long int llrintl (_LONG_DOUBLE);
 507 #endif /* __i386__ */
 508 #endif /* !_LDBL_EQ_DBL && !__CYGWIN__ */
 509
 510 #endif /* __ISO_C_VISIBLE >= 1999 */
 511
 512 #if __MISC_VISIBLE
 513 extern double drem (double, double);
 514 extern float dremf (float, float);
 515 #ifdef __CYGWIN__
 516 extern float dreml (long double, long double);
 517 #endif /* __CYGWIN__ */
 518 extern double gamma_r (double, int *);
 519 extern double lgamma_r (double, int *);
 520 extern float gammaf_r (float, int *);
 521 extern float lgammaf_r (float, int *);
 522 #endif
 523
 524 #if __MISC_VISIBLE || __XSI_VISIBLE
 525 extern double y0 (double);
 526 extern double y1 (double);
 527 extern double yn (int, double);
 528 extern double j0 (double);
 529 extern double j1 (double);
 530 extern double jn (int, double);
 531 #endif
 532
 533 #if __MISC_VISIBLE || __XSI_VISIBLE >= 600
 534 extern float y0f (float);
 535 extern float y1f (float);
 536 extern float ynf (int, float);
 537 extern float j0f (float);
 538 extern float j1f (float);
 539 extern float jnf (int, float);
 540 #endif
 541
 542 /* GNU extensions */
 543 #if __GNU_VISIBLE
 544 extern void sincos (double, double *, double *);
 545 extern void sincosf (float, float *, float *);
 546 #ifdef __CYGWIN__
 547 extern void sincosl (long double, long double *, long double *);
 548 #endif /* __CYGWIN__ */
 549 # ifndef exp10
 550 extern double exp10 (double);
 551 # endif
 552 # ifndef pow10
 553 extern double pow10 (double);
 554 # endif
 555 # ifndef exp10f
 556 extern float exp10f (float);
 557 # endif
 558 # ifndef pow10f
 559 extern float pow10f (float);
 560 # endif
 561 #ifdef __CYGWIN__
 562 # ifndef exp10l
 563 extern float exp10l (float);
 564 # endif
 565 # ifndef pow10l
 566 extern float pow10l (float);
 567 # endif
 568 #endif /* __CYGWIN__ */
 569 #endif /* __GNU_VISIBLE */
 570
 571 #if __MISC_VISIBLE || __XSI_VISIBLE
 572 /* The gamma functions use a global variable, signgam.  */
 573 #ifndef _REENT_ONLY
 574 #define signgam (*__signgam())
 575 extern int *__signgam (void);
 576 #endif /* ! defined (_REENT_ONLY) */
 577
 578 #define __signgam_r(ptr) _REENT_SIGNGAM(ptr)
 579 #endif /* __MISC_VISIBLE || __XSI_VISIBLE */
 580
 581 /* Useful constants.  */
 582
 583 #if __BSD_VISIBLE || __XSI_VISIBLE
 584
 585 #define MAXFLOAT        3.40282347e+38F
 586
 587 #define M_E             2.7182818284590452354
 588 #define M_LOG2E         1.4426950408889634074
 589 #define M_LOG10E        0.43429448190325182765
 590 #define M_LN2           _M_LN2
 591 #define M_LN10          2.30258509299404568402
 592 #define M_PI            3.14159265358979323846
 593 #define M_PI_2          1.57079632679489661923
 594 #define M_PI_4          0.78539816339744830962
 595 #define M_1_PI          0.31830988618379067154
 596 #define M_2_PI          0.63661977236758134308
 597 #define M_2_SQRTPI      1.12837916709551257390
 598 #define M_SQRT2         1.41421356237309504880
 599 #define M_SQRT1_2       0.70710678118654752440
 600
 601 #endif
 602
 603 #if __BSD_VISIBLE
 604
 605 #define M_TWOPI         (M_PI * 2.0)
 606 #define M_3PI_4         2.3561944901923448370E0
 607 #define M_SQRTPI        1.77245385090551602792981
 608 #define M_LN2LO         1.9082149292705877000E-10
 609 #define M_LN2HI         6.9314718036912381649E-1
 610 #define M_SQRT3 1.73205080756887719000
 611 #define M_IVLN10        0.43429448190325182765 /* 1 / log(10) */
 612 #define M_LOG2_E        _M_LN2
 613 #define M_INVLN2        1.4426950408889633870E0  /* 1 / log(2) */
 614
 615 #endif /* __BSD_VISIBLE */
 616
 617 _END_STD_C
 618
 619 #ifdef __FAST_MATH__
 620 #include <machine/fastmath.h>
 621 #endif
 622
 623 #endif /* _MATH_H_ */