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