math/math.h

   1 /* Declarations for math functions.
   2    Copyright (C) 1991-1993,1995-1999,2001,2002 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, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 /*
  21  *      ISO C99 Standard: 7.12 Mathematics      <math.h>
  22  */
  23
  24 #ifndef _MATH_H
  25 #define _MATH_H 1
  26
  27 #include <features.h>
  28
  29 __BEGIN_DECLS
  30
  31 /* Get machine-dependent HUGE_VAL value (returned on overflow).
  32    On all IEEE754 machines, this is +Infinity.  */
  33 #include <bits/huge_val.h>
  34
  35 /* Get machine-dependent NAN value (returned for some domain errors).  */
  36 #ifdef   __USE_ISOC99
  37 # include <bits/nan.h>
  38 #endif
  39 /* Get general and ISO C99 specific information.  */
  40 #include <bits/mathdef.h>
  41
  42
  43 /* The file <bits/mathcalls.h> contains the prototypes for all the
  44    actual math functions.  These macros are used for those prototypes,
  45    so we can easily declare each function as both `name' and `__name',
  46    and can declare the float versions `namef' and `__namef'.  */
  47
  48 #define __MATHCALL(function,suffix, args)       \
  49   __MATHDECL (_Mdouble_,function,suffix, args)
  50 #define __MATHDECL(type, function,suffix, args) \
  51   __MATHDECL_1(type, function,suffix, args); \
  52   __MATHDECL_1(type, __CONCAT(__,function),suffix, args)
  53 #define __MATHCALLX(function,suffix, args, attrib)      \
  54   __MATHDECLX (_Mdouble_,function,suffix, args, attrib)
  55 #define __MATHDECLX(type, function,suffix, args, attrib) \
  56   __MATHDECL_1(type, function,suffix, args) __attribute__ (attrib); \
  57   __MATHDECL_1(type, __CONCAT(__,function),suffix, args) __attribute__ (attrib)
  58 #define __MATHDECL_1(type, function,suffix, args) \
  59   extern type __MATH_PRECNAME(function,suffix) args __THROW
  60
  61 #define _Mdouble_               double
  62 #define __MATH_PRECNAME(name,r) __CONCAT(name,r)
  63 # define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_STD
  64 # define _Mdouble_END_NAMESPACE   __END_NAMESPACE_STD
  65 #include <bits/mathcalls.h>
  66 #undef  _Mdouble_
  67 #undef _Mdouble_BEGIN_NAMESPACE
  68 #undef _Mdouble_END_NAMESPACE
  69 #undef  __MATH_PRECNAME
  70
  71 #if defined __USE_MISC || defined __USE_ISOC99
  72
  73
  74 /* Include the file of declarations again, this time using `float'
  75    instead of `double' and appending f to each function name.  */
  76
  77 # ifndef _Mfloat_
  78 #  define _Mfloat_              float
  79 # endif
  80 # define _Mdouble_              _Mfloat_
  81 # ifdef __STDC__
  82 #  define __MATH_PRECNAME(name,r) name##f##r
  83 # else
  84 #  define __MATH_PRECNAME(name,r) name/**/f/**/r
  85 # endif
  86 # define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99
  87 # define _Mdouble_END_NAMESPACE   __END_NAMESPACE_C99
  88 # include <bits/mathcalls.h>
  89 # undef _Mdouble_
  90 # undef _Mdouble_BEGIN_NAMESPACE
  91 # undef _Mdouble_END_NAMESPACE
  92 # undef __MATH_PRECNAME
  93
  94 # if (__STDC__ - 0 || __GNUC__ - 0) && !defined __NO_LONG_DOUBLE_MATH
  95 /* Include the file of declarations again, this time using `long double'
  96    instead of `double' and appending l to each function name.  */
  97
  98 #  ifndef _Mlong_double_
  99 #   define _Mlong_double_       long double
 100 #  endif
 101 #  define _Mdouble_             _Mlong_double_
 102 #  ifdef __STDC__
 103 #   define __MATH_PRECNAME(name,r) name##l##r
 104 #  else
 105 #   define __MATH_PRECNAME(name,r) name/**/l/**/r
 106 #  endif
 107 #  define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99
 108 #  define _Mdouble_END_NAMESPACE   __END_NAMESPACE_C99
 109 #  include <bits/mathcalls.h>
 110 #  undef _Mdouble_
 111 # undef _Mdouble_BEGIN_NAMESPACE
 112 # undef _Mdouble_END_NAMESPACE
 113 #  undef __MATH_PRECNAME
 114
 115 # endif /* __STDC__ || __GNUC__ */
 116
 117 #endif  /* Use misc or ISO C99.  */
 118 #undef  __MATHDECL_1
 119 #undef  __MATHDECL
 120 #undef  __MATHCALL
 121
 122
 123 #if defined __USE_MISC || defined __USE_XOPEN
 124 /* This variable is used by `gamma' and `lgamma'.  */
 125 extern int signgam;
 126 #endif
 127
 128
 129 /* ISO C99 defines some generic macros which work on any data type.  */
 130 #if __USE_ISOC99
 131
 132 /* Get the architecture specific values describing the floating-point
 133    evaluation.  The following symbols will get defined:
 134
 135     float_t     floating-point type at least as wide as `float' used
 136                 to evaluate `float' expressions
 137     double_t    floating-point type at least as wide as `double' used
 138                 to evaluate `double' expressions
 139
 140     FLT_EVAL_METHOD
 141                 Defined to
 142                   0     if `float_t' is `float' and `double_t' is `double'
 143                   1     if `float_t' and `double_t' are `double'
 144                   2     if `float_t' and `double_t' are `long double'
 145                   else  `float_t' and `double_t' are unspecified
 146
 147     INFINITY    representation of the infinity value of type `float'
 148
 149     FP_FAST_FMA
 150     FP_FAST_FMAF
 151     FP_FAST_FMAL
 152                 If defined it indicates that the `fma' function
 153                 generally executes about as fast as a multiply and an add.
 154                 This macro is defined only iff the `fma' function is
 155                 implemented directly with a hardware multiply-add instructions.
 156
 157     FP_ILOGB0   Expands to a value returned by `ilogb (0.0)'.
 158     FP_ILOGBNAN Expands to a value returned by `ilogb (NAN)'.
 159
 160     DECIMAL_DIG Number of decimal digits supported by conversion between
 161                 decimal and all internal floating-point formats.
 162
 163 */
 164
 165 /* All floating-point numbers can be put in one of these categories.  */
 166 enum
 167   {
 168     FP_NAN,
 169 # define FP_NAN FP_NAN
 170     FP_INFINITE,
 171 # define FP_INFINITE FP_INFINITE
 172     FP_ZERO,
 173 # define FP_ZERO FP_ZERO
 174     FP_SUBNORMAL,
 175 # define FP_SUBNORMAL FP_SUBNORMAL
 176     FP_NORMAL
 177 # define FP_NORMAL FP_NORMAL
 178   };
 179
 180 /* Return number of classification appropriate for X.  */
 181 # ifdef __NO_LONG_DOUBLE_MATH
 182 #  define fpclassify(x) \
 183      (sizeof (x) == sizeof (float) ? __fpclassifyf (x) : __fpclassify (x))
 184 # else
 185 #  define fpclassify(x) \
 186      (sizeof (x) == sizeof (float)                                            \
 187       ? __fpclassifyf (x)                                                     \
 188       : sizeof (x) == sizeof (double)                                         \
 189       ? __fpclassify (x) : __fpclassifyl (x))
 190 # endif
 191
 192 /* Return nonzero value if sign of X is negative.  */
 193 # ifdef __NO_LONG_DOUBLE_MATH
 194 #  define signbit(x) \
 195      (sizeof (x) == sizeof (float) ? __signbitf (x) : __signbit (x))
 196 # else
 197 #  define signbit(x) \
 198      (sizeof (x) == sizeof (float)                                            \
 199       ? __signbitf (x)                                                        \
 200       : sizeof (x) == sizeof (double)                                         \
 201       ? __signbit (x) : __signbitl (x))
 202 # endif
 203
 204 /* Return nonzero value if X is not +-Inf or NaN.  */
 205 # ifdef __NO_LONG_DOUBLE_MATH
 206 #  define isfinite(x) \
 207      (sizeof (x) == sizeof (float) ? __finitef (x) : __finite (x))
 208 # else
 209 #  define isfinite(x) \
 210      (sizeof (x) == sizeof (float)                                            \
 211       ? __finitef (x)                                                         \
 212       : sizeof (x) == sizeof (double)                                         \
 213       ? __finite (x) : __finitel (x))
 214 # endif
 215
 216 /* Return nonzero value if X is neither zero, subnormal, Inf, nor NaN.  */
 217 # define isnormal(x) (fpclassify (x) == FP_NORMAL)
 218
 219 /* Return nonzero value if X is a NaN.  We could use `fpclassify' but
 220    we already have this functions `__isnan' and it is faster.  */
 221 # ifdef __NO_LONG_DOUBLE_MATH
 222 #  define isnan(x) \
 223      (sizeof (x) == sizeof (float) ? __isnanf (x) : __isnan (x))
 224 # else
 225 #  define isnan(x) \
 226      (sizeof (x) == sizeof (float)                                            \
 227       ? __isnanf (x)                                                          \
 228       : sizeof (x) == sizeof (double)                                         \
 229       ? __isnan (x) : __isnanl (x))
 230 # endif
 231
 232 /* Return nonzero value is X is positive or negative infinity.  */
 233 # ifdef __NO_LONG_DOUBLE_MATH
 234 #  define isinf(x) \
 235      (sizeof (x) == sizeof (float) ? __isinff (x) : __isinf (x))
 236 # else
 237 #  define isinf(x) \
 238      (sizeof (x) == sizeof (float)                                            \
 239       ? __isinff (x)                                                          \
 240       : sizeof (x) == sizeof (double)                                         \
 241       ? __isinf (x) : __isinfl (x))
 242 # endif
 243
 244 /* Bitmasks for the math_errhandling macro.  */
 245 # define MATH_ERRNO     1       /* errno set by math functions.  */
 246 # define MATH_ERREXCEPT 2       /* Exceptions raised by math functions.  */
 247
 248 #endif /* Use ISO C99.  */
 249
 250 #ifdef  __USE_MISC
 251 /* Support for various different standard error handling behaviors.  */
 252 typedef enum
 253 {
 254   _IEEE_ = -1,  /* According to IEEE 754/IEEE 854.  */
 255   _SVID_,       /* According to System V, release 4.  */
 256   _XOPEN_,      /* Nowadays also Unix98.  */
 257   _POSIX_,
 258   _ISOC_        /* Actually this is ISO C99.  */
 259 } _LIB_VERSION_TYPE;
 260
 261 /* This variable can be changed at run-time to any of the values above to
 262    affect floating point error handling behavior (it may also be necessary
 263    to change the hardware FPU exception settings).  */
 264 extern _LIB_VERSION_TYPE _LIB_VERSION;
 265 #endif
 266
 267
 268 #ifdef __USE_SVID
 269 /* In SVID error handling, `matherr' is called with this description
 270    of the exceptional condition.
 271
 272    We have a problem when using C++ since `exception' is a reserved
 273    name in C++.  */
 274 # ifdef __cplusplus
 275 struct __exception
 276 # else
 277 struct exception
 278 # endif
 279   {
 280     int type;
 281     char *name;
 282     double arg1;
 283     double arg2;
 284     double retval;
 285   };
 286
 287 # ifdef __cplusplus
 288 extern int matherr (struct __exception *__exc) throw ();
 289 # else
 290 extern int matherr (struct exception *__exc);
 291 # endif
 292
 293 # define X_TLOSS        1.41484755040568800000e+16
 294
 295 /* Types of exceptions in the `type' field.  */
 296 # define DOMAIN         1
 297 # define SING           2
 298 # define OVERFLOW       3
 299 # define UNDERFLOW      4
 300 # define TLOSS          5
 301 # define PLOSS          6
 302
 303 /* SVID mode specifies returning this large value instead of infinity.  */
 304 # define HUGE           3.40282347e+38F
 305
 306 #else   /* !SVID */
 307
 308 # ifdef __USE_XOPEN
 309 /* X/Open wants another strange constant.  */
 310 #  define MAXFLOAT      3.40282347e+38F
 311 # endif
 312
 313 #endif  /* SVID */
 314
 315
 316 /* Some useful constants.  */
 317 #if defined __USE_BSD || defined __USE_XOPEN
 318 # define M_E            2.7182818284590452354   /* e */
 319 # define M_LOG2E        1.4426950408889634074   /* log_2 e */
 320 # define M_LOG10E       0.43429448190325182765  /* log_10 e */
 321 # define M_LN2          0.69314718055994530942  /* log_e 2 */
 322 # define M_LN10         2.30258509299404568402  /* log_e 10 */
 323 # define M_PI           3.14159265358979323846  /* pi */
 324 # define M_PI_2         1.57079632679489661923  /* pi/2 */
 325 # define M_PI_4         0.78539816339744830962  /* pi/4 */
 326 # define M_1_PI         0.31830988618379067154  /* 1/pi */
 327 # define M_2_PI         0.63661977236758134308  /* 2/pi */
 328 # define M_2_SQRTPI     1.12837916709551257390  /* 2/sqrt(pi) */
 329 # define M_SQRT2        1.41421356237309504880  /* sqrt(2) */
 330 # define M_SQRT1_2      0.70710678118654752440  /* 1/sqrt(2) */
 331 #endif
 332
 333 /* The above constants are not adequate for computation using `long double's.
 334    Therefore we provide as an extension constants with similar names as a
 335    GNU extension.  Provide enough digits for the 128-bit IEEE quad.  */
 336 #ifdef __USE_GNU
 337 # define M_El           2.7182818284590452353602874713526625L  /* e */
 338 # define M_LOG2El       1.4426950408889634073599246810018922L  /* log_2 e */
 339 # define M_LOG10El      0.4342944819032518276511289189166051L  /* log_10 e */
 340 # define M_LN2l         0.6931471805599453094172321214581766L  /* log_e 2 */
 341 # define M_LN10l        2.3025850929940456840179914546843642L  /* log_e 10 */
 342 # define M_PIl          3.1415926535897932384626433832795029L  /* pi */
 343 # define M_PI_2l        1.5707963267948966192313216916397514L  /* pi/2 */
 344 # define M_PI_4l        0.7853981633974483096156608458198757L  /* pi/4 */
 345 # define M_1_PIl        0.3183098861837906715377675267450287L  /* 1/pi */
 346 # define M_2_PIl        0.6366197723675813430755350534900574L  /* 2/pi */
 347 # define M_2_SQRTPIl    1.1283791670955125738961589031215452L  /* 2/sqrt(pi) */
 348 # define M_SQRT2l       1.4142135623730950488016887242096981L  /* sqrt(2) */
 349 # define M_SQRT1_2l     0.7071067811865475244008443621048490L  /* 1/sqrt(2) */
 350 #endif
 351
 352
 353 /* When compiling in strict ISO C compatible mode we must not use the
 354    inline functions since they, among other things, do not set the
 355    `errno' variable correctly.  */
 356 #if defined __STRICT_ANSI__ && !defined __NO_MATH_INLINES
 357 # define __NO_MATH_INLINES      1
 358 #endif
 359
 360 /* Get machine-dependent inline versions (if there are any).  */
 361 #ifdef __USE_EXTERN_INLINES
 362 # include <bits/mathinline.h>
 363 #endif
 364
 365
 366 #if __USE_ISOC99
 367 /* ISO C99 defines some macros to compare number while taking care
 368    for unordered numbers.  Since many FPUs provide special
 369    instructions to support these operations and these tests are
 370    defined in <bits/mathinline.h>, we define the generic macros at
 371    this late point and only if they are not defined yet.  */
 372
 373 /* Return nonzero value if X is greater than Y.  */
 374 # ifndef isgreater
 375 #  define isgreater(x, y) \
 376   (__extension__                                                              \
 377    ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);                       \
 378       !isunordered (__x, __y) && __x > __y; }))
 379 # endif
 380
 381 /* Return nonzero value if X is greater than or equal to Y.  */
 382 # ifndef isgreaterequal
 383 #  define isgreaterequal(x, y) \
 384   (__extension__                                                              \
 385    ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);                       \
 386       !isunordered (__x, __y) && __x >= __y; }))
 387 # endif
 388
 389 /* Return nonzero value if X is less than Y.  */
 390 # ifndef isless
 391 #  define isless(x, y) \
 392   (__extension__                                                              \
 393    ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);                       \
 394       !isunordered (__x, __y) && __x < __y; }))
 395 # endif
 396
 397 /* Return nonzero value if X is less than or equal to Y.  */
 398 # ifndef islessequal
 399 #  define islessequal(x, y) \
 400   (__extension__                                                              \
 401    ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);                       \
 402       !isunordered (__x, __y) && __x <= __y; }))
 403 # endif
 404
 405 /* Return nonzero value if either X is less than Y or Y is less than X.  */
 406 # ifndef islessgreater
 407 #  define islessgreater(x, y) \
 408   (__extension__                                                              \
 409    ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);                       \
 410       !isunordered (__x, __y) && (__x < __y || __y < __x); }))
 411 # endif
 412
 413 /* Return nonzero value if arguments are unordered.  */
 414 # ifndef isunordered
 415 #  define isunordered(u, v) \
 416   (__extension__                                                              \
 417    ({ __typeof__(u) __u = (u); __typeof__(v) __v = (v);                       \
 418       fpclassify (__u) == FP_NAN || fpclassify (__v) == FP_NAN; }))
 419 # endif
 420
 421 #endif
 422
 423 __END_DECLS
 424
 425
 426 #endif /* math.h  */