math/mathcalls.h

   1 /* Prototype declarations for math functions; helper file for <math.h>.
   2    Copyright (C) 1996, 1997 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 Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    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    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, USA.  */
  19
  20 /* NOTE: Because of the special way this file is used by <math.h>, this
  21    file must NOT be protected from multiple inclusion as header files
  22    usually are.
  23
  24    This file provides prototype declarations for the math functions.
  25    Most functions are declared using the macro:
  26
  27    __MATHCALL (NAME,[_r], (ARGS...));
  28
  29    This means there is a function `NAME' returning `double' and a function
  30    `NAMEf' returning `float'.  Each place `_Mdouble_' appears in the
  31    prototype, that is actually `double' in the prototype for `NAME' and
  32    `float' in the prototype for `NAMEf'.  Reentrant variant functions are
  33    called `NAME_r' and `NAMEf_r'.
  34
  35    Functions returning other types like `int' are declared using the macro:
  36
  37    __MATHDECL (TYPE, NAME,[_r], (ARGS...));
  38
  39    This is just like __MATHCALL but for a function returning `TYPE'
  40    instead of `_Mdouble_'.  In all of these cases, there is still
  41    both a `NAME' and a `NAMEf' that takes `float' arguments.  */
  42
  43 #ifndef _MATH_H
  44  #error "Never include mathcalls.h directly; include <math.h> instead."
  45 #endif
  46
  47
  48 /* Trigonometric functions.  */
  49
  50 /* Arc cosine of X.  */
  51 __MATHCALL (acos,, (_Mdouble_ __x));
  52 /* Arc sine of X.  */
  53 __MATHCALL (asin,, (_Mdouble_ __x));
  54 /* Arc tangent of X.  */
  55 __MATHCALL (atan,, (_Mdouble_ __x));
  56 /* Arc tangent of Y/X.  */
  57 __MATHCALL (atan2,, (_Mdouble_ __y, _Mdouble_ __x));
  58
  59 /* Cosine of X.  */
  60 __MATHCALL (cos,, (_Mdouble_ __x));
  61 /* Sine of X.  */
  62 __MATHCALL (sin,, (_Mdouble_ __x));
  63 /* Tangent of X.  */
  64 __MATHCALL (tan,, (_Mdouble_ __x));
  65
  66 #ifdef __USE_GNU
  67 /* Cosine and sine of X.  */
  68 __MATHDECL (void, sincos,,
  69             (_Mdouble_ __x, _Mdouble_ *__sinx, _Mdouble_ *__cosx));
  70 #endif
  71
  72 /* Hyperbolic functions.  */
  73
  74 /* Hyperbolic cosine of X.  */
  75 __MATHCALL (cosh,, (_Mdouble_ __x));
  76 /* Hyperbolic sine of X.  */
  77 __MATHCALL (sinh,, (_Mdouble_ __x));
  78 /* Hyperbolic tangent of X.  */
  79 __MATHCALL (tanh,, (_Mdouble_ __x));
  80
  81 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC9X
  82 /* Hyperbolic arc cosine of X.  */
  83 __MATHCALL (acosh,, (_Mdouble_ __x));
  84 /* Hyperbolic arc sine of X.  */
  85 __MATHCALL (asinh,, (_Mdouble_ __x));
  86 /* Hyperbolic arc tangent of X.  */
  87 __MATHCALL (atanh,, (_Mdouble_ __x));
  88 #endif
  89
  90 /* Exponential and logarithmic functions.  */
  91
  92 /* Exponential function of X.  */
  93 __MATHCALL (exp,, (_Mdouble_ __x));
  94
  95 /* Break VALUE into a normalized fraction and an integral power of 2.  */
  96 __MATHCALL (frexp,, (_Mdouble_ __x, int *__exponent));
  97
  98 /* X times (two to the EXP power).  */
  99 __MATHCALL (ldexp,, (_Mdouble_ __x, int __exponent));
 100
 101 /* Natural logarithm of X.  */
 102 __MATHCALL (log,, (_Mdouble_ __x));
 103
 104 /* Base-ten logarithm of X.  */
 105 __MATHCALL (log10,, (_Mdouble_ __x));
 106
 107 /* Break VALUE into integral and fractional parts.  */
 108 __MATHCALL (modf,, (_Mdouble_ __x, _Mdouble_ *__iptr));
 109
 110 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC9X
 111 /* Return exp(X) - 1.  */
 112 __MATHCALL (expm1,, (_Mdouble_ __x));
 113
 114 /* Return log(1 + X).  */
 115 __MATHCALL (log1p,, (_Mdouble_ __x));
 116
 117 /* Return the base 2 signed integral exponent of X.  */
 118 __MATHCALL (logb,, (_Mdouble_ __x));
 119 #endif
 120
 121 #ifdef __USE_ISOC9X
 122 /* Compute base-2 exponential of X.  */
 123 __MATHCALL (exp2,, (_Mdouble_ __x));
 124
 125 /* Compute base-2 logarithm of X.  */
 126 __MATHCALL (log2,, (_Mdouble_ __x));
 127 #endif
 128
 129
 130 /* Power functions.  */
 131
 132 /* Return X to the Y power.  */
 133 __MATHCALL (pow,, (_Mdouble_ __x, _Mdouble_ __y));
 134
 135 /* Return the square root of X.  */
 136 __MATHCALL (sqrt,, (_Mdouble_ __x));
 137
 138 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC9X
 139 /* Return `sqrt(X*X + Y*Y)'.  */
 140 __MATHCALL (hypot,, (_Mdouble_ __x, _Mdouble_ __y));
 141 #endif
 142
 143 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED
 144 /* Return the cube root of X.  */
 145 __MATHCALL (cbrt,, (_Mdouble_ __x));
 146 #endif
 147
 148
 149 /* Nearest integer, absolute value, and remainder functions.  */
 150
 151 /* Smallest integral value not less than X.  */
 152 __MATHCALL (ceil,, (_Mdouble_ __x));
 153
 154 /* Absolute value of X.  */
 155 __MATHCALLX (fabs,, (_Mdouble_ __x), (__const__));
 156
 157 /* Largest integer not greater than X.  */
 158 __MATHCALL (floor,, (_Mdouble_ __x));
 159
 160 /* Floating-point modulo remainder of X/Y.  */
 161 __MATHCALL (fmod,, (_Mdouble_ __x, _Mdouble_ __y));
 162
 163
 164 #ifdef __USE_MISC
 165 /* Return 0 if VALUE is finite or NaN, +1 if it
 166    is +Infinity, -1 if it is -Infinity.  */
 167 __MATHDECLX (int,isinf,, (_Mdouble_ __value), (__const__));
 168
 169 /* Return nonzero if VALUE is finite and not NaN.  */
 170 __MATHDECLX (int,finite,, (_Mdouble_ __value), (__const__));
 171
 172 /* Deal with an infinite or NaN result.
 173    If ERROR is ERANGE, result is +Inf;
 174    if ERROR is - ERANGE, result is -Inf;
 175    otherwise result is NaN.
 176    This will set `errno' to either ERANGE or EDOM,
 177    and may return an infinity or NaN, or may do something else.  */
 178 __MATHCALLX (infnan,, (int __error), (__const__));
 179
 180 /* Return X times (2 to the Nth power).  */
 181 __MATHCALL (scalbn,, (_Mdouble_ __x, int __n));
 182
 183 /* Return the remainder of X/Y.  */
 184 __MATHCALL (drem,, (_Mdouble_ __x, _Mdouble_ __y));
 185
 186
 187 /* Return the fractional part of X after dividing out `ilogb (X)'.  */
 188 __MATHCALL (significand,, (_Mdouble_ __x));
 189 #endif /* Use misc.  */
 190
 191 #if defined __USE_MISC || defined __USE_ISOC9X
 192 /* Return X with its signed changed to Y's.  */
 193 __MATHCALLX (copysign,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
 194 #endif
 195
 196 #ifdef __USE_ISOC9X
 197 /* Return representation of NaN for double type.  */
 198 __MATHCALLX (nan,, (__const char *__tagb), (__const__));
 199 #endif
 200
 201
 202 #if defined __USE_MISC || defined __USE_XOPEN
 203 /* Return nonzero if VALUE is not a number.  */
 204 __MATHDECLX (int,isnan,, (_Mdouble_ __value), (__const__));
 205
 206 /* Return the binary exponent of X, which must be nonzero.  */
 207 __MATHDECL (int,ilogb,, (_Mdouble_ __x));
 208
 209 /* Bessel functions.  */
 210 __MATHCALL (j0,, (_Mdouble_));
 211 __MATHCALL (j1,, (_Mdouble_));
 212 __MATHCALL (jn,, (int, _Mdouble_));
 213 __MATHCALL (y0,, (_Mdouble_));
 214 __MATHCALL (y1,, (_Mdouble_));
 215 __MATHCALL (yn,, (int, _Mdouble_));
 216 #endif
 217
 218
 219 #if defined __USE_MISC || defined __USE_XOPEN || defined __USE_ISOC9X
 220 /* Error, gamma, and Bessel functions.  */
 221 __MATHCALL (erf,, (_Mdouble_));
 222 __MATHCALL (erfc,, (_Mdouble_));
 223 __MATHCALL (gamma,, (_Mdouble_));
 224 __MATHCALL (lgamma,, (_Mdouble_));
 225
 226 #ifdef __USE_MISC
 227 /* Reentrant versions of gamma and lgamma.  Those functions use the global
 228    variable `signgam'.  The reentrant versions instead take a pointer and
 229    store the value through it.  */
 230 __MATHCALL (gamma,_r, (_Mdouble_, int *));
 231 __MATHCALL (lgamma,_r, (_Mdouble_, int *));
 232 #endif
 233
 234 #endif /* Use misc or X/Open.  */
 235
 236
 237 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC9X
 238 /* Return the integer nearest X in the direction of the
 239    prevailing rounding mode.  */
 240 __MATHCALL (rint,, (_Mdouble_ __x));
 241
 242 /* Return X + epsilon if X < Y, X - epsilon if X > Y.  */
 243 __MATHCALLX (nextafter,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
 244
 245 /* Return the remainder of integer divison X / Y with infinite precision.  */
 246 __MATHCALL (remainder,, (_Mdouble_ __x, _Mdouble_ __y));
 247 #endif
 248
 249 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED
 250 /* Return X times (2 to the Nth power).  */
 251 __MATHCALL (scalb,, (_Mdouble_ __x, _Mdouble_ __n));
 252 #endif
 253
 254 #ifdef __USE_ISOC9X
 255 /* Round X to integral valuein floating-point format using current
 256    rounding direction, but do not raise inexact exception.  */
 257 __MATHCALL (nearbyint,, (_Mdouble_ __x));
 258
 259 /* Round X to nearest integral value, rounding halfway cases away from
 260    zero.  */
 261 __MATHCALL (round,, (_Mdouble_ __x));
 262
 263 /* Round X to the integral value in floating-point format nearest but
 264    not larger in magnitude.  */
 265 __MATHCALLX (trunc,, (_Mdouble_ __x), (__const__));
 266
 267 /* Compute remainder of X and Y and put in *QUO a value with sign of x/y
 268    and magnitude congruent `mod 2^n' to the magnitude of the integral
 269    quotient x/y, with n >= 3.  */
 270 __MATHCALL (remquo,, (_Mdouble_ __x, _Mdouble_ __y, int *__quo));
 271
 272
 273 /* Return positive difference between X and Y.  */
 274 __MATHCALL (fdim,, (_Mdouble_ __x, _Mdouble_ __y));
 275
 276 /* Return maximum numeric value from X and Y.  */
 277 __MATHCALL (fmax,, (_Mdouble_ __x, _Mdouble_ __y));
 278
 279 /* Return minimum numeric value from X and Y.  */
 280 __MATHCALL (fmin,, (_Mdouble_ __x, _Mdouble_ __y));
 281
 282
 283 /* Classify given number.  */
 284 __MATHDECL_1 (int, __fpclassify,, (_Mdouble_ __value))
 285      __attribute__ ((__const__));
 286
 287 /* Test for negative number.  */
 288 __MATHDECL_1 (int, __signbit,, (_Mdouble_ __value))
 289      __attribute__ ((__const__));
 290 #endif /* Use ISO C 9X.  */