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