math/bits/math-finite.h

   1 /* Entry points to finite-math-only compiler runs.
   2    Copyright (C) 2011 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 #ifndef _MATH_H
  21 # error "Never use <bits/math-finite.h> directly; include <math.h> instead."
  22 #endif
  23
  24 /* acos.  */
  25 extern double __REDIRECT_NTH (acos, (double), __acos_finite);
  26 extern float __REDIRECT_NTH (acosf, (float), __acosf_finite);
  27 #ifdef __MATH_DECLARE_LDOUBLE
  28 extern long double __REDIRECT_NTH (acosl, (long double), __acosl_finite);
  29 #endif
  30
  31 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
  32 /* acosh.  */
  33 extern double __REDIRECT_NTH (acosh, (double), __acosh_finite);
  34 extern float __REDIRECT_NTH (acoshf, (float), __acoshf_finite);
  35 # ifdef __MATH_DECLARE_LDOUBLE
  36 extern long double __REDIRECT_NTH (acoshl, (long double), __acoshl_finite);
  37 # endif
  38 #endif
  39
  40 /* asin.  */
  41 extern double __REDIRECT_NTH (asin, (double), __asin_finite);
  42 extern float __REDIRECT_NTH (asinf, (float), __asinf_finite);
  43 #ifdef __MATH_DECLARE_LDOUBLE
  44 extern long double __REDIRECT_NTH (asinl, (long double), __asinl_finite);
  45 #endif
  46
  47 /* atan2.  */
  48 extern double __REDIRECT_NTH (atan2, (double, double), __atan2_finite);
  49 extern float __REDIRECT_NTH (atan2f, (float, float), __atan2f_finite);
  50 #ifdef __MATH_DECLARE_LDOUBLE
  51 extern long double __REDIRECT_NTH (atan2l, (long double, long double),
  52                                    __atan2l_finite);
  53 #endif
  54
  55 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
  56 /* atanh.  */
  57 extern double __REDIRECT_NTH (atanh, (double), __atanh_finite);
  58 extern float __REDIRECT_NTH (atanhf, (float), __atanhf_finite);
  59 # ifdef __MATH_DECLARE_LDOUBLE
  60 extern long double __REDIRECT_NTH (atanhl, (long double), __atanhl_finite);
  61 # endif
  62 #endif
  63
  64 /* cosh.  */
  65 extern double __REDIRECT_NTH (cosh, (double), __cosh_finite);
  66 extern float __REDIRECT_NTH (coshf, (float), __coshf_finite);
  67 #ifdef __MATH_DECLARE_LDOUBLE
  68 extern long double __REDIRECT_NTH (coshl, (long double), __coshl_finite);
  69 #endif
  70
  71 /* exp.  */
  72 extern double __REDIRECT_NTH (exp, (double), __exp_finite);
  73 extern float __REDIRECT_NTH (expf, (float), __expf_finite);
  74 #ifdef __MATH_DECLARE_LDOUBLE
  75 extern long double __REDIRECT_NTH (expl, (long double), __expl_finite);
  76 #endif
  77
  78 #ifdef __USE_GNU
  79 /* exp10.  */
  80 extern double __REDIRECT_NTH (exp10, (double), __exp10_finite);
  81 extern float __REDIRECT_NTH (exp10f, (float), __exp10f_finite);
  82 # ifdef __MATH_DECLARE_LDOUBLE
  83 extern long double __REDIRECT_NTH (exp10l, (long double), __exp10l_finite);
  84 # endif
  85
  86 /* pow10.  */
  87 extern double __REDIRECT_NTH (pow10, (double), __exp10_finite);
  88 extern float __REDIRECT_NTH (pow10f, (float), __exp10f_finite);
  89 # ifdef __MATH_DECLARE_LDOUBLE
  90 extern long double __REDIRECT_NTH (pow10l, (long double), __exp10l_finite);
  91 # endif
  92 #endif
  93
  94 #ifdef __USE_ISOC99
  95 /* exp2.  */
  96 extern double __REDIRECT_NTH (exp2, (double), __exp2_finite);
  97 extern float __REDIRECT_NTH (exp2f, (float), __exp2f_finite);
  98 # ifdef __MATH_DECLARE_LDOUBLE
  99 extern long double __REDIRECT_NTH (exp2l, (long double), __exp2l_finite);
 100 # endif
 101 #endif
 102
 103 /* fmod.  */
 104 extern double __REDIRECT_NTH (fmod, (double, double), __fmod_finite);
 105 extern float __REDIRECT_NTH (fmodf, (float, float), __fmodf_finite);
 106 #ifdef __MATH_DECLARE_LDOUBLE
 107 extern long double __REDIRECT_NTH (fmodl, (long double, long double),
 108                                    __fmodl_finite);
 109 #endif
 110
 111 #ifdef __USE_ISOC99
 112 /* hypot.  */
 113 extern double __REDIRECT_NTH (hypot, (double, double), __hypot_finite);
 114 extern float __REDIRECT_NTH (hypotf, (float, float), __hypotf_finite);
 115 # ifdef __MATH_DECLARE_LDOUBLE
 116 extern long double __REDIRECT_NTH (hypotl, (long double, long double),
 117                                    __hypotl_finite);
 118 # endif
 119 #endif
 120
 121 #if defined __USE_MISC || defined __USE_XOPEN
 122 /* j0.  */
 123 extern double __REDIRECT_NTH (j0, (double), __j0_finite);
 124 extern float __REDIRECT_NTH (j0f, (float), __j0f_finite);
 125 # ifdef __MATH_DECLARE_LDOUBLE
 126 extern long double __REDIRECT_NTH (j0l, (long double), __j0l_finite);
 127 # endif
 128
 129 /* y0.  */
 130 extern double __REDIRECT_NTH (y0, (double), __y0_finite);
 131 extern float __REDIRECT_NTH (y0f, (float), __y0f_finite);
 132 # ifdef __MATH_DECLARE_LDOUBLE
 133 extern long double __REDIRECT_NTH (y0l, (long double), __y0l_finite);
 134 # endif
 135
 136 /* j1.  */
 137 extern double __REDIRECT_NTH (j1, (double), __j1_finite);
 138 extern float __REDIRECT_NTH (j1f, (float), __j1f_finite);
 139 # ifdef __MATH_DECLARE_LDOUBLE
 140 extern long double __REDIRECT_NTH (j1l, (long double), __j1l_finite);
 141 # endif
 142
 143 /* y1.  */
 144 extern double __REDIRECT_NTH (y1, (double), __y1_finite);
 145 extern float __REDIRECT_NTH (y1f, (float), __y1f_finite);
 146 # ifdef __MATH_DECLARE_LDOUBLE
 147 extern long double __REDIRECT_NTH (y1l, (long double), __y1l_finite);
 148 # endif
 149
 150 /* jn.  */
 151 extern double __REDIRECT_NTH (jn, (int, double), __jn_finite);
 152 extern float __REDIRECT_NTH (jnf, (int, float), __jnf_finite);
 153 # ifdef __MATH_DECLARE_LDOUBLE
 154 extern long double __REDIRECT_NTH (jnl, (int, long double), __jnl_finite);
 155 # endif
 156
 157 /* yn.  */
 158 extern double __REDIRECT_NTH (yn, (int, double), __yn_finite);
 159 extern float __REDIRECT_NTH (ynf, (int, float), __ynf_finite);
 160 # ifdef __MATH_DECLARE_LDOUBLE
 161 extern long double __REDIRECT_NTH (ynl, (int, long double), __ynl_finite);
 162 # endif
 163 #endif
 164
 165 #ifdef __USE_MISC
 166 /* lgamma_r.  */
 167 extern double __REDIRECT_NTH (lgamma_r, (double, int *), __lgamma_r_finite);
 168 extern float __REDIRECT_NTH (lgammaf_r, (float, int *), __lgammaf_r_finite);
 169 # ifdef __MATH_DECLARE_LDOUBLE
 170 extern long double __REDIRECT_NTH (lgammal_r, (long double, int *),
 171                                    __lgammal_r_finite);
 172 # endif
 173 #endif
 174
 175 #if defined __USE_MISC || defined __USE_XOPEN || defined __USE_ISOC99
 176 /* lgamma.  */
 177 __extern_always_inline double __NTH (lgamma (double __d))
 178 {
 179 # ifdef __USE_ISOC99
 180   int __local_signgam = 0;
 181   return lgamma_r (__d, &__local_signgam);
 182 # else
 183   return lgamma_r (__d, &signgam);
 184 # endif
 185 }
 186 __extern_always_inline float __NTH (lgammaf (float __d))
 187 {
 188 # ifdef __USE_ISOC99
 189   int __local_signgam = 0;
 190   return lgammaf_r (__d, &__local_signgam);
 191 # else
 192   return lgammaf_r (__d, &signgam);
 193 # endif
 194 }
 195 # ifdef __MATH_DECLARE_LDOUBLE
 196 __extern_always_inline long double __NTH (lgammal (long double __d))
 197 {
 198 # ifdef __USE_ISOC99
 199   int __local_signgam = 0;
 200   return lgammal_r (__d, &__local_signgam);
 201 # else
 202   return lgammal_r (__d, &signgam);
 203 # endif
 204 }
 205 # endif
 206 #endif
 207
 208 #if defined __USE_MISC || defined __USE_XOPEN
 209 /* gamma.  */
 210 __extern_always_inline double __NTH (gamma (double __d))
 211 {
 212 # ifdef __USE_ISOC99
 213   int __local_signgam = 0;
 214   return lgamma_r (__d, &__local_signgam);
 215 # else
 216   return lgamma_r (__d, &signgam);
 217 # endif
 218 }
 219 __extern_always_inline float __NTH (gammaf (float __d))
 220 {
 221 # ifdef __USE_ISOC99
 222   int __local_signgam = 0;
 223   return lgammaf_r (__d, &__local_signgam);
 224 # else
 225   return lgammaf_r (__d, &signgam);
 226 # endif
 227 }
 228 # ifdef __MATH_DECLARE_LDOUBLE
 229 __extern_always_inline long double __NTH (gammal (long double __d))
 230 {
 231 #  ifdef __USE_ISOC99
 232   int __local_signgam = 0;
 233   return lgammal_r (__d, &__local_signgam);
 234 #  else
 235   return lgammal_r (__d, &signgam);
 236 #  endif
 237 }
 238 # endif
 239 #endif
 240
 241 /* log.  */
 242 extern double __REDIRECT_NTH (log, (double), __log_finite);
 243 extern float __REDIRECT_NTH (logf, (float), __logf_finite);
 244 #ifdef __MATH_DECLARE_LDOUBLE
 245 extern long double __REDIRECT_NTH (logl, (long double), __logl_finite);
 246 #endif
 247
 248 /* log10.  */
 249 extern double __REDIRECT_NTH (log10, (double), __log10_finite);
 250 extern float __REDIRECT_NTH (log10f, (float), __log10f_finite);
 251 #ifdef __MATH_DECLARE_LDOUBLE
 252 extern long double __REDIRECT_NTH (log10l, (long double), __log10l_finite);
 253 #endif
 254
 255 #ifdef __USE_ISOC99
 256 /* log2.  */
 257 extern double __REDIRECT_NTH (log2, (double), __log2_finite);
 258 extern float __REDIRECT_NTH (log2f, (float), __log2f_finite);
 259 # ifdef __MATH_DECLARE_LDOUBLE
 260 extern long double __REDIRECT_NTH (log2l, (long double), __log2l_finite);
 261 # endif
 262 #endif
 263
 264 /* pow.  */
 265 extern double __REDIRECT_NTH (pow, (double, double), __pow_finite);
 266 extern float __REDIRECT_NTH (powf, (float, float), __powf_finite);
 267 #ifdef __MATH_DECLARE_LDOUBLE
 268 extern long double __REDIRECT_NTH (powl, (long double, long double),
 269                                    __powl_finite);
 270 #endif
 271
 272 /* remainder.  */
 273 extern double __REDIRECT_NTH (remainder, (double, double), __remainder_finite);
 274 extern float __REDIRECT_NTH (remainderf, (float, float), __remainderf_finite);
 275 #ifdef __MATH_DECLARE_LDOUBLE
 276 extern long double __REDIRECT_NTH (remainderl, (long double, long double),
 277                                    __remainderl_finite);
 278 #endif
 279
 280 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED
 281 /* scalb.  */
 282 extern double __REDIRECT_NTH (scalb, (double, double), __scalb_finite);
 283 extern float __REDIRECT_NTH (scalbf, (float, float), __scalbf_finite);
 284 # ifdef __MATH_DECLARE_LDOUBLE
 285 extern long double __REDIRECT_NTH (scalbl, (long double, long double),
 286                                    __scalbl_finite);
 287 # endif
 288 #endif
 289
 290 /* sinh.  */
 291 extern double __REDIRECT_NTH (sinh, (double), __sinh_finite);
 292 extern float __REDIRECT_NTH (sinhf, (float), __sinhf_finite);
 293 #ifdef __MATH_DECLARE_LDOUBLE
 294 extern long double __REDIRECT_NTH (sinhl, (long double), __sinhl_finite);
 295 #endif
 296
 297 /* sqrt.  */
 298 extern double __REDIRECT_NTH (sqrt, (double), __sqrt_finite);
 299 extern float __REDIRECT_NTH (sqrtf, (float), __sqrtf_finite);
 300 #ifdef __MATH_DECLARE_LDOUBLE
 301 extern long double __REDIRECT_NTH (sqrtl, (long double), __sqrtl_finite);
 302 #endif
 303
 304 #ifdef __USE_ISOC99
 305 /* tgamma.  */
 306 extern double __gamma_r_finite (double, int *);
 307 __extern_always_inline double __NTH (tgamma (double __d))
 308 {
 309   int __local_signgam = 0;
 310   double __res = __gamma_r_finite (__d, &__local_signgam);
 311   return __local_signgam < 0 ? -__res : __res;
 312 }
 313 extern float __gammaf_r_finite (float, int *);
 314 __extern_always_inline float __NTH (tgammaf (float __d))
 315 {
 316   int __local_signgam = 0;
 317   float __res = __gammaf_r_finite (__d, &__local_signgam);
 318   return __local_signgam < 0 ? -__res : __res;
 319 }
 320 # ifdef __MATH_DECLARE_LDOUBLE
 321 extern long double __gammal_r_finite (long double, int *);
 322 __extern_always_inline long double __NTH (tgammal (long double __d))
 323 {
 324   int __local_signgam = 0;
 325   long double __res = __gammal_r_finite (__d, &__local_signgam);
 326   return __local_signgam < 0 ? -__res : __res;
 327 }
 328 # endif
 329 #endif