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 _CPP_CMATH
45 #define _CPP_CMATH 1
46 
47 #pragma GCC system_header
48 
49 #include <bits/c++config.h>
50 
51 #include <math.h>
52 
53 // Get rid of those macros defined in <math.h> in lieu of real functions.
54 #undef abs
55 #undef div
56 #undef acos
57 #undef asin
58 #undef atan
59 #undef atan2
60 #undef ceil
61 #undef cos
62 #undef cosh
63 #undef exp
64 #undef fabs
65 #undef floor
66 #undef fmod
67 #undef frexp
68 #undef ldexp
69 #undef log
70 #undef log10
71 #undef modf
72 #undef pow
73 #undef sin
74 #undef sinh
75 #undef sqrt
76 #undef tan
77 #undef tanh
78 
79 // ...and in the darkness bind them...
80 namespace __gnu_cxx
81 {
82   namespace  __c99_binding
83   {
84 #if _GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_CHECK || \
85     _GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC
86     extern "C" float (acosf)(float);
87     extern "C" float (asinf)(float);
88     extern "C" float (atanf)(float);
89     extern "C" float (atan2f)(float, float);
90     extern "C" float (ceilf)(float);
91     extern "C" float (coshf)(float);
92     extern "C" float (expf)(float);
93     extern "C" float (floorf)(float);
94     extern "C" float (fmodf)(float, float);
95     extern "C" float (frexpf)(float, int*);
96     extern "C" float (ldexpf)(float, int);
97     extern "C" float (logf)(float);
98     extern "C" float (log10f)(float);
99     extern "C" float (modff)(float, float*);
100     extern "C" float (powf)(float, float);
101     extern "C" float (sinhf)(float);
102     extern "C" float (tanf)(float);
103     extern "C" float (tanhf)(float);
104 #endif
105 #if !_GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC
106 #if _GLIBCPP_HAVE_ACOSF
107     using ::acosf;
108 #endif
109 #if _GLIBCPP_HAVE_ASINF
110     using ::asinf;
111 #endif
112 #if _GLIBCPP_HAVE_ATANF
113     using ::atanf;
114 #endif
115 #if _GLIBCPP_HAVE_ATAN2F
116     using ::atan2f;
117 #endif
118 #if _GLIBCPP_HAVE_CEILF
119     using ::ceilf;
120 #endif
121 #if _GLIBCPP_HAVE_COSHF
122     using ::coshf;
123 #endif
124 #if _GLIBCPP_HAVE_EXPF
125     using ::expf;
126 #endif
127 #if _GLIBCPP_HAVE_FLOORF
128     using ::floorf;
129 #endif
130 #if _GLIBCPP_HAVE_FMODF
131     using ::fmodf;
132 #endif
133 #if _GLIBCPP_HAVE_FREXPF
134     using ::frexpf;
135 #endif
136 #if _GLIBCPP_HAVE_LDEXPF
137     using ::ldexpf;
138 #endif
139 #if _GLIBCPP_HAVE_LOGF
140     using ::logf;
141 #endif
142 #if _GLIBCPP_HAVE_LOG10F
143     using ::log10f;
144 #endif
145 #if _GLIBCPP_HAVE_MODFF
146     using ::modff;
147 #endif
148 #if _GLIBCPP_HAVE_POWF
149     using ::powf;
150 #endif
151 #if _GLIBCPP_HAVE_SINHF
152     using ::sinhf;
153 #endif
154 #if _GLIBCPP_HAVE_TANF
155     using ::tanf;
156 #endif
157 #if _GLIBCPP_HAVE_TANHF
158     using ::tanhf;
159 #endif
160 #endif /* _GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC */
161   }
162 }
163 
164 namespace std
165 {
166   // Forward declaration of a helper function.  This really should be
167   // an `exported' forward declaration.
168   template<typename _Tp> _Tp __cmath_power(_Tp, unsigned int);
169 
170   inline double
171   abs(double __x)
172   { return __builtin_fabs(__x); }
173 
174   inline float
175   abs(float __x)
176   { return __builtin_fabsf(__x); }
177 
178   inline long double
179   abs(long double __x)
180   { return __builtin_fabsl(__x); }
181 
182 #if _GLIBCPP_HAVE_ACOSF
183   inline float
184   acos(float __x) { return __gnu_cxx::__c99_binding::acosf(__x); }
185 #else
186   inline float
187   acos(float __x) { return ::acos(static_cast<double>(__x)); }
188 #endif
189 
190   using ::acos;
191 
192 #if _GLIBCPP_HAVE_ACOSL
193   inline long double
194   acos(long double __x) { return ::acosl(__x); }
195 #else
196   inline long double
197   acos(long double __x) { return ::acos(static_cast<double>(__x)); }
198 #endif
199 
200   using ::asin;
201 
202 #if _GLIBCPP_HAVE_ASINF
203   inline float
204   asin(float __x) { return __gnu_cxx::__c99_binding::asinf(__x); }
205 #else
206   inline float
207   asin(float __x) { return ::asin(static_cast<double>(__x)); }
208 #endif
209 
210 #if _GLIBCPP_HAVE_ASINL
211   inline long double
212   asin(long double __x) { return ::asinl(__x); }
213 #else
214   inline long double
215   asin(long double __x) { return ::asin(static_cast<double>(__x)); }
216 #endif
217 
218   using ::atan;
219 
220 #if _GLIBCPP_HAVE_ATANF
221   inline float
222   atan(float __x) { return __gnu_cxx::__c99_binding::atanf(__x); }
223 #else
224   inline float
225   atan(float __x) { return ::atan(static_cast<double>(__x)); }
226 #endif
227 
228 #if _GLIBCPP_HAVE_ATANL
229   inline long double
230   atan(long double __x) { return ::atanl(__x); }
231 #else
232   inline long double
233   atan(long double __x) { return ::atan(static_cast<double>(__x)); }
234 #endif
235 
236   using ::atan2;
237 
238 #if _GLIBCPP_HAVE_ATAN2F
239   inline float
240   atan2(float __y, float __x) { return __gnu_cxx::__c99_binding::atan2f(__y, __x); }
241 #else
242   inline float
243   atan2(float __y, float __x)
244   { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); }
245 #endif
246 
247 #if _GLIBCPP_HAVE_ATAN2L
248   inline long double
249   atan2(long double __y, long double __x) { return ::atan2l(__y, __x); }
250 #else
251   inline long double
252   atan2(long double __y, long double __x)
253   { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); }
254 #endif
255 
256   using ::ceil;
257 
258 #if _GLIBCPP_HAVE_CEILF
259   inline float
260   ceil(float __x) { return __gnu_cxx::__c99_binding::ceilf(__x); }
261 #else
262   inline float
263   ceil(float __x) { return ::ceil(static_cast<double>(__x)); }
264 #endif
265 
266 #if _GLIBCPP_HAVE_CEILL
267   inline long double
268   ceil(long double __x) { return ::ceill(__x); }
269 #else
270   inline long double
271   ceil(long double __x) { return ::ceil(static_cast<double>(__x)); }
272 #endif
273 
274   using ::cos;
275 
276   inline float
277   cos(float __x)
278   { return __builtin_cosf(__x); }
279 
280   inline long double
281   cos(long double __x)
282   { return __builtin_cosl(__x); }
283 
284   using ::cosh;
285 
286 #if _GLIBCPP_HAVE_COSHF
287   inline float
288   cosh(float __x) { return __gnu_cxx::__c99_binding::coshf(__x); }
289 #else
290   inline float
291   cosh(float __x) { return ::cosh(static_cast<double>(__x)); }
292 #endif
293 
294 #if _GLIBCPP_HAVE_COSHL
295   inline long double
296   cosh(long double __x) { return ::coshl(__x); }
297 #else
298   inline long double
299   cosh(long double __x) { return ::cosh(static_cast<double>(__x)); }
300 #endif
301 
302   using ::exp;
303 
304 #if _GLIBCPP_HAVE_EXPF
305   inline float
306   exp(float __x) { return __gnu_cxx::__c99_binding::expf(__x); }
307 #else
308   inline float
309   exp(float __x) { return ::exp(static_cast<double>(__x)); }
310 #endif
311 
312 #if _GLIBCPP_HAVE_EXPL
313   inline long double
314   exp(long double __x) { return ::expl(__x); }
315 #else
316   inline long double
317   exp(long double __x) { return ::exp(static_cast<double>(__x)); }
318 #endif
319 
320   using ::fabs;
321 
322   inline float
323   fabs(float __x)
324   { return __builtin_fabsf(__x); }
325 
326   inline long double
327   fabs(long double __x)
328   { return __builtin_fabsl(__x); }
329 
330   using ::floor;
331 
332 #if _GLIBCPP_HAVE_FLOORF
333   inline float
334   floor(float __x) { return __gnu_cxx::__c99_binding::floorf(__x); }
335 #else
336   inline float
337   floor(float __x) { return ::floor(static_cast<double>(__x)); }
338 #endif
339 
340 #if _GLIBCPP_HAVE_FLOORL
341   inline long double
342   floor(long double __x) { return ::floorl(__x); }
343 #else
344   inline long double
345   floor(long double __x) { return ::floor(static_cast<double>(__x)); }
346 #endif
347 
348   using ::fmod;
349 
350 #if _GLIBCPP_HAVE_FMODF
351   inline float
352   fmod(float __x, float __y) { return __gnu_cxx::__c99_binding::fmodf(__x, __y); }
353 #else
354   inline float
355   fmod(float __x, float __y)
356   { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
357 #endif
358 
359 #if _GLIBCPP_HAVE_FMODL
360   inline long double
361   fmod(long double __x, long double __y) { return ::fmodl(__x, __y); }
362 #else
363   inline long double
364   fmod(long double __x, long double __y)
365   { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
366 #endif
367 
368   using ::frexp;
369 
370 #if _GLIBCPP_HAVE_FREXPF
371   inline float
372   frexp(float __x, int* __exp) { return __gnu_cxx::__c99_binding::frexpf(__x, __exp); }
373 #else
374   inline float
375   frexp(float __x, int* __exp) { return ::frexp(__x, __exp); }
376 #endif
377 
378 #if _GLIBCPP_HAVE_FREXPL
379   inline long double
380   frexp(long double __x, int* __exp) { return ::frexpl(__x, __exp); }
381 #else
382   inline long double
383   frexp(long double __x, int* __exp)
384   { return ::frexp(static_cast<double>(__x), __exp); }
385 #endif
386 
387   using ::ldexp;
388 
389 #if _GLIBCPP_HAVE_LDEXPF
390   inline float
391   ldexp(float __x, int __exp) { return __gnu_cxx::__c99_binding::ldexpf(__x, __exp); }
392 #else
393   inline float
394   ldexp(float __x, int __exp)
395   { return ::ldexp(static_cast<double>(__x), __exp); }
396 #endif
397 
398 #if _GLIBCPP_HAVE_LDEXPL
399   inline long double
400   ldexp(long double __x, int __exp) { return ::ldexpl(__x, __exp); }
401 #else
402   inline long double
403   ldexp(long double __x, int __exp)
404   { return ::ldexp(static_cast<double>(__x), __exp); }
405 #endif
406 
407   using ::log;
408 
409 #if _GLIBCPP_HAVE_LOGF
410   inline float
411   log(float __x) { return __gnu_cxx::__c99_binding::logf(__x); }
412 #else
413   inline float log(float __x)
414   { return ::log(static_cast<double>(__x)); }
415 #endif
416 
417 #if _GLIBCPP_HAVE_LOGL
418   inline long double
419   log(long double __x) { return ::logl(__x); }
420 #else
421   inline long double
422   log(long double __x) { return ::log(static_cast<double>(__x)); }
423 #endif
424 
425   using ::log10;
426 
427 #if _GLIBCPP_HAVE_LOG10F
428   inline float
429   log10(float __x) { return __gnu_cxx::__c99_binding::log10f(__x); }
430 #else
431   inline float
432   log10(float __x) { return ::log10(static_cast<double>(__x)); }
433 #endif
434 
435 #if _GLIBCPP_HAVE_LOG10L
436   inline long double
437   log10(long double __x) { return ::log10l(__x); }
438 #else
439   inline long double
440   log10(long double __x) { return ::log10(static_cast<double>(__x)); }
441 #endif
442 
443   using ::modf;
444 
445 #if _GLIBCPP_HAVE_MODFF
446   inline float
447   modf(float __x, float* __iptr) { return __gnu_cxx::__c99_binding::modff(__x, __iptr); }
448 #else
449   inline float
450   modf(float __x, float* __iptr)
451   {
452     double __tmp;
453     double __res = ::modf(static_cast<double>(__x), &__tmp);
454     *__iptr = static_cast<float>(__tmp);
455     return __res;
456   }
457 #endif
458 
459 #if _GLIBCPP_HAVE_MODFL
460   inline long double
461   modf(long double __x, long double* __iptr) { return ::modfl(__x, __iptr); }
462 #else
463   inline long double
464   modf(long double __x, long double* __iptr)
465   {
466     double __tmp;
467     double __res = ::modf(static_cast<double>(__x), &__tmp);
468     * __iptr = static_cast<long double>(__tmp);
469     return __res;
470   }
471 #endif
472 
473   template<typename _Tp>
474     inline _Tp
475     __pow_helper(_Tp __x, int __n)
476     {
477       return __n < 0
478         ? _Tp(1)/__cmath_power(__x, -__n)
479         : __cmath_power(__x, __n);
480     }
481 
482   using ::pow;
483 
484 #if _GLIBCPP_HAVE_POWF
485   inline float
486   pow(float __x, float __y) { return __gnu_cxx::__c99_binding::powf(__x, __y); }
487 #else
488   inline float
489   pow(float __x, float __y)
490   { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
491 #endif
492 
493 #if _GLIBCPP_HAVE_POWL
494   inline long double
495   pow(long double __x, long double __y) { return ::powl(__x, __y); }
496 #else
497   inline long double
498   pow(long double __x, long double __y)
499   { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
500 #endif
501 
502   inline double
503   pow(double __x, int __i)
504   { return __pow_helper(__x, __i); }
505 
506   inline float
507   pow(float __x, int __n)
508   { return __pow_helper(__x, __n); }
509 
510   inline long double
511   pow(long double __x, int __n)
512   { return __pow_helper(__x, __n); }
513 
514   using ::sin;
515 
516   inline float
517   sin(float __x)
518   { return __builtin_sinf(__x); }
519 
520   inline long double
521   sin(long double __x)
522   { return __builtin_sinl(__x); }
523 
524   using ::sinh;
525 
526 #if _GLIBCPP_HAVE_SINHF
527   inline float
528   sinh(float __x) { return __gnu_cxx::__c99_binding::sinhf(__x); }
529 #else
530   inline float
531   sinh(float __x) { return ::sinh(static_cast<double>(__x)); }
532 #endif
533 
534 #if _GLIBCPP_HAVE_SINHL
535   inline long double
536   sinh(long double __x) { return ::sinhl(__x); }
537 #else
538   inline long double
539   sinh(long double __x) { return ::sinh(static_cast<double>(__x)); }
540 #endif
541 
542   using ::sqrt;
543 
544   inline float
545   sqrt(float __x)
546   { return __builtin_sqrtf(__x); }
547 
548   inline long double
549   sqrt(long double __x)
550   { return __builtin_sqrtl(__x); }
551 
552   using ::tan;
553 
554 #if _GLIBCPP_HAVE_TANF
555   inline float
556   tan(float __x) { return __gnu_cxx::__c99_binding::tanf(__x); }
557 #else
558   inline float
559   tan(float __x) { return ::tan(static_cast<double>(__x)); }
560 #endif
561 
562 #if _GLIBCPP_HAVE_TANL
563   inline long double
564   tan(long double __x) { return ::tanl(__x); }
565 #else
566   inline long double
567   tan(long double __x) { return ::tan(static_cast<double>(__x)); }
568 #endif
569 
570   using ::tanh;
571 
572 #if _GLIBCPP_HAVE_TANHF
573   inline float
574   tanh(float __x) { return __gnu_cxx::__c99_binding::tanhf(__x); }
575 #else
576   inline float
577   tanh(float __x) { return ::tanh(static_cast<double>(__x)); }
578 #endif
579 
580 #if _GLIBCPP_HAVE_TANHL
581   inline long double
582   tanh(long double __x) { return ::tanhl(__x); }
583 #else
584   inline long double
585   tanh(long double __x) { return ::tanh(static_cast<double>(__x)); }
586 #endif
587 }
588 
589 
590 #if _GLIBCPP_USE_C99
591 #if !_GLIBCPP_USE_C99_FP_MACROS_DYNAMIC
592 // These are possible macros imported from C99-land. For strict
593 // conformance, remove possible C99-injected names from the global
594 // namespace, and sequester them in the __gnu_cxx extension namespace.
595 namespace __gnu_cxx
596 {
597   template<typename _Tp>
598     int
599     __capture_fpclassify(_Tp __f) { return fpclassify(__f); }
600 
601   template<typename _Tp>
602     int
603     __capture_isfinite(_Tp __f) { return isfinite(__f); }
604 
605   template<typename _Tp>
606     int
607     __capture_isinf(_Tp __f) { return isinf(__f); }
608 
609   template<typename _Tp>
610     int
611     __capture_isnan(_Tp __f) { return isnan(__f); }
612 
613   template<typename _Tp>
614     int
615     __capture_isnormal(_Tp __f) { return isnormal(__f); }
616 
617   template<typename _Tp>
618     int
619     __capture_signbit(_Tp __f) { return signbit(__f); }
620 
621   template<typename _Tp>
622     int
623     __capture_isgreater(_Tp __f1, _Tp __f2)
624     { return isgreater(__f1, __f2); }
625 
626   template<typename _Tp>
627      int
628      __capture_isgreaterequal(_Tp __f1, _Tp __f2)
629      { return isgreaterequal(__f1, __f2); }
630 
631   template<typename _Tp>
632      int
633      __capture_isless(_Tp __f1, _Tp __f2) { return isless(__f1, __f2); }
634 
635   template<typename _Tp>
636      int
637      __capture_islessequal(_Tp __f1, _Tp __f2)
638      { return islessequal(__f1, __f2); }
639 
640   template<typename _Tp>
641      int
642      __capture_islessgreater(_Tp __f1, _Tp __f2)
643      { return islessgreater(__f1, __f2); }
644 
645   template<typename _Tp>
646      int
647      __capture_isunordered(_Tp __f1, _Tp __f2)
648      { return isunordered(__f1, __f2); }
649 }
650 #endif /* _GLIBCPP_USE_C99_FP_MACROS_DYNAMIC */
651 #endif
652 
653 #undef fpclassify
654 #undef isfinite
655 #undef isinf
656 #undef isnan
657 #undef isnormal
658 #undef signbit
659 #undef isgreater
660 #undef isgreaterequal
661 #undef isless
662 #undef islessequal
663 #undef islessgreater
664 #undef isunordered
665 
666 #if _GLIBCPP_USE_C99
667 #if !_GLIBCPP_USE_C99_FP_MACROS_DYNAMIC
668 namespace __gnu_cxx
669 {
670   template<typename _Tp>
671     int
672     fpclassify(_Tp __f) { return __capture_fpclassify(__f); }
673 
674   template<typename _Tp>
675     int
676     isfinite(_Tp __f) { return __capture_isfinite(__f); }
677 
678   template<typename _Tp>
679     int
680     isinf(_Tp __f) { return __capture_isinf(__f); }
681 
682   template<typename _Tp>
683     int
684     isnan(_Tp __f) { return __capture_isnan(__f); }
685 
686   template<typename _Tp>
687     int
688     isnormal(_Tp __f) { return __capture_isnormal(__f); }
689 
690   template<typename _Tp>
691     int
692     signbit(_Tp __f) { return __capture_signbit(__f); }
693 
694   template<typename _Tp>
695     int
696     isgreater(_Tp __f1, _Tp __f2) { return __capture_isgreater(__f1, __f2); }
697 
698   template<typename _Tp>
699     int
700     isgreaterequal(_Tp __f1, _Tp __f2)
701     { return __capture_isgreaterequal(__f1, __f2); }
702 
703   template<typename _Tp>
704     int
705     isless(_Tp __f1, _Tp __f2) { return __capture_isless(__f1, __f2); }
706 
707   template<typename _Tp>
708     int
709     islessequal(_Tp __f1, _Tp __f2)
710     { return __capture_islessequal(__f1, __f2); }
711 
712   template<typename _Tp>
713     int
714     islessgreater(_Tp __f1, _Tp __f2)
715     { return __capture_islessgreater(__f1, __f2); }
716 
717   template<typename _Tp>
718     int
719     isunordered(_Tp __f1, _Tp __f2)
720     { return __capture_isunordered(__f1, __f2); }
721 }
722 
723 namespace std
724 {
725   using __gnu_cxx::fpclassify;
726   using __gnu_cxx::isfinite;
727   using __gnu_cxx::isinf;
728   using __gnu_cxx::isnan;
729   using __gnu_cxx::isnormal;
730   using __gnu_cxx::signbit;
731   using __gnu_cxx::isgreater;
732   using __gnu_cxx::isgreaterequal;
733   using __gnu_cxx::isless;
734   using __gnu_cxx::islessequal;
735   using __gnu_cxx::islessgreater;
736   using __gnu_cxx::isunordered;
737 }
738 #endif /* _GLIBCPP_USE_C99_FP_MACROS_DYNAMIC */
739 #endif
740 
741 #ifdef _GLIBCPP_NO_TEMPLATE_EXPORT
742 #  define export
743 #  include <bits/cmath.tcc>
744 #endif
745 
746 #endif
747