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