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