1// -*- C++ -*- C forwarding header.
2
3// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4// 2006, 2007, 2008, 2009, 2010
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 @a *.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#ifndef _GLIBCXX_CMATH
42#define _GLIBCXX_CMATH 1
43
44#pragma GCC system_header
45
46#include <bits/c++config.h>
47#include <bits/cpp_type_traits.h>
48#include <ext/type_traits.h>
49
50#include <math.h>
51
52// Get rid of those macros defined in <math.h> in lieu of real functions.
53#undef abs
54#undef div
55#undef acos
56#undef asin
57#undef atan
58#undef atan2
59#undef ceil
60#undef cos
61#undef cosh
62#undef exp
63#undef fabs
64#undef floor
65#undef fmod
66#undef frexp
67#undef ldexp
68#undef log
69#undef log10
70#undef modf
71#undef pow
72#undef sin
73#undef sinh
74#undef sqrt
75#undef tan
76#undef tanh
77
78namespace std _GLIBCXX_VISIBILITY(default)
79{
80_GLIBCXX_BEGIN_NAMESPACE_VERSION
81
82  inline double
83  abs(double __x)
84  { return __builtin_fabs(__x); }
85
86  inline float
87  abs(float __x)
88  { return __builtin_fabsf(__x); }
89
90  inline long double
91  abs(long double __x)
92  { return __builtin_fabsl(__x); }
93
94  template<typename _Tp>
95    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
96					   double>::__type
97    abs(_Tp __x)
98    { return __builtin_fabs(__x); }
99
100  using ::acos;
101
102  inline float
103  acos(float __x)
104  { return __builtin_acosf(__x); }
105
106  inline long double
107  acos(long double __x)
108  { return __builtin_acosl(__x); }
109
110  template<typename _Tp>
111    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
112					   double>::__type
113    acos(_Tp __x)
114    { return __builtin_acos(__x); }
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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
128					   double>::__type
129    asin(_Tp __x)
130    { return __builtin_asin(__x); }
131
132  using ::atan;
133
134  inline float
135  atan(float __x)
136  { return __builtin_atanf(__x); }
137
138  inline long double
139  atan(long double __x)
140  { return __builtin_atanl(__x); }
141
142  template<typename _Tp>
143    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
144					   double>::__type
145    atan(_Tp __x)
146    { return __builtin_atan(__x); }
147
148  using ::atan2;
149
150  inline float
151  atan2(float __y, float __x)
152  { return __builtin_atan2f(__y, __x); }
153
154  inline long double
155  atan2(long double __y, long double __x)
156  { return __builtin_atan2l(__y, __x); }
157
158  template<typename _Tp, typename _Up>
159    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value
160    					   && __is_integer<_Up>::__value,
161					   double>::__type
162    atan2(_Tp __y, _Up __x)
163    { return __builtin_atan2(__y, __x); }
164
165  using ::ceil;
166
167  inline float
168  ceil(float __x)
169  { return __builtin_ceilf(__x); }
170
171  inline long double
172  ceil(long double __x)
173  { return __builtin_ceill(__x); }
174
175  template<typename _Tp>
176    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
177					   double>::__type
178    ceil(_Tp __x)
179    { return __builtin_ceil(__x); }
180
181  using ::cos;
182
183  inline float
184  cos(float __x)
185  { return __builtin_cosf(__x); }
186
187  inline long double
188  cos(long double __x)
189  { return __builtin_cosl(__x); }
190
191  template<typename _Tp>
192    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
193					   double>::__type
194    cos(_Tp __x)
195    { return __builtin_cos(__x); }
196
197  using ::cosh;
198
199  inline float
200  cosh(float __x)
201  { return __builtin_coshf(__x); }
202
203  inline long double
204  cosh(long double __x)
205  { return __builtin_coshl(__x); }
206
207  template<typename _Tp>
208    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
209					   double>::__type
210    cosh(_Tp __x)
211    { return __builtin_cosh(__x); }
212
213  using ::exp;
214
215  inline float
216  exp(float __x)
217  { return __builtin_expf(__x); }
218
219  inline long double
220  exp(long double __x)
221  { return __builtin_expl(__x); }
222
223  template<typename _Tp>
224    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
225					   double>::__type
226    exp(_Tp __x)
227    { return __builtin_exp(__x); }
228
229  using ::fabs;
230
231  inline float
232  fabs(float __x)
233  { return __builtin_fabsf(__x); }
234
235  inline long double
236  fabs(long double __x)
237  { return __builtin_fabsl(__x); }
238
239  template<typename _Tp>
240    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
241					   double>::__type
242    fabs(_Tp __x)
243    { return __builtin_fabs(__x); }
244
245  using ::floor;
246
247  inline float
248  floor(float __x)
249  { return __builtin_floorf(__x); }
250
251  inline long double
252  floor(long double __x)
253  { return __builtin_floorl(__x); }
254
255  template<typename _Tp>
256    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
257					   double>::__type
258    floor(_Tp __x)
259    { return __builtin_floor(__x); }
260
261  using ::fmod;
262
263  inline float
264  fmod(float __x, float __y)
265  { return __builtin_fmodf(__x, __y); }
266
267  inline long double
268  fmod(long double __x, long double __y)
269  { return __builtin_fmodl(__x, __y); }
270
271  template<typename _Tp, typename _Up>
272    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value
273    					   && __is_integer<_Up>::__value,
274					   double>::__type
275    fmod(_Tp __x, _Up __y)
276    { return __builtin_fmod(__x, __y); }
277
278  using ::frexp;
279
280  inline float
281  frexp(float __x, int* __exp)
282  { return __builtin_frexpf(__x, __exp); }
283
284  inline long double
285  frexp(long double __x, int* __exp)
286  { return __builtin_frexpl(__x, __exp); }
287
288  template<typename _Tp>
289    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
290					   double>::__type
291    frexp(_Tp __x, int* __exp)
292    { return __builtin_frexp(__x, __exp); }
293
294  using ::ldexp;
295
296  inline float
297  ldexp(float __x, int __exp)
298  { return __builtin_ldexpf(__x, __exp); }
299
300  inline long double
301  ldexp(long double __x, int __exp)
302  { return __builtin_ldexpl(__x, __exp); }
303
304  template<typename _Tp>
305    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
306					   double>::__type
307    ldexp(_Tp __x, int __exp)
308    { return __builtin_ldexp(__x, __exp); }
309
310  using ::log;
311
312  inline float
313  log(float __x)
314  { return __builtin_logf(__x); }
315
316  inline long double
317  log(long double __x)
318  { return __builtin_logl(__x); }
319
320  template<typename _Tp>
321    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
322					   double>::__type
323    log(_Tp __x)
324    { return __builtin_log(__x); }
325
326  using ::log10;
327
328  inline float
329  log10(float __x)
330  { return __builtin_log10f(__x); }
331
332  inline long double
333  log10(long double __x)
334  { return __builtin_log10l(__x); }
335
336  template<typename _Tp>
337    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
338					   double>::__type
339    log10(_Tp __x)
340    { return __builtin_log10(__x); }
341
342  using ::modf;
343
344  inline float
345  modf(float __x, float* __iptr)
346  { return __builtin_modff(__x, __iptr); }
347
348  inline long double
349  modf(long double __x, long double* __iptr)
350  { return __builtin_modfl(__x, __iptr); }
351
352  using ::pow;
353
354  inline float
355  pow(float __x, float __y)
356  { return __builtin_powf(__x, __y); }
357
358  inline long double
359  pow(long double __x, long double __y)
360  { return __builtin_powl(__x, __y); }
361
362  inline double
363  pow(double __x, int __i)
364  { return __builtin_powi(__x, __i); }
365
366  inline float
367  pow(float __x, int __n)
368  { return __builtin_powif(__x, __n); }
369
370  inline long double
371  pow(long double __x, int __n)
372  { return __builtin_powil(__x, __n); }
373
374  using ::sin;
375
376  inline float
377  sin(float __x)
378  { return __builtin_sinf(__x); }
379
380  inline long double
381  sin(long double __x)
382  { return __builtin_sinl(__x); }
383
384  template<typename _Tp>
385    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
386					   double>::__type
387    sin(_Tp __x)
388    { return __builtin_sin(__x); }
389
390  using ::sinh;
391
392  inline float
393  sinh(float __x)
394  { return __builtin_sinhf(__x); }
395
396  inline long double
397  sinh(long double __x)
398  { return __builtin_sinhl(__x); }
399
400  template<typename _Tp>
401    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
402					   double>::__type
403    sinh(_Tp __x)
404    { return __builtin_sinh(__x); }
405
406  using ::sqrt;
407
408  inline float
409  sqrt(float __x)
410  { return __builtin_sqrtf(__x); }
411
412  inline long double
413  sqrt(long double __x)
414  { return __builtin_sqrtl(__x); }
415
416  template<typename _Tp>
417    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
418					   double>::__type
419    sqrt(_Tp __x)
420    { return __builtin_sqrt(__x); }
421
422  using ::tan;
423
424  inline float
425  tan(float __x)
426  { return __builtin_tanf(__x); }
427
428  inline long double
429  tan(long double __x)
430  { return __builtin_tanl(__x); }
431
432  template<typename _Tp>
433    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
434					   double>::__type
435    tan(_Tp __x)
436    { return __builtin_tan(__x); }
437
438  using ::tanh;
439
440  inline float
441  tanh(float __x)
442  { return __builtin_tanhf(__x); }
443
444  inline long double
445  tanh(long double __x)
446  { return __builtin_tanhl(__x); }
447
448  template<typename _Tp>
449    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
450					   double>::__type
451    tanh(_Tp __x)
452    { return __builtin_tanh(__x); }
453
454_GLIBCXX_END_NAMESPACE_VERSION
455} // namespace
456
457#if _GLIBCXX_USE_C99_MATH
458#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
459
460// These are possible macros imported from C99-land.
461#undef fpclassify
462#undef isfinite
463#undef isinf
464#undef isnan
465#undef isnormal
466#undef signbit
467#undef isgreater
468#undef isgreaterequal
469#undef isless
470#undef islessequal
471#undef islessgreater
472#undef isunordered
473
474namespace std _GLIBCXX_VISIBILITY(default)
475{
476_GLIBCXX_BEGIN_NAMESPACE_VERSION
477
478  template<typename _Tp>
479    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
480					   int>::__type
481    fpclassify(_Tp __f)
482    {
483      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
484      return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
485				  FP_SUBNORMAL, FP_ZERO, __type(__f));
486    }
487
488  template<typename _Tp>
489    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
490					   int>::__type
491    isfinite(_Tp __f)
492    {
493      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
494      return __builtin_isfinite(__type(__f));
495    }
496
497  template<typename _Tp>
498    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
499					   int>::__type
500    isinf(_Tp __f)
501    {
502      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
503      return __builtin_isinf(__type(__f));
504    }
505
506  template<typename _Tp>
507    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
508					   int>::__type
509    isnan(_Tp __f)
510    {
511      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
512      return __builtin_isnan(__type(__f));
513    }
514
515  template<typename _Tp>
516    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
517					   int>::__type
518    isnormal(_Tp __f)
519    {
520      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
521      return __builtin_isnormal(__type(__f));
522    }
523
524  template<typename _Tp>
525    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
526					   int>::__type
527    signbit(_Tp __f)
528    {
529      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
530      return __builtin_signbit(__type(__f));
531    }
532
533  template<typename _Tp>
534    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
535					   int>::__type
536    isgreater(_Tp __f1, _Tp __f2)
537    {
538      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
539      return __builtin_isgreater(__type(__f1), __type(__f2));
540    }
541
542  template<typename _Tp>
543    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
544					   int>::__type
545    isgreaterequal(_Tp __f1, _Tp __f2)
546    {
547      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
548      return __builtin_isgreaterequal(__type(__f1), __type(__f2));
549    }
550
551  template<typename _Tp>
552    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
553					   int>::__type
554    isless(_Tp __f1, _Tp __f2)
555    {
556      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
557      return __builtin_isless(__type(__f1), __type(__f2));
558    }
559
560  template<typename _Tp>
561    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
562					   int>::__type
563    islessequal(_Tp __f1, _Tp __f2)
564    {
565      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
566      return __builtin_islessequal(__type(__f1), __type(__f2));
567    }
568
569  template<typename _Tp>
570    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
571					   int>::__type
572    islessgreater(_Tp __f1, _Tp __f2)
573    {
574      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
575      return __builtin_islessgreater(__type(__f1), __type(__f2));
576    }
577
578  template<typename _Tp>
579    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
580					   int>::__type
581    isunordered(_Tp __f1, _Tp __f2)
582    {
583      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
584      return __builtin_isunordered(__type(__f1), __type(__f2));
585    }
586
587_GLIBCXX_END_NAMESPACE_VERSION
588} // namespace std
589
590#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
591#endif
592
593#endif
594