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