math/math.h

   1 /* Declarations for math functions.
   2    Copyright (C) 1991-2016 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 /*
  20  *      ISO C99 Standard: 7.12 Mathematics      <math.h>
  21  */
  22
  23 #ifndef _MATH_H
  24 #define _MATH_H 1
  25
  26 #define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION
  27 #include <bits/libc-header-start.h>
  28
  29 __BEGIN_DECLS
  30
  31 /* Get machine-dependent vector math functions declarations.  */
  32 #include <bits/math-vector.h>
  33
  34 /* Get machine-dependent HUGE_VAL value (returned on overflow).
  35    On all IEEE754 machines, this is +Infinity.  */
  36 #include <bits/huge_val.h>
  37 #ifdef __USE_ISOC99
  38 # include <bits/huge_valf.h>
  39 # include <bits/huge_vall.h>
  40
  41 /* Get machine-dependent INFINITY value.  */
  42 # include <bits/inf.h>
  43
  44 /* Get machine-dependent NAN value (returned for some domain errors).  */
  45 # include <bits/nan.h>
  46 #endif /* __USE_ISOC99 */
  47
  48 #if __GLIBC_USE (IEC_60559_BFP_EXT)
  49 /* Signaling NaN macros, if supported.  */
  50 # if __GNUC_PREREQ (3, 3)
  51 #  define SNANF (__builtin_nansf (""))
  52 #  define SNAN (__builtin_nans (""))
  53 #  define SNANL (__builtin_nansl (""))
  54 # endif
  55 #endif
  56
  57 /* Get __GLIBC_FLT_EVAL_METHOD.  */
  58 #include <bits/flt-eval-method.h>
  59
  60 #ifdef __USE_ISOC99
  61 /* Define the following typedefs.
  62
  63     float_t     floating-point type at least as wide as `float' used
  64                 to evaluate `float' expressions
  65     double_t    floating-point type at least as wide as `double' used
  66                 to evaluate `double' expressions
  67 */
  68 # if __GLIBC_FLT_EVAL_METHOD == 0 || __GLIBC_FLT_EVAL_METHOD == 16
  69 typedef float float_t;
  70 typedef double double_t;
  71 # elif __GLIBC_FLT_EVAL_METHOD == 1
  72 typedef double float_t;
  73 typedef double double_t;
  74 # elif __GLIBC_FLT_EVAL_METHOD == 2
  75 typedef long double float_t;
  76 typedef long double double_t;
  77 # elif __GLIBC_FLT_EVAL_METHOD == 32
  78 typedef _Float32 float_t;
  79 typedef double double_t;
  80 # elif __GLIBC_FLT_EVAL_METHOD == 33
  81 typedef _Float32x float_t;
  82 typedef _Float32x double_t;
  83 # elif __GLIBC_FLT_EVAL_METHOD == 64
  84 typedef _Float64 float_t;
  85 typedef _Float64 double_t;
  86 # elif __GLIBC_FLT_EVAL_METHOD == 65
  87 typedef _Float64x float_t;
  88 typedef _Float64x double_t;
  89 # elif __GLIBC_FLT_EVAL_METHOD == 128
  90 typedef _Float128 float_t;
  91 typedef _Float128 double_t;
  92 # elif __GLIBC_FLT_EVAL_METHOD == 129
  93 typedef _Float128x float_t;
  94 typedef _Float128x double_t;
  95 # else
  96 #  error "Unknown __GLIBC_FLT_EVAL_METHOD"
  97 # endif
  98 #endif
  99
 100 /* Define macros for the return values of ilogb and llogb, based on
 101    __FP_LOGB0_IS_MIN and __FP_LOGBNAN_IS_MIN.
 102
 103     FP_ILOGB0   Expands to a value returned by `ilogb (0.0)'.
 104     FP_ILOGBNAN Expands to a value returned by `ilogb (NAN)'.
 105     FP_LLOGB0   Expands to a value returned by `llogb (0.0)'.
 106     FP_LLOGBNAN Expands to a value returned by `llogb (NAN)'.
 107
 108 */
 109
 110 #include <bits/fp-logb.h>
 111 #ifdef __USE_ISOC99
 112 # if __FP_LOGB0_IS_MIN
 113 #  define FP_ILOGB0     (-2147483647 - 1)
 114 # else
 115 #  define FP_ILOGB0     (-2147483647)
 116 # endif
 117 # if __FP_LOGBNAN_IS_MIN
 118 #  define FP_ILOGBNAN   (-2147483647 - 1)
 119 # else
 120 #  define FP_ILOGBNAN   2147483647
 121 # endif
 122 #endif
 123 #if __GLIBC_USE (IEC_60559_BFP_EXT)
 124 # if __WORDSIZE == 32
 125 #  define __FP_LONG_MAX 0x7fffffffL
 126 # else
 127 #  define __FP_LONG_MAX 0x7fffffffffffffffL
 128 # endif
 129 # if __FP_LOGB0_IS_MIN
 130 #  define FP_LLOGB0     (-__FP_LONG_MAX - 1)
 131 # else
 132 #  define FP_LLOGB0     (-__FP_LONG_MAX)
 133 # endif
 134 # if __FP_LOGBNAN_IS_MIN
 135 #  define FP_LLOGBNAN   (-__FP_LONG_MAX - 1)
 136 # else
 137 #  define FP_LLOGBNAN   __FP_LONG_MAX
 138 # endif
 139 #endif
 140
 141 /* Get information about long double.  */
 142
 143 #include <bits/mathdef.h>
 144
 145 /* Get the architecture specific values describing the floating-point
 146    evaluation.  The following symbols will get defined:
 147
 148     FP_FAST_FMA
 149     FP_FAST_FMAF
 150     FP_FAST_FMAL
 151                 If defined it indicates that the `fma' function
 152                 generally executes about as fast as a multiply and an add.
 153                 This macro is defined only iff the `fma' function is
 154                 implemented directly with a hardware multiply-add instructions.
 155 */
 156
 157 #include <bits/fp-fast.h>
 158
 159 /* The file <bits/mathcalls.h> contains the prototypes for all the
 160    actual math functions.  These macros are used for those prototypes,
 161    so we can easily declare each function as both `name' and `__name',
 162    and can declare the float versions `namef' and `__namef'.  */
 163
 164 #define __SIMD_DECL(function) __CONCAT (__DECL_SIMD_, function)
 165
 166 #define __MATHCALL_VEC(function, suffix, args)  \
 167   __SIMD_DECL (__MATH_PRECNAME (function, suffix)) \
 168   __MATHCALL (function, suffix, args)
 169
 170 #define __MATHDECL_VEC(type, function,suffix, args) \
 171   __SIMD_DECL (__MATH_PRECNAME (function, suffix)) \
 172   __MATHDECL(type, function,suffix, args)
 173
 174 #define __MATHCALL(function,suffix, args)       \
 175   __MATHDECL (_Mdouble_,function,suffix, args)
 176 #define __MATHDECL(type, function,suffix, args) \
 177   __MATHDECL_1(type, function,suffix, args); \
 178   __MATHDECL_1(type, __CONCAT(__,function),suffix, args)
 179 #define __MATHCALLX(function,suffix, args, attrib)      \
 180   __MATHDECLX (_Mdouble_,function,suffix, args, attrib)
 181 #define __MATHDECLX(type, function,suffix, args, attrib) \
 182   __MATHDECL_1(type, function,suffix, args) __attribute__ (attrib); \
 183   __MATHDECL_1(type, __CONCAT(__,function),suffix, args) __attribute__ (attrib)
 184 #define __MATHDECL_1(type, function,suffix, args) \
 185   extern type __MATH_PRECNAME(function,suffix) args __THROW
 186
 187 #define _Mdouble_               double
 188 #define __MATH_PRECNAME(name,r) __CONCAT(name,r)
 189 #define __MATH_DECLARING_DOUBLE  1
 190 #define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_STD
 191 #define _Mdouble_END_NAMESPACE   __END_NAMESPACE_STD
 192 #include <bits/mathcalls.h>
 193 #undef  _Mdouble_
 194 #undef _Mdouble_BEGIN_NAMESPACE
 195 #undef _Mdouble_END_NAMESPACE
 196 #undef  __MATH_PRECNAME
 197 #undef __MATH_DECLARING_DOUBLE
 198
 199 #ifdef __USE_ISOC99
 200
 201
 202 /* Include the file of declarations again, this time using `float'
 203    instead of `double' and appending f to each function name.  */
 204
 205 # ifndef _Mfloat_
 206 #  define _Mfloat_              float
 207 # endif
 208 # define _Mdouble_              _Mfloat_
 209 # define __MATH_PRECNAME(name,r) name##f##r
 210 # define __MATH_DECLARING_DOUBLE  0
 211 # define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99
 212 # define _Mdouble_END_NAMESPACE   __END_NAMESPACE_C99
 213 # include <bits/mathcalls.h>
 214 # undef _Mdouble_
 215 # undef _Mdouble_BEGIN_NAMESPACE
 216 # undef _Mdouble_END_NAMESPACE
 217 # undef __MATH_PRECNAME
 218 # undef __MATH_DECLARING_DOUBLE
 219
 220 # if !(defined __NO_LONG_DOUBLE_MATH && defined _LIBC) \
 221      || defined __LDBL_COMPAT \
 222      || defined _LIBC_TEST
 223 #  ifdef __LDBL_COMPAT
 224
 225 #   ifdef __USE_ISOC99
 226 extern float __nldbl_nexttowardf (float __x, long double __y)
 227                                   __THROW __attribute__ ((__const__));
 228 #    ifdef __REDIRECT_NTH
 229 extern float __REDIRECT_NTH (nexttowardf, (float __x, long double __y),
 230                              __nldbl_nexttowardf)
 231      __attribute__ ((__const__));
 232 extern double __REDIRECT_NTH (nexttoward, (double __x, long double __y),
 233                               nextafter) __attribute__ ((__const__));
 234 extern long double __REDIRECT_NTH (nexttowardl,
 235                                    (long double __x, long double __y),
 236                                    nextafter) __attribute__ ((__const__));
 237 #    endif
 238 #   endif
 239
 240 #   undef __MATHDECL_1
 241 #   define __MATHDECL_2(type, function,suffix, args, alias) \
 242   extern type __REDIRECT_NTH(__MATH_PRECNAME(function,suffix), \
 243                              args, alias)
 244 #   define __MATHDECL_1(type, function,suffix, args) \
 245   __MATHDECL_2(type, function,suffix, args, __CONCAT(function,suffix))
 246 #  endif
 247
 248 /* Include the file of declarations again, this time using `long double'
 249    instead of `double' and appending l to each function name.  */
 250
 251 #  ifndef _Mlong_double_
 252 #   define _Mlong_double_       long double
 253 #  endif
 254 #  define _Mdouble_             _Mlong_double_
 255 #  define __MATH_PRECNAME(name,r) name##l##r
 256 #  define __MATH_DECLARING_DOUBLE  0
 257 #  define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99
 258 #  define _Mdouble_END_NAMESPACE   __END_NAMESPACE_C99
 259 #  define __MATH_DECLARE_LDOUBLE   1
 260 #  include <bits/mathcalls.h>
 261 #  undef _Mdouble_
 262 #  undef _Mdouble_BEGIN_NAMESPACE
 263 #  undef _Mdouble_END_NAMESPACE
 264 #  undef __MATH_PRECNAME
 265 #  undef __MATH_DECLARING_DOUBLE
 266
 267 # endif /* !(__NO_LONG_DOUBLE_MATH && _LIBC) || __LDBL_COMPAT */
 268
 269 #endif  /* Use ISO C99.  */
 270 #undef  __MATHDECL_1
 271 #undef  __MATHDECL
 272 #undef  __MATHCALL
 273
 274
 275 #if defined __USE_MISC || defined __USE_XOPEN
 276 /* This variable is used by `gamma' and `lgamma'.  */
 277 extern int signgam;
 278 #endif
 279
 280
 281 /* Depending on the type of TG_ARG, call an appropriately suffixed
 282    version of FUNC with arguments (including parentheses) ARGS.
 283    Suffixed functions may not exist for long double if it has the same
 284    format as double, or for other types with the same format as float,
 285    double or long double.  The behavior is undefined if the argument
 286    does not have a real floating type.  The definition may use a
 287    conditional expression, so all suffixed versions of FUNC must
 288    return the same type (FUNC may include a cast if necessary rather
 289    than being a single identifier).  */
 290 #ifdef __NO_LONG_DOUBLE_MATH
 291 # define __MATH_TG(TG_ARG, FUNC, ARGS)                                  \
 292   (sizeof (TG_ARG) == sizeof (float) ? FUNC ## f ARGS : FUNC ARGS)
 293 #else
 294 # define __MATH_TG(TG_ARG, FUNC, ARGS)          \
 295   (sizeof (TG_ARG) == sizeof (float)            \
 296    ? FUNC ## f ARGS                             \
 297    : sizeof (TG_ARG) == sizeof (double)         \
 298    ? FUNC ARGS                                  \
 299    : FUNC ## l ARGS)
 300 #endif
 301
 302 /* ISO C99 defines some generic macros which work on any data type.  */
 303 #ifdef __USE_ISOC99
 304
 305 /* All floating-point numbers can be put in one of these categories.  */
 306 enum
 307   {
 308     FP_NAN =
 309 # define FP_NAN 0
 310       FP_NAN,
 311     FP_INFINITE =
 312 # define FP_INFINITE 1
 313       FP_INFINITE,
 314     FP_ZERO =
 315 # define FP_ZERO 2
 316       FP_ZERO,
 317     FP_SUBNORMAL =
 318 # define FP_SUBNORMAL 3
 319       FP_SUBNORMAL,
 320     FP_NORMAL =
 321 # define FP_NORMAL 4
 322       FP_NORMAL
 323   };
 324
 325 /* GCC bug 66462 means we cannot use the math builtins with -fsignaling-nan,
 326    so disable builtins if this is enabled.  When fixed in a newer GCC,
 327    the __SUPPORT_SNAN__ check may be skipped for those versions.  */
 328
 329 /* Return number of classification appropriate for X.  */
 330 # if __GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__                         \
 331      && !defined __OPTIMIZE_SIZE__
 332 #  define fpclassify(x) __builtin_fpclassify (FP_NAN, FP_INFINITE,            \
 333      FP_NORMAL, FP_SUBNORMAL, FP_ZERO, x)
 334 # else
 335 #  define fpclassify(x) __MATH_TG ((x), __fpclassify, (x))
 336 # endif
 337
 338 /* Return nonzero value if sign of X is negative.  */
 339 # if __GNUC_PREREQ (4,0)
 340 #  define signbit(x) __MATH_TG ((x), __builtin_signbit, (x))
 341 # else
 342 #  define signbit(x) __MATH_TG ((x), __signbit, (x))
 343 # endif
 344
 345 /* Return nonzero value if X is not +-Inf or NaN.  */
 346 # if __GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__
 347 #  define isfinite(x) __builtin_isfinite (x)
 348 # else
 349 #  define isfinite(x) __MATH_TG ((x), __finite, (x))
 350 # endif
 351
 352 /* Return nonzero value if X is neither zero, subnormal, Inf, nor NaN.  */
 353 # if __GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__
 354 #  define isnormal(x) __builtin_isnormal (x)
 355 # else
 356 #  define isnormal(x) (fpclassify (x) == FP_NORMAL)
 357 # endif
 358
 359 /* Return nonzero value if X is a NaN.  We could use `fpclassify' but
 360    we already have this functions `__isnan' and it is faster.  */
 361 # if __GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__
 362 #  define isnan(x) __builtin_isnan (x)
 363 # else
 364 #  define isnan(x) __MATH_TG ((x), __isnan, (x))
 365 # endif
 366
 367 /* Return nonzero value if X is positive or negative infinity.  */
 368 # if __GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__
 369 #  define isinf(x) __builtin_isinf_sign (x)
 370 # else
 371 #  define isinf(x) __MATH_TG ((x), __isinf, (x))
 372 # endif
 373
 374 /* Bitmasks for the math_errhandling macro.  */
 375 # define MATH_ERRNO     1       /* errno set by math functions.  */
 376 # define MATH_ERREXCEPT 2       /* Exceptions raised by math functions.  */
 377
 378 /* By default all functions support both errno and exception handling.
 379    In gcc's fast math mode and if inline functions are defined this
 380    might not be true.  */
 381 # ifndef __FAST_MATH__
 382 #  define math_errhandling      (MATH_ERRNO | MATH_ERREXCEPT)
 383 # endif
 384
 385 #endif /* Use ISO C99.  */
 386
 387 #if __GLIBC_USE (IEC_60559_BFP_EXT)
 388 # include <bits/iscanonical.h>
 389
 390 /* Return nonzero value if X is a signaling NaN.  */
 391 # define issignaling(x) __MATH_TG ((x), __issignaling, (x))
 392
 393 /* Return nonzero value if X is subnormal.  */
 394 # define issubnormal(x) (fpclassify (x) == FP_SUBNORMAL)
 395
 396 /* Return nonzero value if X is zero.  */
 397 # ifndef __cplusplus
 398 #  ifdef __SUPPORT_SNAN__
 399 #   define iszero(x) (fpclassify (x) == FP_ZERO)
 400 #  else
 401 #   define iszero(x) (((__typeof (x)) (x)) == 0)
 402 #  endif
 403 # else  /* __cplusplus */
 404 extern "C++" {
 405 template <class __T> inline bool
 406 iszero (__T __val)
 407 {
 408 #  ifdef __SUPPORT_SNAN__
 409   return fpclassify (__val) == FP_ZERO;
 410 #  else
 411   return __val == 0;
 412 #  endif
 413 }
 414 } /* extern C++ */
 415 # endif /* __cplusplus */
 416 #endif /* Use IEC_60559_BFP_EXT.  */
 417
 418 #ifdef  __USE_MISC
 419 /* Support for various different standard error handling behaviors.  */
 420 typedef enum
 421 {
 422   _IEEE_ = -1,  /* According to IEEE 754/IEEE 854.  */
 423   _SVID_,       /* According to System V, release 4.  */
 424   _XOPEN_,      /* Nowadays also Unix98.  */
 425   _POSIX_,
 426   _ISOC_        /* Actually this is ISO C99.  */
 427 } _LIB_VERSION_TYPE;
 428
 429 /* This variable can be changed at run-time to any of the values above to
 430    affect floating point error handling behavior (it may also be necessary
 431    to change the hardware FPU exception settings).  */
 432 extern _LIB_VERSION_TYPE _LIB_VERSION;
 433 #endif
 434
 435
 436 #ifdef __USE_MISC
 437 /* In SVID error handling, `matherr' is called with this description
 438    of the exceptional condition.
 439
 440    We have a problem when using C++ since `exception' is a reserved
 441    name in C++.  */
 442 # ifdef __cplusplus
 443 struct __exception
 444 # else
 445 struct exception
 446 # endif
 447   {
 448     int type;
 449     char *name;
 450     double arg1;
 451     double arg2;
 452     double retval;
 453   };
 454
 455 # ifdef __cplusplus
 456 extern int matherr (struct __exception *__exc) throw ();
 457 # else
 458 extern int matherr (struct exception *__exc);
 459 # endif
 460
 461 # define X_TLOSS        1.41484755040568800000e+16
 462
 463 /* Types of exceptions in the `type' field.  */
 464 # define DOMAIN         1
 465 # define SING           2
 466 # define OVERFLOW       3
 467 # define UNDERFLOW      4
 468 # define TLOSS          5
 469 # define PLOSS          6
 470
 471 /* SVID mode specifies returning this large value instead of infinity.  */
 472 # define HUGE           3.40282347e+38F
 473
 474 #else   /* !Misc.  */
 475
 476 # ifdef __USE_XOPEN
 477 /* X/Open wants another strange constant.  */
 478 #  define MAXFLOAT      3.40282347e+38F
 479 # endif
 480
 481 #endif  /* Misc.  */
 482
 483
 484 /* Some useful constants.  */
 485 #if defined __USE_MISC || defined __USE_XOPEN
 486 # define M_E            2.7182818284590452354   /* e */
 487 # define M_LOG2E        1.4426950408889634074   /* log_2 e */
 488 # define M_LOG10E       0.43429448190325182765  /* log_10 e */
 489 # define M_LN2          0.69314718055994530942  /* log_e 2 */
 490 # define M_LN10         2.30258509299404568402  /* log_e 10 */
 491 # define M_PI           3.14159265358979323846  /* pi */
 492 # define M_PI_2         1.57079632679489661923  /* pi/2 */
 493 # define M_PI_4         0.78539816339744830962  /* pi/4 */
 494 # define M_1_PI         0.31830988618379067154  /* 1/pi */
 495 # define M_2_PI         0.63661977236758134308  /* 2/pi */
 496 # define M_2_SQRTPI     1.12837916709551257390  /* 2/sqrt(pi) */
 497 # define M_SQRT2        1.41421356237309504880  /* sqrt(2) */
 498 # define M_SQRT1_2      0.70710678118654752440  /* 1/sqrt(2) */
 499 #endif
 500
 501 /* The above constants are not adequate for computation using `long double's.
 502    Therefore we provide as an extension constants with similar names as a
 503    GNU extension.  Provide enough digits for the 128-bit IEEE quad.  */
 504 #ifdef __USE_GNU
 505 # define M_El           2.718281828459045235360287471352662498L /* e */
 506 # define M_LOG2El       1.442695040888963407359924681001892137L /* log_2 e */
 507 # define M_LOG10El      0.434294481903251827651128918916605082L /* log_10 e */
 508 # define M_LN2l         0.693147180559945309417232121458176568L /* log_e 2 */
 509 # define M_LN10l        2.302585092994045684017991454684364208L /* log_e 10 */
 510 # define M_PIl          3.141592653589793238462643383279502884L /* pi */
 511 # define M_PI_2l        1.570796326794896619231321691639751442L /* pi/2 */
 512 # define M_PI_4l        0.785398163397448309615660845819875721L /* pi/4 */
 513 # define M_1_PIl        0.318309886183790671537767526745028724L /* 1/pi */
 514 # define M_2_PIl        0.636619772367581343075535053490057448L /* 2/pi */
 515 # define M_2_SQRTPIl    1.128379167095512573896158903121545172L /* 2/sqrt(pi) */
 516 # define M_SQRT2l       1.414213562373095048801688724209698079L /* sqrt(2) */
 517 # define M_SQRT1_2l     0.707106781186547524400844362104849039L /* 1/sqrt(2) */
 518 #endif
 519
 520
 521 /* When compiling in strict ISO C compatible mode we must not use the
 522    inline functions since they, among other things, do not set the
 523    `errno' variable correctly.  */
 524 #if defined __STRICT_ANSI__ && !defined __NO_MATH_INLINES
 525 # define __NO_MATH_INLINES      1
 526 #endif
 527
 528 #if defined __USE_ISOC99 && __GNUC_PREREQ(2,97)
 529 /* ISO C99 defines some macros to compare number while taking care for
 530    unordered numbers.  Many FPUs provide special instructions to support
 531    these operations.  Generic support in GCC for these as builtins went
 532    in before 3.0.0, but not all cpus added their patterns.  We define
 533    versions that use the builtins here, and <bits/mathinline.h> will
 534    undef/redefine as appropriate for the specific GCC version in use.  */
 535 # define isgreater(x, y)        __builtin_isgreater(x, y)
 536 # define isgreaterequal(x, y)   __builtin_isgreaterequal(x, y)
 537 # define isless(x, y)           __builtin_isless(x, y)
 538 # define islessequal(x, y)      __builtin_islessequal(x, y)
 539 # define islessgreater(x, y)    __builtin_islessgreater(x, y)
 540 # define isunordered(u, v)      __builtin_isunordered(u, v)
 541 #endif
 542
 543 /* Get machine-dependent inline versions (if there are any).  */
 544 #ifdef __USE_EXTERN_INLINES
 545 # include <bits/mathinline.h>
 546 #endif
 547
 548 /* Define special entry points to use when the compiler got told to
 549    only expect finite results.  */
 550 #if defined __FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ > 0
 551 # include <bits/math-finite.h>
 552 #endif
 553
 554 #ifdef __USE_ISOC99
 555 /* If we've still got undefined comparison macros, provide defaults.  */
 556
 557 /* Return nonzero value if X is greater than Y.  */
 558 # ifndef isgreater
 559 #  define isgreater(x, y) \
 560   (__extension__                                                              \
 561    ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);                       \
 562       !isunordered (__x, __y) && __x > __y; }))
 563 # endif
 564
 565 /* Return nonzero value if X is greater than or equal to Y.  */
 566 # ifndef isgreaterequal
 567 #  define isgreaterequal(x, y) \
 568   (__extension__                                                              \
 569    ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);                       \
 570       !isunordered (__x, __y) && __x >= __y; }))
 571 # endif
 572
 573 /* Return nonzero value if X is less than Y.  */
 574 # ifndef isless
 575 #  define isless(x, y) \
 576   (__extension__                                                              \
 577    ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);                       \
 578       !isunordered (__x, __y) && __x < __y; }))
 579 # endif
 580
 581 /* Return nonzero value if X is less than or equal to Y.  */
 582 # ifndef islessequal
 583 #  define islessequal(x, y) \
 584   (__extension__                                                              \
 585    ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);                       \
 586       !isunordered (__x, __y) && __x <= __y; }))
 587 # endif
 588
 589 /* Return nonzero value if either X is less than Y or Y is less than X.  */
 590 # ifndef islessgreater
 591 #  define islessgreater(x, y) \
 592   (__extension__                                                              \
 593    ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);                       \
 594       !isunordered (__x, __y) && (__x < __y || __y < __x); }))
 595 # endif
 596
 597 /* Return nonzero value if arguments are unordered.  */
 598 # ifndef isunordered
 599 #  define isunordered(u, v) \
 600   (__extension__                                                              \
 601    ({ __typeof__(u) __u = (u); __typeof__(v) __v = (v);                       \
 602       fpclassify (__u) == FP_NAN || fpclassify (__v) == FP_NAN; }))
 603 # endif
 604
 605 #endif
 606
 607 #if __GLIBC_USE (IEC_60559_BFP_EXT)
 608 /* An expression whose type has the widest of the evaluation formats
 609    of X and Y (which are of floating-point types).  */
 610 # if __FLT_EVAL_METHOD__ == 2 || __FLT_EVAL_METHOD__ > 64
 611 #  define __MATH_EVAL_FMT2(x, y) ((x) + (y) + 0.0L)
 612 # elif __FLT_EVAL_METHOD__ == 1 || __FLT_EVAL_METHOD__ > 32
 613 #  define __MATH_EVAL_FMT2(x, y) ((x) + (y) + 0.0)
 614 # else
 615 #  define __MATH_EVAL_FMT2(x, y) ((x) + (y))
 616 # endif
 617
 618 /* Return X == Y but raising "invalid" and setting errno if X or Y is
 619    a NaN.  */
 620 # define iseqsig(x, y) \
 621   __MATH_TG (__MATH_EVAL_FMT2 (x, y), __iseqsig, ((x), (y)))
 622 #endif
 623
 624 __END_DECLS
 625
 626
 627 #endif /* math.h  */