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
  67 /* Hyperbolic functions.  */
  68
  69 /* Hyperbolic cosine of X.  */
  70 __MATHCALL (cosh,, (_Mdouble_ __x));
  71 /* Hyperbolic sine of X.  */
  72 __MATHCALL (sinh,, (_Mdouble_ __x));
  73 /* Hyperbolic tangent of X.  */
  74 __MATHCALL (tanh,, (_Mdouble_ __x));
  75
  76 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC9X
  77 /* Hyperbolic arc cosine of X.  */
  78 __MATHCALL (acosh,, (_Mdouble_ __x));
  79 /* Hyperbolic arc sine of X.  */
  80 __MATHCALL (asinh,, (_Mdouble_ __x));
  81 /* Hyperbolic arc tangent of X.  */
  82 __MATHCALL (atanh,, (_Mdouble_ __x));
  83 #endif
  84
  85 /* Exponential and logarithmic functions.  */
  86
  87 /* Exponential function of X.  */
  88 __MATHCALL (exp,, (_Mdouble_ __x));
  89
  90 /* Break VALUE into a normalized fraction and an integral power of 2.  */
  91 __MATHCALL (frexp,, (_Mdouble_ __x, int *__exponent));
  92
  93 /* X times (two to the EXP power).  */
  94 __MATHCALL (ldexp,, (_Mdouble_ __x, int __exponent));
  95
  96 /* Natural logarithm of X.  */
  97 __MATHCALL (log,, (_Mdouble_ __x));
  98
  99 /* Base-ten logarithm of X.  */
 100 __MATHCALL (log10,, (_Mdouble_ __x));
 101
 102 /* Break VALUE into integral and fractional parts.  */
 103 __MATHCALL (modf,, (_Mdouble_ __x, _Mdouble_ *__iptr));
 104
 105 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC9X
 106 /* Return exp(X) - 1.  */
 107 __MATHCALL (expm1,, (_Mdouble_ __x));
 108
 109 /* Return log(1 + X).  */
 110 __MATHCALL (log1p,, (_Mdouble_ __x));
 111
 112 /* Return the base 2 signed integral exponent of X.  */
 113 __MATHCALL (logb,, (_Mdouble_ __x));
 114 #endif
 115
 116 #ifdef __USE_ISOC9X
 117 /* Compute base-2 exponential of X.  */
 118 __MATHCALL (exp2,, (_Mdouble_ __x));
 119
 120 /* Compute base-2 logarithm of X.  */
 121 __MATHCALL (log2,, (_Mdouble_ __x));
 122 #endif
 123
 124
 125 /* Power functions.  */
 126
 127 /* Return X to the Y power.  */
 128 __MATHCALL (pow,, (_Mdouble_ __x, _Mdouble_ __y));
 129
 130 /* Return the square root of X.  */
 131 __MATHCALL (sqrt,, (_Mdouble_ __x));
 132
 133 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC9X
 134 /* Return `sqrt(X*X + Y*Y)'.  */
 135 __MATHCALL (hypot,, (_Mdouble_ __x, _Mdouble_ __y));
 136 #endif
 137
 138 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED
 139 /* Return the cube root of X.  */
 140 __MATHCALL (cbrt,, (_Mdouble_ __x));
 141 #endif
 142
 143
 144 /* Nearest integer, absolute value, and remainder functions.  */
 145
 146 /* Smallest integral value not less than X.  */
 147 __MATHCALL (ceil,, (_Mdouble_ __x));
 148
 149 /* Absolute value of X.  */
 150 __MATHCALL (fabs,, (_Mdouble_ __x));
 151
 152 /* Largest integer not greater than X.  */
 153 __MATHCALL (floor,, (_Mdouble_ __x));
 154
 155 /* Floating-point modulo remainder of X/Y.  */
 156 __MATHCALL (fmod,, (_Mdouble_ __x, _Mdouble_ __y));
 157
 158
 159 #ifdef __USE_MISC
 160 /* Return 0 if VALUE is finite or NaN, +1 if it
 161    is +Infinity, -1 if it is -Infinity.  */
 162 __MATHDECL (int,isinf,, (_Mdouble_ __value));
 163
 164 /* Return nonzero if VALUE is finite and not NaN.  */
 165 __MATHDECL (int,finite,, (_Mdouble_ __value));
 166
 167 /* Deal with an infinite or NaN result.
 168    If ERROR is ERANGE, result is +Inf;
 169    if ERROR is - ERANGE, result is -Inf;
 170    otherwise result is NaN.
 171    This will set `errno' to either ERANGE or EDOM,
 172    and may return an infinity or NaN, or may do something else.  */
 173 __MATHCALL (infnan,, (int __error));
 174
 175 /* Return X times (2 to the Nth power).  */
 176 __MATHCALL (scalbn,, (_Mdouble_ __x, int __n));
 177
 178 /* Return the remainder of X/Y.  */
 179 __MATHCALL (drem,, (_Mdouble_ __x, _Mdouble_ __y));
 180
 181
 182 /* Return the fractional part of X after dividing out `ilogb (X)'.  */
 183 __MATHCALL (significand,, (_Mdouble_ __x));
 184 #endif /* Use misc.  */
 185
 186 #if defined __USE_MISC || defined __USE_ISOC9X
 187 /* Return X with its signed changed to Y's.  */
 188 __MATHCALL (copysign,, (_Mdouble_ __x, _Mdouble_ __y));
 189 #endif
 190
 191 #ifdef __USE_ISOC9X
 192 /* Return representation of NaN for double type.  */
 193 __MATHCALL (nan,, (__const char *__tagb));
 194 #endif
 195
 196
 197 #if defined __USE_MISC || defined __USE_XOPEN
 198 /* Return nonzero if VALUE is not a number.  */
 199 __MATHDECL (int,isnan,, (_Mdouble_ __value));
 200
 201 /* Return the binary exponent of X, which must be nonzero.  */
 202 __MATHDECL (int,ilogb,, (_Mdouble_ __x));
 203
 204 /* Bessel functions.  */
 205 __MATHCALL (j0,, (_Mdouble_));
 206 __MATHCALL (j1,, (_Mdouble_));
 207 __MATHCALL (jn,, (int, _Mdouble_));
 208 __MATHCALL (y0,, (_Mdouble_));
 209 __MATHCALL (y1,, (_Mdouble_));
 210 __MATHCALL (yn,, (int, _Mdouble_));
 211 #endif
 212
 213
 214 #if defined __USE_MISC || defined __USE_XOPEN || defined __USE_ISOC9X
 215 /* Error, gamma, and Bessel functions.  */
 216 __MATHCALL (erf,, (_Mdouble_));
 217 __MATHCALL (erfc,, (_Mdouble_));
 218 __MATHCALL (gamma,, (_Mdouble_));
 219 __MATHCALL (lgamma,, (_Mdouble_));
 220
 221 #ifdef __USE_MISC
 222 /* Reentrant versions of gamma and lgamma.  Those functions use the global
 223    variable `signgam'.  The reentrant versions instead take a pointer and
 224    store the value through it.  */
 225 __MATHCALL (gamma,_r, (_Mdouble_, int *));
 226 __MATHCALL (lgamma,_r, (_Mdouble_, int *));
 227 #endif
 228
 229 #endif /* Use misc or X/Open.  */
 230
 231
 232 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC9X
 233 /* Return the integer nearest X in the direction of the
 234    prevailing rounding mode.  */
 235 __MATHCALL (rint,, (_Mdouble_ __x));
 236
 237 /* Return X + epsilon if X < Y, X - epsilon if X > Y.  */
 238 __MATHCALL (nextafter,, (_Mdouble_ __x, _Mdouble_ __y));
 239
 240 /* Return the remainder of integer divison X / Y with infinite precision.  */
 241 __MATHCALL (remainder,, (_Mdouble_ __x, _Mdouble_ __y));
 242 #endif
 243
 244 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED
 245 /* Return X times (2 to the Nth power).  */
 246 __MATHCALL (scalb,, (_Mdouble_ __x, _Mdouble_ __n));
 247 #endif
 248
 249 #ifdef __USE_ISOC9X
 250 /* Round X to integral valuein floating-point format using current
 251    rounding direction, but do not raise inexact exception.  */
 252 __MATHCALL (nearbyint,, (_Mdouble_ __x));
 253
 254 /* Round X to nearest integral value, rounding halfway cases away from
 255    zero.  */
 256 __MATHCALL (round,, (_Mdouble_ __x));
 257
 258 /* Round X to the integral value in floating-point format nearest but
 259    not larger in magnitude.  */
 260 __MATHCALL (trunc,, (_Mdouble_ __x));
 261
 262 /* Compute remainder of X and Y and put in *QUO a value with sign of x/y
 263    and magnitude congruent `mod 2^n' to the magnitude of the integral
 264    quotient x/y, with n >= 3.  */
 265 __MATHCALL (remquo,, (_Mdouble_ __x, _Mdouble_ __y, int *__quo));
 266
 267
 268 /* Return positive difference between X and Y.  */
 269 __MATHCALL (fdim,, (_Mdouble_ __x, _Mdouble_ __y));
 270
 271 /* Return maximum numeric value from X and Y.  */
 272 __MATHCALL (fmax,, (_Mdouble_ __x, _Mdouble_ __y));
 273
 274 /* Return minimum numeric value from X and Y.  */
 275 __MATHCALL (fmin,, (_Mdouble_ __x, _Mdouble_ __y));
 276
 277
 278 /* Classify given number.  */
 279 __MATHDECL_1 (int, __fpclassify,, (_Mdouble_ __value));
 280
 281 /* Test for negative number.  */
 282 __MATHDECL_1 (int, __signbit,, (_Mdouble_ __value));
 283 #endif /* Use ISO C 9X.  */