1 // -*- C++ -*-
2 //===---------------------------- math.h ----------------------------------===//
3 //
4 // The LLVM Compiler Infrastructure
5 //
6 // This file is dual licensed under the MIT and the University of Illinois Open
7 // Source Licenses. See LICENSE.TXT for details.
8 //
9 //===----------------------------------------------------------------------===//
10
11 // This include lives outside the header guard in order to support an MSVC
12 // extension which allows users to do:
13 //
14 // #define _USE_MATH_DEFINES
15 // #include <math.h>
16 //
17 // and receive the definitions of mathematical constants, even if <math.h>
18 // has previously been included.
19 #include_next <math.h>
20
21 #ifndef _LIBCPP_MATH_H
22 #define _LIBCPP_MATH_H
23
24 /*
25 math.h synopsis
26
27 Macros:
28
29 HUGE_VAL
30 HUGE_VALF // C99
31 HUGE_VALL // C99
32 INFINITY // C99
33 NAN // C99
34 FP_INFINITE // C99
35 FP_NAN // C99
36 FP_NORMAL // C99
37 FP_SUBNORMAL // C99
38 FP_ZERO // C99
39 FP_FAST_FMA // C99
40 FP_FAST_FMAF // C99
41 FP_FAST_FMAL // C99
42 FP_ILOGB0 // C99
43 FP_ILOGBNAN // C99
44 MATH_ERRNO // C99
45 MATH_ERREXCEPT // C99
46 math_errhandling // C99
47
48 Types:
49
50 float_t // C99
51 double_t // C99
52
53 // C90
54
55 floating_point abs(floating_point x);
56
57 floating_point acos (arithmetic x);
58 float acosf(float x);
59 long double acosl(long double x);
60
61 floating_point asin (arithmetic x);
62 float asinf(float x);
63 long double asinl(long double x);
64
65 floating_point atan (arithmetic x);
66 float atanf(float x);
67 long double atanl(long double x);
68
69 floating_point atan2 (arithmetic y, arithmetic x);
70 float atan2f(float y, float x);
71 long double atan2l(long double y, long double x);
72
73 floating_point ceil (arithmetic x);
74 float ceilf(float x);
75 long double ceill(long double x);
76
77 floating_point cos (arithmetic x);
78 float cosf(float x);
79 long double cosl(long double x);
80
81 floating_point cosh (arithmetic x);
82 float coshf(float x);
83 long double coshl(long double x);
84
85 floating_point exp (arithmetic x);
86 float expf(float x);
87 long double expl(long double x);
88
89 floating_point fabs (arithmetic x);
90 float fabsf(float x);
91 long double fabsl(long double x);
92
93 floating_point floor (arithmetic x);
94 float floorf(float x);
95 long double floorl(long double x);
96
97 floating_point fmod (arithmetic x, arithmetic y);
98 float fmodf(float x, float y);
99 long double fmodl(long double x, long double y);
100
101 floating_point frexp (arithmetic value, int* exp);
102 float frexpf(float value, int* exp);
103 long double frexpl(long double value, int* exp);
104
105 floating_point ldexp (arithmetic value, int exp);
106 float ldexpf(float value, int exp);
107 long double ldexpl(long double value, int exp);
108
109 floating_point log (arithmetic x);
110 float logf(float x);
111 long double logl(long double x);
112
113 floating_point log10 (arithmetic x);
114 float log10f(float x);
115 long double log10l(long double x);
116
117 floating_point modf (floating_point value, floating_point* iptr);
118 float modff(float value, float* iptr);
119 long double modfl(long double value, long double* iptr);
120
121 floating_point pow (arithmetic x, arithmetic y);
122 float powf(float x, float y);
123 long double powl(long double x, long double y);
124
125 floating_point sin (arithmetic x);
126 float sinf(float x);
127 long double sinl(long double x);
128
129 floating_point sinh (arithmetic x);
130 float sinhf(float x);
131 long double sinhl(long double x);
132
133 floating_point sqrt (arithmetic x);
134 float sqrtf(float x);
135 long double sqrtl(long double x);
136
137 floating_point tan (arithmetic x);
138 float tanf(float x);
139 long double tanl(long double x);
140
141 floating_point tanh (arithmetic x);
142 float tanhf(float x);
143 long double tanhl(long double x);
144
145 // C99
146
147 bool signbit(arithmetic x);
148
149 int fpclassify(arithmetic x);
150
151 bool isfinite(arithmetic x);
152 bool isinf(arithmetic x);
153 bool isnan(arithmetic x);
154 bool isnormal(arithmetic x);
155
156 bool isgreater(arithmetic x, arithmetic y);
157 bool isgreaterequal(arithmetic x, arithmetic y);
158 bool isless(arithmetic x, arithmetic y);
159 bool islessequal(arithmetic x, arithmetic y);
160 bool islessgreater(arithmetic x, arithmetic y);
161 bool isunordered(arithmetic x, arithmetic y);
162
163 floating_point acosh (arithmetic x);
164 float acoshf(float x);
165 long double acoshl(long double x);
166
167 floating_point asinh (arithmetic x);
168 float asinhf(float x);
169 long double asinhl(long double x);
170
171 floating_point atanh (arithmetic x);
172 float atanhf(float x);
173 long double atanhl(long double x);
174
175 floating_point cbrt (arithmetic x);
176 float cbrtf(float x);
177 long double cbrtl(long double x);
178
179 floating_point copysign (arithmetic x, arithmetic y);
180 float copysignf(float x, float y);
181 long double copysignl(long double x, long double y);
182
183 floating_point erf (arithmetic x);
184 float erff(float x);
185 long double erfl(long double x);
186
187 floating_point erfc (arithmetic x);
188 float erfcf(float x);
189 long double erfcl(long double x);
190
191 floating_point exp2 (arithmetic x);
192 float exp2f(float x);
193 long double exp2l(long double x);
194
195 floating_point expm1 (arithmetic x);
196 float expm1f(float x);
197 long double expm1l(long double x);
198
199 floating_point fdim (arithmetic x, arithmetic y);
200 float fdimf(float x, float y);
201 long double fdiml(long double x, long double y);
202
203 floating_point fma (arithmetic x, arithmetic y, arithmetic z);
204 float fmaf(float x, float y, float z);
205 long double fmal(long double x, long double y, long double z);
206
207 floating_point fmax (arithmetic x, arithmetic y);
208 float fmaxf(float x, float y);
209 long double fmaxl(long double x, long double y);
210
211 floating_point fmin (arithmetic x, arithmetic y);
212 float fminf(float x, float y);
213 long double fminl(long double x, long double y);
214
215 floating_point hypot (arithmetic x, arithmetic y);
216 float hypotf(float x, float y);
217 long double hypotl(long double x, long double y);
218
219 int ilogb (arithmetic x);
220 int ilogbf(float x);
221 int ilogbl(long double x);
222
223 floating_point lgamma (arithmetic x);
224 float lgammaf(float x);
225 long double lgammal(long double x);
226
227 long long llrint (arithmetic x);
228 long long llrintf(float x);
229 long long llrintl(long double x);
230
231 long long llround (arithmetic x);
232 long long llroundf(float x);
233 long long llroundl(long double x);
234
235 floating_point log1p (arithmetic x);
236 float log1pf(float x);
237 long double log1pl(long double x);
238
239 floating_point log2 (arithmetic x);
240 float log2f(float x);
241 long double log2l(long double x);
242
243 floating_point logb (arithmetic x);
244 float logbf(float x);
245 long double logbl(long double x);
246
247 long lrint (arithmetic x);
248 long lrintf(float x);
249 long lrintl(long double x);
250
251 long lround (arithmetic x);
252 long lroundf(float x);
253 long lroundl(long double x);
254
255 double nan (const char* str);
256 float nanf(const char* str);
257 long double nanl(const char* str);
258
259 floating_point nearbyint (arithmetic x);
260 float nearbyintf(float x);
261 long double nearbyintl(long double x);
262
263 floating_point nextafter (arithmetic x, arithmetic y);
264 float nextafterf(float x, float y);
265 long double nextafterl(long double x, long double y);
266
267 floating_point nexttoward (arithmetic x, long double y);
268 float nexttowardf(float x, long double y);
269 long double nexttowardl(long double x, long double y);
270
271 floating_point remainder (arithmetic x, arithmetic y);
272 float remainderf(float x, float y);
273 long double remainderl(long double x, long double y);
274
275 floating_point remquo (arithmetic x, arithmetic y, int* pquo);
276 float remquof(float x, float y, int* pquo);
277 long double remquol(long double x, long double y, int* pquo);
278
279 floating_point rint (arithmetic x);
280 float rintf(float x);
281 long double rintl(long double x);
282
283 floating_point round (arithmetic x);
284 float roundf(float x);
285 long double roundl(long double x);
286
287 floating_point scalbln (arithmetic x, long ex);
288 float scalblnf(float x, long ex);
289 long double scalblnl(long double x, long ex);
290
291 floating_point scalbn (arithmetic x, int ex);
292 float scalbnf(float x, int ex);
293 long double scalbnl(long double x, int ex);
294
295 floating_point tgamma (arithmetic x);
296 float tgammaf(float x);
297 long double tgammal(long double x);
298
299 floating_point trunc (arithmetic x);
300 float truncf(float x);
301 long double truncl(long double x);
302
303 */
304
305 #include <__config>
306
307 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
308 #pragma GCC system_header
309 #endif
310
311 #ifdef __cplusplus
312
313 // We support including .h headers inside 'extern "C"' contexts, so switch
314 // back to C++ linkage before including these C++ headers.
315 extern "C++" {
316
317 #include <type_traits>
318 #include <limits>
319
320 // signbit
321
322 #ifdef signbit
323
324 template <class _A1>
325 _LIBCPP_ALWAYS_INLINE
326 bool
__libcpp_signbit(_A1 __lcpp_x)327 __libcpp_signbit(_A1 __lcpp_x) _NOEXCEPT
328 {
329 return signbit(__lcpp_x);
330 }
331
332 #undef signbit
333
334 template <class _A1>
335 inline _LIBCPP_INLINE_VISIBILITY
336 typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
signbit(_A1 __lcpp_x)337 signbit(_A1 __lcpp_x) _NOEXCEPT
338 {
339 return __libcpp_signbit((typename std::__promote<_A1>::type)__lcpp_x);
340 }
341
342 template <class _A1>
343 inline _LIBCPP_INLINE_VISIBILITY
344 typename std::enable_if<
345 std::is_integral<_A1>::value && std::is_signed<_A1>::value, bool>::type
signbit(_A1 __lcpp_x)346 signbit(_A1 __lcpp_x) _NOEXCEPT
347 { return __lcpp_x < 0; }
348
349 template <class _A1>
350 inline _LIBCPP_INLINE_VISIBILITY
351 typename std::enable_if<
352 std::is_integral<_A1>::value && !std::is_signed<_A1>::value, bool>::type
signbit(_A1)353 signbit(_A1) _NOEXCEPT
354 { return false; }
355
356 #elif defined(_LIBCPP_MSVCRT)
357
358 template <typename _A1>
359 inline _LIBCPP_INLINE_VISIBILITY
360 typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
361 signbit(_A1 __lcpp_x) _NOEXCEPT
362 {
363 return ::signbit(static_cast<typename std::__promote<_A1>::type>(__lcpp_x));
364 }
365
366 template <class _A1>
367 inline _LIBCPP_INLINE_VISIBILITY
368 typename std::enable_if<
369 std::is_integral<_A1>::value && std::is_signed<_A1>::value, bool>::type
370 signbit(_A1 __lcpp_x) _NOEXCEPT
371 { return __lcpp_x < 0; }
372
373 template <class _A1>
374 inline _LIBCPP_INLINE_VISIBILITY
375 typename std::enable_if<
376 std::is_integral<_A1>::value && !std::is_signed<_A1>::value, bool>::type
377 signbit(_A1) _NOEXCEPT
378 { return false; }
379
380 #endif // signbit
381
382 // fpclassify
383
384 #ifdef fpclassify
385
386 template <class _A1>
387 _LIBCPP_ALWAYS_INLINE
388 int
__libcpp_fpclassify(_A1 __lcpp_x)389 __libcpp_fpclassify(_A1 __lcpp_x) _NOEXCEPT
390 {
391 return fpclassify(__lcpp_x);
392 }
393
394 #undef fpclassify
395
396 template <class _A1>
397 inline _LIBCPP_INLINE_VISIBILITY
398 typename std::enable_if<std::is_floating_point<_A1>::value, int>::type
fpclassify(_A1 __lcpp_x)399 fpclassify(_A1 __lcpp_x) _NOEXCEPT
400 {
401 return __libcpp_fpclassify((typename std::__promote<_A1>::type)__lcpp_x);
402 }
403
404 template <class _A1>
405 inline _LIBCPP_INLINE_VISIBILITY
406 typename std::enable_if<std::is_integral<_A1>::value, int>::type
fpclassify(_A1 __lcpp_x)407 fpclassify(_A1 __lcpp_x) _NOEXCEPT
408 { return __lcpp_x == 0 ? FP_ZERO : FP_NORMAL; }
409
410 #elif defined(_LIBCPP_MSVCRT)
411
412 template <typename _A1>
413 inline _LIBCPP_INLINE_VISIBILITY
414 typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
fpclassify(_A1 __lcpp_x)415 fpclassify(_A1 __lcpp_x) _NOEXCEPT
416 {
417 return ::fpclassify(static_cast<typename std::__promote<_A1>::type>(__lcpp_x));
418 }
419
420 template <class _A1>
421 inline _LIBCPP_INLINE_VISIBILITY
422 typename std::enable_if<std::is_integral<_A1>::value, int>::type
fpclassify(_A1 __lcpp_x)423 fpclassify(_A1 __lcpp_x) _NOEXCEPT
424 { return __lcpp_x == 0 ? FP_ZERO : FP_NORMAL; }
425
426 #endif // fpclassify
427
428 // isfinite
429
430 #ifdef isfinite
431
432 template <class _A1>
433 _LIBCPP_ALWAYS_INLINE
434 bool
__libcpp_isfinite(_A1 __lcpp_x)435 __libcpp_isfinite(_A1 __lcpp_x) _NOEXCEPT
436 {
437 return isfinite(__lcpp_x);
438 }
439
440 #undef isfinite
441
442 template <class _A1>
443 inline _LIBCPP_INLINE_VISIBILITY
444 typename std::enable_if<
445 std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity,
446 bool>::type
isfinite(_A1 __lcpp_x)447 isfinite(_A1 __lcpp_x) _NOEXCEPT
448 {
449 return __libcpp_isfinite((typename std::__promote<_A1>::type)__lcpp_x);
450 }
451
452 template <class _A1>
453 inline _LIBCPP_INLINE_VISIBILITY
454 typename std::enable_if<
455 std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity,
456 bool>::type
isfinite(_A1)457 isfinite(_A1) _NOEXCEPT
458 { return true; }
459
460 #endif // isfinite
461
462 // isinf
463
464 #ifdef isinf
465
466 template <class _A1>
467 _LIBCPP_ALWAYS_INLINE
468 bool
__libcpp_isinf(_A1 __lcpp_x)469 __libcpp_isinf(_A1 __lcpp_x) _NOEXCEPT
470 {
471 return isinf(__lcpp_x);
472 }
473
474 #undef isinf
475
476 template <class _A1>
477 inline _LIBCPP_INLINE_VISIBILITY
478 typename std::enable_if<
479 std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity,
480 bool>::type
isinf(_A1 __lcpp_x)481 isinf(_A1 __lcpp_x) _NOEXCEPT
482 {
483 return __libcpp_isinf((typename std::__promote<_A1>::type)__lcpp_x);
484 }
485
486 template <class _A1>
487 inline _LIBCPP_INLINE_VISIBILITY
488 typename std::enable_if<
489 std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity,
490 bool>::type
isinf(_A1)491 isinf(_A1) _NOEXCEPT
492 { return false; }
493
494 #endif // isinf
495
496 // isnan
497
498 #ifdef isnan
499
500 template <class _A1>
501 _LIBCPP_ALWAYS_INLINE
502 bool
__libcpp_isnan(_A1 __lcpp_x)503 __libcpp_isnan(_A1 __lcpp_x) _NOEXCEPT
504 {
505 return isnan(__lcpp_x);
506 }
507
508 #undef isnan
509
510 template <class _A1>
511 inline _LIBCPP_INLINE_VISIBILITY
512 typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
isnan(_A1 __lcpp_x)513 isnan(_A1 __lcpp_x) _NOEXCEPT
514 {
515 return __libcpp_isnan((typename std::__promote<_A1>::type)__lcpp_x);
516 }
517
518 template <class _A1>
519 inline _LIBCPP_INLINE_VISIBILITY
520 typename std::enable_if<std::is_integral<_A1>::value, bool>::type
isnan(_A1)521 isnan(_A1) _NOEXCEPT
522 { return false; }
523
524 #endif // isnan
525
526 // isnormal
527
528 #ifdef isnormal
529
530 template <class _A1>
531 _LIBCPP_ALWAYS_INLINE
532 bool
__libcpp_isnormal(_A1 __lcpp_x)533 __libcpp_isnormal(_A1 __lcpp_x) _NOEXCEPT
534 {
535 return isnormal(__lcpp_x);
536 }
537
538 #undef isnormal
539
540 template <class _A1>
541 inline _LIBCPP_INLINE_VISIBILITY
542 typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
isnormal(_A1 __lcpp_x)543 isnormal(_A1 __lcpp_x) _NOEXCEPT
544 {
545 return __libcpp_isnormal((typename std::__promote<_A1>::type)__lcpp_x);
546 }
547
548 template <class _A1>
549 inline _LIBCPP_INLINE_VISIBILITY
550 typename std::enable_if<std::is_integral<_A1>::value, bool>::type
isnormal(_A1 __lcpp_x)551 isnormal(_A1 __lcpp_x) _NOEXCEPT
552 { return __lcpp_x != 0; }
553
554 #endif // isnormal
555
556 // isgreater
557
558 #ifdef isgreater
559
560 template <class _A1, class _A2>
561 _LIBCPP_ALWAYS_INLINE
562 bool
__libcpp_isgreater(_A1 __lcpp_x,_A2 __lcpp_y)563 __libcpp_isgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
564 {
565 return isgreater(__lcpp_x, __lcpp_y);
566 }
567
568 #undef isgreater
569
570 template <class _A1, class _A2>
571 inline _LIBCPP_INLINE_VISIBILITY
572 typename std::enable_if
573 <
574 std::is_arithmetic<_A1>::value &&
575 std::is_arithmetic<_A2>::value,
576 bool
577 >::type
isgreater(_A1 __lcpp_x,_A2 __lcpp_y)578 isgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
579 {
580 typedef typename std::__promote<_A1, _A2>::type type;
581 return __libcpp_isgreater((type)__lcpp_x, (type)__lcpp_y);
582 }
583
584 #endif // isgreater
585
586 // isgreaterequal
587
588 #ifdef isgreaterequal
589
590 template <class _A1, class _A2>
591 _LIBCPP_ALWAYS_INLINE
592 bool
__libcpp_isgreaterequal(_A1 __lcpp_x,_A2 __lcpp_y)593 __libcpp_isgreaterequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
594 {
595 return isgreaterequal(__lcpp_x, __lcpp_y);
596 }
597
598 #undef isgreaterequal
599
600 template <class _A1, class _A2>
601 inline _LIBCPP_INLINE_VISIBILITY
602 typename std::enable_if
603 <
604 std::is_arithmetic<_A1>::value &&
605 std::is_arithmetic<_A2>::value,
606 bool
607 >::type
isgreaterequal(_A1 __lcpp_x,_A2 __lcpp_y)608 isgreaterequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
609 {
610 typedef typename std::__promote<_A1, _A2>::type type;
611 return __libcpp_isgreaterequal((type)__lcpp_x, (type)__lcpp_y);
612 }
613
614 #endif // isgreaterequal
615
616 // isless
617
618 #ifdef isless
619
620 template <class _A1, class _A2>
621 _LIBCPP_ALWAYS_INLINE
622 bool
__libcpp_isless(_A1 __lcpp_x,_A2 __lcpp_y)623 __libcpp_isless(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
624 {
625 return isless(__lcpp_x, __lcpp_y);
626 }
627
628 #undef isless
629
630 template <class _A1, class _A2>
631 inline _LIBCPP_INLINE_VISIBILITY
632 typename std::enable_if
633 <
634 std::is_arithmetic<_A1>::value &&
635 std::is_arithmetic<_A2>::value,
636 bool
637 >::type
isless(_A1 __lcpp_x,_A2 __lcpp_y)638 isless(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
639 {
640 typedef typename std::__promote<_A1, _A2>::type type;
641 return __libcpp_isless((type)__lcpp_x, (type)__lcpp_y);
642 }
643
644 #endif // isless
645
646 // islessequal
647
648 #ifdef islessequal
649
650 template <class _A1, class _A2>
651 _LIBCPP_ALWAYS_INLINE
652 bool
__libcpp_islessequal(_A1 __lcpp_x,_A2 __lcpp_y)653 __libcpp_islessequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
654 {
655 return islessequal(__lcpp_x, __lcpp_y);
656 }
657
658 #undef islessequal
659
660 template <class _A1, class _A2>
661 inline _LIBCPP_INLINE_VISIBILITY
662 typename std::enable_if
663 <
664 std::is_arithmetic<_A1>::value &&
665 std::is_arithmetic<_A2>::value,
666 bool
667 >::type
islessequal(_A1 __lcpp_x,_A2 __lcpp_y)668 islessequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
669 {
670 typedef typename std::__promote<_A1, _A2>::type type;
671 return __libcpp_islessequal((type)__lcpp_x, (type)__lcpp_y);
672 }
673
674 #endif // islessequal
675
676 // islessgreater
677
678 #ifdef islessgreater
679
680 template <class _A1, class _A2>
681 _LIBCPP_ALWAYS_INLINE
682 bool
__libcpp_islessgreater(_A1 __lcpp_x,_A2 __lcpp_y)683 __libcpp_islessgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
684 {
685 return islessgreater(__lcpp_x, __lcpp_y);
686 }
687
688 #undef islessgreater
689
690 template <class _A1, class _A2>
691 inline _LIBCPP_INLINE_VISIBILITY
692 typename std::enable_if
693 <
694 std::is_arithmetic<_A1>::value &&
695 std::is_arithmetic<_A2>::value,
696 bool
697 >::type
islessgreater(_A1 __lcpp_x,_A2 __lcpp_y)698 islessgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
699 {
700 typedef typename std::__promote<_A1, _A2>::type type;
701 return __libcpp_islessgreater((type)__lcpp_x, (type)__lcpp_y);
702 }
703
704 #endif // islessgreater
705
706 // isunordered
707
708 #ifdef isunordered
709
710 template <class _A1, class _A2>
711 _LIBCPP_ALWAYS_INLINE
712 bool
__libcpp_isunordered(_A1 __lcpp_x,_A2 __lcpp_y)713 __libcpp_isunordered(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
714 {
715 return isunordered(__lcpp_x, __lcpp_y);
716 }
717
718 #undef isunordered
719
720 template <class _A1, class _A2>
721 inline _LIBCPP_INLINE_VISIBILITY
722 typename std::enable_if
723 <
724 std::is_arithmetic<_A1>::value &&
725 std::is_arithmetic<_A2>::value,
726 bool
727 >::type
isunordered(_A1 __lcpp_x,_A2 __lcpp_y)728 isunordered(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
729 {
730 typedef typename std::__promote<_A1, _A2>::type type;
731 return __libcpp_isunordered((type)__lcpp_x, (type)__lcpp_y);
732 }
733
734 #endif // isunordered
735
736 // abs
737
738 #if !(defined(_AIX) || defined(__sun__))
739 inline _LIBCPP_INLINE_VISIBILITY
740 float
abs(float __lcpp_x)741 abs(float __lcpp_x) _NOEXCEPT {return ::fabsf(__lcpp_x);}
742
743 inline _LIBCPP_INLINE_VISIBILITY
744 double
abs(double __lcpp_x)745 abs(double __lcpp_x) _NOEXCEPT {return ::fabs(__lcpp_x);}
746
747 inline _LIBCPP_INLINE_VISIBILITY
748 long double
abs(long double __lcpp_x)749 abs(long double __lcpp_x) _NOEXCEPT {return ::fabsl(__lcpp_x);}
750 #endif // !(defined(_AIX) || defined(__sun__))
751
752 // acos
753
754 #if !(defined(_AIX) || defined(__sun__))
acos(float __lcpp_x)755 inline _LIBCPP_INLINE_VISIBILITY float acos(float __lcpp_x) _NOEXCEPT {return ::acosf(__lcpp_x);}
acos(long double __lcpp_x)756 inline _LIBCPP_INLINE_VISIBILITY long double acos(long double __lcpp_x) _NOEXCEPT {return ::acosl(__lcpp_x);}
757 #endif
758
759 template <class _A1>
760 inline _LIBCPP_INLINE_VISIBILITY
761 typename std::enable_if<std::is_integral<_A1>::value, double>::type
acos(_A1 __lcpp_x)762 acos(_A1 __lcpp_x) _NOEXCEPT {return ::acos((double)__lcpp_x);}
763
764 // asin
765
766 #if !(defined(_AIX) || defined(__sun__))
asin(float __lcpp_x)767 inline _LIBCPP_INLINE_VISIBILITY float asin(float __lcpp_x) _NOEXCEPT {return ::asinf(__lcpp_x);}
asin(long double __lcpp_x)768 inline _LIBCPP_INLINE_VISIBILITY long double asin(long double __lcpp_x) _NOEXCEPT {return ::asinl(__lcpp_x);}
769 #endif
770
771 template <class _A1>
772 inline _LIBCPP_INLINE_VISIBILITY
773 typename std::enable_if<std::is_integral<_A1>::value, double>::type
asin(_A1 __lcpp_x)774 asin(_A1 __lcpp_x) _NOEXCEPT {return ::asin((double)__lcpp_x);}
775
776 // atan
777
778 #if !(defined(_AIX) || defined(__sun__))
atan(float __lcpp_x)779 inline _LIBCPP_INLINE_VISIBILITY float atan(float __lcpp_x) _NOEXCEPT {return ::atanf(__lcpp_x);}
atan(long double __lcpp_x)780 inline _LIBCPP_INLINE_VISIBILITY long double atan(long double __lcpp_x) _NOEXCEPT {return ::atanl(__lcpp_x);}
781 #endif
782
783 template <class _A1>
784 inline _LIBCPP_INLINE_VISIBILITY
785 typename std::enable_if<std::is_integral<_A1>::value, double>::type
atan(_A1 __lcpp_x)786 atan(_A1 __lcpp_x) _NOEXCEPT {return ::atan((double)__lcpp_x);}
787
788 // atan2
789
790 #if !(defined(_AIX) || defined(__sun__))
atan2(float __lcpp_y,float __lcpp_x)791 inline _LIBCPP_INLINE_VISIBILITY float atan2(float __lcpp_y, float __lcpp_x) _NOEXCEPT {return ::atan2f(__lcpp_y, __lcpp_x);}
atan2(long double __lcpp_y,long double __lcpp_x)792 inline _LIBCPP_INLINE_VISIBILITY long double atan2(long double __lcpp_y, long double __lcpp_x) _NOEXCEPT {return ::atan2l(__lcpp_y, __lcpp_x);}
793 #endif
794
795 template <class _A1, class _A2>
796 inline _LIBCPP_INLINE_VISIBILITY
797 typename std::__lazy_enable_if
798 <
799 std::is_arithmetic<_A1>::value &&
800 std::is_arithmetic<_A2>::value,
801 std::__promote<_A1, _A2>
802 >::type
atan2(_A1 __lcpp_y,_A2 __lcpp_x)803 atan2(_A1 __lcpp_y, _A2 __lcpp_x) _NOEXCEPT
804 {
805 typedef typename std::__promote<_A1, _A2>::type __result_type;
806 static_assert((!(std::is_same<_A1, __result_type>::value &&
807 std::is_same<_A2, __result_type>::value)), "");
808 return ::atan2((__result_type)__lcpp_y, (__result_type)__lcpp_x);
809 }
810
811 // ceil
812
813 #if !(defined(_AIX) || defined(__sun__))
ceil(float __lcpp_x)814 inline _LIBCPP_INLINE_VISIBILITY float ceil(float __lcpp_x) _NOEXCEPT {return ::ceilf(__lcpp_x);}
ceil(long double __lcpp_x)815 inline _LIBCPP_INLINE_VISIBILITY long double ceil(long double __lcpp_x) _NOEXCEPT {return ::ceill(__lcpp_x);}
816 #endif
817
818 template <class _A1>
819 inline _LIBCPP_INLINE_VISIBILITY
820 typename std::enable_if<std::is_integral<_A1>::value, double>::type
ceil(_A1 __lcpp_x)821 ceil(_A1 __lcpp_x) _NOEXCEPT {return ::ceil((double)__lcpp_x);}
822
823 // cos
824
825 #if !(defined(_AIX) || defined(__sun__))
cos(float __lcpp_x)826 inline _LIBCPP_INLINE_VISIBILITY float cos(float __lcpp_x) _NOEXCEPT {return ::cosf(__lcpp_x);}
cos(long double __lcpp_x)827 inline _LIBCPP_INLINE_VISIBILITY long double cos(long double __lcpp_x) _NOEXCEPT {return ::cosl(__lcpp_x);}
828 #endif
829
830 template <class _A1>
831 inline _LIBCPP_INLINE_VISIBILITY
832 typename std::enable_if<std::is_integral<_A1>::value, double>::type
cos(_A1 __lcpp_x)833 cos(_A1 __lcpp_x) _NOEXCEPT {return ::cos((double)__lcpp_x);}
834
835 // cosh
836
837 #if !(defined(_AIX) || defined(__sun__))
cosh(float __lcpp_x)838 inline _LIBCPP_INLINE_VISIBILITY float cosh(float __lcpp_x) _NOEXCEPT {return ::coshf(__lcpp_x);}
cosh(long double __lcpp_x)839 inline _LIBCPP_INLINE_VISIBILITY long double cosh(long double __lcpp_x) _NOEXCEPT {return ::coshl(__lcpp_x);}
840 #endif
841
842 template <class _A1>
843 inline _LIBCPP_INLINE_VISIBILITY
844 typename std::enable_if<std::is_integral<_A1>::value, double>::type
cosh(_A1 __lcpp_x)845 cosh(_A1 __lcpp_x) _NOEXCEPT {return ::cosh((double)__lcpp_x);}
846
847 // exp
848
849 #if !(defined(_AIX) || defined(__sun__))
exp(float __lcpp_x)850 inline _LIBCPP_INLINE_VISIBILITY float exp(float __lcpp_x) _NOEXCEPT {return ::expf(__lcpp_x);}
exp(long double __lcpp_x)851 inline _LIBCPP_INLINE_VISIBILITY long double exp(long double __lcpp_x) _NOEXCEPT {return ::expl(__lcpp_x);}
852 #endif
853
854 template <class _A1>
855 inline _LIBCPP_INLINE_VISIBILITY
856 typename std::enable_if<std::is_integral<_A1>::value, double>::type
exp(_A1 __lcpp_x)857 exp(_A1 __lcpp_x) _NOEXCEPT {return ::exp((double)__lcpp_x);}
858
859 // fabs
860
861 #if !(defined(_AIX) || defined(__sun__))
fabs(float __lcpp_x)862 inline _LIBCPP_INLINE_VISIBILITY float fabs(float __lcpp_x) _NOEXCEPT {return ::fabsf(__lcpp_x);}
fabs(long double __lcpp_x)863 inline _LIBCPP_INLINE_VISIBILITY long double fabs(long double __lcpp_x) _NOEXCEPT {return ::fabsl(__lcpp_x);}
864 #endif
865
866 template <class _A1>
867 inline _LIBCPP_INLINE_VISIBILITY
868 typename std::enable_if<std::is_integral<_A1>::value, double>::type
fabs(_A1 __lcpp_x)869 fabs(_A1 __lcpp_x) _NOEXCEPT {return ::fabs((double)__lcpp_x);}
870
871 // floor
872
873 #if !(defined(_AIX) || defined(__sun__))
floor(float __lcpp_x)874 inline _LIBCPP_INLINE_VISIBILITY float floor(float __lcpp_x) _NOEXCEPT {return ::floorf(__lcpp_x);}
floor(long double __lcpp_x)875 inline _LIBCPP_INLINE_VISIBILITY long double floor(long double __lcpp_x) _NOEXCEPT {return ::floorl(__lcpp_x);}
876 #endif
877
878 template <class _A1>
879 inline _LIBCPP_INLINE_VISIBILITY
880 typename std::enable_if<std::is_integral<_A1>::value, double>::type
floor(_A1 __lcpp_x)881 floor(_A1 __lcpp_x) _NOEXCEPT {return ::floor((double)__lcpp_x);}
882
883 // fmod
884
885 #if !(defined(_AIX) || defined(__sun__))
fmod(float __lcpp_x,float __lcpp_y)886 inline _LIBCPP_INLINE_VISIBILITY float fmod(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::fmodf(__lcpp_x, __lcpp_y);}
fmod(long double __lcpp_x,long double __lcpp_y)887 inline _LIBCPP_INLINE_VISIBILITY long double fmod(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fmodl(__lcpp_x, __lcpp_y);}
888 #endif
889
890 template <class _A1, class _A2>
891 inline _LIBCPP_INLINE_VISIBILITY
892 typename std::__lazy_enable_if
893 <
894 std::is_arithmetic<_A1>::value &&
895 std::is_arithmetic<_A2>::value,
896 std::__promote<_A1, _A2>
897 >::type
fmod(_A1 __lcpp_x,_A2 __lcpp_y)898 fmod(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
899 {
900 typedef typename std::__promote<_A1, _A2>::type __result_type;
901 static_assert((!(std::is_same<_A1, __result_type>::value &&
902 std::is_same<_A2, __result_type>::value)), "");
903 return ::fmod((__result_type)__lcpp_x, (__result_type)__lcpp_y);
904 }
905
906 // frexp
907
908 #if !(defined(_AIX) || defined(__sun__))
frexp(float __lcpp_x,int * __lcpp_e)909 inline _LIBCPP_INLINE_VISIBILITY float frexp(float __lcpp_x, int* __lcpp_e) _NOEXCEPT {return ::frexpf(__lcpp_x, __lcpp_e);}
frexp(long double __lcpp_x,int * __lcpp_e)910 inline _LIBCPP_INLINE_VISIBILITY long double frexp(long double __lcpp_x, int* __lcpp_e) _NOEXCEPT {return ::frexpl(__lcpp_x, __lcpp_e);}
911 #endif
912
913 template <class _A1>
914 inline _LIBCPP_INLINE_VISIBILITY
915 typename std::enable_if<std::is_integral<_A1>::value, double>::type
frexp(_A1 __lcpp_x,int * __lcpp_e)916 frexp(_A1 __lcpp_x, int* __lcpp_e) _NOEXCEPT {return ::frexp((double)__lcpp_x, __lcpp_e);}
917
918 // ldexp
919
920 #if !(defined(_AIX) || defined(__sun__))
ldexp(float __lcpp_x,int __lcpp_e)921 inline _LIBCPP_INLINE_VISIBILITY float ldexp(float __lcpp_x, int __lcpp_e) _NOEXCEPT {return ::ldexpf(__lcpp_x, __lcpp_e);}
ldexp(long double __lcpp_x,int __lcpp_e)922 inline _LIBCPP_INLINE_VISIBILITY long double ldexp(long double __lcpp_x, int __lcpp_e) _NOEXCEPT {return ::ldexpl(__lcpp_x, __lcpp_e);}
923 #endif
924
925 template <class _A1>
926 inline _LIBCPP_INLINE_VISIBILITY
927 typename std::enable_if<std::is_integral<_A1>::value, double>::type
ldexp(_A1 __lcpp_x,int __lcpp_e)928 ldexp(_A1 __lcpp_x, int __lcpp_e) _NOEXCEPT {return ::ldexp((double)__lcpp_x, __lcpp_e);}
929
930 // log
931
932 #if !(defined(_AIX) || defined(__sun__))
log(float __lcpp_x)933 inline _LIBCPP_INLINE_VISIBILITY float log(float __lcpp_x) _NOEXCEPT {return ::logf(__lcpp_x);}
log(long double __lcpp_x)934 inline _LIBCPP_INLINE_VISIBILITY long double log(long double __lcpp_x) _NOEXCEPT {return ::logl(__lcpp_x);}
935 #endif
936
937 template <class _A1>
938 inline _LIBCPP_INLINE_VISIBILITY
939 typename std::enable_if<std::is_integral<_A1>::value, double>::type
log(_A1 __lcpp_x)940 log(_A1 __lcpp_x) _NOEXCEPT {return ::log((double)__lcpp_x);}
941
942 // log10
943
944 #if !(defined(_AIX) || defined(__sun__))
log10(float __lcpp_x)945 inline _LIBCPP_INLINE_VISIBILITY float log10(float __lcpp_x) _NOEXCEPT {return ::log10f(__lcpp_x);}
log10(long double __lcpp_x)946 inline _LIBCPP_INLINE_VISIBILITY long double log10(long double __lcpp_x) _NOEXCEPT {return ::log10l(__lcpp_x);}
947 #endif
948
949 template <class _A1>
950 inline _LIBCPP_INLINE_VISIBILITY
951 typename std::enable_if<std::is_integral<_A1>::value, double>::type
log10(_A1 __lcpp_x)952 log10(_A1 __lcpp_x) _NOEXCEPT {return ::log10((double)__lcpp_x);}
953
954 // modf
955
956 #if !(defined(_AIX) || defined(__sun__))
modf(float __lcpp_x,float * __lcpp_y)957 inline _LIBCPP_INLINE_VISIBILITY float modf(float __lcpp_x, float* __lcpp_y) _NOEXCEPT {return ::modff(__lcpp_x, __lcpp_y);}
modf(long double __lcpp_x,long double * __lcpp_y)958 inline _LIBCPP_INLINE_VISIBILITY long double modf(long double __lcpp_x, long double* __lcpp_y) _NOEXCEPT {return ::modfl(__lcpp_x, __lcpp_y);}
959 #endif
960
961 // pow
962
963 #if !(defined(_AIX) || defined(__sun__))
pow(float __lcpp_x,float __lcpp_y)964 inline _LIBCPP_INLINE_VISIBILITY float pow(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::powf(__lcpp_x, __lcpp_y);}
pow(long double __lcpp_x,long double __lcpp_y)965 inline _LIBCPP_INLINE_VISIBILITY long double pow(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::powl(__lcpp_x, __lcpp_y);}
966 #endif
967
968 template <class _A1, class _A2>
969 inline _LIBCPP_INLINE_VISIBILITY
970 typename std::__lazy_enable_if
971 <
972 std::is_arithmetic<_A1>::value &&
973 std::is_arithmetic<_A2>::value,
974 std::__promote<_A1, _A2>
975 >::type
pow(_A1 __lcpp_x,_A2 __lcpp_y)976 pow(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
977 {
978 typedef typename std::__promote<_A1, _A2>::type __result_type;
979 static_assert((!(std::is_same<_A1, __result_type>::value &&
980 std::is_same<_A2, __result_type>::value)), "");
981 return ::pow((__result_type)__lcpp_x, (__result_type)__lcpp_y);
982 }
983
984 // sin
985
986 #if !(defined(_AIX) || defined(__sun__))
sin(float __lcpp_x)987 inline _LIBCPP_INLINE_VISIBILITY float sin(float __lcpp_x) _NOEXCEPT {return ::sinf(__lcpp_x);}
sin(long double __lcpp_x)988 inline _LIBCPP_INLINE_VISIBILITY long double sin(long double __lcpp_x) _NOEXCEPT {return ::sinl(__lcpp_x);}
989 #endif
990
991 template <class _A1>
992 inline _LIBCPP_INLINE_VISIBILITY
993 typename std::enable_if<std::is_integral<_A1>::value, double>::type
sin(_A1 __lcpp_x)994 sin(_A1 __lcpp_x) _NOEXCEPT {return ::sin((double)__lcpp_x);}
995
996 // sinh
997
998 #if !(defined(_AIX) || defined(__sun__))
sinh(float __lcpp_x)999 inline _LIBCPP_INLINE_VISIBILITY float sinh(float __lcpp_x) _NOEXCEPT {return ::sinhf(__lcpp_x);}
sinh(long double __lcpp_x)1000 inline _LIBCPP_INLINE_VISIBILITY long double sinh(long double __lcpp_x) _NOEXCEPT {return ::sinhl(__lcpp_x);}
1001 #endif
1002
1003 template <class _A1>
1004 inline _LIBCPP_INLINE_VISIBILITY
1005 typename std::enable_if<std::is_integral<_A1>::value, double>::type
sinh(_A1 __lcpp_x)1006 sinh(_A1 __lcpp_x) _NOEXCEPT {return ::sinh((double)__lcpp_x);}
1007
1008 // sqrt
1009
1010 #if !(defined(_AIX) || defined(__sun__))
sqrt(float __lcpp_x)1011 inline _LIBCPP_INLINE_VISIBILITY float sqrt(float __lcpp_x) _NOEXCEPT {return ::sqrtf(__lcpp_x);}
sqrt(long double __lcpp_x)1012 inline _LIBCPP_INLINE_VISIBILITY long double sqrt(long double __lcpp_x) _NOEXCEPT {return ::sqrtl(__lcpp_x);}
1013 #endif
1014
1015 template <class _A1>
1016 inline _LIBCPP_INLINE_VISIBILITY
1017 typename std::enable_if<std::is_integral<_A1>::value, double>::type
sqrt(_A1 __lcpp_x)1018 sqrt(_A1 __lcpp_x) _NOEXCEPT {return ::sqrt((double)__lcpp_x);}
1019
1020 // tan
1021
1022 #if !(defined(_AIX) || defined(__sun__))
tan(float __lcpp_x)1023 inline _LIBCPP_INLINE_VISIBILITY float tan(float __lcpp_x) _NOEXCEPT {return ::tanf(__lcpp_x);}
tan(long double __lcpp_x)1024 inline _LIBCPP_INLINE_VISIBILITY long double tan(long double __lcpp_x) _NOEXCEPT {return ::tanl(__lcpp_x);}
1025 #endif
1026
1027 template <class _A1>
1028 inline _LIBCPP_INLINE_VISIBILITY
1029 typename std::enable_if<std::is_integral<_A1>::value, double>::type
tan(_A1 __lcpp_x)1030 tan(_A1 __lcpp_x) _NOEXCEPT {return ::tan((double)__lcpp_x);}
1031
1032 // tanh
1033
1034 #if !(defined(_AIX) || defined(__sun__))
tanh(float __lcpp_x)1035 inline _LIBCPP_INLINE_VISIBILITY float tanh(float __lcpp_x) _NOEXCEPT {return ::tanhf(__lcpp_x);}
tanh(long double __lcpp_x)1036 inline _LIBCPP_INLINE_VISIBILITY long double tanh(long double __lcpp_x) _NOEXCEPT {return ::tanhl(__lcpp_x);}
1037 #endif
1038
1039 template <class _A1>
1040 inline _LIBCPP_INLINE_VISIBILITY
1041 typename std::enable_if<std::is_integral<_A1>::value, double>::type
tanh(_A1 __lcpp_x)1042 tanh(_A1 __lcpp_x) _NOEXCEPT {return ::tanh((double)__lcpp_x);}
1043
1044 // acosh
1045
acosh(float __lcpp_x)1046 inline _LIBCPP_INLINE_VISIBILITY float acosh(float __lcpp_x) _NOEXCEPT {return ::acoshf(__lcpp_x);}
acosh(long double __lcpp_x)1047 inline _LIBCPP_INLINE_VISIBILITY long double acosh(long double __lcpp_x) _NOEXCEPT {return ::acoshl(__lcpp_x);}
1048
1049 template <class _A1>
1050 inline _LIBCPP_INLINE_VISIBILITY
1051 typename std::enable_if<std::is_integral<_A1>::value, double>::type
acosh(_A1 __lcpp_x)1052 acosh(_A1 __lcpp_x) _NOEXCEPT {return ::acosh((double)__lcpp_x);}
1053
1054 // asinh
1055
asinh(float __lcpp_x)1056 inline _LIBCPP_INLINE_VISIBILITY float asinh(float __lcpp_x) _NOEXCEPT {return ::asinhf(__lcpp_x);}
asinh(long double __lcpp_x)1057 inline _LIBCPP_INLINE_VISIBILITY long double asinh(long double __lcpp_x) _NOEXCEPT {return ::asinhl(__lcpp_x);}
1058
1059 template <class _A1>
1060 inline _LIBCPP_INLINE_VISIBILITY
1061 typename std::enable_if<std::is_integral<_A1>::value, double>::type
asinh(_A1 __lcpp_x)1062 asinh(_A1 __lcpp_x) _NOEXCEPT {return ::asinh((double)__lcpp_x);}
1063
1064 // atanh
1065
atanh(float __lcpp_x)1066 inline _LIBCPP_INLINE_VISIBILITY float atanh(float __lcpp_x) _NOEXCEPT {return ::atanhf(__lcpp_x);}
atanh(long double __lcpp_x)1067 inline _LIBCPP_INLINE_VISIBILITY long double atanh(long double __lcpp_x) _NOEXCEPT {return ::atanhl(__lcpp_x);}
1068
1069 template <class _A1>
1070 inline _LIBCPP_INLINE_VISIBILITY
1071 typename std::enable_if<std::is_integral<_A1>::value, double>::type
atanh(_A1 __lcpp_x)1072 atanh(_A1 __lcpp_x) _NOEXCEPT {return ::atanh((double)__lcpp_x);}
1073
1074 // cbrt
1075
cbrt(float __lcpp_x)1076 inline _LIBCPP_INLINE_VISIBILITY float cbrt(float __lcpp_x) _NOEXCEPT {return ::cbrtf(__lcpp_x);}
cbrt(long double __lcpp_x)1077 inline _LIBCPP_INLINE_VISIBILITY long double cbrt(long double __lcpp_x) _NOEXCEPT {return ::cbrtl(__lcpp_x);}
1078
1079 template <class _A1>
1080 inline _LIBCPP_INLINE_VISIBILITY
1081 typename std::enable_if<std::is_integral<_A1>::value, double>::type
cbrt(_A1 __lcpp_x)1082 cbrt(_A1 __lcpp_x) _NOEXCEPT {return ::cbrt((double)__lcpp_x);}
1083
1084 // copysign
1085
copysign(float __lcpp_x,float __lcpp_y)1086 inline _LIBCPP_INLINE_VISIBILITY float copysign(float __lcpp_x,
1087 float __lcpp_y) _NOEXCEPT {
1088 return ::copysignf(__lcpp_x, __lcpp_y);
1089 }
1090 inline _LIBCPP_INLINE_VISIBILITY long double
copysign(long double __lcpp_x,long double __lcpp_y)1091 copysign(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {
1092 return ::copysignl(__lcpp_x, __lcpp_y);
1093 }
1094
1095 template <class _A1, class _A2>
1096 inline _LIBCPP_INLINE_VISIBILITY
1097 typename std::__lazy_enable_if
1098 <
1099 std::is_arithmetic<_A1>::value &&
1100 std::is_arithmetic<_A2>::value,
1101 std::__promote<_A1, _A2>
1102 >::type
copysign(_A1 __lcpp_x,_A2 __lcpp_y)1103 copysign(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
1104 {
1105 typedef typename std::__promote<_A1, _A2>::type __result_type;
1106 static_assert((!(std::is_same<_A1, __result_type>::value &&
1107 std::is_same<_A2, __result_type>::value)), "");
1108 return ::copysign((__result_type)__lcpp_x, (__result_type)__lcpp_y);
1109 }
1110
1111 // erf
1112
erf(float __lcpp_x)1113 inline _LIBCPP_INLINE_VISIBILITY float erf(float __lcpp_x) _NOEXCEPT {return ::erff(__lcpp_x);}
erf(long double __lcpp_x)1114 inline _LIBCPP_INLINE_VISIBILITY long double erf(long double __lcpp_x) _NOEXCEPT {return ::erfl(__lcpp_x);}
1115
1116 template <class _A1>
1117 inline _LIBCPP_INLINE_VISIBILITY
1118 typename std::enable_if<std::is_integral<_A1>::value, double>::type
erf(_A1 __lcpp_x)1119 erf(_A1 __lcpp_x) _NOEXCEPT {return ::erf((double)__lcpp_x);}
1120
1121 // erfc
1122
erfc(float __lcpp_x)1123 inline _LIBCPP_INLINE_VISIBILITY float erfc(float __lcpp_x) _NOEXCEPT {return ::erfcf(__lcpp_x);}
erfc(long double __lcpp_x)1124 inline _LIBCPP_INLINE_VISIBILITY long double erfc(long double __lcpp_x) _NOEXCEPT {return ::erfcl(__lcpp_x);}
1125
1126 template <class _A1>
1127 inline _LIBCPP_INLINE_VISIBILITY
1128 typename std::enable_if<std::is_integral<_A1>::value, double>::type
erfc(_A1 __lcpp_x)1129 erfc(_A1 __lcpp_x) _NOEXCEPT {return ::erfc((double)__lcpp_x);}
1130
1131 // exp2
1132
exp2(float __lcpp_x)1133 inline _LIBCPP_INLINE_VISIBILITY float exp2(float __lcpp_x) _NOEXCEPT {return ::exp2f(__lcpp_x);}
exp2(long double __lcpp_x)1134 inline _LIBCPP_INLINE_VISIBILITY long double exp2(long double __lcpp_x) _NOEXCEPT {return ::exp2l(__lcpp_x);}
1135
1136 template <class _A1>
1137 inline _LIBCPP_INLINE_VISIBILITY
1138 typename std::enable_if<std::is_integral<_A1>::value, double>::type
exp2(_A1 __lcpp_x)1139 exp2(_A1 __lcpp_x) _NOEXCEPT {return ::exp2((double)__lcpp_x);}
1140
1141 // expm1
1142
expm1(float __lcpp_x)1143 inline _LIBCPP_INLINE_VISIBILITY float expm1(float __lcpp_x) _NOEXCEPT {return ::expm1f(__lcpp_x);}
expm1(long double __lcpp_x)1144 inline _LIBCPP_INLINE_VISIBILITY long double expm1(long double __lcpp_x) _NOEXCEPT {return ::expm1l(__lcpp_x);}
1145
1146 template <class _A1>
1147 inline _LIBCPP_INLINE_VISIBILITY
1148 typename std::enable_if<std::is_integral<_A1>::value, double>::type
expm1(_A1 __lcpp_x)1149 expm1(_A1 __lcpp_x) _NOEXCEPT {return ::expm1((double)__lcpp_x);}
1150
1151 // fdim
1152
fdim(float __lcpp_x,float __lcpp_y)1153 inline _LIBCPP_INLINE_VISIBILITY float fdim(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::fdimf(__lcpp_x, __lcpp_y);}
fdim(long double __lcpp_x,long double __lcpp_y)1154 inline _LIBCPP_INLINE_VISIBILITY long double fdim(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fdiml(__lcpp_x, __lcpp_y);}
1155
1156 template <class _A1, class _A2>
1157 inline _LIBCPP_INLINE_VISIBILITY
1158 typename std::__lazy_enable_if
1159 <
1160 std::is_arithmetic<_A1>::value &&
1161 std::is_arithmetic<_A2>::value,
1162 std::__promote<_A1, _A2>
1163 >::type
fdim(_A1 __lcpp_x,_A2 __lcpp_y)1164 fdim(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
1165 {
1166 typedef typename std::__promote<_A1, _A2>::type __result_type;
1167 static_assert((!(std::is_same<_A1, __result_type>::value &&
1168 std::is_same<_A2, __result_type>::value)), "");
1169 return ::fdim((__result_type)__lcpp_x, (__result_type)__lcpp_y);
1170 }
1171
1172 // fma
1173
fma(float __lcpp_x,float __lcpp_y,float __lcpp_z)1174 inline _LIBCPP_INLINE_VISIBILITY float fma(float __lcpp_x, float __lcpp_y, float __lcpp_z) _NOEXCEPT {return ::fmaf(__lcpp_x, __lcpp_y, __lcpp_z);}
fma(long double __lcpp_x,long double __lcpp_y,long double __lcpp_z)1175 inline _LIBCPP_INLINE_VISIBILITY long double fma(long double __lcpp_x, long double __lcpp_y, long double __lcpp_z) _NOEXCEPT {return ::fmal(__lcpp_x, __lcpp_y, __lcpp_z);}
1176
1177 template <class _A1, class _A2, class _A3>
1178 inline _LIBCPP_INLINE_VISIBILITY
1179 typename std::__lazy_enable_if
1180 <
1181 std::is_arithmetic<_A1>::value &&
1182 std::is_arithmetic<_A2>::value &&
1183 std::is_arithmetic<_A3>::value,
1184 std::__promote<_A1, _A2, _A3>
1185 >::type
fma(_A1 __lcpp_x,_A2 __lcpp_y,_A3 __lcpp_z)1186 fma(_A1 __lcpp_x, _A2 __lcpp_y, _A3 __lcpp_z) _NOEXCEPT
1187 {
1188 typedef typename std::__promote<_A1, _A2, _A3>::type __result_type;
1189 static_assert((!(std::is_same<_A1, __result_type>::value &&
1190 std::is_same<_A2, __result_type>::value &&
1191 std::is_same<_A3, __result_type>::value)), "");
1192 return ::fma((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z);
1193 }
1194
1195 // fmax
1196
fmax(float __lcpp_x,float __lcpp_y)1197 inline _LIBCPP_INLINE_VISIBILITY float fmax(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::fmaxf(__lcpp_x, __lcpp_y);}
fmax(long double __lcpp_x,long double __lcpp_y)1198 inline _LIBCPP_INLINE_VISIBILITY long double fmax(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fmaxl(__lcpp_x, __lcpp_y);}
1199
1200 template <class _A1, class _A2>
1201 inline _LIBCPP_INLINE_VISIBILITY
1202 typename std::__lazy_enable_if
1203 <
1204 std::is_arithmetic<_A1>::value &&
1205 std::is_arithmetic<_A2>::value,
1206 std::__promote<_A1, _A2>
1207 >::type
fmax(_A1 __lcpp_x,_A2 __lcpp_y)1208 fmax(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
1209 {
1210 typedef typename std::__promote<_A1, _A2>::type __result_type;
1211 static_assert((!(std::is_same<_A1, __result_type>::value &&
1212 std::is_same<_A2, __result_type>::value)), "");
1213 return ::fmax((__result_type)__lcpp_x, (__result_type)__lcpp_y);
1214 }
1215
1216 // fmin
1217
fmin(float __lcpp_x,float __lcpp_y)1218 inline _LIBCPP_INLINE_VISIBILITY float fmin(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::fminf(__lcpp_x, __lcpp_y);}
fmin(long double __lcpp_x,long double __lcpp_y)1219 inline _LIBCPP_INLINE_VISIBILITY long double fmin(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fminl(__lcpp_x, __lcpp_y);}
1220
1221 template <class _A1, class _A2>
1222 inline _LIBCPP_INLINE_VISIBILITY
1223 typename std::__lazy_enable_if
1224 <
1225 std::is_arithmetic<_A1>::value &&
1226 std::is_arithmetic<_A2>::value,
1227 std::__promote<_A1, _A2>
1228 >::type
fmin(_A1 __lcpp_x,_A2 __lcpp_y)1229 fmin(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
1230 {
1231 typedef typename std::__promote<_A1, _A2>::type __result_type;
1232 static_assert((!(std::is_same<_A1, __result_type>::value &&
1233 std::is_same<_A2, __result_type>::value)), "");
1234 return ::fmin((__result_type)__lcpp_x, (__result_type)__lcpp_y);
1235 }
1236
1237 // hypot
1238
hypot(float __lcpp_x,float __lcpp_y)1239 inline _LIBCPP_INLINE_VISIBILITY float hypot(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::hypotf(__lcpp_x, __lcpp_y);}
hypot(long double __lcpp_x,long double __lcpp_y)1240 inline _LIBCPP_INLINE_VISIBILITY long double hypot(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::hypotl(__lcpp_x, __lcpp_y);}
1241
1242 template <class _A1, class _A2>
1243 inline _LIBCPP_INLINE_VISIBILITY
1244 typename std::__lazy_enable_if
1245 <
1246 std::is_arithmetic<_A1>::value &&
1247 std::is_arithmetic<_A2>::value,
1248 std::__promote<_A1, _A2>
1249 >::type
hypot(_A1 __lcpp_x,_A2 __lcpp_y)1250 hypot(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
1251 {
1252 typedef typename std::__promote<_A1, _A2>::type __result_type;
1253 static_assert((!(std::is_same<_A1, __result_type>::value &&
1254 std::is_same<_A2, __result_type>::value)), "");
1255 return ::hypot((__result_type)__lcpp_x, (__result_type)__lcpp_y);
1256 }
1257
1258 // ilogb
1259
ilogb(float __lcpp_x)1260 inline _LIBCPP_INLINE_VISIBILITY int ilogb(float __lcpp_x) _NOEXCEPT {return ::ilogbf(__lcpp_x);}
ilogb(long double __lcpp_x)1261 inline _LIBCPP_INLINE_VISIBILITY int ilogb(long double __lcpp_x) _NOEXCEPT {return ::ilogbl(__lcpp_x);}
1262
1263 template <class _A1>
1264 inline _LIBCPP_INLINE_VISIBILITY
1265 typename std::enable_if<std::is_integral<_A1>::value, int>::type
ilogb(_A1 __lcpp_x)1266 ilogb(_A1 __lcpp_x) _NOEXCEPT {return ::ilogb((double)__lcpp_x);}
1267
1268 // lgamma
1269
lgamma(float __lcpp_x)1270 inline _LIBCPP_INLINE_VISIBILITY float lgamma(float __lcpp_x) _NOEXCEPT {return ::lgammaf(__lcpp_x);}
lgamma(long double __lcpp_x)1271 inline _LIBCPP_INLINE_VISIBILITY long double lgamma(long double __lcpp_x) _NOEXCEPT {return ::lgammal(__lcpp_x);}
1272
1273 template <class _A1>
1274 inline _LIBCPP_INLINE_VISIBILITY
1275 typename std::enable_if<std::is_integral<_A1>::value, double>::type
lgamma(_A1 __lcpp_x)1276 lgamma(_A1 __lcpp_x) _NOEXCEPT {return ::lgamma((double)__lcpp_x);}
1277
1278 // llrint
1279
llrint(float __lcpp_x)1280 inline _LIBCPP_INLINE_VISIBILITY long long llrint(float __lcpp_x) _NOEXCEPT {return ::llrintf(__lcpp_x);}
llrint(long double __lcpp_x)1281 inline _LIBCPP_INLINE_VISIBILITY long long llrint(long double __lcpp_x) _NOEXCEPT {return ::llrintl(__lcpp_x);}
1282
1283 template <class _A1>
1284 inline _LIBCPP_INLINE_VISIBILITY
1285 typename std::enable_if<std::is_integral<_A1>::value, long long>::type
llrint(_A1 __lcpp_x)1286 llrint(_A1 __lcpp_x) _NOEXCEPT {return ::llrint((double)__lcpp_x);}
1287
1288 // llround
1289
llround(float __lcpp_x)1290 inline _LIBCPP_INLINE_VISIBILITY long long llround(float __lcpp_x) _NOEXCEPT {return ::llroundf(__lcpp_x);}
llround(long double __lcpp_x)1291 inline _LIBCPP_INLINE_VISIBILITY long long llround(long double __lcpp_x) _NOEXCEPT {return ::llroundl(__lcpp_x);}
1292
1293 template <class _A1>
1294 inline _LIBCPP_INLINE_VISIBILITY
1295 typename std::enable_if<std::is_integral<_A1>::value, long long>::type
llround(_A1 __lcpp_x)1296 llround(_A1 __lcpp_x) _NOEXCEPT {return ::llround((double)__lcpp_x);}
1297
1298 // log1p
1299
log1p(float __lcpp_x)1300 inline _LIBCPP_INLINE_VISIBILITY float log1p(float __lcpp_x) _NOEXCEPT {return ::log1pf(__lcpp_x);}
log1p(long double __lcpp_x)1301 inline _LIBCPP_INLINE_VISIBILITY long double log1p(long double __lcpp_x) _NOEXCEPT {return ::log1pl(__lcpp_x);}
1302
1303 template <class _A1>
1304 inline _LIBCPP_INLINE_VISIBILITY
1305 typename std::enable_if<std::is_integral<_A1>::value, double>::type
log1p(_A1 __lcpp_x)1306 log1p(_A1 __lcpp_x) _NOEXCEPT {return ::log1p((double)__lcpp_x);}
1307
1308 // log2
1309
log2(float __lcpp_x)1310 inline _LIBCPP_INLINE_VISIBILITY float log2(float __lcpp_x) _NOEXCEPT {return ::log2f(__lcpp_x);}
log2(long double __lcpp_x)1311 inline _LIBCPP_INLINE_VISIBILITY long double log2(long double __lcpp_x) _NOEXCEPT {return ::log2l(__lcpp_x);}
1312
1313 template <class _A1>
1314 inline _LIBCPP_INLINE_VISIBILITY
1315 typename std::enable_if<std::is_integral<_A1>::value, double>::type
log2(_A1 __lcpp_x)1316 log2(_A1 __lcpp_x) _NOEXCEPT {return ::log2((double)__lcpp_x);}
1317
1318 // logb
1319
logb(float __lcpp_x)1320 inline _LIBCPP_INLINE_VISIBILITY float logb(float __lcpp_x) _NOEXCEPT {return ::logbf(__lcpp_x);}
logb(long double __lcpp_x)1321 inline _LIBCPP_INLINE_VISIBILITY long double logb(long double __lcpp_x) _NOEXCEPT {return ::logbl(__lcpp_x);}
1322
1323 template <class _A1>
1324 inline _LIBCPP_INLINE_VISIBILITY
1325 typename std::enable_if<std::is_integral<_A1>::value, double>::type
logb(_A1 __lcpp_x)1326 logb(_A1 __lcpp_x) _NOEXCEPT {return ::logb((double)__lcpp_x);}
1327
1328 // lrint
1329
lrint(float __lcpp_x)1330 inline _LIBCPP_INLINE_VISIBILITY long lrint(float __lcpp_x) _NOEXCEPT {return ::lrintf(__lcpp_x);}
lrint(long double __lcpp_x)1331 inline _LIBCPP_INLINE_VISIBILITY long lrint(long double __lcpp_x) _NOEXCEPT {return ::lrintl(__lcpp_x);}
1332
1333 template <class _A1>
1334 inline _LIBCPP_INLINE_VISIBILITY
1335 typename std::enable_if<std::is_integral<_A1>::value, long>::type
lrint(_A1 __lcpp_x)1336 lrint(_A1 __lcpp_x) _NOEXCEPT {return ::lrint((double)__lcpp_x);}
1337
1338 // lround
1339
lround(float __lcpp_x)1340 inline _LIBCPP_INLINE_VISIBILITY long lround(float __lcpp_x) _NOEXCEPT {return ::lroundf(__lcpp_x);}
lround(long double __lcpp_x)1341 inline _LIBCPP_INLINE_VISIBILITY long lround(long double __lcpp_x) _NOEXCEPT {return ::lroundl(__lcpp_x);}
1342
1343 template <class _A1>
1344 inline _LIBCPP_INLINE_VISIBILITY
1345 typename std::enable_if<std::is_integral<_A1>::value, long>::type
lround(_A1 __lcpp_x)1346 lround(_A1 __lcpp_x) _NOEXCEPT {return ::lround((double)__lcpp_x);}
1347
1348 // nan
1349
1350 // nearbyint
1351
nearbyint(float __lcpp_x)1352 inline _LIBCPP_INLINE_VISIBILITY float nearbyint(float __lcpp_x) _NOEXCEPT {return ::nearbyintf(__lcpp_x);}
nearbyint(long double __lcpp_x)1353 inline _LIBCPP_INLINE_VISIBILITY long double nearbyint(long double __lcpp_x) _NOEXCEPT {return ::nearbyintl(__lcpp_x);}
1354
1355 template <class _A1>
1356 inline _LIBCPP_INLINE_VISIBILITY
1357 typename std::enable_if<std::is_integral<_A1>::value, double>::type
nearbyint(_A1 __lcpp_x)1358 nearbyint(_A1 __lcpp_x) _NOEXCEPT {return ::nearbyint((double)__lcpp_x);}
1359
1360 // nextafter
1361
nextafter(float __lcpp_x,float __lcpp_y)1362 inline _LIBCPP_INLINE_VISIBILITY float nextafter(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::nextafterf(__lcpp_x, __lcpp_y);}
nextafter(long double __lcpp_x,long double __lcpp_y)1363 inline _LIBCPP_INLINE_VISIBILITY long double nextafter(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nextafterl(__lcpp_x, __lcpp_y);}
1364
1365 template <class _A1, class _A2>
1366 inline _LIBCPP_INLINE_VISIBILITY
1367 typename std::__lazy_enable_if
1368 <
1369 std::is_arithmetic<_A1>::value &&
1370 std::is_arithmetic<_A2>::value,
1371 std::__promote<_A1, _A2>
1372 >::type
nextafter(_A1 __lcpp_x,_A2 __lcpp_y)1373 nextafter(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
1374 {
1375 typedef typename std::__promote<_A1, _A2>::type __result_type;
1376 static_assert((!(std::is_same<_A1, __result_type>::value &&
1377 std::is_same<_A2, __result_type>::value)), "");
1378 return ::nextafter((__result_type)__lcpp_x, (__result_type)__lcpp_y);
1379 }
1380
1381 // nexttoward
1382
nexttoward(float __lcpp_x,long double __lcpp_y)1383 inline _LIBCPP_INLINE_VISIBILITY float nexttoward(float __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nexttowardf(__lcpp_x, __lcpp_y);}
nexttoward(long double __lcpp_x,long double __lcpp_y)1384 inline _LIBCPP_INLINE_VISIBILITY long double nexttoward(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nexttowardl(__lcpp_x, __lcpp_y);}
1385
1386 template <class _A1>
1387 inline _LIBCPP_INLINE_VISIBILITY
1388 typename std::enable_if<std::is_integral<_A1>::value, double>::type
nexttoward(_A1 __lcpp_x,long double __lcpp_y)1389 nexttoward(_A1 __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nexttoward((double)__lcpp_x, __lcpp_y);}
1390
1391 // remainder
1392
remainder(float __lcpp_x,float __lcpp_y)1393 inline _LIBCPP_INLINE_VISIBILITY float remainder(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::remainderf(__lcpp_x, __lcpp_y);}
remainder(long double __lcpp_x,long double __lcpp_y)1394 inline _LIBCPP_INLINE_VISIBILITY long double remainder(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::remainderl(__lcpp_x, __lcpp_y);}
1395
1396 template <class _A1, class _A2>
1397 inline _LIBCPP_INLINE_VISIBILITY
1398 typename std::__lazy_enable_if
1399 <
1400 std::is_arithmetic<_A1>::value &&
1401 std::is_arithmetic<_A2>::value,
1402 std::__promote<_A1, _A2>
1403 >::type
remainder(_A1 __lcpp_x,_A2 __lcpp_y)1404 remainder(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
1405 {
1406 typedef typename std::__promote<_A1, _A2>::type __result_type;
1407 static_assert((!(std::is_same<_A1, __result_type>::value &&
1408 std::is_same<_A2, __result_type>::value)), "");
1409 return ::remainder((__result_type)__lcpp_x, (__result_type)__lcpp_y);
1410 }
1411
1412 // remquo
1413
remquo(float __lcpp_x,float __lcpp_y,int * __lcpp_z)1414 inline _LIBCPP_INLINE_VISIBILITY float remquo(float __lcpp_x, float __lcpp_y, int* __lcpp_z) _NOEXCEPT {return ::remquof(__lcpp_x, __lcpp_y, __lcpp_z);}
remquo(long double __lcpp_x,long double __lcpp_y,int * __lcpp_z)1415 inline _LIBCPP_INLINE_VISIBILITY long double remquo(long double __lcpp_x, long double __lcpp_y, int* __lcpp_z) _NOEXCEPT {return ::remquol(__lcpp_x, __lcpp_y, __lcpp_z);}
1416
1417 template <class _A1, class _A2>
1418 inline _LIBCPP_INLINE_VISIBILITY
1419 typename std::__lazy_enable_if
1420 <
1421 std::is_arithmetic<_A1>::value &&
1422 std::is_arithmetic<_A2>::value,
1423 std::__promote<_A1, _A2>
1424 >::type
remquo(_A1 __lcpp_x,_A2 __lcpp_y,int * __lcpp_z)1425 remquo(_A1 __lcpp_x, _A2 __lcpp_y, int* __lcpp_z) _NOEXCEPT
1426 {
1427 typedef typename std::__promote<_A1, _A2>::type __result_type;
1428 static_assert((!(std::is_same<_A1, __result_type>::value &&
1429 std::is_same<_A2, __result_type>::value)), "");
1430 return ::remquo((__result_type)__lcpp_x, (__result_type)__lcpp_y, __lcpp_z);
1431 }
1432
1433 // rint
1434
rint(float __lcpp_x)1435 inline _LIBCPP_INLINE_VISIBILITY float rint(float __lcpp_x) _NOEXCEPT {return ::rintf(__lcpp_x);}
rint(long double __lcpp_x)1436 inline _LIBCPP_INLINE_VISIBILITY long double rint(long double __lcpp_x) _NOEXCEPT {return ::rintl(__lcpp_x);}
1437
1438 template <class _A1>
1439 inline _LIBCPP_INLINE_VISIBILITY
1440 typename std::enable_if<std::is_integral<_A1>::value, double>::type
rint(_A1 __lcpp_x)1441 rint(_A1 __lcpp_x) _NOEXCEPT {return ::rint((double)__lcpp_x);}
1442
1443 // round
1444
round(float __lcpp_x)1445 inline _LIBCPP_INLINE_VISIBILITY float round(float __lcpp_x) _NOEXCEPT {return ::roundf(__lcpp_x);}
round(long double __lcpp_x)1446 inline _LIBCPP_INLINE_VISIBILITY long double round(long double __lcpp_x) _NOEXCEPT {return ::roundl(__lcpp_x);}
1447
1448 template <class _A1>
1449 inline _LIBCPP_INLINE_VISIBILITY
1450 typename std::enable_if<std::is_integral<_A1>::value, double>::type
round(_A1 __lcpp_x)1451 round(_A1 __lcpp_x) _NOEXCEPT {return ::round((double)__lcpp_x);}
1452
1453 // scalbln
1454
scalbln(float __lcpp_x,long __lcpp_y)1455 inline _LIBCPP_INLINE_VISIBILITY float scalbln(float __lcpp_x, long __lcpp_y) _NOEXCEPT {return ::scalblnf(__lcpp_x, __lcpp_y);}
scalbln(long double __lcpp_x,long __lcpp_y)1456 inline _LIBCPP_INLINE_VISIBILITY long double scalbln(long double __lcpp_x, long __lcpp_y) _NOEXCEPT {return ::scalblnl(__lcpp_x, __lcpp_y);}
1457
1458 template <class _A1>
1459 inline _LIBCPP_INLINE_VISIBILITY
1460 typename std::enable_if<std::is_integral<_A1>::value, double>::type
scalbln(_A1 __lcpp_x,long __lcpp_y)1461 scalbln(_A1 __lcpp_x, long __lcpp_y) _NOEXCEPT {return ::scalbln((double)__lcpp_x, __lcpp_y);}
1462
1463 // scalbn
1464
scalbn(float __lcpp_x,int __lcpp_y)1465 inline _LIBCPP_INLINE_VISIBILITY float scalbn(float __lcpp_x, int __lcpp_y) _NOEXCEPT {return ::scalbnf(__lcpp_x, __lcpp_y);}
scalbn(long double __lcpp_x,int __lcpp_y)1466 inline _LIBCPP_INLINE_VISIBILITY long double scalbn(long double __lcpp_x, int __lcpp_y) _NOEXCEPT {return ::scalbnl(__lcpp_x, __lcpp_y);}
1467
1468 template <class _A1>
1469 inline _LIBCPP_INLINE_VISIBILITY
1470 typename std::enable_if<std::is_integral<_A1>::value, double>::type
scalbn(_A1 __lcpp_x,int __lcpp_y)1471 scalbn(_A1 __lcpp_x, int __lcpp_y) _NOEXCEPT {return ::scalbn((double)__lcpp_x, __lcpp_y);}
1472
1473 // tgamma
1474
tgamma(float __lcpp_x)1475 inline _LIBCPP_INLINE_VISIBILITY float tgamma(float __lcpp_x) _NOEXCEPT {return ::tgammaf(__lcpp_x);}
tgamma(long double __lcpp_x)1476 inline _LIBCPP_INLINE_VISIBILITY long double tgamma(long double __lcpp_x) _NOEXCEPT {return ::tgammal(__lcpp_x);}
1477
1478 template <class _A1>
1479 inline _LIBCPP_INLINE_VISIBILITY
1480 typename std::enable_if<std::is_integral<_A1>::value, double>::type
tgamma(_A1 __lcpp_x)1481 tgamma(_A1 __lcpp_x) _NOEXCEPT {return ::tgamma((double)__lcpp_x);}
1482
1483 // trunc
1484
trunc(float __lcpp_x)1485 inline _LIBCPP_INLINE_VISIBILITY float trunc(float __lcpp_x) _NOEXCEPT {return ::truncf(__lcpp_x);}
trunc(long double __lcpp_x)1486 inline _LIBCPP_INLINE_VISIBILITY long double trunc(long double __lcpp_x) _NOEXCEPT {return ::truncl(__lcpp_x);}
1487
1488 template <class _A1>
1489 inline _LIBCPP_INLINE_VISIBILITY
1490 typename std::enable_if<std::is_integral<_A1>::value, double>::type
trunc(_A1 __lcpp_x)1491 trunc(_A1 __lcpp_x) _NOEXCEPT {return ::trunc((double)__lcpp_x);}
1492
1493 } // extern "C++"
1494
1495 #endif // __cplusplus
1496
1497 #endif // _LIBCPP_MATH_H
1498