1 | // -*- C++ -*- C forwarding header. |
2 | |
3 | // Copyright (C) 1997-2016 Free Software Foundation, Inc. |
4 | // |
5 | // This file is part of the GNU ISO C++ Library. This library is free |
6 | // software; you can redistribute it and/or modify it under the |
7 | // terms of the GNU General Public License as published by the |
8 | // Free Software Foundation; either version 3, or (at your option) |
9 | // any later version. |
10 | |
11 | // This library is distributed in the hope that it will be useful, |
12 | // but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
14 | // GNU General Public License for more details. |
15 | |
16 | // Under Section 7 of GPL version 3, you are granted additional |
17 | // permissions described in the GCC Runtime Library Exception, version |
18 | // 3.1, as published by the Free Software Foundation. |
19 | |
20 | // You should have received a copy of the GNU General Public License and |
21 | // a copy of the GCC Runtime Library Exception along with this program; |
22 | // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
23 | // <http://www.gnu.org/licenses/>. |
24 | |
25 | /** @file include/cmath |
26 | * This is a Standard C++ Library file. You should @c \#include this file |
27 | * in your programs, rather than any of the @a *.h implementation files. |
28 | * |
29 | * This is the C++ version of the Standard C Library header @c math.h, |
30 | * and its contents are (mostly) the same as that header, but are all |
31 | * contained in the namespace @c std (except for names which are defined |
32 | * as macros in C). |
33 | */ |
34 | |
35 | // |
36 | // ISO C++ 14882: 26.5 C library |
37 | // |
38 | |
39 | #pragma GCC system_header |
40 | |
41 | #include <bits/c++config.h> |
42 | #include <bits/cpp_type_traits.h> |
43 | #include <ext/type_traits.h> |
44 | #define |
45 | #include_next <math.h> |
46 | #undef _GLIBCXX_INCLUDE_NEXT_C_HEADERS |
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 | extern "C++" |
78 | { |
79 | namespace std _GLIBCXX_VISIBILITY(default) |
80 | { |
81 | _GLIBCXX_BEGIN_NAMESPACE_VERSION |
82 | |
83 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
84 | inline _GLIBCXX_CONSTEXPR double |
85 | abs(double __x) |
86 | { return __builtin_fabs(__x); } |
87 | #endif |
88 | |
89 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
90 | inline _GLIBCXX_CONSTEXPR float |
91 | abs(float __x) |
92 | { return __builtin_fabsf(__x); } |
93 | |
94 | inline _GLIBCXX_CONSTEXPR long double |
95 | abs(long double __x) |
96 | { return __builtin_fabsl(__x); } |
97 | #endif |
98 | |
99 | template<typename _Tp> |
100 | inline _GLIBCXX_CONSTEXPR |
101 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
102 | double>::__type |
103 | abs(_Tp __x) |
104 | { return __builtin_fabs(__x); } |
105 | |
106 | using ::acos; |
107 | |
108 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
109 | inline _GLIBCXX_CONSTEXPR float |
110 | acos(float __x) |
111 | { return __builtin_acosf(__x); } |
112 | |
113 | inline _GLIBCXX_CONSTEXPR long double |
114 | acos(long double __x) |
115 | { return __builtin_acosl(__x); } |
116 | #endif |
117 | |
118 | template<typename _Tp> |
119 | inline _GLIBCXX_CONSTEXPR |
120 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
121 | double>::__type |
122 | acos(_Tp __x) |
123 | { return __builtin_acos(__x); } |
124 | |
125 | using ::asin; |
126 | |
127 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
128 | inline _GLIBCXX_CONSTEXPR float |
129 | asin(float __x) |
130 | { return __builtin_asinf(__x); } |
131 | |
132 | inline _GLIBCXX_CONSTEXPR long double |
133 | asin(long double __x) |
134 | { return __builtin_asinl(__x); } |
135 | #endif |
136 | |
137 | template<typename _Tp> |
138 | inline _GLIBCXX_CONSTEXPR |
139 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
140 | double>::__type |
141 | asin(_Tp __x) |
142 | { return __builtin_asin(__x); } |
143 | |
144 | using ::atan; |
145 | |
146 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
147 | inline _GLIBCXX_CONSTEXPR float |
148 | atan(float __x) |
149 | { return __builtin_atanf(__x); } |
150 | |
151 | inline _GLIBCXX_CONSTEXPR long double |
152 | atan(long double __x) |
153 | { return __builtin_atanl(__x); } |
154 | #endif |
155 | |
156 | template<typename _Tp> |
157 | inline _GLIBCXX_CONSTEXPR |
158 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
159 | double>::__type |
160 | atan(_Tp __x) |
161 | { return __builtin_atan(__x); } |
162 | |
163 | using ::atan2; |
164 | |
165 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
166 | inline _GLIBCXX_CONSTEXPR float |
167 | atan2(float __y, float __x) |
168 | { return __builtin_atan2f(__y, __x); } |
169 | |
170 | inline _GLIBCXX_CONSTEXPR long double |
171 | atan2(long double __y, long double __x) |
172 | { return __builtin_atan2l(__y, __x); } |
173 | #endif |
174 | |
175 | template<typename _Tp, typename _Up> |
176 | inline _GLIBCXX_CONSTEXPR |
177 | typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
178 | atan2(_Tp __y, _Up __x) |
179 | { |
180 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
181 | return atan2(__type(__y), __type(__x)); |
182 | } |
183 | |
184 | using ::ceil; |
185 | |
186 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
187 | inline _GLIBCXX_CONSTEXPR float |
188 | ceil(float __x) |
189 | { return __builtin_ceilf(__x); } |
190 | |
191 | inline _GLIBCXX_CONSTEXPR long double |
192 | ceil(long double __x) |
193 | { return __builtin_ceill(__x); } |
194 | #endif |
195 | |
196 | template<typename _Tp> |
197 | inline _GLIBCXX_CONSTEXPR |
198 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
199 | double>::__type |
200 | ceil(_Tp __x) |
201 | { return __builtin_ceil(__x); } |
202 | |
203 | using ::cos; |
204 | |
205 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
206 | inline _GLIBCXX_CONSTEXPR float |
207 | cos(float __x) |
208 | { return __builtin_cosf(__x); } |
209 | |
210 | inline _GLIBCXX_CONSTEXPR long double |
211 | cos(long double __x) |
212 | { return __builtin_cosl(__x); } |
213 | #endif |
214 | |
215 | template<typename _Tp> |
216 | inline _GLIBCXX_CONSTEXPR |
217 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
218 | double>::__type |
219 | cos(_Tp __x) |
220 | { return __builtin_cos(__x); } |
221 | |
222 | using ::cosh; |
223 | |
224 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
225 | inline _GLIBCXX_CONSTEXPR float |
226 | cosh(float __x) |
227 | { return __builtin_coshf(__x); } |
228 | |
229 | inline _GLIBCXX_CONSTEXPR long double |
230 | cosh(long double __x) |
231 | { return __builtin_coshl(__x); } |
232 | #endif |
233 | |
234 | template<typename _Tp> |
235 | inline _GLIBCXX_CONSTEXPR |
236 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
237 | double>::__type |
238 | cosh(_Tp __x) |
239 | { return __builtin_cosh(__x); } |
240 | |
241 | using ::exp; |
242 | |
243 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
244 | inline _GLIBCXX_CONSTEXPR float |
245 | exp(float __x) |
246 | { return __builtin_expf(__x); } |
247 | |
248 | inline _GLIBCXX_CONSTEXPR long double |
249 | exp(long double __x) |
250 | { return __builtin_expl(__x); } |
251 | #endif |
252 | |
253 | template<typename _Tp> |
254 | inline _GLIBCXX_CONSTEXPR |
255 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
256 | double>::__type |
257 | exp(_Tp __x) |
258 | { return __builtin_exp(__x); } |
259 | |
260 | using ::fabs; |
261 | |
262 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
263 | inline _GLIBCXX_CONSTEXPR float |
264 | fabs(float __x) |
265 | { return __builtin_fabsf(__x); } |
266 | |
267 | inline _GLIBCXX_CONSTEXPR long double |
268 | fabs(long double __x) |
269 | { return __builtin_fabsl(__x); } |
270 | #endif |
271 | |
272 | template<typename _Tp> |
273 | inline _GLIBCXX_CONSTEXPR |
274 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
275 | double>::__type |
276 | fabs(_Tp __x) |
277 | { return __builtin_fabs(__x); } |
278 | |
279 | using ::floor; |
280 | |
281 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
282 | inline _GLIBCXX_CONSTEXPR float |
283 | floor(float __x) |
284 | { return __builtin_floorf(__x); } |
285 | |
286 | inline _GLIBCXX_CONSTEXPR long double |
287 | floor(long double __x) |
288 | { return __builtin_floorl(__x); } |
289 | #endif |
290 | |
291 | template<typename _Tp> |
292 | inline _GLIBCXX_CONSTEXPR |
293 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
294 | double>::__type |
295 | floor(_Tp __x) |
296 | { return __builtin_floor(__x); } |
297 | |
298 | using ::fmod; |
299 | |
300 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
301 | inline _GLIBCXX_CONSTEXPR float |
302 | fmod(float __x, float __y) |
303 | { return __builtin_fmodf(__x, __y); } |
304 | |
305 | inline _GLIBCXX_CONSTEXPR long double |
306 | fmod(long double __x, long double __y) |
307 | { return __builtin_fmodl(__x, __y); } |
308 | #endif |
309 | |
310 | template<typename _Tp, typename _Up> |
311 | inline _GLIBCXX_CONSTEXPR |
312 | typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
313 | fmod(_Tp __x, _Up __y) |
314 | { |
315 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
316 | return fmod(__type(__x), __type(__y)); |
317 | } |
318 | |
319 | using ::frexp; |
320 | |
321 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
322 | inline float |
323 | frexp(float __x, int* __exp) |
324 | { return __builtin_frexpf(__x, __exp); } |
325 | |
326 | inline long double |
327 | frexp(long double __x, int* __exp) |
328 | { return __builtin_frexpl(__x, __exp); } |
329 | #endif |
330 | |
331 | template<typename _Tp> |
332 | inline _GLIBCXX_CONSTEXPR |
333 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
334 | double>::__type |
335 | frexp(_Tp __x, int* __exp) |
336 | { return __builtin_frexp(__x, __exp); } |
337 | |
338 | using ::ldexp; |
339 | |
340 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
341 | inline _GLIBCXX_CONSTEXPR float |
342 | ldexp(float __x, int __exp) |
343 | { return __builtin_ldexpf(__x, __exp); } |
344 | |
345 | inline _GLIBCXX_CONSTEXPR long double |
346 | ldexp(long double __x, int __exp) |
347 | { return __builtin_ldexpl(__x, __exp); } |
348 | #endif |
349 | |
350 | template<typename _Tp> |
351 | inline _GLIBCXX_CONSTEXPR |
352 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
353 | double>::__type |
354 | ldexp(_Tp __x, int __exp) |
355 | { return __builtin_ldexp(__x, __exp); } |
356 | |
357 | using ::log; |
358 | |
359 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
360 | inline _GLIBCXX_CONSTEXPR float |
361 | log(float __x) |
362 | { return __builtin_logf(__x); } |
363 | |
364 | inline _GLIBCXX_CONSTEXPR long double |
365 | log(long double __x) |
366 | { return __builtin_logl(__x); } |
367 | #endif |
368 | |
369 | template<typename _Tp> |
370 | inline _GLIBCXX_CONSTEXPR |
371 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
372 | double>::__type |
373 | log(_Tp __x) |
374 | { return __builtin_log(__x); } |
375 | |
376 | using ::log10; |
377 | |
378 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
379 | inline _GLIBCXX_CONSTEXPR float |
380 | log10(float __x) |
381 | { return __builtin_log10f(__x); } |
382 | |
383 | inline _GLIBCXX_CONSTEXPR long double |
384 | log10(long double __x) |
385 | { return __builtin_log10l(__x); } |
386 | #endif |
387 | |
388 | template<typename _Tp> |
389 | inline _GLIBCXX_CONSTEXPR |
390 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
391 | double>::__type |
392 | log10(_Tp __x) |
393 | { return __builtin_log10(__x); } |
394 | |
395 | using ::modf; |
396 | |
397 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
398 | inline float |
399 | modf(float __x, float* __iptr) |
400 | { return __builtin_modff(__x, __iptr); } |
401 | |
402 | inline long double |
403 | modf(long double __x, long double* __iptr) |
404 | { return __builtin_modfl(__x, __iptr); } |
405 | #endif |
406 | |
407 | using ::pow; |
408 | |
409 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
410 | inline _GLIBCXX_CONSTEXPR float |
411 | pow(float __x, float __y) |
412 | { return __builtin_powf(__x, __y); } |
413 | |
414 | inline _GLIBCXX_CONSTEXPR long double |
415 | pow(long double __x, long double __y) |
416 | { return __builtin_powl(__x, __y); } |
417 | |
418 | #if __cplusplus < 201103L |
419 | // _GLIBCXX_RESOLVE_LIB_DEFECTS |
420 | // DR 550. What should the return type of pow(float,int) be? |
421 | inline double |
422 | pow(double __x, int __i) |
423 | { return __builtin_powi(__x, __i); } |
424 | |
425 | inline float |
426 | pow(float __x, int __n) |
427 | { return __builtin_powif(__x, __n); } |
428 | |
429 | inline long double |
430 | pow(long double __x, int __n) |
431 | { return __builtin_powil(__x, __n); } |
432 | #endif |
433 | #endif |
434 | |
435 | template<typename _Tp, typename _Up> |
436 | inline _GLIBCXX_CONSTEXPR |
437 | typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
438 | pow(_Tp __x, _Up __y) |
439 | { |
440 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
441 | return pow(__type(__x), __type(__y)); |
442 | } |
443 | |
444 | using ::sin; |
445 | |
446 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
447 | inline _GLIBCXX_CONSTEXPR float |
448 | sin(float __x) |
449 | { return __builtin_sinf(__x); } |
450 | |
451 | inline _GLIBCXX_CONSTEXPR long double |
452 | sin(long double __x) |
453 | { return __builtin_sinl(__x); } |
454 | #endif |
455 | |
456 | template<typename _Tp> |
457 | inline _GLIBCXX_CONSTEXPR |
458 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
459 | double>::__type |
460 | sin(_Tp __x) |
461 | { return __builtin_sin(__x); } |
462 | |
463 | using ::sinh; |
464 | |
465 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
466 | inline _GLIBCXX_CONSTEXPR float |
467 | sinh(float __x) |
468 | { return __builtin_sinhf(__x); } |
469 | |
470 | inline _GLIBCXX_CONSTEXPR long double |
471 | sinh(long double __x) |
472 | { return __builtin_sinhl(__x); } |
473 | #endif |
474 | |
475 | template<typename _Tp> |
476 | inline _GLIBCXX_CONSTEXPR |
477 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
478 | double>::__type |
479 | sinh(_Tp __x) |
480 | { return __builtin_sinh(__x); } |
481 | |
482 | using ::sqrt; |
483 | |
484 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
485 | inline _GLIBCXX_CONSTEXPR float |
486 | sqrt(float __x) |
487 | { return __builtin_sqrtf(__x); } |
488 | |
489 | inline _GLIBCXX_CONSTEXPR long double |
490 | sqrt(long double __x) |
491 | { return __builtin_sqrtl(__x); } |
492 | #endif |
493 | |
494 | template<typename _Tp> |
495 | inline _GLIBCXX_CONSTEXPR |
496 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
497 | double>::__type |
498 | sqrt(_Tp __x) |
499 | { return __builtin_sqrt(__x); } |
500 | |
501 | using ::tan; |
502 | |
503 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
504 | inline _GLIBCXX_CONSTEXPR float |
505 | tan(float __x) |
506 | { return __builtin_tanf(__x); } |
507 | |
508 | inline _GLIBCXX_CONSTEXPR long double |
509 | tan(long double __x) |
510 | { return __builtin_tanl(__x); } |
511 | #endif |
512 | |
513 | template<typename _Tp> |
514 | inline _GLIBCXX_CONSTEXPR |
515 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
516 | double>::__type |
517 | tan(_Tp __x) |
518 | { return __builtin_tan(__x); } |
519 | |
520 | using ::tanh; |
521 | |
522 | #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
523 | inline _GLIBCXX_CONSTEXPR float |
524 | tanh(float __x) |
525 | { return __builtin_tanhf(__x); } |
526 | |
527 | inline _GLIBCXX_CONSTEXPR long double |
528 | tanh(long double __x) |
529 | { return __builtin_tanhl(__x); } |
530 | #endif |
531 | |
532 | template<typename _Tp> |
533 | inline _GLIBCXX_CONSTEXPR |
534 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
535 | double>::__type |
536 | tanh(_Tp __x) |
537 | { return __builtin_tanh(__x); } |
538 | |
539 | _GLIBCXX_END_NAMESPACE_VERSION |
540 | } // namespace |
541 | |
542 | #if _GLIBCXX_USE_C99_MATH |
543 | #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC |
544 | |
545 | // These are possible macros imported from C99-land. |
546 | #undef fpclassify |
547 | #undef isfinite |
548 | #undef isinf |
549 | #undef isnan |
550 | #undef isnormal |
551 | #undef signbit |
552 | #undef isgreater |
553 | #undef isgreaterequal |
554 | #undef isless |
555 | #undef islessequal |
556 | #undef islessgreater |
557 | #undef isunordered |
558 | |
559 | namespace std _GLIBCXX_VISIBILITY(default) |
560 | { |
561 | _GLIBCXX_BEGIN_NAMESPACE_VERSION |
562 | |
563 | #if __cplusplus >= 201103L |
564 | |
565 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
566 | constexpr int |
567 | fpclassify(float __x) |
568 | { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, |
569 | FP_SUBNORMAL, FP_ZERO, __x); } |
570 | |
571 | constexpr int |
572 | fpclassify(double __x) |
573 | { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, |
574 | FP_SUBNORMAL, FP_ZERO, __x); } |
575 | |
576 | constexpr int |
577 | fpclassify(long double __x) |
578 | { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, |
579 | FP_SUBNORMAL, FP_ZERO, __x); } |
580 | #endif |
581 | |
582 | template<typename _Tp> |
583 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
584 | int>::__type |
585 | fpclassify(_Tp __x) |
586 | { return __x != 0 ? FP_NORMAL : FP_ZERO; } |
587 | |
588 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
589 | constexpr bool |
590 | isfinite(float __x) |
591 | { return __builtin_isfinite(__x); } |
592 | |
593 | constexpr bool |
594 | isfinite(double __x) |
595 | { return __builtin_isfinite(__x); } |
596 | |
597 | constexpr bool |
598 | isfinite(long double __x) |
599 | { return __builtin_isfinite(__x); } |
600 | #endif |
601 | |
602 | template<typename _Tp> |
603 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
604 | bool>::__type |
605 | isfinite(_Tp __x) |
606 | { return true; } |
607 | |
608 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
609 | constexpr bool |
610 | isinf(float __x) |
611 | { return __builtin_isinf(__x); } |
612 | |
613 | #if _GLIBCXX_HAVE_OBSOLETE_ISINF \ |
614 | && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC |
615 | using ::isinf; |
616 | #else |
617 | constexpr bool |
618 | isinf(double __x) |
619 | { return __builtin_isinf(__x); } |
620 | #endif |
621 | |
622 | constexpr bool |
623 | isinf(long double __x) |
624 | { return __builtin_isinf(__x); } |
625 | #endif |
626 | |
627 | template<typename _Tp> |
628 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
629 | bool>::__type |
630 | isinf(_Tp __x) |
631 | { return false; } |
632 | |
633 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
634 | constexpr bool |
635 | isnan(float __x) |
636 | { return __builtin_isnan(__x); } |
637 | |
638 | #if _GLIBCXX_HAVE_OBSOLETE_ISNAN \ |
639 | && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC |
640 | using ::isnan; |
641 | #else |
642 | constexpr bool |
643 | isnan(double __x) |
644 | { return __builtin_isnan(__x); } |
645 | #endif |
646 | |
647 | constexpr bool |
648 | isnan(long double __x) |
649 | { return __builtin_isnan(__x); } |
650 | #endif |
651 | |
652 | template<typename _Tp> |
653 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
654 | bool>::__type |
655 | isnan(_Tp __x) |
656 | { return false; } |
657 | |
658 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
659 | constexpr bool |
660 | isnormal(float __x) |
661 | { return __builtin_isnormal(__x); } |
662 | |
663 | constexpr bool |
664 | isnormal(double __x) |
665 | { return __builtin_isnormal(__x); } |
666 | |
667 | constexpr bool |
668 | isnormal(long double __x) |
669 | { return __builtin_isnormal(__x); } |
670 | #endif |
671 | |
672 | template<typename _Tp> |
673 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
674 | bool>::__type |
675 | isnormal(_Tp __x) |
676 | { return __x != 0 ? true : false; } |
677 | |
678 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
679 | // Note: middle-end/36757 is fixed, __builtin_signbit is type-generic. |
680 | constexpr bool |
681 | signbit(float __x) |
682 | { return __builtin_signbit(__x); } |
683 | |
684 | constexpr bool |
685 | signbit(double __x) |
686 | { return __builtin_signbit(__x); } |
687 | |
688 | constexpr bool |
689 | signbit(long double __x) |
690 | { return __builtin_signbit(__x); } |
691 | #endif |
692 | |
693 | template<typename _Tp> |
694 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
695 | bool>::__type |
696 | signbit(_Tp __x) |
697 | { return __x < 0 ? true : false; } |
698 | |
699 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
700 | constexpr bool |
701 | isgreater(float __x, float __y) |
702 | { return __builtin_isgreater(__x, __y); } |
703 | |
704 | constexpr bool |
705 | isgreater(double __x, double __y) |
706 | { return __builtin_isgreater(__x, __y); } |
707 | |
708 | constexpr bool |
709 | isgreater(long double __x, long double __y) |
710 | { return __builtin_isgreater(__x, __y); } |
711 | #endif |
712 | |
713 | template<typename _Tp, typename _Up> |
714 | constexpr typename |
715 | __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value |
716 | && __is_arithmetic<_Up>::__value), bool>::__type |
717 | isgreater(_Tp __x, _Up __y) |
718 | { |
719 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
720 | return __builtin_isgreater(__type(__x), __type(__y)); |
721 | } |
722 | |
723 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
724 | constexpr bool |
725 | isgreaterequal(float __x, float __y) |
726 | { return __builtin_isgreaterequal(__x, __y); } |
727 | |
728 | constexpr bool |
729 | isgreaterequal(double __x, double __y) |
730 | { return __builtin_isgreaterequal(__x, __y); } |
731 | |
732 | constexpr bool |
733 | isgreaterequal(long double __x, long double __y) |
734 | { return __builtin_isgreaterequal(__x, __y); } |
735 | #endif |
736 | |
737 | template<typename _Tp, typename _Up> |
738 | constexpr typename |
739 | __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value |
740 | && __is_arithmetic<_Up>::__value), bool>::__type |
741 | isgreaterequal(_Tp __x, _Up __y) |
742 | { |
743 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
744 | return __builtin_isgreaterequal(__type(__x), __type(__y)); |
745 | } |
746 | |
747 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
748 | constexpr bool |
749 | isless(float __x, float __y) |
750 | { return __builtin_isless(__x, __y); } |
751 | |
752 | constexpr bool |
753 | isless(double __x, double __y) |
754 | { return __builtin_isless(__x, __y); } |
755 | |
756 | constexpr bool |
757 | isless(long double __x, long double __y) |
758 | { return __builtin_isless(__x, __y); } |
759 | #endif |
760 | |
761 | template<typename _Tp, typename _Up> |
762 | constexpr typename |
763 | __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value |
764 | && __is_arithmetic<_Up>::__value), bool>::__type |
765 | isless(_Tp __x, _Up __y) |
766 | { |
767 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
768 | return __builtin_isless(__type(__x), __type(__y)); |
769 | } |
770 | |
771 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
772 | constexpr bool |
773 | islessequal(float __x, float __y) |
774 | { return __builtin_islessequal(__x, __y); } |
775 | |
776 | constexpr bool |
777 | islessequal(double __x, double __y) |
778 | { return __builtin_islessequal(__x, __y); } |
779 | |
780 | constexpr bool |
781 | islessequal(long double __x, long double __y) |
782 | { return __builtin_islessequal(__x, __y); } |
783 | #endif |
784 | |
785 | template<typename _Tp, typename _Up> |
786 | constexpr typename |
787 | __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value |
788 | && __is_arithmetic<_Up>::__value), bool>::__type |
789 | islessequal(_Tp __x, _Up __y) |
790 | { |
791 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
792 | return __builtin_islessequal(__type(__x), __type(__y)); |
793 | } |
794 | |
795 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
796 | constexpr bool |
797 | islessgreater(float __x, float __y) |
798 | { return __builtin_islessgreater(__x, __y); } |
799 | |
800 | constexpr bool |
801 | islessgreater(double __x, double __y) |
802 | { return __builtin_islessgreater(__x, __y); } |
803 | |
804 | constexpr bool |
805 | islessgreater(long double __x, long double __y) |
806 | { return __builtin_islessgreater(__x, __y); } |
807 | #endif |
808 | |
809 | template<typename _Tp, typename _Up> |
810 | constexpr typename |
811 | __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value |
812 | && __is_arithmetic<_Up>::__value), bool>::__type |
813 | islessgreater(_Tp __x, _Up __y) |
814 | { |
815 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
816 | return __builtin_islessgreater(__type(__x), __type(__y)); |
817 | } |
818 | |
819 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
820 | constexpr bool |
821 | isunordered(float __x, float __y) |
822 | { return __builtin_isunordered(__x, __y); } |
823 | |
824 | constexpr bool |
825 | isunordered(double __x, double __y) |
826 | { return __builtin_isunordered(__x, __y); } |
827 | |
828 | constexpr bool |
829 | isunordered(long double __x, long double __y) |
830 | { return __builtin_isunordered(__x, __y); } |
831 | #endif |
832 | |
833 | template<typename _Tp, typename _Up> |
834 | constexpr typename |
835 | __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value |
836 | && __is_arithmetic<_Up>::__value), bool>::__type |
837 | isunordered(_Tp __x, _Up __y) |
838 | { |
839 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
840 | return __builtin_isunordered(__type(__x), __type(__y)); |
841 | } |
842 | |
843 | #else |
844 | |
845 | template<typename _Tp> |
846 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
847 | int>::__type |
848 | fpclassify(_Tp __f) |
849 | { |
850 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
851 | return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, |
852 | FP_SUBNORMAL, FP_ZERO, __type(__f)); |
853 | } |
854 | |
855 | template<typename _Tp> |
856 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
857 | int>::__type |
858 | isfinite(_Tp __f) |
859 | { |
860 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
861 | return __builtin_isfinite(__type(__f)); |
862 | } |
863 | |
864 | template<typename _Tp> |
865 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
866 | int>::__type |
867 | isinf(_Tp __f) |
868 | { |
869 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
870 | return __builtin_isinf(__type(__f)); |
871 | } |
872 | |
873 | template<typename _Tp> |
874 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
875 | int>::__type |
876 | isnan(_Tp __f) |
877 | { |
878 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
879 | return __builtin_isnan(__type(__f)); |
880 | } |
881 | |
882 | template<typename _Tp> |
883 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
884 | int>::__type |
885 | isnormal(_Tp __f) |
886 | { |
887 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
888 | return __builtin_isnormal(__type(__f)); |
889 | } |
890 | |
891 | template<typename _Tp> |
892 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
893 | int>::__type |
894 | signbit(_Tp __f) |
895 | { |
896 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
897 | return __builtin_signbit(__type(__f)); |
898 | } |
899 | |
900 | template<typename _Tp> |
901 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
902 | int>::__type |
903 | isgreater(_Tp __f1, _Tp __f2) |
904 | { |
905 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
906 | return __builtin_isgreater(__type(__f1), __type(__f2)); |
907 | } |
908 | |
909 | template<typename _Tp> |
910 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
911 | int>::__type |
912 | isgreaterequal(_Tp __f1, _Tp __f2) |
913 | { |
914 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
915 | return __builtin_isgreaterequal(__type(__f1), __type(__f2)); |
916 | } |
917 | |
918 | template<typename _Tp> |
919 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
920 | int>::__type |
921 | isless(_Tp __f1, _Tp __f2) |
922 | { |
923 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
924 | return __builtin_isless(__type(__f1), __type(__f2)); |
925 | } |
926 | |
927 | template<typename _Tp> |
928 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
929 | int>::__type |
930 | islessequal(_Tp __f1, _Tp __f2) |
931 | { |
932 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
933 | return __builtin_islessequal(__type(__f1), __type(__f2)); |
934 | } |
935 | |
936 | template<typename _Tp> |
937 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
938 | int>::__type |
939 | islessgreater(_Tp __f1, _Tp __f2) |
940 | { |
941 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
942 | return __builtin_islessgreater(__type(__f1), __type(__f2)); |
943 | } |
944 | |
945 | template<typename _Tp> |
946 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
947 | int>::__type |
948 | isunordered(_Tp __f1, _Tp __f2) |
949 | { |
950 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
951 | return __builtin_isunordered(__type(__f1), __type(__f2)); |
952 | } |
953 | |
954 | #endif |
955 | |
956 | _GLIBCXX_END_NAMESPACE_VERSION |
957 | } // namespace |
958 | |
959 | #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */ |
960 | #endif |
961 | |
962 | #if __cplusplus >= 201103L |
963 | |
964 | #ifdef _GLIBCXX_USE_C99_MATH_TR1 |
965 | |
966 | #undef acosh |
967 | #undef acoshf |
968 | #undef acoshl |
969 | #undef asinh |
970 | #undef asinhf |
971 | #undef asinhl |
972 | #undef atanh |
973 | #undef atanhf |
974 | #undef atanhl |
975 | #undef cbrt |
976 | #undef cbrtf |
977 | #undef cbrtl |
978 | #undef copysign |
979 | #undef copysignf |
980 | #undef copysignl |
981 | #undef erf |
982 | #undef erff |
983 | #undef erfl |
984 | #undef erfc |
985 | #undef erfcf |
986 | #undef erfcl |
987 | #undef exp2 |
988 | #undef exp2f |
989 | #undef exp2l |
990 | #undef expm1 |
991 | #undef expm1f |
992 | #undef expm1l |
993 | #undef fdim |
994 | #undef fdimf |
995 | #undef fdiml |
996 | #undef fma |
997 | #undef fmaf |
998 | #undef fmal |
999 | #undef fmax |
1000 | #undef fmaxf |
1001 | #undef fmaxl |
1002 | #undef fmin |
1003 | #undef fminf |
1004 | #undef fminl |
1005 | #undef hypot |
1006 | #undef hypotf |
1007 | #undef hypotl |
1008 | #undef ilogb |
1009 | #undef ilogbf |
1010 | #undef ilogbl |
1011 | #undef lgamma |
1012 | #undef lgammaf |
1013 | #undef lgammal |
1014 | #undef llrint |
1015 | #undef llrintf |
1016 | #undef llrintl |
1017 | #undef llround |
1018 | #undef llroundf |
1019 | #undef llroundl |
1020 | #undef log1p |
1021 | #undef log1pf |
1022 | #undef log1pl |
1023 | #undef log2 |
1024 | #undef log2f |
1025 | #undef log2l |
1026 | #undef logb |
1027 | #undef logbf |
1028 | #undef logbl |
1029 | #undef lrint |
1030 | #undef lrintf |
1031 | #undef lrintl |
1032 | #undef lround |
1033 | #undef lroundf |
1034 | #undef lroundl |
1035 | #undef nan |
1036 | #undef nanf |
1037 | #undef nanl |
1038 | #undef nearbyint |
1039 | #undef nearbyintf |
1040 | #undef nearbyintl |
1041 | #undef nextafter |
1042 | #undef nextafterf |
1043 | #undef nextafterl |
1044 | #undef nexttoward |
1045 | #undef nexttowardf |
1046 | #undef nexttowardl |
1047 | #undef remainder |
1048 | #undef remainderf |
1049 | #undef remainderl |
1050 | #undef remquo |
1051 | #undef remquof |
1052 | #undef remquol |
1053 | #undef rint |
1054 | #undef rintf |
1055 | #undef rintl |
1056 | #undef round |
1057 | #undef roundf |
1058 | #undef roundl |
1059 | #undef scalbln |
1060 | #undef scalblnf |
1061 | #undef scalblnl |
1062 | #undef scalbn |
1063 | #undef scalbnf |
1064 | #undef scalbnl |
1065 | #undef tgamma |
1066 | #undef tgammaf |
1067 | #undef tgammal |
1068 | #undef trunc |
1069 | #undef truncf |
1070 | #undef truncl |
1071 | |
1072 | namespace std _GLIBCXX_VISIBILITY(default) |
1073 | { |
1074 | _GLIBCXX_BEGIN_NAMESPACE_VERSION |
1075 | |
1076 | // types |
1077 | using ::double_t; |
1078 | using ::float_t; |
1079 | |
1080 | // functions |
1081 | using ::acosh; |
1082 | using ::acoshf; |
1083 | using ::acoshl; |
1084 | |
1085 | using ::asinh; |
1086 | using ::asinhf; |
1087 | using ::asinhl; |
1088 | |
1089 | using ::atanh; |
1090 | using ::atanhf; |
1091 | using ::atanhl; |
1092 | |
1093 | using ::cbrt; |
1094 | using ::cbrtf; |
1095 | using ::cbrtl; |
1096 | |
1097 | using ::copysign; |
1098 | using ::copysignf; |
1099 | using ::copysignl; |
1100 | |
1101 | using ::erf; |
1102 | using ::erff; |
1103 | using ::erfl; |
1104 | |
1105 | using ::erfc; |
1106 | using ::erfcf; |
1107 | using ::erfcl; |
1108 | |
1109 | using ::exp2; |
1110 | using ::exp2f; |
1111 | using ::exp2l; |
1112 | |
1113 | using ::expm1; |
1114 | using ::expm1f; |
1115 | using ::expm1l; |
1116 | |
1117 | using ::fdim; |
1118 | using ::fdimf; |
1119 | using ::fdiml; |
1120 | |
1121 | using ::fma; |
1122 | using ::fmaf; |
1123 | using ::fmal; |
1124 | |
1125 | using ::fmax; |
1126 | using ::fmaxf; |
1127 | using ::fmaxl; |
1128 | |
1129 | using ::fmin; |
1130 | using ::fminf; |
1131 | using ::fminl; |
1132 | |
1133 | using ::hypot; |
1134 | using ::hypotf; |
1135 | using ::hypotl; |
1136 | |
1137 | using ::ilogb; |
1138 | using ::ilogbf; |
1139 | using ::ilogbl; |
1140 | |
1141 | using ::lgamma; |
1142 | using ::lgammaf; |
1143 | using ::lgammal; |
1144 | |
1145 | using ::llrint; |
1146 | using ::llrintf; |
1147 | using ::llrintl; |
1148 | |
1149 | using ::llround; |
1150 | using ::llroundf; |
1151 | using ::llroundl; |
1152 | |
1153 | using ::log1p; |
1154 | using ::log1pf; |
1155 | using ::log1pl; |
1156 | |
1157 | using ::log2; |
1158 | using ::log2f; |
1159 | using ::log2l; |
1160 | |
1161 | using ::logb; |
1162 | using ::logbf; |
1163 | using ::logbl; |
1164 | |
1165 | using ::lrint; |
1166 | using ::lrintf; |
1167 | using ::lrintl; |
1168 | |
1169 | using ::lround; |
1170 | using ::lroundf; |
1171 | using ::lroundl; |
1172 | |
1173 | using ::nan; |
1174 | using ::nanf; |
1175 | using ::nanl; |
1176 | |
1177 | using ::nearbyint; |
1178 | using ::nearbyintf; |
1179 | using ::nearbyintl; |
1180 | |
1181 | using ::nextafter; |
1182 | using ::nextafterf; |
1183 | using ::nextafterl; |
1184 | |
1185 | using ::nexttoward; |
1186 | using ::nexttowardf; |
1187 | using ::nexttowardl; |
1188 | |
1189 | using ::remainder; |
1190 | using ::remainderf; |
1191 | using ::remainderl; |
1192 | |
1193 | using ::remquo; |
1194 | using ::remquof; |
1195 | using ::remquol; |
1196 | |
1197 | using ::rint; |
1198 | using ::rintf; |
1199 | using ::rintl; |
1200 | |
1201 | using ::round; |
1202 | using ::roundf; |
1203 | using ::roundl; |
1204 | |
1205 | using ::scalbln; |
1206 | using ::scalblnf; |
1207 | using ::scalblnl; |
1208 | |
1209 | using ::scalbn; |
1210 | using ::scalbnf; |
1211 | using ::scalbnl; |
1212 | |
1213 | using ::tgamma; |
1214 | using ::tgammaf; |
1215 | using ::tgammal; |
1216 | |
1217 | using ::trunc; |
1218 | using ::truncf; |
1219 | using ::truncl; |
1220 | |
1221 | /// Additional overloads. |
1222 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1223 | constexpr float |
1224 | acosh(float __x) |
1225 | { return __builtin_acoshf(__x); } |
1226 | |
1227 | constexpr long double |
1228 | acosh(long double __x) |
1229 | { return __builtin_acoshl(__x); } |
1230 | #endif |
1231 | |
1232 | template<typename _Tp> |
1233 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1234 | double>::__type |
1235 | acosh(_Tp __x) |
1236 | { return __builtin_acosh(__x); } |
1237 | |
1238 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1239 | constexpr float |
1240 | asinh(float __x) |
1241 | { return __builtin_asinhf(__x); } |
1242 | |
1243 | constexpr long double |
1244 | asinh(long double __x) |
1245 | { return __builtin_asinhl(__x); } |
1246 | #endif |
1247 | |
1248 | template<typename _Tp> |
1249 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1250 | double>::__type |
1251 | asinh(_Tp __x) |
1252 | { return __builtin_asinh(__x); } |
1253 | |
1254 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1255 | constexpr float |
1256 | atanh(float __x) |
1257 | { return __builtin_atanhf(__x); } |
1258 | |
1259 | constexpr long double |
1260 | atanh(long double __x) |
1261 | { return __builtin_atanhl(__x); } |
1262 | #endif |
1263 | |
1264 | template<typename _Tp> |
1265 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1266 | double>::__type |
1267 | atanh(_Tp __x) |
1268 | { return __builtin_atanh(__x); } |
1269 | |
1270 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1271 | constexpr float |
1272 | cbrt(float __x) |
1273 | { return __builtin_cbrtf(__x); } |
1274 | |
1275 | constexpr long double |
1276 | cbrt(long double __x) |
1277 | { return __builtin_cbrtl(__x); } |
1278 | #endif |
1279 | |
1280 | template<typename _Tp> |
1281 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1282 | double>::__type |
1283 | cbrt(_Tp __x) |
1284 | { return __builtin_cbrt(__x); } |
1285 | |
1286 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1287 | constexpr float |
1288 | copysign(float __x, float __y) |
1289 | { return __builtin_copysignf(__x, __y); } |
1290 | |
1291 | constexpr long double |
1292 | copysign(long double __x, long double __y) |
1293 | { return __builtin_copysignl(__x, __y); } |
1294 | #endif |
1295 | |
1296 | template<typename _Tp, typename _Up> |
1297 | constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
1298 | copysign(_Tp __x, _Up __y) |
1299 | { |
1300 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
1301 | return copysign(__type(__x), __type(__y)); |
1302 | } |
1303 | |
1304 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1305 | constexpr float |
1306 | erf(float __x) |
1307 | { return __builtin_erff(__x); } |
1308 | |
1309 | constexpr long double |
1310 | erf(long double __x) |
1311 | { return __builtin_erfl(__x); } |
1312 | #endif |
1313 | |
1314 | template<typename _Tp> |
1315 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1316 | double>::__type |
1317 | erf(_Tp __x) |
1318 | { return __builtin_erf(__x); } |
1319 | |
1320 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1321 | constexpr float |
1322 | erfc(float __x) |
1323 | { return __builtin_erfcf(__x); } |
1324 | |
1325 | constexpr long double |
1326 | erfc(long double __x) |
1327 | { return __builtin_erfcl(__x); } |
1328 | #endif |
1329 | |
1330 | template<typename _Tp> |
1331 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1332 | double>::__type |
1333 | erfc(_Tp __x) |
1334 | { return __builtin_erfc(__x); } |
1335 | |
1336 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1337 | constexpr float |
1338 | exp2(float __x) |
1339 | { return __builtin_exp2f(__x); } |
1340 | |
1341 | constexpr long double |
1342 | exp2(long double __x) |
1343 | { return __builtin_exp2l(__x); } |
1344 | #endif |
1345 | |
1346 | template<typename _Tp> |
1347 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1348 | double>::__type |
1349 | exp2(_Tp __x) |
1350 | { return __builtin_exp2(__x); } |
1351 | |
1352 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1353 | constexpr float |
1354 | expm1(float __x) |
1355 | { return __builtin_expm1f(__x); } |
1356 | |
1357 | constexpr long double |
1358 | expm1(long double __x) |
1359 | { return __builtin_expm1l(__x); } |
1360 | #endif |
1361 | |
1362 | template<typename _Tp> |
1363 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1364 | double>::__type |
1365 | expm1(_Tp __x) |
1366 | { return __builtin_expm1(__x); } |
1367 | |
1368 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1369 | constexpr float |
1370 | fdim(float __x, float __y) |
1371 | { return __builtin_fdimf(__x, __y); } |
1372 | |
1373 | constexpr long double |
1374 | fdim(long double __x, long double __y) |
1375 | { return __builtin_fdiml(__x, __y); } |
1376 | #endif |
1377 | |
1378 | template<typename _Tp, typename _Up> |
1379 | constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
1380 | fdim(_Tp __x, _Up __y) |
1381 | { |
1382 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
1383 | return fdim(__type(__x), __type(__y)); |
1384 | } |
1385 | |
1386 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1387 | constexpr float |
1388 | fma(float __x, float __y, float __z) |
1389 | { return __builtin_fmaf(__x, __y, __z); } |
1390 | |
1391 | constexpr long double |
1392 | fma(long double __x, long double __y, long double __z) |
1393 | { return __builtin_fmal(__x, __y, __z); } |
1394 | #endif |
1395 | |
1396 | template<typename _Tp, typename _Up, typename _Vp> |
1397 | constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type |
1398 | fma(_Tp __x, _Up __y, _Vp __z) |
1399 | { |
1400 | typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; |
1401 | return fma(__type(__x), __type(__y), __type(__z)); |
1402 | } |
1403 | |
1404 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1405 | constexpr float |
1406 | fmax(float __x, float __y) |
1407 | { return __builtin_fmaxf(__x, __y); } |
1408 | |
1409 | constexpr long double |
1410 | fmax(long double __x, long double __y) |
1411 | { return __builtin_fmaxl(__x, __y); } |
1412 | #endif |
1413 | |
1414 | template<typename _Tp, typename _Up> |
1415 | constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
1416 | fmax(_Tp __x, _Up __y) |
1417 | { |
1418 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
1419 | return fmax(__type(__x), __type(__y)); |
1420 | } |
1421 | |
1422 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1423 | constexpr float |
1424 | fmin(float __x, float __y) |
1425 | { return __builtin_fminf(__x, __y); } |
1426 | |
1427 | constexpr long double |
1428 | fmin(long double __x, long double __y) |
1429 | { return __builtin_fminl(__x, __y); } |
1430 | #endif |
1431 | |
1432 | template<typename _Tp, typename _Up> |
1433 | constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
1434 | fmin(_Tp __x, _Up __y) |
1435 | { |
1436 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
1437 | return fmin(__type(__x), __type(__y)); |
1438 | } |
1439 | |
1440 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1441 | constexpr float |
1442 | hypot(float __x, float __y) |
1443 | { return __builtin_hypotf(__x, __y); } |
1444 | |
1445 | constexpr long double |
1446 | hypot(long double __x, long double __y) |
1447 | { return __builtin_hypotl(__x, __y); } |
1448 | #endif |
1449 | |
1450 | template<typename _Tp, typename _Up> |
1451 | constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
1452 | hypot(_Tp __x, _Up __y) |
1453 | { |
1454 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
1455 | return hypot(__type(__x), __type(__y)); |
1456 | } |
1457 | |
1458 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1459 | constexpr int |
1460 | ilogb(float __x) |
1461 | { return __builtin_ilogbf(__x); } |
1462 | |
1463 | constexpr int |
1464 | ilogb(long double __x) |
1465 | { return __builtin_ilogbl(__x); } |
1466 | #endif |
1467 | |
1468 | template<typename _Tp> |
1469 | constexpr |
1470 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1471 | int>::__type |
1472 | ilogb(_Tp __x) |
1473 | { return __builtin_ilogb(__x); } |
1474 | |
1475 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1476 | constexpr float |
1477 | lgamma(float __x) |
1478 | { return __builtin_lgammaf(__x); } |
1479 | |
1480 | constexpr long double |
1481 | lgamma(long double __x) |
1482 | { return __builtin_lgammal(__x); } |
1483 | #endif |
1484 | |
1485 | template<typename _Tp> |
1486 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1487 | double>::__type |
1488 | lgamma(_Tp __x) |
1489 | { return __builtin_lgamma(__x); } |
1490 | |
1491 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1492 | constexpr long long |
1493 | llrint(float __x) |
1494 | { return __builtin_llrintf(__x); } |
1495 | |
1496 | constexpr long long |
1497 | llrint(long double __x) |
1498 | { return __builtin_llrintl(__x); } |
1499 | #endif |
1500 | |
1501 | template<typename _Tp> |
1502 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1503 | long long>::__type |
1504 | llrint(_Tp __x) |
1505 | { return __builtin_llrint(__x); } |
1506 | |
1507 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1508 | constexpr long long |
1509 | llround(float __x) |
1510 | { return __builtin_llroundf(__x); } |
1511 | |
1512 | constexpr long long |
1513 | llround(long double __x) |
1514 | { return __builtin_llroundl(__x); } |
1515 | #endif |
1516 | |
1517 | template<typename _Tp> |
1518 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1519 | long long>::__type |
1520 | llround(_Tp __x) |
1521 | { return __builtin_llround(__x); } |
1522 | |
1523 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1524 | constexpr float |
1525 | log1p(float __x) |
1526 | { return __builtin_log1pf(__x); } |
1527 | |
1528 | constexpr long double |
1529 | log1p(long double __x) |
1530 | { return __builtin_log1pl(__x); } |
1531 | #endif |
1532 | |
1533 | template<typename _Tp> |
1534 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1535 | double>::__type |
1536 | log1p(_Tp __x) |
1537 | { return __builtin_log1p(__x); } |
1538 | |
1539 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1540 | // DR 568. |
1541 | constexpr float |
1542 | log2(float __x) |
1543 | { return __builtin_log2f(__x); } |
1544 | |
1545 | constexpr long double |
1546 | log2(long double __x) |
1547 | { return __builtin_log2l(__x); } |
1548 | #endif |
1549 | |
1550 | template<typename _Tp> |
1551 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1552 | double>::__type |
1553 | log2(_Tp __x) |
1554 | { return __builtin_log2(__x); } |
1555 | |
1556 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1557 | constexpr float |
1558 | logb(float __x) |
1559 | { return __builtin_logbf(__x); } |
1560 | |
1561 | constexpr long double |
1562 | logb(long double __x) |
1563 | { return __builtin_logbl(__x); } |
1564 | #endif |
1565 | |
1566 | template<typename _Tp> |
1567 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1568 | double>::__type |
1569 | logb(_Tp __x) |
1570 | { return __builtin_logb(__x); } |
1571 | |
1572 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1573 | constexpr long |
1574 | lrint(float __x) |
1575 | { return __builtin_lrintf(__x); } |
1576 | |
1577 | constexpr long |
1578 | lrint(long double __x) |
1579 | { return __builtin_lrintl(__x); } |
1580 | #endif |
1581 | |
1582 | template<typename _Tp> |
1583 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1584 | long>::__type |
1585 | lrint(_Tp __x) |
1586 | { return __builtin_lrint(__x); } |
1587 | |
1588 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1589 | constexpr long |
1590 | lround(float __x) |
1591 | { return __builtin_lroundf(__x); } |
1592 | |
1593 | constexpr long |
1594 | lround(long double __x) |
1595 | { return __builtin_lroundl(__x); } |
1596 | #endif |
1597 | |
1598 | template<typename _Tp> |
1599 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1600 | long>::__type |
1601 | lround(_Tp __x) |
1602 | { return __builtin_lround(__x); } |
1603 | |
1604 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1605 | constexpr float |
1606 | nearbyint(float __x) |
1607 | { return __builtin_nearbyintf(__x); } |
1608 | |
1609 | constexpr long double |
1610 | nearbyint(long double __x) |
1611 | { return __builtin_nearbyintl(__x); } |
1612 | #endif |
1613 | |
1614 | template<typename _Tp> |
1615 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1616 | double>::__type |
1617 | nearbyint(_Tp __x) |
1618 | { return __builtin_nearbyint(__x); } |
1619 | |
1620 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1621 | constexpr float |
1622 | nextafter(float __x, float __y) |
1623 | { return __builtin_nextafterf(__x, __y); } |
1624 | |
1625 | constexpr long double |
1626 | nextafter(long double __x, long double __y) |
1627 | { return __builtin_nextafterl(__x, __y); } |
1628 | #endif |
1629 | |
1630 | template<typename _Tp, typename _Up> |
1631 | constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
1632 | nextafter(_Tp __x, _Up __y) |
1633 | { |
1634 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
1635 | return nextafter(__type(__x), __type(__y)); |
1636 | } |
1637 | |
1638 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1639 | constexpr float |
1640 | nexttoward(float __x, long double __y) |
1641 | { return __builtin_nexttowardf(__x, __y); } |
1642 | |
1643 | constexpr long double |
1644 | nexttoward(long double __x, long double __y) |
1645 | { return __builtin_nexttowardl(__x, __y); } |
1646 | #endif |
1647 | |
1648 | template<typename _Tp> |
1649 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1650 | double>::__type |
1651 | nexttoward(_Tp __x, long double __y) |
1652 | { return __builtin_nexttoward(__x, __y); } |
1653 | |
1654 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1655 | constexpr float |
1656 | remainder(float __x, float __y) |
1657 | { return __builtin_remainderf(__x, __y); } |
1658 | |
1659 | constexpr long double |
1660 | remainder(long double __x, long double __y) |
1661 | { return __builtin_remainderl(__x, __y); } |
1662 | #endif |
1663 | |
1664 | template<typename _Tp, typename _Up> |
1665 | constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
1666 | remainder(_Tp __x, _Up __y) |
1667 | { |
1668 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
1669 | return remainder(__type(__x), __type(__y)); |
1670 | } |
1671 | |
1672 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1673 | inline float |
1674 | remquo(float __x, float __y, int* __pquo) |
1675 | { return __builtin_remquof(__x, __y, __pquo); } |
1676 | |
1677 | inline long double |
1678 | remquo(long double __x, long double __y, int* __pquo) |
1679 | { return __builtin_remquol(__x, __y, __pquo); } |
1680 | #endif |
1681 | |
1682 | template<typename _Tp, typename _Up> |
1683 | inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
1684 | remquo(_Tp __x, _Up __y, int* __pquo) |
1685 | { |
1686 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
1687 | return remquo(__type(__x), __type(__y), __pquo); |
1688 | } |
1689 | |
1690 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1691 | constexpr float |
1692 | rint(float __x) |
1693 | { return __builtin_rintf(__x); } |
1694 | |
1695 | constexpr long double |
1696 | rint(long double __x) |
1697 | { return __builtin_rintl(__x); } |
1698 | #endif |
1699 | |
1700 | template<typename _Tp> |
1701 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1702 | double>::__type |
1703 | rint(_Tp __x) |
1704 | { return __builtin_rint(__x); } |
1705 | |
1706 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1707 | constexpr float |
1708 | round(float __x) |
1709 | { return __builtin_roundf(__x); } |
1710 | |
1711 | constexpr long double |
1712 | round(long double __x) |
1713 | { return __builtin_roundl(__x); } |
1714 | #endif |
1715 | |
1716 | template<typename _Tp> |
1717 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1718 | double>::__type |
1719 | round(_Tp __x) |
1720 | { return __builtin_round(__x); } |
1721 | |
1722 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1723 | constexpr float |
1724 | scalbln(float __x, long __ex) |
1725 | { return __builtin_scalblnf(__x, __ex); } |
1726 | |
1727 | constexpr long double |
1728 | scalbln(long double __x, long __ex) |
1729 | { return __builtin_scalblnl(__x, __ex); } |
1730 | #endif |
1731 | |
1732 | template<typename _Tp> |
1733 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1734 | double>::__type |
1735 | scalbln(_Tp __x, long __ex) |
1736 | { return __builtin_scalbln(__x, __ex); } |
1737 | |
1738 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1739 | constexpr float |
1740 | scalbn(float __x, int __ex) |
1741 | { return __builtin_scalbnf(__x, __ex); } |
1742 | |
1743 | constexpr long double |
1744 | scalbn(long double __x, int __ex) |
1745 | { return __builtin_scalbnl(__x, __ex); } |
1746 | #endif |
1747 | |
1748 | template<typename _Tp> |
1749 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1750 | double>::__type |
1751 | scalbn(_Tp __x, int __ex) |
1752 | { return __builtin_scalbn(__x, __ex); } |
1753 | |
1754 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1755 | constexpr float |
1756 | tgamma(float __x) |
1757 | { return __builtin_tgammaf(__x); } |
1758 | |
1759 | constexpr long double |
1760 | tgamma(long double __x) |
1761 | { return __builtin_tgammal(__x); } |
1762 | #endif |
1763 | |
1764 | template<typename _Tp> |
1765 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1766 | double>::__type |
1767 | tgamma(_Tp __x) |
1768 | { return __builtin_tgamma(__x); } |
1769 | |
1770 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
1771 | constexpr float |
1772 | trunc(float __x) |
1773 | { return __builtin_truncf(__x); } |
1774 | |
1775 | constexpr long double |
1776 | trunc(long double __x) |
1777 | { return __builtin_truncl(__x); } |
1778 | #endif |
1779 | |
1780 | template<typename _Tp> |
1781 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1782 | double>::__type |
1783 | trunc(_Tp __x) |
1784 | { return __builtin_trunc(__x); } |
1785 | |
1786 | _GLIBCXX_END_NAMESPACE_VERSION |
1787 | } // namespace |
1788 | |
1789 | #endif // _GLIBCXX_USE_C99_MATH_TR1 |
1790 | |
1791 | #endif // C++11 |
1792 | |
1793 | #if __STDCPP_WANT_MATH_SPEC_FUNCS__ == 1 |
1794 | # include <bits/specfun.h> |
1795 | #endif |
1796 | |
1797 | } // extern "C++" |
1798 | |
1799 | #endif |
1800 | |