This is an archive of the discontinued LLVM Phabricator instance.

Differential D137498

[libc++][math.h][NFC] Reformat functions
ClosedPublic

Authored by philnik on Nov 5 2022, 1:48 PM.

Details

Reviewers
ldionne
Mordante
var-const
huixie90
EricWF
Group Reviewers
Restricted Project
Commits
rGe1e1cad6fd75: [libc++][math.h][NFC] Reformat functions
Summary

This is just to make to follow-up diffs simpler

Diff Detail

Event Timeline

philnik created this revision.Nov 5 2022, 1:48 PM
Herald added a project: Restricted Project. · View Herald TranscriptNov 5 2022, 1:48 PM
philnik requested review of this revision.Nov 5 2022, 1:48 PM
Herald added a project: Restricted Project. · View Herald TranscriptNov 5 2022, 1:48 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
philnik added a parent revision: D136908: [libc++] Remove duplication in math_h.pass.cpp and improve coverage.Nov 5 2022, 1:49 PM
philnik added a child revision: D135781: [libc++] Assume that builtins for math.h functions are available.
Harbormaster completed remote builds in B196319: Diff 473460.Nov 5 2022, 3:07 PM
EricWF accepted this revision.Nov 6 2022, 2:38 PM
EricWF added a subscriber: EricWF.

This is from clang-format? LGTM then.

This revision is now accepted and ready to land.Nov 6 2022, 2:38 PM
ldionne accepted this revision.Nov 17 2022, 9:28 AM

LGTM

Closed by commit rGe1e1cad6fd75: [libc++][math.h][NFC] Reformat functions (authored by philnik). · Explain WhyNov 21 2022, 1:52 PM
This revision was automatically updated to reflect the committed changes.
philnik added a commit: rGe1e1cad6fd75: [libc++][math.h][NFC] Reformat functions.
philnik removed a child revision: D135781: [libc++] Assume that builtins for math.h functions are available.Nov 21 2022, 1:53 PM

Revision Contents

PathSize
libcxx/
include/
468 lines

Diff 476993

libcxx/include/math.h

Show First 20 Lines • Show All 308 Lines • ▼ Show 20 Lines
#include <__type_traits/promote.h> #include <__type_traits/promote.h>
#include <limits> #include <limits>
#include <stdlib.h> #include <stdlib.h>
#include <type_traits> #include <type_traits>
// signbit // signbit
#ifdef signbit # ifdef signbit
template <class _A1> template <class _A1>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI bool __libcpp_signbit(_A1 __x) _NOEXCEPT {
bool
__libcpp_signbit(_A1 __x) _NOEXCEPT
{
#if __has_builtin(__builtin_signbit) # if __has_builtin(__builtin_signbit)
return __builtin_signbit(__x); return __builtin_signbit(__x);
#else # else
return signbit(__x); return signbit(__x);
#endif # endif
} }
#undef signbit # undef signbit
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type signbit(_A1 __x) _NOEXCEPT {
signbit(_A1 __x) _NOEXCEPT
{
return __libcpp_signbit(__x); return __libcpp_signbit(__x);
} }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename std::enable_if< typename std::enable_if< std::is_integral<_A1>::value && std::is_signed<_A1>::value, bool>::type
std::is_integral<_A1>::value && std::is_signed<_A1>::value, bool>::type signbit(_A1 __x) _NOEXCEPT {
signbit(_A1 __x) _NOEXCEPT return __x < 0;
{ return __x < 0; } }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename std::enable_if< typename std::enable_if< std::is_integral<_A1>::value && !std::is_signed<_A1>::value, bool>::type
std::is_integral<_A1>::value && !std::is_signed<_A1>::value, bool>::type signbit(_A1) _NOEXCEPT {
signbit(_A1) _NOEXCEPT return false;
{ return false; } }
#elif defined(_LIBCPP_MSVCRT) # elif defined(_LIBCPP_MSVCRT)
template <typename _A1> template <typename _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type signbit(_A1 __x) _NOEXCEPT {
signbit(_A1 __x) _NOEXCEPT
{
return ::signbit(__x); return ::signbit(__x);
} }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename std::enable_if< typename std::enable_if< std::is_integral<_A1>::value && std::is_signed<_A1>::value, bool>::type
std::is_integral<_A1>::value && std::is_signed<_A1>::value, bool>::type signbit(_A1 __x) _NOEXCEPT {
signbit(_A1 __x) _NOEXCEPT return __x < 0;
{ return __x < 0; } }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename std::enable_if< typename std::enable_if< std::is_integral<_A1>::value && !std::is_signed<_A1>::value, bool>::type
std::is_integral<_A1>::value && !std::is_signed<_A1>::value, bool>::type signbit(_A1) _NOEXCEPT {
signbit(_A1) _NOEXCEPT return false;
{ return false; } }
#endif // signbit # endif // signbit
// fpclassify // fpclassify
#ifdef fpclassify # ifdef fpclassify
template <class _A1> template <class _A1>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI int __libcpp_fpclassify(_A1 __x) _NOEXCEPT {
int
__libcpp_fpclassify(_A1 __x) _NOEXCEPT
{
#if __has_builtin(__builtin_fpclassify) # if __has_builtin(__builtin_fpclassify)
return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, __x);
FP_ZERO, __x);
#else # else
return fpclassify(__x); return fpclassify(__x);
#endif # endif
} }
#undef fpclassify # undef fpclassify
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if<std::is_floating_point<_A1>::value, int>::type
typename std::enable_if<std::is_floating_point<_A1>::value, int>::type fpclassify(_A1 __x) _NOEXCEPT {
fpclassify(_A1 __x) _NOEXCEPT
{
return __libcpp_fpclassify(__x); return __libcpp_fpclassify(__x);
} }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if<std::is_integral<_A1>::value, int>::type
typename std::enable_if<std::is_integral<_A1>::value, int>::type fpclassify(_A1 __x) _NOEXCEPT {
fpclassify(_A1 __x) _NOEXCEPT return __x == 0 ? FP_ZERO : FP_NORMAL;
{ return __x == 0 ? FP_ZERO : FP_NORMAL; } }
#elif defined(_LIBCPP_MSVCRT) # elif defined(_LIBCPP_MSVCRT)
template <typename _A1> template <typename _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type fpclassify(_A1 __x) _NOEXCEPT {
fpclassify(_A1 __x) _NOEXCEPT
{
return ::fpclassify(__x); return ::fpclassify(__x);
} }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if<std::is_integral<_A1>::value, int>::type
typename std::enable_if<std::is_integral<_A1>::value, int>::type fpclassify(_A1 __x) _NOEXCEPT {
fpclassify(_A1 __x) _NOEXCEPT return __x == 0 ? FP_ZERO : FP_NORMAL;
{ return __x == 0 ? FP_ZERO : FP_NORMAL; } }
#endif // fpclassify # endif // fpclassify
// isfinite // isfinite
#ifdef isfinite # ifdef isfinite
template <class _A1> template <class _A1>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI bool __libcpp_isfinite(_A1 __x) _NOEXCEPT {
bool
__libcpp_isfinite(_A1 __x) _NOEXCEPT
{
#if __has_builtin(__builtin_isfinite) # if __has_builtin(__builtin_isfinite)
return __builtin_isfinite(__x); return __builtin_isfinite(__x);
#else # else
return isfinite(__x); return isfinite(__x);
#endif # endif
} }
#undef isfinite # undef isfinite
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename std::enable_if< typename std::enable_if< std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity, bool>::type
std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity, isfinite(_A1 __x) _NOEXCEPT {
bool>::type
isfinite(_A1 __x) _NOEXCEPT
{
return __libcpp_isfinite((typename std::__promote<_A1>::type)__x); return __libcpp_isfinite((typename std::__promote<_A1>::type)__x);
} }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename std::enable_if< typename std::enable_if< std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity, bool>::type
std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity, isfinite(_A1) _NOEXCEPT {
bool>::type return true;
isfinite(_A1) _NOEXCEPT }
{ return true; }
#endif // isfinite # endif // isfinite
// isinf // isinf
#ifdef isinf # ifdef isinf
template <class _A1> template <class _A1>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI bool __libcpp_isinf(_A1 __x) _NOEXCEPT {
bool
__libcpp_isinf(_A1 __x) _NOEXCEPT
{
#if __has_builtin(__builtin_isinf) # if __has_builtin(__builtin_isinf)
return __builtin_isinf(__x); return __builtin_isinf(__x);
#else # else
return isinf(__x); return isinf(__x);
#endif # endif
} }
#undef isinf # undef isinf
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename std::enable_if< typename std::enable_if< std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity, bool>::type
std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity, isinf(_A1 __x) _NOEXCEPT {
bool>::type
isinf(_A1 __x) _NOEXCEPT
{
return __libcpp_isinf((typename std::__promote<_A1>::type)__x); return __libcpp_isinf((typename std::__promote<_A1>::type)__x);
} }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename std::enable_if< typename std::enable_if< std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity, bool>::type
std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity, isinf(_A1) _NOEXCEPT {
bool>::type return false;
isinf(_A1) _NOEXCEPT }
{ return false; }
#ifdef _LIBCPP_PREFERRED_OVERLOAD # ifdef _LIBCPP_PREFERRED_OVERLOAD
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI bool isinf(float __x) _NOEXCEPT { return __libcpp_isinf(__x); }
bool
isinf(float __x) _NOEXCEPT { return __libcpp_isinf(__x); }
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD bool isinf(double __x) _NOEXCEPT { return __libcpp_isinf(__x); }
bool
isinf(double __x) _NOEXCEPT { return __libcpp_isinf(__x); }
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI bool isinf(long double __x) _NOEXCEPT { return __libcpp_isinf(__x); }
bool
isinf(long double __x) _NOEXCEPT { return __libcpp_isinf(__x); }
#endif # endif
#endif // isinf # endif // isinf
// isnan // isnan
#ifdef isnan # ifdef isnan
template <class _A1> template <class _A1>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI bool __libcpp_isnan(_A1 __x) _NOEXCEPT {
bool
__libcpp_isnan(_A1 __x) _NOEXCEPT
{
#if __has_builtin(__builtin_isnan) # if __has_builtin(__builtin_isnan)
return __builtin_isnan(__x); return __builtin_isnan(__x);
#else # else
return isnan(__x); return isnan(__x);
#endif # endif
} }
#undef isnan # undef isnan
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type isnan(_A1 __x) _NOEXCEPT {
isnan(_A1 __x) _NOEXCEPT
{
return __libcpp_isnan(__x); return __libcpp_isnan(__x);
} }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if<std::is_integral<_A1>::value, bool>::type isnan(_A1) _NOEXCEPT {
typename std::enable_if<std::is_integral<_A1>::value, bool>::type return false;
isnan(_A1) _NOEXCEPT }
{ return false; }
#ifdef _LIBCPP_PREFERRED_OVERLOAD # ifdef _LIBCPP_PREFERRED_OVERLOAD
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI bool isnan(float __x) _NOEXCEPT { return __libcpp_isnan(__x); }
bool
isnan(float __x) _NOEXCEPT { return __libcpp_isnan(__x); }
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD bool isnan(double __x) _NOEXCEPT { return __libcpp_isnan(__x); }
bool
isnan(double __x) _NOEXCEPT { return __libcpp_isnan(__x); }
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI bool isnan(long double __x) _NOEXCEPT { return __libcpp_isnan(__x); }
bool
isnan(long double __x) _NOEXCEPT { return __libcpp_isnan(__x); }
#endif # endif
#endif // isnan # endif // isnan
// isnormal // isnormal
#ifdef isnormal # ifdef isnormal
template <class _A1> template <class _A1>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI bool __libcpp_isnormal(_A1 __x) _NOEXCEPT {
bool
__libcpp_isnormal(_A1 __x) _NOEXCEPT
{
#if __has_builtin(__builtin_isnormal) # if __has_builtin(__builtin_isnormal)
return __builtin_isnormal(__x); return __builtin_isnormal(__x);
#else # else
return isnormal(__x); return isnormal(__x);
#endif # endif
} }
#undef isnormal # undef isnormal
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type isnormal(_A1 __x) _NOEXCEPT {
isnormal(_A1 __x) _NOEXCEPT
{
return __libcpp_isnormal(__x); return __libcpp_isnormal(__x);
} }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if<std::is_integral<_A1>::value, bool>::type
typename std::enable_if<std::is_integral<_A1>::value, bool>::type isnormal(_A1 __x) _NOEXCEPT {
isnormal(_A1 __x) _NOEXCEPT return __x != 0;
{ return __x != 0; } }
#endif // isnormal # endif // isnormal
// isgreater // isgreater
#ifdef isgreater # ifdef isgreater
template <class _A1, class _A2> template <class _A1, class _A2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI bool __libcpp_isgreater(_A1 __x, _A2 __y) _NOEXCEPT {
bool
__libcpp_isgreater(_A1 __x, _A2 __y) _NOEXCEPT
{
return isgreater(__x, __y); return isgreater(__x, __y);
} }
#undef isgreater # undef isgreater
template <class _A1, class _A2> template <class _A1, class _A2>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename std::enable_if typename std::enable_if< std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, bool >::type
< isgreater(_A1 __x, _A2 __y) _NOEXCEPT {
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
bool
>::type
isgreater(_A1 __x, _A2 __y) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type type; typedef typename std::__promote<_A1, _A2>::type type;
return __libcpp_isgreater((type)__x, (type)__y); return __libcpp_isgreater((type)__x, (type)__y);
} }
#endif // isgreater # endif // isgreater
// isgreaterequal // isgreaterequal
#ifdef isgreaterequal # ifdef isgreaterequal
template <class _A1, class _A2> template <class _A1, class _A2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI bool __libcpp_isgreaterequal(_A1 __x, _A2 __y) _NOEXCEPT {
bool
__libcpp_isgreaterequal(_A1 __x, _A2 __y) _NOEXCEPT
{
return isgreaterequal(__x, __y); return isgreaterequal(__x, __y);
} }
#undef isgreaterequal # undef isgreaterequal
template <class _A1, class _A2> template <class _A1, class _A2>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename std::enable_if typename std::enable_if< std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, bool >::type
< isgreaterequal(_A1 __x, _A2 __y) _NOEXCEPT {
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
bool
>::type
isgreaterequal(_A1 __x, _A2 __y) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type type; typedef typename std::__promote<_A1, _A2>::type type;
return __libcpp_isgreaterequal((type)__x, (type)__y); return __libcpp_isgreaterequal((type)__x, (type)__y);
} }
#endif // isgreaterequal # endif // isgreaterequal
// isless // isless
#ifdef isless # ifdef isless
template <class _A1, class _A2> template <class _A1, class _A2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI bool __libcpp_isless(_A1 __x, _A2 __y) _NOEXCEPT {
bool
__libcpp_isless(_A1 __x, _A2 __y) _NOEXCEPT
{
return isless(__x, __y); return isless(__x, __y);
} }
#undef isless # undef isless
template <class _A1, class _A2> template <class _A1, class _A2>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename std::enable_if typename std::enable_if< std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, bool >::type
< isless(_A1 __x, _A2 __y) _NOEXCEPT {
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
bool
>::type
isless(_A1 __x, _A2 __y) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type type; typedef typename std::__promote<_A1, _A2>::type type;
return __libcpp_isless((type)__x, (type)__y); return __libcpp_isless((type)__x, (type)__y);
} }
#endif // isless # endif // isless
// islessequal // islessequal
#ifdef islessequal # ifdef islessequal
template <class _A1, class _A2> template <class _A1, class _A2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI bool __libcpp_islessequal(_A1 __x, _A2 __y) _NOEXCEPT {
bool
__libcpp_islessequal(_A1 __x, _A2 __y) _NOEXCEPT
{
return islessequal(__x, __y); return islessequal(__x, __y);
} }
#undef islessequal # undef islessequal
template <class _A1, class _A2> template <class _A1, class _A2>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename std::enable_if typename std::enable_if< std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, bool >::type
< islessequal(_A1 __x, _A2 __y) _NOEXCEPT {
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
bool
>::type
islessequal(_A1 __x, _A2 __y) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type type; typedef typename std::__promote<_A1, _A2>::type type;
return __libcpp_islessequal((type)__x, (type)__y); return __libcpp_islessequal((type)__x, (type)__y);
} }
#endif // islessequal # endif // islessequal
// islessgreater // islessgreater
#ifdef islessgreater # ifdef islessgreater
template <class _A1, class _A2> template <class _A1, class _A2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI bool __libcpp_islessgreater(_A1 __x, _A2 __y) _NOEXCEPT {
bool
__libcpp_islessgreater(_A1 __x, _A2 __y) _NOEXCEPT
{
return islessgreater(__x, __y); return islessgreater(__x, __y);
} }
#undef islessgreater # undef islessgreater
template <class _A1, class _A2> template <class _A1, class _A2>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename std::enable_if typename std::enable_if< std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, bool >::type
< islessgreater(_A1 __x, _A2 __y) _NOEXCEPT {
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
bool
>::type
islessgreater(_A1 __x, _A2 __y) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type type; typedef typename std::__promote<_A1, _A2>::type type;
return __libcpp_islessgreater((type)__x, (type)__y); return __libcpp_islessgreater((type)__x, (type)__y);
} }
#endif // islessgreater # endif // islessgreater
// isunordered // isunordered
#ifdef isunordered # ifdef isunordered
template <class _A1, class _A2> template <class _A1, class _A2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI bool __libcpp_isunordered(_A1 __x, _A2 __y) _NOEXCEPT {
bool
__libcpp_isunordered(_A1 __x, _A2 __y) _NOEXCEPT
{
return isunordered(__x, __y); return isunordered(__x, __y);
} }
#undef isunordered # undef isunordered
template <class _A1, class _A2> template <class _A1, class _A2>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename std::enable_if typename std::enable_if< std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, bool >::type
< isunordered(_A1 __x, _A2 __y) _NOEXCEPT {
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
bool
>::type
isunordered(_A1 __x, _A2 __y) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type type; typedef typename std::__promote<_A1, _A2>::type type;
return __libcpp_isunordered((type)__x, (type)__y); return __libcpp_isunordered((type)__x, (type)__y);
} }
#endif // isunordered # endif // isunordered
// abs // abs
// //
// handled in stdlib.h // handled in stdlib.h
// div // div
// //
// handled in stdlib.h // handled in stdlib.h
▲ Show 20 Lines • Show All 976 Lines • Show Last 20 Lines