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