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