OSDN Git Service

* include/c_std/cmath.tcc, include/c_std/std_cassert.h,
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / include / c_std / std_cmath.h
1 // -*- C++ -*- C forwarding header.
2
3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
4 // Free Software Foundation, Inc.
5 //
6 // This file is part of the GNU ISO C++ Library.  This library is free
7 // software; you can redistribute it and/or modify it under the
8 // terms of the GNU General Public License as published by the
9 // Free Software Foundation; either version 2, or (at your option)
10 // any later version.
11
12 // This library is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 // GNU General Public License for more details.
16
17 // You should have received a copy of the GNU General Public License along
18 // with this library; see the file COPYING.  If not, write to the Free
19 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
20 // USA.
21
22 // As a special exception, you may use this file as part of a free software
23 // library without restriction.  Specifically, if other files instantiate
24 // templates or use macros or inline functions from this file, or you compile
25 // this file and link it with other files to produce an executable, this
26 // file does not by itself cause the resulting executable to be covered by
27 // the GNU General Public License.  This exception does not however
28 // invalidate any other reasons why the executable file might be covered by
29 // the GNU General Public License.
30
31 //
32 // ISO C++ 14882: 26.5  C library
33 //
34
35 /** @file cmath
36  *  This is a Standard C++ Library file.  You should @c #include this file
37  *  in your programs, rather than any of the "*.h" implementation files.
38  *
39  *  This is the C++ version of the Standard C Library header @c math.h,
40  *  and its contents are (mostly) the same as that header, but are all
41  *  contained in the namespace @c std.
42  */
43
44 #ifndef _GLIBCXX_CMATH
45 #define _GLIBCXX_CMATH 1
46
47 #pragma GCC system_header
48
49 #include <bits/c++config.h>
50 #include <bits/cpp_type_traits.h>
51
52 #include <math.h>
53
54 // Get rid of those macros defined in <math.h> in lieu of real functions.
55 #undef abs
56 #undef div
57 #undef acos
58 #undef asin
59 #undef atan
60 #undef atan2
61 #undef ceil
62 #undef cos
63 #undef cosh
64 #undef exp
65 #undef fabs
66 #undef floor
67 #undef fmod
68 #undef frexp
69 #undef ldexp
70 #undef log
71 #undef log10
72 #undef modf
73 #undef pow
74 #undef sin
75 #undef sinh
76 #undef sqrt
77 #undef tan
78 #undef tanh
79
80
81 namespace std
82 {
83   // Forward declaration of a helper function.  This really should be
84   // an `exported' forward declaration.
85   template<typename _Tp> _Tp __cmath_power(_Tp, unsigned int);
86
87   inline double
88   abs(double __x)
89   { return __builtin_fabs(__x); }
90
91   inline float
92   abs(float __x)
93   { return __builtin_fabsf(__x); }
94
95   inline long double
96   abs(long double __x)
97   { return __builtin_fabsl(__x); }
98
99   using ::acos;
100
101   inline float
102   acos(float __x)
103   { return __builtin_acosf(__x); }
104
105   inline long double
106   acos(long double __x)
107   { return __builtin_acosl(__x); }
108
109   template<typename _Tp>
110     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
111     acos(_Tp __x)
112     {
113       return __builtin_acos(__x);
114     }
115
116   using ::asin;
117
118   inline float
119   asin(float __x)
120   { return __builtin_asinf(__x); }
121
122   inline long double
123   asin(long double __x)
124   { return __builtin_asinl(__x); }
125
126   template<typename _Tp>
127     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
128     asin(_Tp __x)
129     { return __builtin_asin(__x); }
130
131   using ::atan;
132
133   inline float
134   atan(float __x)
135   { return __builtin_atanf(__x); }
136
137   inline long double
138   atan(long double __x)
139   { return __builtin_atanl(__x); }
140
141   template<typename _Tp>
142     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
143     atan(_Tp __x)
144     { return __builtin_atan(__x); }
145
146   using ::atan2;
147
148   inline float
149   atan2(float __y, float __x)
150   { return __builtin_atan2f(__y, __x); }
151
152   inline long double
153   atan2(long double __y, long double __x)
154   { return __builtin_atan2l(__y, __x); }
155
156   template<typename _Tp, typename _Up>
157     inline typename __enable_if<double, __is_integer<_Tp>::_M_type
158                                         && __is_integer<_Up>::_M_type>::_M_type
159     atan2(_Tp __y, _Up __x)
160     { return __builtin_atan2(__y, __x); }
161
162   using ::ceil;
163
164   inline float
165   ceil(float __x)
166   { return __builtin_ceilf(__x); }
167
168   inline long double
169   ceil(long double __x)
170   { return __builtin_ceill(__x); }
171
172   template<typename _Tp>
173     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
174     ceil(_Tp __x)
175     { return __builtin_ceil(__x); }
176
177   using ::cos;
178
179   inline float
180   cos(float __x)
181   { return __builtin_cosf(__x); }
182
183   inline long double
184   cos(long double __x)
185   { return __builtin_cosl(__x); }
186
187   template<typename _Tp>
188     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
189     cos(_Tp __x)
190     { return __builtin_cos(__x); }
191
192   using ::cosh;
193
194   inline float
195   cosh(float __x)
196   { return __builtin_coshf(__x); }
197
198   inline long double
199   cosh(long double __x)
200   { return __builtin_coshl(__x); }
201
202   template<typename _Tp>
203     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
204     cosh(_Tp __x)
205     { return __builtin_cosh(__x); }
206
207   using ::exp;
208
209   inline float
210   exp(float __x)
211   { return __builtin_expf(__x); }
212
213   inline long double
214   exp(long double __x)
215   { return __builtin_expl(__x); }
216
217   template<typename _Tp>
218     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
219     exp(_Tp __x)
220     { return __builtin_exp(__x); }
221
222   using ::fabs;
223
224   inline float
225   fabs(float __x)
226   { return __builtin_fabsf(__x); }
227
228   inline long double
229   fabs(long double __x)
230   { return __builtin_fabsl(__x); }
231
232   template<typename _Tp>
233     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
234     fabs(_Tp __x)
235     { return __builtin_fabs(__x); }
236
237   using ::floor;
238
239   inline float
240   floor(float __x)
241   { return __builtin_floorf(__x); }
242
243   inline long double
244   floor(long double __x)
245   { return __builtin_floorl(__x); }
246
247   template<typename _Tp>
248     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
249     floor(_Tp __x)
250     { return __builtin_floor(__x); }
251
252   using ::fmod;
253
254   inline float
255   fmod(float __x, float __y)
256   { return __builtin_fmodf(__x, __y); }
257
258   inline long double
259   fmod(long double __x, long double __y)
260   { return __builtin_fmodl(__x, __y); }
261
262   using ::frexp;
263
264   inline float
265   frexp(float __x, int* __exp)
266   { return __builtin_frexpf(__x, __exp); }
267
268   inline long double
269   frexp(long double __x, int* __exp)
270   { return __builtin_frexpl(__x, __exp); }
271
272   template<typename _Tp>
273     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
274     frexp(_Tp __x, int* __exp)
275     { return __builtin_frexp(__x, __exp); }
276
277   using ::ldexp;
278
279   inline float
280   ldexp(float __x, int __exp)
281   { return __builtin_ldexpf(__x, __exp); }
282
283   inline long double
284   ldexp(long double __x, int __exp)
285   { return __builtin_ldexpl(__x, __exp); }
286
287   template<typename _Tp>
288   inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
289   ldexp(_Tp __x, int __exp)
290   { return __builtin_ldexp(__x, __exp); }
291
292   using ::log;
293
294   inline float
295   log(float __x)
296   { return __builtin_logf(__x); }
297
298   inline long double
299   log(long double __x)
300   { return __builtin_logl(__x); }
301
302   template<typename _Tp>
303     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
304     log(_Tp __x)
305     { return __builtin_log(__x); }
306
307   using ::log10;
308
309   inline float
310   log10(float __x)
311   { return __builtin_log10f(__x); }
312
313   inline long double
314   log10(long double __x)
315   { return __builtin_log10l(__x); }
316
317   template<typename _Tp>
318     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
319     log10(_Tp __x)
320     { return __builtin_log10(__x); }
321
322   using ::modf;
323
324   inline float
325   modf(float __x, float* __iptr)
326   { return __builtin_modff(__x, __iptr); }
327
328   inline long double
329   modf(long double __x, long double* __iptr)
330   { return __builtin_modfl(__x, __iptr); }
331
332   template<typename _Tp>
333     inline _Tp
334     __pow_helper(_Tp __x, int __n)
335     {
336       return __n < 0
337         ? _Tp(1)/__cmath_power(__x, -__n)
338         : __cmath_power(__x, __n);
339     }
340
341   using ::pow;
342
343   inline float
344   pow(float __x, float __y)
345   { return __builtin_powf(__x, __y); }
346
347   inline long double
348   pow(long double __x, long double __y)
349   { return __builtin_powl(__x, __y); }
350
351   inline double
352   pow(double __x, int __i)
353   { return __pow_helper(__x, __i); }
354
355   inline float
356   pow(float __x, int __n)
357   { return __pow_helper(__x, __n); }
358
359   inline long double
360   pow(long double __x, int __n)
361   { return __pow_helper(__x, __n); }
362
363   using ::sin;
364
365   inline float
366   sin(float __x)
367   { return __builtin_sinf(__x); }
368
369   inline long double
370   sin(long double __x)
371   { return __builtin_sinl(__x); }
372
373   template<typename _Tp>
374     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
375     sin(_Tp __x)
376     { return __builtin_sin(__x); }
377
378   using ::sinh;
379
380   inline float
381   sinh(float __x)
382   { return __builtin_sinhf(__x); }
383
384   inline long double
385   sinh(long double __x)
386   { return __builtin_sinhl(__x); }
387
388   template<typename _Tp>
389     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
390     sinh(_Tp __x)
391     { return __builtin_sinh(__x); }
392
393   using ::sqrt;
394
395   inline float
396   sqrt(float __x)
397   { return __builtin_sqrtf(__x); }
398
399   inline long double
400   sqrt(long double __x)
401   { return __builtin_sqrtl(__x); }
402
403   template<typename _Tp>
404     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
405     sqrt(_Tp __x)
406     { return __builtin_sqrt(__x); }
407
408   using ::tan;
409
410   inline float
411   tan(float __x)
412   { return __builtin_tanf(__x); }
413
414   inline long double
415   tan(long double __x)
416   { return __builtin_tanl(__x); }
417
418   template<typename _Tp>
419     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
420     tan(_Tp __x)
421     { return __builtin_tan(__x); }
422
423   using ::tanh;
424
425   inline float
426   tanh(float __x)
427   { return __builtin_tanhf(__x); }
428
429   inline long double
430   tanh(long double __x)
431   { return __builtin_tanhl(__x); }
432
433   template<typename _Tp>
434     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
435     tanh(_Tp __x)
436     { return __builtin_tanh(__x); }
437 }
438
439
440 #if _GLIBCXX_USE_C99
441 #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
442 // These are possible macros imported from C99-land. For strict
443 // conformance, remove possible C99-injected names from the global
444 // namespace, and sequester them in the __gnu_cxx extension namespace.
445 namespace __gnu_cxx
446 {
447   template<typename _Tp>
448     int
449     __capture_fpclassify(_Tp __f) { return fpclassify(__f); }
450
451   template<typename _Tp>
452     int
453     __capture_isfinite(_Tp __f) { return isfinite(__f); }
454
455   template<typename _Tp>
456     int
457     __capture_isinf(_Tp __f) { return isinf(__f); }
458
459   template<typename _Tp>
460     int
461     __capture_isnan(_Tp __f) { return isnan(__f); }
462
463   template<typename _Tp>
464     int
465     __capture_isnormal(_Tp __f) { return isnormal(__f); }
466
467   template<typename _Tp>
468     int
469     __capture_signbit(_Tp __f) { return signbit(__f); }
470
471   template<typename _Tp>
472     int
473     __capture_isgreater(_Tp __f1, _Tp __f2)
474     { return isgreater(__f1, __f2); }
475
476   template<typename _Tp>
477      int
478      __capture_isgreaterequal(_Tp __f1, _Tp __f2)
479      { return isgreaterequal(__f1, __f2); }
480
481   template<typename _Tp>
482      int
483      __capture_isless(_Tp __f1, _Tp __f2) { return isless(__f1, __f2); }
484
485   template<typename _Tp>
486      int
487      __capture_islessequal(_Tp __f1, _Tp __f2)
488      { return islessequal(__f1, __f2); }
489
490   template<typename _Tp>
491      int
492      __capture_islessgreater(_Tp __f1, _Tp __f2)
493      { return islessgreater(__f1, __f2); }
494
495   template<typename _Tp>
496      int
497      __capture_isunordered(_Tp __f1, _Tp __f2)
498      { return isunordered(__f1, __f2); }
499 }
500
501 // Only undefine the C99 FP macros, if actually captured for namespace movement
502 #undef fpclassify
503 #undef isfinite
504 #undef isinf
505 #undef isnan
506 #undef isnormal
507 #undef signbit
508 #undef isgreater
509 #undef isgreaterequal
510 #undef isless
511 #undef islessequal
512 #undef islessgreater
513 #undef isunordered
514 #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
515 #endif
516
517 #if _GLIBCXX_USE_C99
518 #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
519 namespace __gnu_cxx
520 {
521   template<typename _Tp>
522     int
523     fpclassify(_Tp __f) { return __capture_fpclassify(__f); }
524
525   template<typename _Tp>
526     int
527     isfinite(_Tp __f) { return __capture_isfinite(__f); }
528
529   template<typename _Tp>
530     int
531     isinf(_Tp __f) { return __capture_isinf(__f); }
532
533   template<typename _Tp>
534     int
535     isnan(_Tp __f) { return __capture_isnan(__f); }
536
537   template<typename _Tp>
538     int
539     isnormal(_Tp __f) { return __capture_isnormal(__f); }
540
541   template<typename _Tp>
542     int
543     signbit(_Tp __f) { return __capture_signbit(__f); }
544
545   template<typename _Tp>
546     int
547     isgreater(_Tp __f1, _Tp __f2) { return __capture_isgreater(__f1, __f2); }
548
549   template<typename _Tp>
550     int
551     isgreaterequal(_Tp __f1, _Tp __f2)
552     { return __capture_isgreaterequal(__f1, __f2); }
553
554   template<typename _Tp>
555     int
556     isless(_Tp __f1, _Tp __f2) { return __capture_isless(__f1, __f2); }
557
558   template<typename _Tp>
559     int
560     islessequal(_Tp __f1, _Tp __f2)
561     { return __capture_islessequal(__f1, __f2); }
562
563   template<typename _Tp>
564     int
565     islessgreater(_Tp __f1, _Tp __f2)
566     { return __capture_islessgreater(__f1, __f2); }
567
568   template<typename _Tp>
569     int
570     isunordered(_Tp __f1, _Tp __f2)
571     { return __capture_isunordered(__f1, __f2); }
572 }
573
574 namespace std
575 {
576   using __gnu_cxx::fpclassify;
577   using __gnu_cxx::isfinite;
578   using __gnu_cxx::isinf;
579   using __gnu_cxx::isnan;
580   using __gnu_cxx::isnormal;
581   using __gnu_cxx::signbit;
582   using __gnu_cxx::isgreater;
583   using __gnu_cxx::isgreaterequal;
584   using __gnu_cxx::isless;
585   using __gnu_cxx::islessequal;
586   using __gnu_cxx::islessgreater;
587   using __gnu_cxx::isunordered;
588 }
589 #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
590 #endif
591
592 #ifndef _GLIBCXX_EXPORT_TEMPLATE
593 # include <bits/cmath.tcc>
594 #endif
595
596 #endif