std_cmath.h revision 161653 
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
81namespace 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#if _GLIBCXX_USE_C99_MATH
440#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
441// These are possible macros imported from C99-land. For strict
442// conformance, remove possible C99-injected names from the global
443// namespace, and sequester them in the __gnu_cxx extension namespace.
444namespace __gnu_cxx
445{
446  template<typename _Tp>
447    inline int
448    __capture_fpclassify(_Tp __f) { return fpclassify(__f); }
449
450  template<typename _Tp>
451    inline int
452    __capture_isfinite(_Tp __f) { return isfinite(__f); }
453
454  template<typename _Tp>
455    inline int
456    __capture_isinf(_Tp __f) { return isinf(__f); }
457
458  template<typename _Tp>
459    inline int
460    __capture_isnan(_Tp __f) { return isnan(__f); }
461
462  template<typename _Tp>
463    inline int
464    __capture_isnormal(_Tp __f) { return isnormal(__f); }
465
466  template<typename _Tp>
467    inline int
468    __capture_signbit(_Tp __f) { return signbit(__f); }
469
470  template<typename _Tp>
471    inline int
472    __capture_isgreater(_Tp __f1, _Tp __f2)
473    { return isgreater(__f1, __f2); }
474
475  template<typename _Tp>
476    inline int
477    __capture_isgreaterequal(_Tp __f1, _Tp __f2)
478    { return isgreaterequal(__f1, __f2); }
479
480  template<typename _Tp>
481    inline int
482    __capture_isless(_Tp __f1, _Tp __f2) { return isless(__f1, __f2); }
483
484  template<typename _Tp>
485    inline int
486    __capture_islessequal(_Tp __f1, _Tp __f2)
487    { return islessequal(__f1, __f2); }
488
489  template<typename _Tp>
490    inline int
491    __capture_islessgreater(_Tp __f1, _Tp __f2)
492    { return islessgreater(__f1, __f2); }
493
494  template<typename _Tp>
495    inline int
496    __capture_isunordered(_Tp __f1, _Tp __f2)
497    { return isunordered(__f1, __f2); }
498}
499
500// Only undefine the C99 FP macros, if actually captured for namespace movement
501#undef fpclassify
502#undef isfinite
503#undef isinf
504#undef isnan
505#undef isnormal
506#undef signbit
507#undef isgreater
508#undef isgreaterequal
509#undef isless
510#undef islessequal
511#undef islessgreater
512#undef isunordered
513#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
514#endif
515
516#if _GLIBCXX_USE_C99_MATH
517#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
518namespace __gnu_cxx
519{
520  template<typename _Tp>
521    inline int
522    fpclassify(_Tp __f) { return __capture_fpclassify(__f); }
523
524  template<typename _Tp>
525    inline int
526    isfinite(_Tp __f) { return __capture_isfinite(__f); }
527
528  template<typename _Tp>
529    inline int
530    isinf(_Tp __f) { return __capture_isinf(__f); }
531
532  template<typename _Tp>
533    inline int
534    isnan(_Tp __f) { return __capture_isnan(__f); }
535
536  template<typename _Tp>
537    inline int
538    isnormal(_Tp __f) { return __capture_isnormal(__f); }
539
540  template<typename _Tp>
541    inline int
542    signbit(_Tp __f) { return __capture_signbit(__f); }
543
544  template<typename _Tp>
545    inline int
546    isgreater(_Tp __f1, _Tp __f2) { return __capture_isgreater(__f1, __f2); }
547
548  template<typename _Tp>
549    inline int
550    isgreaterequal(_Tp __f1, _Tp __f2)
551    { return __capture_isgreaterequal(__f1, __f2); }
552
553  template<typename _Tp>
554    inline int
555    isless(_Tp __f1, _Tp __f2) { return __capture_isless(__f1, __f2); }
556
557  template<typename _Tp>
558    inline int
559    islessequal(_Tp __f1, _Tp __f2)
560    { return __capture_islessequal(__f1, __f2); }
561
562  template<typename _Tp>
563    inline int
564    islessgreater(_Tp __f1, _Tp __f2)
565    { return __capture_islessgreater(__f1, __f2); }
566
567  template<typename _Tp>
568    inline int
569    isunordered(_Tp __f1, _Tp __f2)
570    { return __capture_isunordered(__f1, __f2); }
571}
572
573namespace std
574{
575  using __gnu_cxx::fpclassify;
576  using __gnu_cxx::isfinite;
577  using __gnu_cxx::isinf;
578  using __gnu_cxx::isnan;
579  using __gnu_cxx::isnormal;
580  using __gnu_cxx::signbit;
581  using __gnu_cxx::isgreater;
582  using __gnu_cxx::isgreaterequal;
583  using __gnu_cxx::isless;
584  using __gnu_cxx::islessequal;
585  using __gnu_cxx::islessgreater;
586  using __gnu_cxx::isunordered;
587}
588#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
589#endif
590
591#ifndef _GLIBCXX_EXPORT_TEMPLATE
592# include <bits/cmath.tcc>
593#endif
594
595#endif
596