← Back to branch summary

~ubuntu-branches/ubuntu/precise/eglibc/precise

« back to all changes in this revision

Viewing changes to math/bits/math-finite.h

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2011-10-04 17:48:26 UTC
  • mfrom: (216.1.23 oneiric)
  • Revision ID: package-import@ubuntu.com-20111004174826-2cyb9ewn3ucymlsx
Tags: 2.13-20ubuntu5
https://launchpad.net/bugs/853688
libc6-dev: Don't break the current {gnat,gcj}-4.4-base versons. LP: #853688.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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