cmath revision 246468 
1112798Smdodd// -*- C++ -*-
2112798Smdodd//===---------------------------- cmath -----------------------------------===//
3112798Smdodd//
4112798Smdodd//                     The LLVM Compiler Infrastructure
5112798Smdodd//
6112798Smdodd// This file is dual licensed under the MIT and the University of Illinois Open
7112798Smdodd// Source Licenses. See LICENSE.TXT for details.
8112798Smdodd//
9112798Smdodd//===----------------------------------------------------------------------===//
10112798Smdodd
11276696Simp#ifndef _LIBCPP_CMATH
12276696Simp#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(arithmetic x);
141
142int fpclassify(arithmetic x);
143
144bool isfinite(arithmetic x);
145bool isinf(arithmetic x);
146bool isnan(arithmetic x);
147bool isnormal(arithmetic x);
148
149bool isgreater(arithmetic x, arithmetic y);
150bool isgreaterequal(arithmetic x, arithmetic y);
151bool isless(arithmetic x, arithmetic y);
152bool islessequal(arithmetic x, arithmetic y);
153bool islessgreater(arithmetic x, arithmetic y);
154bool isunordered(arithmetic x, arithmetic 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_arithmetic<_A1>::value, bool>::type
329signbit(_A1 __x) _NOEXCEPT
330{
331    return __libcpp_signbit((typename std::__promote<_A1>::type)__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_arithmetic<_A1>::value, int>::type
353fpclassify(_A1 __x) _NOEXCEPT
354{
355    return __libcpp_fpclassify((typename std::__promote<_A1>::type)__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_arithmetic<_A1>::value, bool>::type
377isfinite(_A1 __x) _NOEXCEPT
378{
379    return __libcpp_isfinite((typename std::__promote<_A1>::type)__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_arithmetic<_A1>::value, bool>::type
401isinf(_A1 __x) _NOEXCEPT
402{
403    return __libcpp_isinf((typename std::__promote<_A1>::type)__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_arithmetic<_A1>::value, bool>::type
425isnan(_A1 __x) _NOEXCEPT
426{
427    return __libcpp_isnan((typename std::__promote<_A1>::type)__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_arithmetic<_A1>::value, bool>::type
449isnormal(_A1 __x) _NOEXCEPT
450{
451    return __libcpp_isnormal((typename std::__promote<_A1>::type)__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_arithmetic<_A1>::value &&
475    std::is_arithmetic<_A2>::value,
476    bool
477>::type
478isgreater(_A1 __x, _A2 __y) _NOEXCEPT
479{
480    typedef typename std::__promote<_A1, _A2>::type type;
481    return __libcpp_isgreater((type)__x, (type)__y);
482}
483
484#endif  // isgreater
485
486// isgreaterequal
487
488#ifdef isgreaterequal
489
490template <class _A1, class _A2>
491_LIBCPP_ALWAYS_INLINE
492bool
493__libcpp_isgreaterequal(_A1 __x, _A2 __y) _NOEXCEPT
494{
495    return isgreaterequal(__x, __y);
496}
497
498#undef isgreaterequal
499
500template <class _A1, class _A2>
501inline _LIBCPP_INLINE_VISIBILITY
502typename std::enable_if
503<
504    std::is_arithmetic<_A1>::value &&
505    std::is_arithmetic<_A2>::value,
506    bool
507>::type
508isgreaterequal(_A1 __x, _A2 __y) _NOEXCEPT
509{
510    typedef typename std::__promote<_A1, _A2>::type type;
511    return __libcpp_isgreaterequal((type)__x, (type)__y);
512}
513
514#endif  // isgreaterequal
515
516// isless
517
518#ifdef isless
519
520template <class _A1, class _A2>
521_LIBCPP_ALWAYS_INLINE
522bool
523__libcpp_isless(_A1 __x, _A2 __y) _NOEXCEPT
524{
525    return isless(__x, __y);
526}
527
528#undef isless
529
530template <class _A1, class _A2>
531inline _LIBCPP_INLINE_VISIBILITY
532typename std::enable_if
533<
534    std::is_arithmetic<_A1>::value &&
535    std::is_arithmetic<_A2>::value,
536    bool
537>::type
538isless(_A1 __x, _A2 __y) _NOEXCEPT
539{
540    typedef typename std::__promote<_A1, _A2>::type type;
541    return __libcpp_isless((type)__x, (type)__y);
542}
543
544#endif  // isless
545
546// islessequal
547
548#ifdef islessequal
549
550template <class _A1, class _A2>
551_LIBCPP_ALWAYS_INLINE
552bool
553__libcpp_islessequal(_A1 __x, _A2 __y) _NOEXCEPT
554{
555    return islessequal(__x, __y);
556}
557
558#undef islessequal
559
560template <class _A1, class _A2>
561inline _LIBCPP_INLINE_VISIBILITY
562typename std::enable_if
563<
564    std::is_arithmetic<_A1>::value &&
565    std::is_arithmetic<_A2>::value,
566    bool
567>::type
568islessequal(_A1 __x, _A2 __y) _NOEXCEPT
569{
570    typedef typename std::__promote<_A1, _A2>::type type;
571    return __libcpp_islessequal((type)__x, (type)__y);
572}
573
574#endif  // islessequal
575
576// islessgreater
577
578#ifdef islessgreater
579
580template <class _A1, class _A2>
581_LIBCPP_ALWAYS_INLINE
582bool
583__libcpp_islessgreater(_A1 __x, _A2 __y) _NOEXCEPT
584{
585    return islessgreater(__x, __y);
586}
587
588#undef islessgreater
589
590template <class _A1, class _A2>
591inline _LIBCPP_INLINE_VISIBILITY
592typename std::enable_if
593<
594    std::is_arithmetic<_A1>::value &&
595    std::is_arithmetic<_A2>::value,
596    bool
597>::type
598islessgreater(_A1 __x, _A2 __y) _NOEXCEPT
599{
600    typedef typename std::__promote<_A1, _A2>::type type;
601    return __libcpp_islessgreater((type)__x, (type)__y);
602}
603
604#endif  // islessgreater
605
606// isunordered
607
608#ifdef isunordered
609
610template <class _A1, class _A2>
611_LIBCPP_ALWAYS_INLINE
612bool
613__libcpp_isunordered(_A1 __x, _A2 __y) _NOEXCEPT
614{
615    return isunordered(__x, __y);
616}
617
618#undef isunordered
619
620template <class _A1, class _A2>
621inline _LIBCPP_INLINE_VISIBILITY
622typename std::enable_if
623<
624    std::is_arithmetic<_A1>::value &&
625    std::is_arithmetic<_A2>::value,
626    bool
627>::type
628isunordered(_A1 __x, _A2 __y) _NOEXCEPT
629{
630    typedef typename std::__promote<_A1, _A2>::type type;
631    return __libcpp_isunordered((type)__x, (type)__y);
632}
633
634#endif  // isunordered
635
636_LIBCPP_BEGIN_NAMESPACE_STD
637
638using ::signbit;
639using ::fpclassify;
640using ::isfinite;
641using ::isinf;
642using ::isnan;
643using ::isnormal;
644using ::isgreater;
645using ::isgreaterequal;
646using ::isless;
647using ::islessequal;
648using ::islessgreater;
649using ::isunordered;
650using ::isunordered;
651
652using ::float_t;
653using ::double_t;
654
655// abs
656
657inline _LIBCPP_INLINE_VISIBILITY
658float
659abs(float __x) _NOEXCEPT {return fabsf(__x);}
660
661inline _LIBCPP_INLINE_VISIBILITY
662double
663abs(double __x) _NOEXCEPT {return fabs(__x);}
664
665inline _LIBCPP_INLINE_VISIBILITY
666long double
667abs(long double __x) _NOEXCEPT {return fabsl(__x);}
668
669#ifndef __sun__
670
671// acos
672
673using ::acos;
674using ::acosf;
675
676#ifndef _MSC_VER
677inline _LIBCPP_INLINE_VISIBILITY float       acos(float __x) _NOEXCEPT       {return acosf(__x);}
678inline _LIBCPP_INLINE_VISIBILITY long double acos(long double __x) _NOEXCEPT {return acosl(__x);}
679#endif
680
681template <class _A1>
682inline _LIBCPP_INLINE_VISIBILITY
683typename enable_if<is_integral<_A1>::value, double>::type
684acos(_A1 __x) _NOEXCEPT {return acos((double)__x);}
685
686// asin
687
688using ::asin;
689using ::asinf;
690
691#ifndef _MSC_VER
692inline _LIBCPP_INLINE_VISIBILITY float       asin(float __x) _NOEXCEPT       {return asinf(__x);}
693inline _LIBCPP_INLINE_VISIBILITY long double asin(long double __x) _NOEXCEPT {return asinl(__x);}
694#endif
695
696template <class _A1>
697inline _LIBCPP_INLINE_VISIBILITY
698typename enable_if<is_integral<_A1>::value, double>::type
699asin(_A1 __x) _NOEXCEPT {return asin((double)__x);}
700
701// atan
702
703using ::atan;
704using ::atanf;
705
706#ifndef _MSC_VER
707inline _LIBCPP_INLINE_VISIBILITY float       atan(float __x) _NOEXCEPT       {return atanf(__x);}
708inline _LIBCPP_INLINE_VISIBILITY long double atan(long double __x) _NOEXCEPT {return atanl(__x);}
709#endif
710
711template <class _A1>
712inline _LIBCPP_INLINE_VISIBILITY
713typename enable_if<is_integral<_A1>::value, double>::type
714atan(_A1 __x) _NOEXCEPT {return atan((double)__x);}
715
716// atan2
717
718using ::atan2;
719using ::atan2f;
720
721#ifndef _MSC_VER
722inline _LIBCPP_INLINE_VISIBILITY float       atan2(float __y, float __x) _NOEXCEPT             {return atan2f(__y, __x);}
723inline _LIBCPP_INLINE_VISIBILITY long double atan2(long double __y, long double __x) _NOEXCEPT {return atan2l(__y, __x);}
724#endif
725
726template <class _A1, class _A2>
727inline _LIBCPP_INLINE_VISIBILITY
728typename enable_if
729<
730    is_arithmetic<_A1>::value &&
731    is_arithmetic<_A2>::value,
732    typename __promote<_A1, _A2>::type
733>::type
734atan2(_A1 __y, _A2 __x) _NOEXCEPT
735{
736    typedef typename __promote<_A1, _A2>::type __result_type;
737    static_assert((!(is_same<_A1, __result_type>::value &&
738                      is_same<_A2, __result_type>::value)), "");
739    return atan2((__result_type)__y, (__result_type)__x);
740}
741
742// ceil
743
744using ::ceil;
745using ::ceilf;
746
747#ifndef _MSC_VER
748inline _LIBCPP_INLINE_VISIBILITY float       ceil(float __x) _NOEXCEPT       {return ceilf(__x);}
749inline _LIBCPP_INLINE_VISIBILITY long double ceil(long double __x) _NOEXCEPT {return ceill(__x);}
750#endif
751
752template <class _A1>
753inline _LIBCPP_INLINE_VISIBILITY
754typename enable_if<is_integral<_A1>::value, double>::type
755ceil(_A1 __x) _NOEXCEPT {return ceil((double)__x);}
756
757// cos
758
759using ::cos;
760using ::cosf;
761
762#ifndef _MSC_VER
763inline _LIBCPP_INLINE_VISIBILITY float       cos(float __x) _NOEXCEPT       {return cosf(__x);}
764inline _LIBCPP_INLINE_VISIBILITY long double cos(long double __x) _NOEXCEPT {return cosl(__x);}
765#endif
766
767template <class _A1>
768inline _LIBCPP_ALWAYS_INLINE _LIBCPP_INLINE_VISIBILITY
769typename enable_if<is_integral<_A1>::value, double>::type
770cos(_A1 __x) _NOEXCEPT {return cos((double)__x);}
771
772// cosh
773
774using ::cosh;
775using ::coshf;
776
777#ifndef _MSC_VER
778inline _LIBCPP_INLINE_VISIBILITY float       cosh(float __x) _NOEXCEPT       {return coshf(__x);}
779inline _LIBCPP_INLINE_VISIBILITY long double cosh(long double __x) _NOEXCEPT {return coshl(__x);}
780#endif
781
782template <class _A1>
783inline _LIBCPP_INLINE_VISIBILITY
784typename enable_if<is_integral<_A1>::value, double>::type
785cosh(_A1 __x) _NOEXCEPT {return cosh((double)__x);}
786
787#endif // __sun__
788// exp
789
790using ::exp;
791using ::expf;
792
793#ifndef __sun__
794
795#ifndef _MSC_VER
796inline _LIBCPP_INLINE_VISIBILITY float       exp(float __x) _NOEXCEPT       {return expf(__x);}
797inline _LIBCPP_INLINE_VISIBILITY long double exp(long double __x) _NOEXCEPT {return expl(__x);}
798#endif
799
800
801template <class _A1>
802inline _LIBCPP_INLINE_VISIBILITY
803typename enable_if<is_integral<_A1>::value, double>::type
804exp(_A1 __x) _NOEXCEPT {return exp((double)__x);}
805
806// fabs
807
808using ::fabs;
809using ::fabsf;
810
811#ifndef _MSC_VER
812inline _LIBCPP_INLINE_VISIBILITY float       fabs(float __x) _NOEXCEPT       {return fabsf(__x);}
813inline _LIBCPP_INLINE_VISIBILITY long double fabs(long double __x) _NOEXCEPT {return fabsl(__x);}
814#endif
815
816template <class _A1>
817inline _LIBCPP_INLINE_VISIBILITY
818typename enable_if<is_integral<_A1>::value, double>::type
819fabs(_A1 __x) _NOEXCEPT {return fabs((double)__x);}
820
821// floor
822
823using ::floor;
824using ::floorf;
825
826#ifndef _MSC_VER
827inline _LIBCPP_INLINE_VISIBILITY float       floor(float __x) _NOEXCEPT       {return floorf(__x);}
828inline _LIBCPP_INLINE_VISIBILITY long double floor(long double __x) _NOEXCEPT {return floorl(__x);}
829#endif
830
831template <class _A1>
832inline _LIBCPP_INLINE_VISIBILITY
833typename enable_if<is_integral<_A1>::value, double>::type
834floor(_A1 __x) _NOEXCEPT {return floor((double)__x);}
835
836// fmod
837
838#endif //__sun__
839using ::fmod;
840using ::fmodf;
841#ifndef __sun__
842
843#ifndef _MSC_VER
844inline _LIBCPP_INLINE_VISIBILITY float       fmod(float __x, float __y) _NOEXCEPT             {return fmodf(__x, __y);}
845inline _LIBCPP_INLINE_VISIBILITY long double fmod(long double __x, long double __y) _NOEXCEPT {return fmodl(__x, __y);}
846#endif
847
848template <class _A1, class _A2>
849inline _LIBCPP_INLINE_VISIBILITY
850typename enable_if
851<
852    is_arithmetic<_A1>::value &&
853    is_arithmetic<_A2>::value,
854    typename __promote<_A1, _A2>::type
855>::type
856fmod(_A1 __x, _A2 __y) _NOEXCEPT
857{
858    typedef typename __promote<_A1, _A2>::type __result_type;
859    static_assert((!(is_same<_A1, __result_type>::value &&
860                      is_same<_A2, __result_type>::value)), "");
861    return fmod((__result_type)__x, (__result_type)__y);
862}
863
864
865// frexp
866
867using ::frexp;
868using ::frexpf;
869
870#ifndef _MSC_VER
871inline _LIBCPP_INLINE_VISIBILITY float       frexp(float __x, int* __e) _NOEXCEPT       {return frexpf(__x, __e);}
872inline _LIBCPP_INLINE_VISIBILITY long double frexp(long double __x, int* __e) _NOEXCEPT {return frexpl(__x, __e);}
873#endif
874
875template <class _A1>
876inline _LIBCPP_INLINE_VISIBILITY
877typename enable_if<is_integral<_A1>::value, double>::type
878frexp(_A1 __x, int* __e) _NOEXCEPT {return frexp((double)__x, __e);}
879
880// ldexp
881
882using ::ldexp;
883using ::ldexpf;
884
885#ifndef _MSC_VER
886inline _LIBCPP_INLINE_VISIBILITY float       ldexp(float __x, int __e) _NOEXCEPT       {return ldexpf(__x, __e);}
887inline _LIBCPP_INLINE_VISIBILITY long double ldexp(long double __x, int __e) _NOEXCEPT {return ldexpl(__x, __e);}
888#endif
889
890template <class _A1>
891inline _LIBCPP_INLINE_VISIBILITY
892typename enable_if<is_integral<_A1>::value, double>::type
893ldexp(_A1 __x, int __e) _NOEXCEPT {return ldexp((double)__x, __e);}
894
895// log
896
897#endif // __sun__
898using ::log;
899using ::logf;
900#ifndef __sun__
901
902#ifndef _MSC_VER
903inline _LIBCPP_INLINE_VISIBILITY float       log(float __x) _NOEXCEPT       {return logf(__x);}
904inline _LIBCPP_INLINE_VISIBILITY long double log(long double __x) _NOEXCEPT {return logl(__x);}
905#endif
906
907template <class _A1>
908inline _LIBCPP_INLINE_VISIBILITY
909typename enable_if<is_integral<_A1>::value, double>::type
910log(_A1 __x) _NOEXCEPT {return log((double)__x);}
911
912
913// log10
914
915using ::log10;
916using ::log10f;
917
918#ifndef _MSC_VER
919inline _LIBCPP_INLINE_VISIBILITY float       log10(float __x) _NOEXCEPT       {return log10f(__x);}
920inline _LIBCPP_INLINE_VISIBILITY long double log10(long double __x) _NOEXCEPT {return log10l(__x);}
921#endif
922
923template <class _A1>
924inline _LIBCPP_INLINE_VISIBILITY
925typename enable_if<is_integral<_A1>::value, double>::type
926log10(_A1 __x) _NOEXCEPT {return log10((double)__x);}
927
928// modf
929
930using ::modf;
931using ::modff;
932
933#ifndef _MSC_VER
934inline _LIBCPP_INLINE_VISIBILITY float       modf(float __x, float* __y) _NOEXCEPT             {return modff(__x, __y);}
935inline _LIBCPP_INLINE_VISIBILITY long double modf(long double __x, long double* __y) _NOEXCEPT {return modfl(__x, __y);}
936#endif
937
938// pow
939
940#endif // __sun__ 
941using ::pow;
942using ::powf;
943
944#ifndef __sun__
945
946#ifndef _MSC_VER
947inline _LIBCPP_INLINE_VISIBILITY float       pow(float __x, float __y) _NOEXCEPT             {return powf(__x, __y);}
948inline _LIBCPP_INLINE_VISIBILITY long double pow(long double __x, long double __y) _NOEXCEPT {return powl(__x, __y);}
949#endif
950
951template <class _A1, class _A2>
952inline _LIBCPP_INLINE_VISIBILITY
953typename enable_if
954<
955    is_arithmetic<_A1>::value &&
956    is_arithmetic<_A2>::value,
957    typename __promote<_A1, _A2>::type
958>::type
959pow(_A1 __x, _A2 __y) _NOEXCEPT
960{
961    typedef typename __promote<_A1, _A2>::type __result_type;
962    static_assert((!(is_same<_A1, __result_type>::value &&
963                      is_same<_A2, __result_type>::value)), "");
964    return pow((__result_type)__x, (__result_type)__y);
965}
966
967
968// sin
969
970using ::sin;
971using ::sinf;
972
973#ifndef _MSC_VER
974inline _LIBCPP_INLINE_VISIBILITY float       sin(float __x) _NOEXCEPT       {return sinf(__x);}
975inline _LIBCPP_INLINE_VISIBILITY long double sin(long double __x) _NOEXCEPT {return sinl(__x);}
976#endif
977
978template <class _A1>
979inline _LIBCPP_INLINE_VISIBILITY
980typename enable_if<is_integral<_A1>::value, double>::type
981sin(_A1 __x) _NOEXCEPT {return sin((double)__x);}
982
983// sinh
984
985using ::sinh;
986using ::sinhf;
987
988#ifndef _MSC_VER
989inline _LIBCPP_INLINE_VISIBILITY float       sinh(float __x) _NOEXCEPT       {return sinhf(__x);}
990inline _LIBCPP_INLINE_VISIBILITY long double sinh(long double __x) _NOEXCEPT {return sinhl(__x);}
991#endif
992
993template <class _A1>
994inline _LIBCPP_INLINE_VISIBILITY
995typename enable_if<is_integral<_A1>::value, double>::type
996sinh(_A1 __x) _NOEXCEPT {return sinh((double)__x);}
997
998// sqrt
999
1000#endif // __sun__
1001using ::sqrt;
1002using ::sqrtf;
1003
1004
1005#if !(defined(_MSC_VER) || defined(__sun__))
1006inline _LIBCPP_INLINE_VISIBILITY float       sqrt(float __x) _NOEXCEPT       {return sqrtf(__x);}
1007inline _LIBCPP_INLINE_VISIBILITY long double sqrt(long double __x) _NOEXCEPT {return sqrtl(__x);}
1008#endif
1009
1010template <class _A1>
1011inline _LIBCPP_INLINE_VISIBILITY
1012typename enable_if<is_integral<_A1>::value, double>::type
1013sqrt(_A1 __x) _NOEXCEPT {return sqrt((double)__x);}
1014
1015// tan
1016
1017using ::tan;
1018using ::tanf;
1019#ifndef __sun__
1020
1021#ifndef _MSC_VER
1022inline _LIBCPP_INLINE_VISIBILITY float       tan(float __x) _NOEXCEPT       {return tanf(__x);}
1023inline _LIBCPP_INLINE_VISIBILITY long double tan(long double __x) _NOEXCEPT {return tanl(__x);}
1024#endif
1025
1026template <class _A1>
1027inline _LIBCPP_INLINE_VISIBILITY
1028typename enable_if<is_integral<_A1>::value, double>::type
1029tan(_A1 __x) _NOEXCEPT {return tan((double)__x);}
1030
1031// tanh
1032
1033using ::tanh;
1034using ::tanhf;
1035
1036#ifndef _MSC_VER
1037inline _LIBCPP_INLINE_VISIBILITY float       tanh(float __x) _NOEXCEPT       {return tanhf(__x);}
1038inline _LIBCPP_INLINE_VISIBILITY long double tanh(long double __x) _NOEXCEPT {return tanhl(__x);}
1039#endif
1040
1041template <class _A1>
1042inline _LIBCPP_INLINE_VISIBILITY
1043typename enable_if<is_integral<_A1>::value, double>::type
1044tanh(_A1 __x) _NOEXCEPT {return tanh((double)__x);}
1045
1046// acosh
1047
1048#ifndef _MSC_VER
1049using ::acosh;
1050using ::acoshf;
1051
1052inline _LIBCPP_INLINE_VISIBILITY float       acosh(float __x) _NOEXCEPT       {return acoshf(__x);}
1053inline _LIBCPP_INLINE_VISIBILITY long double acosh(long double __x) _NOEXCEPT {return acoshl(__x);}
1054
1055template <class _A1>
1056inline _LIBCPP_INLINE_VISIBILITY
1057typename enable_if<is_integral<_A1>::value, double>::type
1058acosh(_A1 __x) _NOEXCEPT {return acosh((double)__x);}
1059#endif
1060
1061// asinh
1062
1063#ifndef _MSC_VER
1064using ::asinh;
1065using ::asinhf;
1066
1067inline _LIBCPP_INLINE_VISIBILITY float       asinh(float __x) _NOEXCEPT       {return asinhf(__x);}
1068inline _LIBCPP_INLINE_VISIBILITY long double asinh(long double __x) _NOEXCEPT {return asinhl(__x);}
1069
1070template <class _A1>
1071inline _LIBCPP_INLINE_VISIBILITY
1072typename enable_if<is_integral<_A1>::value, double>::type
1073asinh(_A1 __x) _NOEXCEPT {return asinh((double)__x);}
1074#endif
1075
1076// atanh
1077
1078#ifndef _MSC_VER
1079using ::atanh;
1080using ::atanhf;
1081
1082inline _LIBCPP_INLINE_VISIBILITY float       atanh(float __x) _NOEXCEPT       {return atanhf(__x);}
1083inline _LIBCPP_INLINE_VISIBILITY long double atanh(long double __x) _NOEXCEPT {return atanhl(__x);}
1084
1085template <class _A1>
1086inline _LIBCPP_INLINE_VISIBILITY
1087typename enable_if<is_integral<_A1>::value, double>::type
1088atanh(_A1 __x) _NOEXCEPT {return atanh((double)__x);}
1089#endif
1090
1091// cbrt
1092
1093#ifndef _MSC_VER
1094using ::cbrt;
1095using ::cbrtf;
1096
1097inline _LIBCPP_INLINE_VISIBILITY float       cbrt(float __x) _NOEXCEPT       {return cbrtf(__x);}
1098inline _LIBCPP_INLINE_VISIBILITY long double cbrt(long double __x) _NOEXCEPT {return cbrtl(__x);}
1099
1100template <class _A1>
1101inline _LIBCPP_INLINE_VISIBILITY
1102typename enable_if<is_integral<_A1>::value, double>::type
1103cbrt(_A1 __x) _NOEXCEPT {return cbrt((double)__x);}
1104#endif
1105
1106// copysign
1107
1108using ::copysign;
1109using ::copysignf;
1110
1111inline _LIBCPP_INLINE_VISIBILITY float       copysign(float __x, float __y) _NOEXCEPT             {return copysignf(__x, __y);}
1112inline _LIBCPP_INLINE_VISIBILITY long double copysign(long double __x, long double __y) _NOEXCEPT {return copysignl(__x, __y);}
1113
1114template <class _A1, class _A2>
1115inline _LIBCPP_INLINE_VISIBILITY
1116typename enable_if
1117<
1118    is_arithmetic<_A1>::value &&
1119    is_arithmetic<_A2>::value,
1120    typename __promote<_A1, _A2>::type
1121>::type
1122copysign(_A1 __x, _A2 __y) _NOEXCEPT
1123{
1124    typedef typename __promote<_A1, _A2>::type __result_type;
1125    static_assert((!(is_same<_A1, __result_type>::value &&
1126                      is_same<_A2, __result_type>::value)), "");
1127    return copysign((__result_type)__x, (__result_type)__y);
1128}
1129
1130#ifndef _MSC_VER
1131
1132// erf
1133
1134using ::erf;
1135using ::erff;
1136
1137inline _LIBCPP_INLINE_VISIBILITY float       erf(float __x) _NOEXCEPT       {return erff(__x);}
1138inline _LIBCPP_INLINE_VISIBILITY long double erf(long double __x) _NOEXCEPT {return erfl(__x);}
1139
1140template <class _A1>
1141inline _LIBCPP_INLINE_VISIBILITY
1142typename enable_if<is_integral<_A1>::value, double>::type
1143erf(_A1 __x) _NOEXCEPT {return erf((double)__x);}
1144
1145// erfc
1146
1147using ::erfc;
1148using ::erfcf;
1149
1150inline _LIBCPP_INLINE_VISIBILITY float       erfc(float __x) _NOEXCEPT       {return erfcf(__x);}
1151inline _LIBCPP_INLINE_VISIBILITY long double erfc(long double __x) _NOEXCEPT {return erfcl(__x);}
1152
1153template <class _A1>
1154inline _LIBCPP_INLINE_VISIBILITY
1155typename enable_if<is_integral<_A1>::value, double>::type
1156erfc(_A1 __x) _NOEXCEPT {return erfc((double)__x);}
1157
1158// exp2
1159
1160using ::exp2;
1161using ::exp2f;
1162
1163inline _LIBCPP_INLINE_VISIBILITY float       exp2(float __x) _NOEXCEPT       {return exp2f(__x);}
1164inline _LIBCPP_INLINE_VISIBILITY long double exp2(long double __x) _NOEXCEPT {return exp2l(__x);}
1165
1166template <class _A1>
1167inline _LIBCPP_INLINE_VISIBILITY
1168typename enable_if<is_integral<_A1>::value, double>::type
1169exp2(_A1 __x) _NOEXCEPT {return exp2((double)__x);}
1170
1171// expm1
1172
1173using ::expm1;
1174using ::expm1f;
1175
1176inline _LIBCPP_INLINE_VISIBILITY float       expm1(float __x) _NOEXCEPT       {return expm1f(__x);}
1177inline _LIBCPP_INLINE_VISIBILITY long double expm1(long double __x) _NOEXCEPT {return expm1l(__x);}
1178
1179template <class _A1>
1180inline _LIBCPP_INLINE_VISIBILITY
1181typename enable_if<is_integral<_A1>::value, double>::type
1182expm1(_A1 __x) _NOEXCEPT {return expm1((double)__x);}
1183
1184// fdim
1185
1186using ::fdim;
1187using ::fdimf;
1188
1189inline _LIBCPP_INLINE_VISIBILITY float       fdim(float __x, float __y) _NOEXCEPT             {return fdimf(__x, __y);}
1190inline _LIBCPP_INLINE_VISIBILITY long double fdim(long double __x, long double __y) _NOEXCEPT {return fdiml(__x, __y);}
1191
1192template <class _A1, class _A2>
1193inline _LIBCPP_INLINE_VISIBILITY
1194typename enable_if
1195<
1196    is_arithmetic<_A1>::value &&
1197    is_arithmetic<_A2>::value,
1198    typename __promote<_A1, _A2>::type
1199>::type
1200fdim(_A1 __x, _A2 __y) _NOEXCEPT
1201{
1202    typedef typename __promote<_A1, _A2>::type __result_type;
1203    static_assert((!(is_same<_A1, __result_type>::value &&
1204                      is_same<_A2, __result_type>::value)), "");
1205    return fdim((__result_type)__x, (__result_type)__y);
1206}
1207
1208// fma
1209
1210inline _LIBCPP_INLINE_VISIBILITY float fmaf(float __x, float __y, float __z) _NOEXCEPT {return (float)((double)__x*__y + __z);}
1211#ifndef FP_FAST_FMAF
1212#define FP_FAST_FMAF
1213#endif
1214
1215using ::fma;
1216
1217inline _LIBCPP_INLINE_VISIBILITY float       fma(float __x, float __y, float __z) _NOEXCEPT                   {return fmaf(__x, __y, __z);}
1218inline _LIBCPP_INLINE_VISIBILITY long double fma(long double __x, long double __y, long double __z) _NOEXCEPT {return fmal(__x, __y, __z);}
1219
1220template <class _A1, class _A2, class _A3>
1221inline _LIBCPP_INLINE_VISIBILITY
1222typename enable_if
1223<
1224    is_arithmetic<_A1>::value &&
1225    is_arithmetic<_A2>::value &&
1226    is_arithmetic<_A3>::value,
1227    typename __promote<_A1, _A2, _A3>::type
1228>::type
1229fma(_A1 __x, _A2 __y, _A3 __z) _NOEXCEPT
1230{
1231    typedef typename __promote<_A1, _A2, _A3>::type __result_type;
1232    static_assert((!(is_same<_A1, __result_type>::value &&
1233                      is_same<_A2, __result_type>::value &&
1234                      is_same<_A3, __result_type>::value)), "");
1235    return fma((__result_type)__x, (__result_type)__y, (__result_type)__z);
1236}
1237
1238// fmax
1239
1240using ::fmax;
1241using ::fmaxf;
1242
1243inline _LIBCPP_INLINE_VISIBILITY float       fmax(float __x, float __y) _NOEXCEPT             {return fmaxf(__x, __y);}
1244inline _LIBCPP_INLINE_VISIBILITY long double fmax(long double __x, long double __y) _NOEXCEPT {return fmaxl(__x, __y);}
1245
1246template <class _A1, class _A2>
1247inline _LIBCPP_INLINE_VISIBILITY
1248typename enable_if
1249<
1250    is_arithmetic<_A1>::value &&
1251    is_arithmetic<_A2>::value,
1252    typename __promote<_A1, _A2>::type
1253>::type
1254fmax(_A1 __x, _A2 __y) _NOEXCEPT
1255{
1256    typedef typename __promote<_A1, _A2>::type __result_type;
1257    static_assert((!(is_same<_A1, __result_type>::value &&
1258                      is_same<_A2, __result_type>::value)), "");
1259    return fmax((__result_type)__x, (__result_type)__y);
1260}
1261
1262// fmin
1263
1264using ::fmin;
1265using ::fminf;
1266
1267inline _LIBCPP_INLINE_VISIBILITY float       fmin(float __x, float __y) _NOEXCEPT             {return fminf(__x, __y);}
1268inline _LIBCPP_INLINE_VISIBILITY long double fmin(long double __x, long double __y) _NOEXCEPT {return fminl(__x, __y);}
1269
1270template <class _A1, class _A2>
1271inline _LIBCPP_INLINE_VISIBILITY
1272typename enable_if
1273<
1274    is_arithmetic<_A1>::value &&
1275    is_arithmetic<_A2>::value,
1276    typename __promote<_A1, _A2>::type
1277>::type
1278fmin(_A1 __x, _A2 __y) _NOEXCEPT
1279{
1280    typedef typename __promote<_A1, _A2>::type __result_type;
1281    static_assert((!(is_same<_A1, __result_type>::value &&
1282                      is_same<_A2, __result_type>::value)), "");
1283    return fmin((__result_type)__x, (__result_type)__y);
1284}
1285
1286// hypot
1287
1288using ::hypot;
1289using ::hypotf;
1290
1291inline _LIBCPP_INLINE_VISIBILITY float       hypot(float __x, float __y) _NOEXCEPT             {return hypotf(__x, __y);}
1292inline _LIBCPP_INLINE_VISIBILITY long double hypot(long double __x, long double __y) _NOEXCEPT {return hypotl(__x, __y);}
1293
1294template <class _A1, class _A2>
1295inline _LIBCPP_INLINE_VISIBILITY
1296typename enable_if
1297<
1298    is_arithmetic<_A1>::value &&
1299    is_arithmetic<_A2>::value,
1300    typename __promote<_A1, _A2>::type
1301>::type
1302hypot(_A1 __x, _A2 __y) _NOEXCEPT
1303{
1304    typedef typename __promote<_A1, _A2>::type __result_type;
1305    static_assert((!(is_same<_A1, __result_type>::value &&
1306                      is_same<_A2, __result_type>::value)), "");
1307    return hypot((__result_type)__x, (__result_type)__y);
1308}
1309
1310// ilogb
1311
1312using ::ilogb;
1313using ::ilogbf;
1314
1315inline _LIBCPP_INLINE_VISIBILITY int ilogb(float __x) _NOEXCEPT       {return ilogbf(__x);}
1316inline _LIBCPP_INLINE_VISIBILITY int ilogb(long double __x) _NOEXCEPT {return ilogbl(__x);}
1317
1318template <class _A1>
1319inline _LIBCPP_INLINE_VISIBILITY
1320typename enable_if<is_integral<_A1>::value, int>::type
1321ilogb(_A1 __x) _NOEXCEPT {return ilogb((double)__x);}
1322
1323// lgamma
1324
1325using ::lgamma;
1326using ::lgammaf;
1327
1328inline _LIBCPP_INLINE_VISIBILITY float       lgamma(float __x) _NOEXCEPT       {return lgammaf(__x);}
1329inline _LIBCPP_INLINE_VISIBILITY long double lgamma(long double __x) _NOEXCEPT {return lgammal(__x);}
1330
1331
1332template <class _A1>
1333inline _LIBCPP_INLINE_VISIBILITY
1334typename enable_if<is_integral<_A1>::value, double>::type
1335lgamma(_A1 __x) _NOEXCEPT {return lgamma((double)__x);}
1336
1337
1338// llrint
1339
1340using ::llrint;
1341using ::llrintf;
1342
1343inline _LIBCPP_INLINE_VISIBILITY long long llrint(float __x) _NOEXCEPT       {return llrintf(__x);}
1344inline _LIBCPP_INLINE_VISIBILITY long long llrint(long double __x) _NOEXCEPT {return llrintl(__x);}
1345
1346template <class _A1>
1347inline _LIBCPP_INLINE_VISIBILITY
1348typename enable_if<is_integral<_A1>::value, long long>::type
1349llrint(_A1 __x) _NOEXCEPT {return llrint((double)__x);}
1350
1351// llround
1352
1353using ::llround;
1354using ::llroundf;
1355
1356inline _LIBCPP_INLINE_VISIBILITY long long llround(float __x) _NOEXCEPT       {return llroundf(__x);}
1357inline _LIBCPP_INLINE_VISIBILITY long long llround(long double __x) _NOEXCEPT {return llroundl(__x);}
1358
1359template <class _A1>
1360inline _LIBCPP_INLINE_VISIBILITY
1361typename enable_if<is_integral<_A1>::value, long long>::type
1362llround(_A1 __x) _NOEXCEPT {return llround((double)__x);}
1363
1364// log1p
1365
1366using ::log1p;
1367using ::log1pf;
1368
1369inline _LIBCPP_INLINE_VISIBILITY float       log1p(float __x) _NOEXCEPT       {return log1pf(__x);}
1370inline _LIBCPP_INLINE_VISIBILITY long double log1p(long double __x) _NOEXCEPT {return log1pl(__x);}
1371
1372template <class _A1>
1373inline _LIBCPP_INLINE_VISIBILITY
1374typename enable_if<is_integral<_A1>::value, double>::type
1375log1p(_A1 __x) _NOEXCEPT {return log1p((double)__x);}
1376
1377// log2
1378
1379using ::log2;
1380using ::log2f;
1381
1382inline _LIBCPP_INLINE_VISIBILITY float       log2(float __x) _NOEXCEPT       {return log2f(__x);}
1383inline _LIBCPP_INLINE_VISIBILITY long double log2(long double __x) _NOEXCEPT {return log2l(__x);}
1384
1385template <class _A1>
1386inline _LIBCPP_INLINE_VISIBILITY
1387typename enable_if<is_integral<_A1>::value, double>::type
1388log2(_A1 __x) _NOEXCEPT {return log2((double)__x);}
1389
1390// logb
1391
1392using ::logb;
1393using ::logbf;
1394
1395inline _LIBCPP_INLINE_VISIBILITY float       logb(float __x) _NOEXCEPT       {return logbf(__x);}
1396inline _LIBCPP_INLINE_VISIBILITY long double logb(long double __x) _NOEXCEPT {return logbl(__x);}
1397
1398template <class _A1>
1399inline _LIBCPP_INLINE_VISIBILITY
1400typename enable_if<is_integral<_A1>::value, double>::type
1401logb(_A1 __x) _NOEXCEPT {return logb((double)__x);}
1402
1403// lrint
1404
1405using ::lrint;
1406using ::lrintf;
1407
1408inline _LIBCPP_INLINE_VISIBILITY long lrint(float __x) _NOEXCEPT       {return lrintf(__x);}
1409inline _LIBCPP_INLINE_VISIBILITY long lrint(long double __x) _NOEXCEPT {return lrintl(__x);}
1410
1411template <class _A1>
1412inline _LIBCPP_INLINE_VISIBILITY
1413typename enable_if<is_integral<_A1>::value, long>::type
1414lrint(_A1 __x) _NOEXCEPT {return lrint((double)__x);}
1415
1416// lround
1417
1418using ::lround;
1419using ::lroundf;
1420
1421inline _LIBCPP_INLINE_VISIBILITY long lround(float __x) _NOEXCEPT       {return lroundf(__x);}
1422inline _LIBCPP_INLINE_VISIBILITY long lround(long double __x) _NOEXCEPT {return lroundl(__x);}
1423
1424template <class _A1>
1425inline _LIBCPP_INLINE_VISIBILITY
1426typename enable_if<is_integral<_A1>::value, long>::type
1427lround(_A1 __x) _NOEXCEPT {return lround((double)__x);}
1428
1429// nan
1430#endif // _MSC_VER
1431#endif // __sun__
1432using ::nan;
1433using ::nanf;
1434#ifndef __sun__
1435#ifndef _MSC_VER
1436
1437// nearbyint
1438
1439using ::nearbyint;
1440using ::nearbyintf;
1441
1442inline _LIBCPP_INLINE_VISIBILITY float       nearbyint(float __x) _NOEXCEPT       {return nearbyintf(__x);}
1443inline _LIBCPP_INLINE_VISIBILITY long double nearbyint(long double __x) _NOEXCEPT {return nearbyintl(__x);}
1444
1445template <class _A1>
1446inline _LIBCPP_INLINE_VISIBILITY
1447typename enable_if<is_integral<_A1>::value, double>::type
1448nearbyint(_A1 __x) _NOEXCEPT {return nearbyint((double)__x);}
1449
1450// nextafter
1451
1452using ::nextafter;
1453using ::nextafterf;
1454
1455inline _LIBCPP_INLINE_VISIBILITY float       nextafter(float __x, float __y) _NOEXCEPT             {return nextafterf(__x, __y);}
1456inline _LIBCPP_INLINE_VISIBILITY long double nextafter(long double __x, long double __y) _NOEXCEPT {return nextafterl(__x, __y);}
1457
1458template <class _A1, class _A2>
1459inline _LIBCPP_INLINE_VISIBILITY
1460typename enable_if
1461<
1462    is_arithmetic<_A1>::value &&
1463    is_arithmetic<_A2>::value,
1464    typename __promote<_A1, _A2>::type
1465>::type
1466nextafter(_A1 __x, _A2 __y) _NOEXCEPT
1467{
1468    typedef typename __promote<_A1, _A2>::type __result_type;
1469    static_assert((!(is_same<_A1, __result_type>::value &&
1470                      is_same<_A2, __result_type>::value)), "");
1471    return nextafter((__result_type)__x, (__result_type)__y);
1472}
1473
1474// nexttoward
1475
1476using ::nexttoward;
1477using ::nexttowardf;
1478
1479inline _LIBCPP_INLINE_VISIBILITY float       nexttoward(float __x, long double __y) _NOEXCEPT       {return nexttowardf(__x, __y);}
1480inline _LIBCPP_INLINE_VISIBILITY long double nexttoward(long double __x, long double __y) _NOEXCEPT {return nexttowardl(__x, __y);}
1481
1482template <class _A1>
1483inline _LIBCPP_INLINE_VISIBILITY
1484typename enable_if<is_integral<_A1>::value, double>::type
1485nexttoward(_A1 __x, long double __y) _NOEXCEPT {return nexttoward((double)__x, __y);}
1486
1487// remainder
1488
1489using ::remainder;
1490using ::remainderf;
1491
1492inline _LIBCPP_INLINE_VISIBILITY float       remainder(float __x, float __y) _NOEXCEPT             {return remainderf(__x, __y);}
1493inline _LIBCPP_INLINE_VISIBILITY long double remainder(long double __x, long double __y) _NOEXCEPT {return remainderl(__x, __y);}
1494
1495template <class _A1, class _A2>
1496inline _LIBCPP_INLINE_VISIBILITY
1497typename enable_if
1498<
1499    is_arithmetic<_A1>::value &&
1500    is_arithmetic<_A2>::value,
1501    typename __promote<_A1, _A2>::type
1502>::type
1503remainder(_A1 __x, _A2 __y) _NOEXCEPT
1504{
1505    typedef typename __promote<_A1, _A2>::type __result_type;
1506    static_assert((!(is_same<_A1, __result_type>::value &&
1507                      is_same<_A2, __result_type>::value)), "");
1508    return remainder((__result_type)__x, (__result_type)__y);
1509}
1510
1511// remquo
1512
1513using ::remquo;
1514using ::remquof;
1515
1516inline _LIBCPP_INLINE_VISIBILITY float       remquo(float __x, float __y, int* __z) _NOEXCEPT             {return remquof(__x, __y, __z);}
1517inline _LIBCPP_INLINE_VISIBILITY long double remquo(long double __x, long double __y, int* __z) _NOEXCEPT {return remquol(__x, __y, __z);}
1518
1519template <class _A1, class _A2>
1520inline _LIBCPP_INLINE_VISIBILITY
1521typename enable_if
1522<
1523    is_arithmetic<_A1>::value &&
1524    is_arithmetic<_A2>::value,
1525    typename __promote<_A1, _A2>::type
1526>::type
1527remquo(_A1 __x, _A2 __y, int* __z) _NOEXCEPT
1528{
1529    typedef typename __promote<_A1, _A2>::type __result_type;
1530    static_assert((!(is_same<_A1, __result_type>::value &&
1531                      is_same<_A2, __result_type>::value)), "");
1532    return remquo((__result_type)__x, (__result_type)__y, __z);
1533}
1534
1535// rint
1536
1537using ::rint;
1538using ::rintf;
1539
1540inline _LIBCPP_INLINE_VISIBILITY float       rint(float __x) _NOEXCEPT       {return rintf(__x);}
1541inline _LIBCPP_INLINE_VISIBILITY long double rint(long double __x) _NOEXCEPT {return rintl(__x);}
1542
1543template <class _A1>
1544inline _LIBCPP_INLINE_VISIBILITY
1545typename enable_if<is_integral<_A1>::value, double>::type
1546rint(_A1 __x) _NOEXCEPT {return rint((double)__x);}
1547
1548// round
1549
1550using ::round;
1551using ::roundf;
1552
1553inline _LIBCPP_INLINE_VISIBILITY float       round(float __x) _NOEXCEPT       {return roundf(__x);}
1554inline _LIBCPP_INLINE_VISIBILITY long double round(long double __x) _NOEXCEPT {return roundl(__x);}
1555
1556template <class _A1>
1557inline _LIBCPP_INLINE_VISIBILITY
1558typename enable_if<is_integral<_A1>::value, double>::type
1559round(_A1 __x) _NOEXCEPT {return round((double)__x);}
1560
1561// scalbln
1562
1563using ::scalbln;
1564using ::scalblnf;
1565
1566inline _LIBCPP_INLINE_VISIBILITY float       scalbln(float __x, long __y) _NOEXCEPT       {return scalblnf(__x, __y);}
1567inline _LIBCPP_INLINE_VISIBILITY long double scalbln(long double __x, long __y) _NOEXCEPT {return scalblnl(__x, __y);}
1568
1569template <class _A1>
1570inline _LIBCPP_INLINE_VISIBILITY
1571typename enable_if<is_integral<_A1>::value, double>::type
1572scalbln(_A1 __x, long __y) _NOEXCEPT {return scalbln((double)__x, __y);}
1573
1574// scalbn
1575
1576using ::scalbn;
1577using ::scalbnf;
1578
1579inline _LIBCPP_INLINE_VISIBILITY float       scalbn(float __x, int __y) _NOEXCEPT       {return scalbnf(__x, __y);}
1580inline _LIBCPP_INLINE_VISIBILITY long double scalbn(long double __x, int __y) _NOEXCEPT {return scalbnl(__x, __y);}
1581
1582template <class _A1>
1583inline _LIBCPP_INLINE_VISIBILITY
1584typename enable_if<is_integral<_A1>::value, double>::type
1585scalbn(_A1 __x, int __y) _NOEXCEPT {return scalbn((double)__x, __y);}
1586
1587// tgamma
1588
1589using ::tgamma;
1590using ::tgammaf;
1591
1592inline _LIBCPP_INLINE_VISIBILITY float       tgamma(float __x) _NOEXCEPT       {return tgammaf(__x);}
1593inline _LIBCPP_INLINE_VISIBILITY long double tgamma(long double __x) _NOEXCEPT {return tgammal(__x);}
1594
1595template <class _A1>
1596inline _LIBCPP_INLINE_VISIBILITY
1597typename enable_if<is_integral<_A1>::value, double>::type
1598tgamma(_A1 __x) _NOEXCEPT {return tgamma((double)__x);}
1599
1600// trunc
1601
1602using ::trunc;
1603using ::truncf;
1604
1605inline _LIBCPP_INLINE_VISIBILITY float       trunc(float __x) _NOEXCEPT       {return truncf(__x);}
1606inline _LIBCPP_INLINE_VISIBILITY long double trunc(long double __x) _NOEXCEPT {return truncl(__x);}
1607
1608template <class _A1>
1609inline _LIBCPP_INLINE_VISIBILITY
1610typename enable_if<is_integral<_A1>::value, double>::type
1611trunc(_A1 __x) _NOEXCEPT {return trunc((double)__x);}
1612
1613#endif // !_MSC_VER
1614
1615using ::acosl;
1616using ::asinl;
1617using ::atanl;
1618using ::atan2l;
1619using ::ceill;
1620using ::cosl;
1621using ::coshl;
1622using ::expl;
1623using ::fabsl;
1624using ::floorl;
1625using ::fmodl;
1626using ::frexpl;
1627using ::ldexpl;
1628using ::logl;
1629using ::log10l;
1630using ::modfl;
1631using ::powl;
1632using ::sinl;
1633using ::sinhl;
1634using ::sqrtl;
1635using ::tanl;
1636#ifndef _MSC_VER
1637using ::tanhl;
1638using ::acoshl;
1639using ::asinhl;
1640using ::atanhl;
1641using ::cbrtl;
1642#endif  // !_MSC_VER
1643using ::copysignl;
1644#ifndef _MSC_VER
1645using ::erfl;
1646using ::erfcl;
1647using ::exp2l;
1648using ::expm1l;
1649using ::fdiml;
1650using ::fmal;
1651using ::fmaxl;
1652using ::fminl;
1653using ::hypotl;
1654using ::ilogbl;
1655using ::lgammal;
1656using ::llrintl;
1657using ::llroundl;
1658using ::log1pl;
1659using ::log2l;
1660using ::logbl;
1661using ::lrintl;
1662using ::lroundl;
1663using ::nanl;
1664using ::nearbyintl;
1665using ::nextafterl;
1666using ::nexttowardl;
1667using ::remainderl;
1668using ::remquol;
1669using ::rintl;
1670using ::roundl;
1671using ::scalblnl;
1672using ::scalbnl;
1673using ::tgammal;
1674using ::truncl;
1675#endif // !_MSC_VER
1676
1677#else 
1678using ::lgamma;
1679using ::lgammaf;
1680#endif // __sun__
1681_LIBCPP_END_NAMESPACE_STD
1682
1683#endif  // _LIBCPP_CMATH
1684