This is an archive of the discontinued LLVM Phabricator instance.

Differential D155260

[libc++][NFC] Format math headers
ClosedPublic

Authored by philnik on Jul 13 2023, 9:55 PM.

Details

Reviewers
Mordante
Group Reviewers
Restricted Project
Commits
rG0e4d812f3e98: [libc++][NFC] Format math headers

Diff Detail

Event Timeline

philnik created this revision.Jul 13 2023, 9:55 PM
Herald added a project: Restricted Project. · View Herald TranscriptJul 13 2023, 9:55 PM
philnik requested review of this revision.Jul 13 2023, 9:55 PM
Herald added a project: Restricted Project. · View Herald TranscriptJul 13 2023, 9:55 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Harbormaster completed remote builds in B245283: Diff 540270.Jul 13 2023, 9:56 PM
philnik updated this revision to Diff 540273.Jul 13 2023, 10:04 PM

Rebased

philnik added a parent revision: D155259: [libc++][NFC] Remove std:: qualifications from math headers.Jul 13 2023, 10:05 PM
Harbormaster completed remote builds in B245286: Diff 540273.Jul 13 2023, 10:05 PM
philnik added a child revision: D155261: [libc++][NFC] Refactor the enable_ifs in the math headers.Jul 13 2023, 11:41 PM
Mordante accepted this revision.Jul 14 2023, 9:29 AM
Mordante added a subscriber: Mordante.

LGTM! Please make sure the CI passes, I expect you need changes to formatted file list to mark these headers as formatted properly.

This revision is now accepted and ready to land.Jul 14 2023, 9:29 AM
philnik retitled this revision from [libc++] Format math headers to [libc++][NFC] Format math headers.Jul 14 2023, 11:05 AM
philnik updated this revision to Diff 540725.Jul 15 2023, 12:14 PM

Rebased

Herald added a subscriber: arichardson. · View Herald TranscriptJul 15 2023, 12:14 PM
Harbormaster completed remote builds in B245621: Diff 540725.Jul 15 2023, 12:14 PM
philnik updated this revision to Diff 545194.Jul 28 2023, 9:22 AM

Rebased

Harbormaster completed remote builds in B248874: Diff 545194.Jul 28 2023, 11:26 AM
philnik updated this revision to Diff 545229.Jul 28 2023, 11:27 AM

Try to fix CI

Harbormaster completed remote builds in B248895: Diff 545229.Jul 28 2023, 4:56 PM
Closed by commit rG0e4d812f3e98: [libc++][NFC] Format math headers (authored by philnik). · Explain WhyJul 31 2023, 5:20 PM
This revision was automatically updated to reflect the committed changes.
philnik added a commit: rG0e4d812f3e98: [libc++][NFC] Format math headers.

Revision Contents

PathSize
libcxx/
include/
__math/
13 lines
7 lines
20 lines
105 lines
23 lines
33 lines
20 lines
30 lines
23 lines
30 lines
53 lines
61 lines
50 lines
29 lines
48 lines
23 lines
201 lines
47 lines
30 lines
utils/
data/
19 lines

Diff 545229

libcxx/include/__math/abs.h

Show All 17 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace __math { namespace __math {
// fabs // fabs
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float fabs(float __x) _NOEXCEPT {return __builtin_fabsf(__x);} _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float fabs(float __x) _NOEXCEPT { return __builtin_fabsf(__x); }
template <class = int> template <class = int>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double fabs(double __x) _NOEXCEPT { _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double fabs(double __x) _NOEXCEPT {
return __builtin_fabs(__x); return __builtin_fabs(__x);
} }
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double fabs(long double __x) _NOEXCEPT {return __builtin_fabsl(__x);} _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double fabs(long double __x) _NOEXCEPT {
return __builtin_fabsl(__x);
}
template <class _A1> template <class _A1>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type
typename enable_if<is_integral<_A1>::value, double>::type fabs(_A1 __x) _NOEXCEPT {
fabs(_A1 __x) _NOEXCEPT {return __builtin_fabs((double)__x);} return __builtin_fabs((double)__x);
}
} // namespace __math } // namespace __math
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MATH_ABS_H #endif // _LIBCPP___MATH_ABS_H

libcxx/include/__math/copysign.h

Show All 29 Lines
} }
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double copysign(long double __x, long double __y) _NOEXCEPT { _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double copysign(long double __x, long double __y) _NOEXCEPT {
return ::__builtin_copysignl(__x, __y); return ::__builtin_copysignl(__x, __y);
} }
template <class _A1, class _A2> template <class _A1, class _A2>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI
typename __enable_if_t typename __enable_if_t< is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, __promote<_A1, _A2> >::type
<
is_arithmetic<_A1>::value &&
is_arithmetic<_A2>::value,
__promote<_A1, _A2>
>::type
copysign(_A1 __x, _A2 __y) _NOEXCEPT { copysign(_A1 __x, _A2 __y) _NOEXCEPT {
return ::__builtin_copysign(__x, __y); return ::__builtin_copysign(__x, __y);
} }
} // namespace __math } // namespace __math
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MATH_COPYSIGN_H #endif // _LIBCPP___MATH_COPYSIGN_H

libcxx/include/__math/error_functions.h

Show All 17 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace __math { namespace __math {
// erf // erf
inline _LIBCPP_HIDE_FROM_ABI float erf(float __x) _NOEXCEPT {return __builtin_erff(__x);} inline _LIBCPP_HIDE_FROM_ABI float erf(float __x) _NOEXCEPT { return __builtin_erff(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double erf(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double erf(double __x) _NOEXCEPT {
return __builtin_erf(__x); return __builtin_erf(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double erf(long double __x) _NOEXCEPT {return __builtin_erfl(__x);} inline _LIBCPP_HIDE_FROM_ABI long double erf(long double __x) _NOEXCEPT { return __builtin_erfl(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type erf(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_erf((double)__x);
erf(_A1 __x) _NOEXCEPT {return __builtin_erf((double)__x);} }
// erfc // erfc
inline _LIBCPP_HIDE_FROM_ABI float erfc(float __x) _NOEXCEPT {return __builtin_erfcf(__x);} inline _LIBCPP_HIDE_FROM_ABI float erfc(float __x) _NOEXCEPT { return __builtin_erfcf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double erfc(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double erfc(double __x) _NOEXCEPT {
return __builtin_erfc(__x); return __builtin_erfc(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double erfc(long double __x) _NOEXCEPT {return __builtin_erfcl(__x);} inline _LIBCPP_HIDE_FROM_ABI long double erfc(long double __x) _NOEXCEPT { return __builtin_erfcl(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type erfc(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_erfc((double)__x);
erfc(_A1 __x) _NOEXCEPT {return __builtin_erfc((double)__x);} }
} // namespace __math } // namespace __math
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MATH_ERROR_FUNCTIONS_H #endif // _LIBCPP___MATH_ERROR_FUNCTIONS_H

libcxx/include/__math/exponential_functions.h

Show All 20 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace __math { namespace __math {
// exp // exp
inline _LIBCPP_HIDE_FROM_ABI float exp(float __x) _NOEXCEPT {return __builtin_expf(__x);} inline _LIBCPP_HIDE_FROM_ABI float exp(float __x) _NOEXCEPT { return __builtin_expf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double exp(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double exp(double __x) _NOEXCEPT {
return __builtin_exp(__x); return __builtin_exp(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double exp(long double __x) _NOEXCEPT {return __builtin_expl(__x);} inline _LIBCPP_HIDE_FROM_ABI long double exp(long double __x) _NOEXCEPT { return __builtin_expl(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type exp(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_exp((double)__x);
exp(_A1 __x) _NOEXCEPT {return __builtin_exp((double)__x);} }
// frexp // frexp
inline _LIBCPP_HIDE_FROM_ABI float frexp(float __x, int* __e) _NOEXCEPT {return __builtin_frexpf(__x, __e);} inline _LIBCPP_HIDE_FROM_ABI float frexp(float __x, int* __e) _NOEXCEPT { return __builtin_frexpf(__x, __e); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double frexp(double __x, int* __e) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double frexp(double __x, int* __e) _NOEXCEPT {
return __builtin_frexp(__x, __e); return __builtin_frexp(__x, __e);
} }
inline _LIBCPP_HIDE_FROM_ABI long double frexp(long double __x, int* __e) _NOEXCEPT {return __builtin_frexpl(__x, __e);} inline _LIBCPP_HIDE_FROM_ABI long double frexp(long double __x, int* __e) _NOEXCEPT {
return __builtin_frexpl(__x, __e);
}
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type
typename enable_if<is_integral<_A1>::value, double>::type frexp(_A1 __x, int* __e) _NOEXCEPT {
frexp(_A1 __x, int* __e) _NOEXCEPT {return __builtin_frexp((double)__x, __e);} return __builtin_frexp((double)__x, __e);
}
// ldexp // ldexp
inline _LIBCPP_HIDE_FROM_ABI float ldexp(float __x, int __e) _NOEXCEPT {return __builtin_ldexpf(__x, __e);} inline _LIBCPP_HIDE_FROM_ABI float ldexp(float __x, int __e) _NOEXCEPT { return __builtin_ldexpf(__x, __e); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double ldexp(double __x, int __e) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double ldexp(double __x, int __e) _NOEXCEPT {
return __builtin_ldexp(__x, __e); return __builtin_ldexp(__x, __e);
} }
inline _LIBCPP_HIDE_FROM_ABI long double ldexp(long double __x, int __e) _NOEXCEPT {return __builtin_ldexpl(__x, __e);} inline _LIBCPP_HIDE_FROM_ABI long double ldexp(long double __x, int __e) _NOEXCEPT {
return __builtin_ldexpl(__x, __e);
}
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type
typename enable_if<is_integral<_A1>::value, double>::type ldexp(_A1 __x, int __e) _NOEXCEPT {
ldexp(_A1 __x, int __e) _NOEXCEPT {return __builtin_ldexp((double)__x, __e);} return __builtin_ldexp((double)__x, __e);
}
// exp2 // exp2
inline _LIBCPP_HIDE_FROM_ABI float exp2(float __x) _NOEXCEPT {return __builtin_exp2f(__x);} inline _LIBCPP_HIDE_FROM_ABI float exp2(float __x) _NOEXCEPT { return __builtin_exp2f(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double exp2(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double exp2(double __x) _NOEXCEPT {
return __builtin_exp2(__x); return __builtin_exp2(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double exp2(long double __x) _NOEXCEPT {return __builtin_exp2l(__x);} inline _LIBCPP_HIDE_FROM_ABI long double exp2(long double __x) _NOEXCEPT { return __builtin_exp2l(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type exp2(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_exp2((double)__x);
exp2(_A1 __x) _NOEXCEPT {return __builtin_exp2((double)__x);} }
// expm1 // expm1
inline _LIBCPP_HIDE_FROM_ABI float expm1(float __x) _NOEXCEPT {return __builtin_expm1f(__x);} inline _LIBCPP_HIDE_FROM_ABI float expm1(float __x) _NOEXCEPT { return __builtin_expm1f(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double expm1(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double expm1(double __x) _NOEXCEPT {
return __builtin_expm1(__x); return __builtin_expm1(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double expm1(long double __x) _NOEXCEPT {return __builtin_expm1l(__x);} inline _LIBCPP_HIDE_FROM_ABI long double expm1(long double __x) _NOEXCEPT { return __builtin_expm1l(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type expm1(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_expm1((double)__x);
expm1(_A1 __x) _NOEXCEPT {return __builtin_expm1((double)__x);} }
// scalbln // scalbln
inline _LIBCPP_HIDE_FROM_ABI float scalbln(float __x, long __y) _NOEXCEPT {return __builtin_scalblnf(__x, __y);} inline _LIBCPP_HIDE_FROM_ABI float scalbln(float __x, long __y) _NOEXCEPT { return __builtin_scalblnf(__x, __y); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double scalbln(double __x, long __y) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double scalbln(double __x, long __y) _NOEXCEPT {
return __builtin_scalbln(__x, __y); return __builtin_scalbln(__x, __y);
} }
inline _LIBCPP_HIDE_FROM_ABI long double scalbln(long double __x, long __y) _NOEXCEPT {return __builtin_scalblnl(__x, __y);} inline _LIBCPP_HIDE_FROM_ABI long double scalbln(long double __x, long __y) _NOEXCEPT {
return __builtin_scalblnl(__x, __y);
}
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type
typename enable_if<is_integral<_A1>::value, double>::type scalbln(_A1 __x, long __y) _NOEXCEPT {
scalbln(_A1 __x, long __y) _NOEXCEPT {return __builtin_scalbln((double)__x, __y);} return __builtin_scalbln((double)__x, __y);
}
// scalbn // scalbn
inline _LIBCPP_HIDE_FROM_ABI float scalbn(float __x, int __y) _NOEXCEPT {return __builtin_scalbnf(__x, __y);} inline _LIBCPP_HIDE_FROM_ABI float scalbn(float __x, int __y) _NOEXCEPT { return __builtin_scalbnf(__x, __y); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double scalbn(double __x, int __y) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double scalbn(double __x, int __y) _NOEXCEPT {
return __builtin_scalbn(__x, __y); return __builtin_scalbn(__x, __y);
} }
inline _LIBCPP_HIDE_FROM_ABI long double scalbn(long double __x, int __y) _NOEXCEPT {return __builtin_scalbnl(__x, __y);} inline _LIBCPP_HIDE_FROM_ABI long double scalbn(long double __x, int __y) _NOEXCEPT {
return __builtin_scalbnl(__x, __y);
}
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type
typename enable_if<is_integral<_A1>::value, double>::type scalbn(_A1 __x, int __y) _NOEXCEPT {
scalbn(_A1 __x, int __y) _NOEXCEPT {return __builtin_scalbn((double)__x, __y);} return __builtin_scalbn((double)__x, __y);
}
// pow // pow
inline _LIBCPP_HIDE_FROM_ABI float pow(float __x, float __y) _NOEXCEPT {return __builtin_powf(__x, __y);} inline _LIBCPP_HIDE_FROM_ABI float pow(float __x, float __y) _NOEXCEPT { return __builtin_powf(__x, __y); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double pow(double __x, double __y) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double pow(double __x, double __y) _NOEXCEPT {
return __builtin_pow(__x, __y); return __builtin_pow(__x, __y);
} }
inline _LIBCPP_HIDE_FROM_ABI long double pow(long double __x, long double __y) _NOEXCEPT {return __builtin_powl(__x, __y);} inline _LIBCPP_HIDE_FROM_ABI long double pow(long double __x, long double __y) _NOEXCEPT {
return __builtin_powl(__x, __y);
}
template <class _A1, class _A2> template <class _A1, class _A2>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename __enable_if_t typename __enable_if_t< is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, __promote<_A1, _A2> >::type
< pow(_A1 __x, _A2 __y) _NOEXCEPT {
is_arithmetic<_A1>::value &&
is_arithmetic<_A2>::value,
__promote<_A1, _A2>
>::type
pow(_A1 __x, _A2 __y) _NOEXCEPT
{
typedef typename __promote<_A1, _A2>::type __result_type; typedef typename __promote<_A1, _A2>::type __result_type;
static_assert((!(_IsSame<_A1, __result_type>::value && static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value)), "");
_IsSame<_A2, __result_type>::value)), "");
return __math::pow((__result_type)__x, (__result_type)__y); return __math::pow((__result_type)__x, (__result_type)__y);
} }
} // namespace __math } // namespace __math
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MATH_EXPONENTIAL_FUNCTIONS_H #endif // _LIBCPP___MATH_EXPONENTIAL_FUNCTIONS_H

libcxx/include/__math/fdim.h

Show All 17 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace __math { namespace __math {
inline _LIBCPP_HIDE_FROM_ABI float fdim(float __x, float __y) _NOEXCEPT {return __builtin_fdimf(__x, __y);} inline _LIBCPP_HIDE_FROM_ABI float fdim(float __x, float __y) _NOEXCEPT { return __builtin_fdimf(__x, __y); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double fdim(double __x, double __y) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double fdim(double __x, double __y) _NOEXCEPT {
return __builtin_fdim(__x, __y); return __builtin_fdim(__x, __y);
} }
inline _LIBCPP_HIDE_FROM_ABI long double fdim(long double __x, long double __y) _NOEXCEPT {return __builtin_fdiml(__x, __y);} inline _LIBCPP_HIDE_FROM_ABI long double fdim(long double __x, long double __y) _NOEXCEPT {
return __builtin_fdiml(__x, __y);
}
template <class _A1, class _A2> template <class _A1, class _A2>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename __enable_if_t typename __enable_if_t< is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, __promote<_A1, _A2> >::type
< fdim(_A1 __x, _A2 __y) _NOEXCEPT {
is_arithmetic<_A1>::value &&
is_arithmetic<_A2>::value,
__promote<_A1, _A2>
>::type
fdim(_A1 __x, _A2 __y) _NOEXCEPT
{
typedef typename __promote<_A1, _A2>::type __result_type; typedef typename __promote<_A1, _A2>::type __result_type;
static_assert((!(_IsSame<_A1, __result_type>::value && static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value)), "");
_IsSame<_A2, __result_type>::value)), "");
return __math::fdim((__result_type)__x, (__result_type)__y); return __math::fdim((__result_type)__x, (__result_type)__y);
} }
} // namespace __math } // namespace __math
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MATH_FDIM_H #endif // _LIBCPP___MATH_FDIM_H

libcxx/include/__math/fma.h

Show All 17 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace __math { namespace __math {
inline _LIBCPP_HIDE_FROM_ABI float fma(float __x, float __y, float __z) _NOEXCEPT inline _LIBCPP_HIDE_FROM_ABI float fma(float __x, float __y, float __z) _NOEXCEPT {
{
return __builtin_fmaf(__x, __y, __z); return __builtin_fmaf(__x, __y, __z);
} }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double fma(double __x, double __y, double __z) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double fma(double __x, double __y, double __z) _NOEXCEPT {
return __builtin_fma(__x, __y, __z); return __builtin_fma(__x, __y, __z);
} }
inline _LIBCPP_HIDE_FROM_ABI long double fma(long double __x, long double __y, long double __z) _NOEXCEPT inline _LIBCPP_HIDE_FROM_ABI long double fma(long double __x, long double __y, long double __z) _NOEXCEPT {
{
return __builtin_fmal(__x, __y, __z); return __builtin_fmal(__x, __y, __z);
} }
template <class _A1, class _A2, class _A3> template <class _A1, class _A2, class _A3>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename __enable_if_t typename __enable_if_t< is_arithmetic<_A1>::value && is_arithmetic<_A2>::value && is_arithmetic<_A3>::value,
< __promote<_A1, _A2, _A3> >::type
is_arithmetic<_A1>::value && fma(_A1 __x, _A2 __y, _A3 __z) _NOEXCEPT {
is_arithmetic<_A2>::value &&
is_arithmetic<_A3>::value,
__promote<_A1, _A2, _A3>
>::type
fma(_A1 __x, _A2 __y, _A3 __z) _NOEXCEPT
{
typedef typename __promote<_A1, _A2, _A3>::type __result_type; typedef typename __promote<_A1, _A2, _A3>::type __result_type;
static_assert((!(_IsSame<_A1, __result_type>::value && static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value &&
_IsSame<_A2, __result_type>::value && _IsSame<_A3, __result_type>::value)),
_IsSame<_A3, __result_type>::value)), ""); "");
return __builtin_fma((__result_type)__x, (__result_type)__y, (__result_type)__z); return __builtin_fma((__result_type)__x, (__result_type)__y, (__result_type)__z);
} }
} // namespace __math } // namespace __math
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MATH_FMA_H #endif // _LIBCPP___MATH_FMA_H

libcxx/include/__math/gamma.h

Show All 17 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace __math { namespace __math {
// lgamma // lgamma
inline _LIBCPP_HIDE_FROM_ABI float lgamma(float __x) _NOEXCEPT {return __builtin_lgammaf(__x);} inline _LIBCPP_HIDE_FROM_ABI float lgamma(float __x) _NOEXCEPT { return __builtin_lgammaf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double lgamma(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double lgamma(double __x) _NOEXCEPT {
return __builtin_lgamma(__x); return __builtin_lgamma(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double lgamma(long double __x) _NOEXCEPT {return __builtin_lgammal(__x);} inline _LIBCPP_HIDE_FROM_ABI long double lgamma(long double __x) _NOEXCEPT { return __builtin_lgammal(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type lgamma(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_lgamma((double)__x);
lgamma(_A1 __x) _NOEXCEPT {return __builtin_lgamma((double)__x);} }
// nan // nan
// tgamma // tgamma
inline _LIBCPP_HIDE_FROM_ABI float tgamma(float __x) _NOEXCEPT {return __builtin_tgammaf(__x);} inline _LIBCPP_HIDE_FROM_ABI float tgamma(float __x) _NOEXCEPT { return __builtin_tgammaf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double tgamma(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double tgamma(double __x) _NOEXCEPT {
return __builtin_tgamma(__x); return __builtin_tgamma(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double tgamma(long double __x) _NOEXCEPT {return __builtin_tgammal(__x);} inline _LIBCPP_HIDE_FROM_ABI long double tgamma(long double __x) _NOEXCEPT { return __builtin_tgammal(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type tgamma(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_tgamma((double)__x);
tgamma(_A1 __x) _NOEXCEPT {return __builtin_tgamma((double)__x);} }
} // namespace __math } // namespace __math
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MATH_GAMMA_H #endif // _LIBCPP___MATH_GAMMA_H

libcxx/include/__math/hyperbolic_functions.h

Show All 17 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace __math { namespace __math {
// cosh // cosh
inline _LIBCPP_HIDE_FROM_ABI float cosh(float __x) _NOEXCEPT {return __builtin_coshf(__x);} inline _LIBCPP_HIDE_FROM_ABI float cosh(float __x) _NOEXCEPT { return __builtin_coshf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double cosh(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double cosh(double __x) _NOEXCEPT {
return __builtin_cosh(__x); return __builtin_cosh(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double cosh(long double __x) _NOEXCEPT {return __builtin_coshl(__x);} inline _LIBCPP_HIDE_FROM_ABI long double cosh(long double __x) _NOEXCEPT { return __builtin_coshl(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type cosh(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_cosh((double)__x);
cosh(_A1 __x) _NOEXCEPT {return __builtin_cosh((double)__x);} }
// sinh // sinh
inline _LIBCPP_HIDE_FROM_ABI float sinh(float __x) _NOEXCEPT {return __builtin_sinhf(__x);} inline _LIBCPP_HIDE_FROM_ABI float sinh(float __x) _NOEXCEPT { return __builtin_sinhf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double sinh(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double sinh(double __x) _NOEXCEPT {
return __builtin_sinh(__x); return __builtin_sinh(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double sinh(long double __x) _NOEXCEPT {return __builtin_sinhl(__x);} inline _LIBCPP_HIDE_FROM_ABI long double sinh(long double __x) _NOEXCEPT { return __builtin_sinhl(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type sinh(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_sinh((double)__x);
sinh(_A1 __x) _NOEXCEPT {return __builtin_sinh((double)__x);} }
// tanh // tanh
inline _LIBCPP_HIDE_FROM_ABI float tanh(float __x) _NOEXCEPT {return __builtin_tanhf(__x);} inline _LIBCPP_HIDE_FROM_ABI float tanh(float __x) _NOEXCEPT { return __builtin_tanhf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double tanh(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double tanh(double __x) _NOEXCEPT {
return __builtin_tanh(__x); return __builtin_tanh(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double tanh(long double __x) _NOEXCEPT {return __builtin_tanhl(__x);} inline _LIBCPP_HIDE_FROM_ABI long double tanh(long double __x) _NOEXCEPT { return __builtin_tanhl(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type tanh(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_tanh((double)__x);
tanh(_A1 __x) _NOEXCEPT {return __builtin_tanh((double)__x);} }
} // namespace __math } // namespace __math
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MATH_HYPERBOLIC_FUNCTIONS_H #endif // _LIBCPP___MATH_HYPERBOLIC_FUNCTIONS_H

libcxx/include/__math/hypot.h

Show All 17 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace __math { namespace __math {
inline _LIBCPP_HIDE_FROM_ABI float hypot(float __x, float __y) _NOEXCEPT {return __builtin_hypotf(__x, __y);} inline _LIBCPP_HIDE_FROM_ABI float hypot(float __x, float __y) _NOEXCEPT { return __builtin_hypotf(__x, __y); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double hypot(double __x, double __y) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double hypot(double __x, double __y) _NOEXCEPT {
return __builtin_hypot(__x, __y); return __builtin_hypot(__x, __y);
} }
inline _LIBCPP_HIDE_FROM_ABI long double hypot(long double __x, long double __y) _NOEXCEPT {return __builtin_hypotl(__x, __y);} inline _LIBCPP_HIDE_FROM_ABI long double hypot(long double __x, long double __y) _NOEXCEPT {
return __builtin_hypotl(__x, __y);
}
template <class _A1, class _A2> template <class _A1, class _A2>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename __enable_if_t typename __enable_if_t< is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, __promote<_A1, _A2> >::type
< hypot(_A1 __x, _A2 __y) _NOEXCEPT {
is_arithmetic<_A1>::value &&
is_arithmetic<_A2>::value,
__promote<_A1, _A2>
>::type
hypot(_A1 __x, _A2 __y) _NOEXCEPT
{
typedef typename __promote<_A1, _A2>::type __result_type; typedef typename __promote<_A1, _A2>::type __result_type;
static_assert((!(_IsSame<_A1, __result_type>::value && static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value)), "");
_IsSame<_A2, __result_type>::value)), "");
return __math::hypot((__result_type)__x, (__result_type)__y); return __math::hypot((__result_type)__x, (__result_type)__y);
} }
} // namespace __math } // namespace __math
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MATH_HYPOT_H #endif // _LIBCPP___MATH_HYPOT_H

libcxx/include/__math/inverse_hyperbolic_functions.h

Show All 17 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace __math { namespace __math {
// acosh // acosh
inline _LIBCPP_HIDE_FROM_ABI float acosh(float __x) _NOEXCEPT {return __builtin_acoshf(__x);} inline _LIBCPP_HIDE_FROM_ABI float acosh(float __x) _NOEXCEPT { return __builtin_acoshf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double acosh(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double acosh(double __x) _NOEXCEPT {
return __builtin_acosh(__x); return __builtin_acosh(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double acosh(long double __x) _NOEXCEPT {return __builtin_acoshl(__x);} inline _LIBCPP_HIDE_FROM_ABI long double acosh(long double __x) _NOEXCEPT { return __builtin_acoshl(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type acosh(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_acosh((double)__x);
acosh(_A1 __x) _NOEXCEPT {return __builtin_acosh((double)__x);} }
// asinh // asinh
inline _LIBCPP_HIDE_FROM_ABI float asinh(float __x) _NOEXCEPT {return __builtin_asinhf(__x);} inline _LIBCPP_HIDE_FROM_ABI float asinh(float __x) _NOEXCEPT { return __builtin_asinhf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double asinh(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double asinh(double __x) _NOEXCEPT {
return __builtin_asinh(__x); return __builtin_asinh(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double asinh(long double __x) _NOEXCEPT {return __builtin_asinhl(__x);} inline _LIBCPP_HIDE_FROM_ABI long double asinh(long double __x) _NOEXCEPT { return __builtin_asinhl(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type asinh(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_asinh((double)__x);
asinh(_A1 __x) _NOEXCEPT {return __builtin_asinh((double)__x);} }
// atanh // atanh
inline _LIBCPP_HIDE_FROM_ABI float atanh(float __x) _NOEXCEPT {return __builtin_atanhf(__x);} inline _LIBCPP_HIDE_FROM_ABI float atanh(float __x) _NOEXCEPT { return __builtin_atanhf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double atanh(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double atanh(double __x) _NOEXCEPT {
return __builtin_atanh(__x); return __builtin_atanh(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double atanh(long double __x) _NOEXCEPT {return __builtin_atanhl(__x);} inline _LIBCPP_HIDE_FROM_ABI long double atanh(long double __x) _NOEXCEPT { return __builtin_atanhl(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type atanh(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_atanh((double)__x);
atanh(_A1 __x) _NOEXCEPT {return __builtin_atanh((double)__x);} }
} // namespace __math } // namespace __math
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MATH_INVERSE_HYPERBOLIC_FUNCTIONS_H #endif // _LIBCPP___MATH_INVERSE_HYPERBOLIC_FUNCTIONS_H

libcxx/include/__math/inverse_trigonometric_functions.h

Show All 20 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace __math { namespace __math {
// acos // acos
inline _LIBCPP_HIDE_FROM_ABI float acos(float __x) _NOEXCEPT {return __builtin_acosf(__x);} inline _LIBCPP_HIDE_FROM_ABI float acos(float __x) _NOEXCEPT { return __builtin_acosf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double acos(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double acos(double __x) _NOEXCEPT {
return __builtin_acos(__x); return __builtin_acos(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double acos(long double __x) _NOEXCEPT {return __builtin_acosl(__x);} inline _LIBCPP_HIDE_FROM_ABI long double acos(long double __x) _NOEXCEPT { return __builtin_acosl(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type acos(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_acos((double)__x);
acos(_A1 __x) _NOEXCEPT {return __builtin_acos((double)__x);} }
// asin // asin
inline _LIBCPP_HIDE_FROM_ABI float asin(float __x) _NOEXCEPT {return __builtin_asinf(__x);} inline _LIBCPP_HIDE_FROM_ABI float asin(float __x) _NOEXCEPT { return __builtin_asinf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double asin(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double asin(double __x) _NOEXCEPT {
return __builtin_asin(__x); return __builtin_asin(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double asin(long double __x) _NOEXCEPT {return __builtin_asinl(__x);} inline _LIBCPP_HIDE_FROM_ABI long double asin(long double __x) _NOEXCEPT { return __builtin_asinl(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type asin(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_asin((double)__x);
asin(_A1 __x) _NOEXCEPT {return __builtin_asin((double)__x);} }
// atan // atan
inline _LIBCPP_HIDE_FROM_ABI float atan(float __x) _NOEXCEPT {return __builtin_atanf(__x);} inline _LIBCPP_HIDE_FROM_ABI float atan(float __x) _NOEXCEPT { return __builtin_atanf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double atan(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double atan(double __x) _NOEXCEPT {
return __builtin_atan(__x); return __builtin_atan(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double atan(long double __x) _NOEXCEPT {return __builtin_atanl(__x);} inline _LIBCPP_HIDE_FROM_ABI long double atan(long double __x) _NOEXCEPT { return __builtin_atanl(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type atan(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_atan((double)__x);
atan(_A1 __x) _NOEXCEPT {return __builtin_atan((double)__x);} }
// atan2 // atan2
inline _LIBCPP_HIDE_FROM_ABI float atan2(float __y, float __x) _NOEXCEPT {return __builtin_atan2f(__y, __x);} inline _LIBCPP_HIDE_FROM_ABI float atan2(float __y, float __x) _NOEXCEPT { return __builtin_atan2f(__y, __x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double atan2(double __x, double __y) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double atan2(double __x, double __y) _NOEXCEPT {
return __builtin_atan2(__x, __y); return __builtin_atan2(__x, __y);
} }
inline _LIBCPP_HIDE_FROM_ABI long double atan2(long double __y, long double __x) _NOEXCEPT {return __builtin_atan2l(__y, __x);} inline _LIBCPP_HIDE_FROM_ABI long double atan2(long double __y, long double __x) _NOEXCEPT {
return __builtin_atan2l(__y, __x);
}
template <class _A1, class _A2> template <class _A1, class _A2>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename __enable_if_t typename __enable_if_t< is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, __promote<_A1, _A2> >::type
< atan2(_A1 __y, _A2 __x) _NOEXCEPT {
is_arithmetic<_A1>::value &&
is_arithmetic<_A2>::value,
__promote<_A1, _A2>
>::type
atan2(_A1 __y, _A2 __x) _NOEXCEPT
{
typedef typename __promote<_A1, _A2>::type __result_type; typedef typename __promote<_A1, _A2>::type __result_type;
static_assert((!(_IsSame<_A1, __result_type>::value && static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value)), "");
_IsSame<_A2, __result_type>::value)), "");
return __math::atan2((__result_type)__y, (__result_type)__x); return __math::atan2((__result_type)__y, (__result_type)__x);
} }
} // namespace __math } // namespace __math
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MATH_INVERSE_TRIGONOMETRIC_FUNCTIONS_H #endif // _LIBCPP___MATH_INVERSE_TRIGONOMETRIC_FUNCTIONS_H

libcxx/include/__math/logarithms.h

Show All 17 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace __math { namespace __math {
// log // log
inline _LIBCPP_HIDE_FROM_ABI float log(float __x) _NOEXCEPT {return __builtin_logf(__x);} inline _LIBCPP_HIDE_FROM_ABI float log(float __x) _NOEXCEPT { return __builtin_logf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double log(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double log(double __x) _NOEXCEPT {
return __builtin_log(__x); return __builtin_log(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double log(long double __x) _NOEXCEPT {return __builtin_logl(__x);} inline _LIBCPP_HIDE_FROM_ABI long double log(long double __x) _NOEXCEPT { return __builtin_logl(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type log(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_log((double)__x);
log(_A1 __x) _NOEXCEPT {return __builtin_log((double)__x);} }
// log10 // log10
inline _LIBCPP_HIDE_FROM_ABI float log10(float __x) _NOEXCEPT {return __builtin_log10f(__x);} inline _LIBCPP_HIDE_FROM_ABI float log10(float __x) _NOEXCEPT { return __builtin_log10f(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double log10(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double log10(double __x) _NOEXCEPT {
return __builtin_log10(__x); return __builtin_log10(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double log10(long double __x) _NOEXCEPT {return __builtin_log10l(__x);} inline _LIBCPP_HIDE_FROM_ABI long double log10(long double __x) _NOEXCEPT { return __builtin_log10l(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type log10(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_log10((double)__x);
log10(_A1 __x) _NOEXCEPT {return __builtin_log10((double)__x);} }
// ilogb // ilogb
inline _LIBCPP_HIDE_FROM_ABI int ilogb(float __x) _NOEXCEPT {return __builtin_ilogbf(__x);} inline _LIBCPP_HIDE_FROM_ABI int ilogb(float __x) _NOEXCEPT { return __builtin_ilogbf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double ilogb(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double ilogb(double __x) _NOEXCEPT {
return __builtin_ilogb(__x); return __builtin_ilogb(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI int ilogb(long double __x) _NOEXCEPT {return __builtin_ilogbl(__x);} inline _LIBCPP_HIDE_FROM_ABI int ilogb(long double __x) _NOEXCEPT { return __builtin_ilogbl(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, int>::type ilogb(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, int>::type return __builtin_ilogb((double)__x);
ilogb(_A1 __x) _NOEXCEPT {return __builtin_ilogb((double)__x);} }
// log1p // log1p
inline _LIBCPP_HIDE_FROM_ABI float log1p(float __x) _NOEXCEPT {return __builtin_log1pf(__x);} inline _LIBCPP_HIDE_FROM_ABI float log1p(float __x) _NOEXCEPT { return __builtin_log1pf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double log1p(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double log1p(double __x) _NOEXCEPT {
return __builtin_log1p(__x); return __builtin_log1p(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double log1p(long double __x) _NOEXCEPT {return __builtin_log1pl(__x);} inline _LIBCPP_HIDE_FROM_ABI long double log1p(long double __x) _NOEXCEPT { return __builtin_log1pl(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type log1p(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_log1p((double)__x);
log1p(_A1 __x) _NOEXCEPT {return __builtin_log1p((double)__x);} }
// log2 // log2
inline _LIBCPP_HIDE_FROM_ABI float log2(float __x) _NOEXCEPT {return __builtin_log2f(__x);} inline _LIBCPP_HIDE_FROM_ABI float log2(float __x) _NOEXCEPT { return __builtin_log2f(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double log2(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double log2(double __x) _NOEXCEPT {
return __builtin_log2(__x); return __builtin_log2(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double log2(long double __x) _NOEXCEPT {return __builtin_log2l(__x);} inline _LIBCPP_HIDE_FROM_ABI long double log2(long double __x) _NOEXCEPT { return __builtin_log2l(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type log2(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_log2((double)__x);
log2(_A1 __x) _NOEXCEPT {return __builtin_log2((double)__x);} }
// logb // logb
inline _LIBCPP_HIDE_FROM_ABI float logb(float __x) _NOEXCEPT {return __builtin_logbf(__x);} inline _LIBCPP_HIDE_FROM_ABI float logb(float __x) _NOEXCEPT { return __builtin_logbf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double logb(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double logb(double __x) _NOEXCEPT {
return __builtin_logb(__x); return __builtin_logb(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double logb(long double __x) _NOEXCEPT {return __builtin_logbl(__x);} inline _LIBCPP_HIDE_FROM_ABI long double logb(long double __x) _NOEXCEPT { return __builtin_logbl(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type logb(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_logb((double)__x);
logb(_A1 __x) _NOEXCEPT {return __builtin_logb((double)__x);} }
} // namespace __math } // namespace __math
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MATH_LOGARITHMS_H #endif // _LIBCPP___MATH_LOGARITHMS_H

libcxx/include/__math/min_max.h

Show All 19 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace __math { namespace __math {
// fmax // fmax
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float fmax(float __x, float __y) _NOEXCEPT {return __builtin_fmaxf(__x, __y);} _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float fmax(float __x, float __y) _NOEXCEPT {
return __builtin_fmaxf(__x, __y);
}
template <class = int> template <class = int>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double fmax(double __x, double __y) _NOEXCEPT { _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double fmax(double __x, double __y) _NOEXCEPT {
return __builtin_fmax(__x, __y); return __builtin_fmax(__x, __y);
} }
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double fmax(long double __x, long double __y) _NOEXCEPT {return __builtin_fmaxl(__x, __y);} _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double fmax(long double __x, long double __y) _NOEXCEPT {
return __builtin_fmaxl(__x, __y);
}
template <class _A1, class _A2> template <class _A1, class _A2>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI
typename __enable_if_t typename __enable_if_t< is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, __promote<_A1, _A2> >::type
< fmax(_A1 __x, _A2 __y) _NOEXCEPT {
is_arithmetic<_A1>::value &&
is_arithmetic<_A2>::value,
__promote<_A1, _A2>
>::type
fmax(_A1 __x, _A2 __y) _NOEXCEPT
{
typedef typename __promote<_A1, _A2>::type __result_type; typedef typename __promote<_A1, _A2>::type __result_type;
static_assert((!(_IsSame<_A1, __result_type>::value && static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value)), "");
_IsSame<_A2, __result_type>::value)), "");
return __math::fmax((__result_type)__x, (__result_type)__y); return __math::fmax((__result_type)__x, (__result_type)__y);
} }
// fmin // fmin
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float fmin(float __x, float __y) _NOEXCEPT {return __builtin_fminf(__x, __y);} _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float fmin(float __x, float __y) _NOEXCEPT {
return __builtin_fminf(__x, __y);
}
template <class = int> template <class = int>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double fmin(double __x, double __y) _NOEXCEPT { _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double fmin(double __x, double __y) _NOEXCEPT {
return __builtin_fmin(__x, __y); return __builtin_fmin(__x, __y);
} }
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double fmin(long double __x, long double __y) _NOEXCEPT {return __builtin_fminl(__x, __y);} _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double fmin(long double __x, long double __y) _NOEXCEPT {
return __builtin_fminl(__x, __y);
}
template <class _A1, class _A2> template <class _A1, class _A2>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI
typename __enable_if_t typename __enable_if_t< is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, __promote<_A1, _A2> >::type
< fmin(_A1 __x, _A2 __y) _NOEXCEPT {
is_arithmetic<_A1>::value &&
is_arithmetic<_A2>::value,
__promote<_A1, _A2>
>::type
fmin(_A1 __x, _A2 __y) _NOEXCEPT
{
typedef typename __promote<_A1, _A2>::type __result_type; typedef typename __promote<_A1, _A2>::type __result_type;
static_assert((!(_IsSame<_A1, __result_type>::value && static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value)), "");
_IsSame<_A2, __result_type>::value)), "");
return __math::fmin((__result_type)__x, (__result_type)__y); return __math::fmin((__result_type)__x, (__result_type)__y);
} }
} // namespace __math } // namespace __math
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MATH_MIN_MAX_H #endif // _LIBCPP___MATH_MIN_MAX_H

libcxx/include/__math/modulo.h

Show All 19 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace __math { namespace __math {
// fmod // fmod
inline _LIBCPP_HIDE_FROM_ABI float fmod(float __x, float __y) _NOEXCEPT {return __builtin_fmodf(__x, __y);} inline _LIBCPP_HIDE_FROM_ABI float fmod(float __x, float __y) _NOEXCEPT { return __builtin_fmodf(__x, __y); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double fmod(double __x, double __y) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double fmod(double __x, double __y) _NOEXCEPT {
return __builtin_fmod(__x, __y); return __builtin_fmod(__x, __y);
} }
inline _LIBCPP_HIDE_FROM_ABI long double fmod(long double __x, long double __y) _NOEXCEPT {return __builtin_fmodl(__x, __y);} inline _LIBCPP_HIDE_FROM_ABI long double fmod(long double __x, long double __y) _NOEXCEPT {
return __builtin_fmodl(__x, __y);
}
template <class _A1, class _A2> template <class _A1, class _A2>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename __enable_if_t typename __enable_if_t< is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, __promote<_A1, _A2> >::type
< fmod(_A1 __x, _A2 __y) _NOEXCEPT {
is_arithmetic<_A1>::value &&
is_arithmetic<_A2>::value,
__promote<_A1, _A2>
>::type
fmod(_A1 __x, _A2 __y) _NOEXCEPT
{
typedef typename __promote<_A1, _A2>::type __result_type; typedef typename __promote<_A1, _A2>::type __result_type;
static_assert((!(_IsSame<_A1, __result_type>::value && static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value)), "");
_IsSame<_A2, __result_type>::value)), "");
return __math::fmod((__result_type)__x, (__result_type)__y); return __math::fmod((__result_type)__x, (__result_type)__y);
} }
// modf // modf
inline _LIBCPP_HIDE_FROM_ABI float modf(float __x, float* __y) _NOEXCEPT {return __builtin_modff(__x, __y);} inline _LIBCPP_HIDE_FROM_ABI float modf(float __x, float* __y) _NOEXCEPT { return __builtin_modff(__x, __y); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double modf(double __x, double* __y) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double modf(double __x, double* __y) _NOEXCEPT {
return __builtin_modf(__x, __y); return __builtin_modf(__x, __y);
} }
inline _LIBCPP_HIDE_FROM_ABI long double modf(long double __x, long double* __y) _NOEXCEPT {return __builtin_modfl(__x, __y);} inline _LIBCPP_HIDE_FROM_ABI long double modf(long double __x, long double* __y) _NOEXCEPT {
return __builtin_modfl(__x, __y);
}
} // namespace __math } // namespace __math
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MATH_MODULO_H #endif // _LIBCPP___MATH_MODULO_H

libcxx/include/__math/remainder.h

Show All 20 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace __math { namespace __math {
// remainder // remainder
inline _LIBCPP_HIDE_FROM_ABI float remainder(float __x, float __y) _NOEXCEPT {return __builtin_remainderf(__x, __y);} inline _LIBCPP_HIDE_FROM_ABI float remainder(float __x, float __y) _NOEXCEPT { return __builtin_remainderf(__x, __y); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double remainder(double __x, double __y) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double remainder(double __x, double __y) _NOEXCEPT {
return __builtin_remainder(__x, __y); return __builtin_remainder(__x, __y);
} }
inline _LIBCPP_HIDE_FROM_ABI long double remainder(long double __x, long double __y) _NOEXCEPT {return __builtin_remainderl(__x, __y);} inline _LIBCPP_HIDE_FROM_ABI long double remainder(long double __x, long double __y) _NOEXCEPT {
return __builtin_remainderl(__x, __y);
}
template <class _A1, class _A2> template <class _A1, class _A2>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename __enable_if_t typename __enable_if_t< is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, __promote<_A1, _A2> >::type
< remainder(_A1 __x, _A2 __y) _NOEXCEPT {
is_arithmetic<_A1>::value &&
is_arithmetic<_A2>::value,
__promote<_A1, _A2>
>::type
remainder(_A1 __x, _A2 __y) _NOEXCEPT
{
typedef typename __promote<_A1, _A2>::type __result_type; typedef typename __promote<_A1, _A2>::type __result_type;
static_assert((!(_IsSame<_A1, __result_type>::value && static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value)), "");
_IsSame<_A2, __result_type>::value)), "");
return __math::remainder((__result_type)__x, (__result_type)__y); return __math::remainder((__result_type)__x, (__result_type)__y);
} }
// remquo // remquo
inline _LIBCPP_HIDE_FROM_ABI float remquo(float __x, float __y, int* __z) _NOEXCEPT {return __builtin_remquof(__x, __y, __z);} inline _LIBCPP_HIDE_FROM_ABI float remquo(float __x, float __y, int* __z) _NOEXCEPT {
return __builtin_remquof(__x, __y, __z);
}
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double remquo(double __x, double __y, int* __z) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double remquo(double __x, double __y, int* __z) _NOEXCEPT {
return __builtin_remquo(__x, __y, __z); return __builtin_remquo(__x, __y, __z);
} }
inline _LIBCPP_HIDE_FROM_ABI long double remquo(long double __x, long double __y, int* __z) _NOEXCEPT {return __builtin_remquol(__x, __y, __z);} inline _LIBCPP_HIDE_FROM_ABI long double remquo(long double __x, long double __y, int* __z) _NOEXCEPT {
return __builtin_remquol(__x, __y, __z);
}
template <class _A1, class _A2> template <class _A1, class _A2>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename __enable_if_t typename __enable_if_t< is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, __promote<_A1, _A2> >::type
< remquo(_A1 __x, _A2 __y, int* __z) _NOEXCEPT {
is_arithmetic<_A1>::value &&
is_arithmetic<_A2>::value,
__promote<_A1, _A2>
>::type
remquo(_A1 __x, _A2 __y, int* __z) _NOEXCEPT
{
typedef typename __promote<_A1, _A2>::type __result_type; typedef typename __promote<_A1, _A2>::type __result_type;
static_assert((!(_IsSame<_A1, __result_type>::value && static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value)), "");
_IsSame<_A2, __result_type>::value)), "");
return __math::remquo((__result_type)__x, (__result_type)__y, __z); return __math::remquo((__result_type)__x, (__result_type)__y, __z);
} }
} // namespace __math } // namespace __math
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MATH_REMAINDER_H #endif // _LIBCPP___MATH_REMAINDER_H

libcxx/include/__math/roots.h

Show All 17 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace __math { namespace __math {
// sqrt // sqrt
inline _LIBCPP_HIDE_FROM_ABI float sqrt(float __x) _NOEXCEPT {return __builtin_sqrtf(__x);} inline _LIBCPP_HIDE_FROM_ABI float sqrt(float __x) _NOEXCEPT { return __builtin_sqrtf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double sqrt(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double sqrt(double __x) _NOEXCEPT {
return __builtin_sqrt(__x); return __builtin_sqrt(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double sqrt(long double __x) _NOEXCEPT {return __builtin_sqrtl(__x);} inline _LIBCPP_HIDE_FROM_ABI long double sqrt(long double __x) _NOEXCEPT { return __builtin_sqrtl(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type sqrt(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_sqrt((double)__x);
sqrt(_A1 __x) _NOEXCEPT {return __builtin_sqrt((double)__x);} }
// cbrt // cbrt
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float cbrt(float __x) _NOEXCEPT {return __builtin_cbrtf(__x);} _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float cbrt(float __x) _NOEXCEPT { return __builtin_cbrtf(__x); }
template <class = int> template <class = int>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double cbrt(double __x) _NOEXCEPT { _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double cbrt(double __x) _NOEXCEPT {
return __builtin_cbrt(__x); return __builtin_cbrt(__x);
} }
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double cbrt(long double __x) _NOEXCEPT {return __builtin_cbrtl(__x);} _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double cbrt(long double __x) _NOEXCEPT {
return __builtin_cbrtl(__x);
}
template <class _A1> template <class _A1>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type
typename enable_if<is_integral<_A1>::value, double>::type cbrt(_A1 __x) _NOEXCEPT {
cbrt(_A1 __x) _NOEXCEPT {return __builtin_cbrt((double)__x);} return __builtin_cbrt((double)__x);
}
} // namespace __math } // namespace __math
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MATH_ROOTS_H #endif // _LIBCPP___MATH_ROOTS_H

libcxx/include/__math/rounding_functions.h

Show All 20 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace __math { namespace __math {
// ceil // ceil
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float ceil(float __x) _NOEXCEPT {return __builtin_ceilf(__x);} _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float ceil(float __x) _NOEXCEPT { return __builtin_ceilf(__x); }
template <class = int> template <class = int>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double ceil(double __x) _NOEXCEPT { _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double ceil(double __x) _NOEXCEPT {
return __builtin_ceil(__x); return __builtin_ceil(__x);
} }
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double ceil(long double __x) _NOEXCEPT {return __builtin_ceill(__x);} _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double ceil(long double __x) _NOEXCEPT {
return __builtin_ceill(__x);
}
template <class _A1> template <class _A1>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type
typename enable_if<is_integral<_A1>::value, double>::type ceil(_A1 __x) _NOEXCEPT {
ceil(_A1 __x) _NOEXCEPT {return __builtin_ceil((double)__x);} return __builtin_ceil((double)__x);
}
// floor // floor
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float floor(float __x) _NOEXCEPT {return __builtin_floorf(__x);} _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float floor(float __x) _NOEXCEPT { return __builtin_floorf(__x); }
template <class = int> template <class = int>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double floor(double __x) _NOEXCEPT { _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double floor(double __x) _NOEXCEPT {
return __builtin_floor(__x); return __builtin_floor(__x);
} }
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double floor(long double __x) _NOEXCEPT {return __builtin_floorl(__x);} _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double floor(long double __x) _NOEXCEPT {
return __builtin_floorl(__x);
}
template <class _A1> template <class _A1>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type
typename enable_if<is_integral<_A1>::value, double>::type floor(_A1 __x) _NOEXCEPT {
floor(_A1 __x) _NOEXCEPT {return __builtin_floor((double)__x);} return __builtin_floor((double)__x);
}
// llrint // llrint
inline _LIBCPP_HIDE_FROM_ABI long long llrint(float __x) _NOEXCEPT inline _LIBCPP_HIDE_FROM_ABI long long llrint(float __x) _NOEXCEPT { return __builtin_llrintf(__x); }
{
return __builtin_llrintf(__x);
}
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI long long llrint(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI long long llrint(double __x) _NOEXCEPT {
return __builtin_llrint(__x); return __builtin_llrint(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long long llrint(long double __x) _NOEXCEPT inline _LIBCPP_HIDE_FROM_ABI long long llrint(long double __x) _NOEXCEPT { return __builtin_llrintl(__x); }
{
return __builtin_llrintl(__x);
}
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, long long>::type llrint(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, long long>::type
llrint(_A1 __x) _NOEXCEPT
{
return __builtin_llrint((double)__x); return __builtin_llrint((double)__x);
} }
// llround // llround
inline _LIBCPP_HIDE_FROM_ABI long long llround(float __x) _NOEXCEPT inline _LIBCPP_HIDE_FROM_ABI long long llround(float __x) _NOEXCEPT { return __builtin_llroundf(__x); }
{
return __builtin_llroundf(__x);
}
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI long long llround(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI long long llround(double __x) _NOEXCEPT {
return __builtin_llround(__x); return __builtin_llround(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long long llround(long double __x) _NOEXCEPT inline _LIBCPP_HIDE_FROM_ABI long long llround(long double __x) _NOEXCEPT { return __builtin_llroundl(__x); }
{
return __builtin_llroundl(__x);
}
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, long long>::type llround(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, long long>::type
llround(_A1 __x) _NOEXCEPT
{
return __builtin_llround((double)__x); return __builtin_llround((double)__x);
} }
// lrint // lrint
inline _LIBCPP_HIDE_FROM_ABI long lrint(float __x) _NOEXCEPT inline _LIBCPP_HIDE_FROM_ABI long lrint(float __x) _NOEXCEPT { return __builtin_lrintf(__x); }
{
return __builtin_lrintf(__x);
}
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI long lrint(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI long lrint(double __x) _NOEXCEPT {
return __builtin_lrint(__x); return __builtin_lrint(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long lrint(long double __x) _NOEXCEPT inline _LIBCPP_HIDE_FROM_ABI long lrint(long double __x) _NOEXCEPT { return __builtin_lrintl(__x); }
{
return __builtin_lrintl(__x);
}
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, long>::type lrint(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, long>::type
lrint(_A1 __x) _NOEXCEPT
{
return __builtin_lrint((double)__x); return __builtin_lrint((double)__x);
} }
// lround // lround
inline _LIBCPP_HIDE_FROM_ABI long lround(float __x) _NOEXCEPT inline _LIBCPP_HIDE_FROM_ABI long lround(float __x) _NOEXCEPT { return __builtin_lroundf(__x); }
{
return __builtin_lroundf(__x);
}
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI long lround(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI long lround(double __x) _NOEXCEPT {
return __builtin_lround(__x); return __builtin_lround(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long lround(long double __x) _NOEXCEPT inline _LIBCPP_HIDE_FROM_ABI long lround(long double __x) _NOEXCEPT { return __builtin_lroundl(__x); }
{
return __builtin_lroundl(__x);
}
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, long>::type lround(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, long>::type
lround(_A1 __x) _NOEXCEPT
{
return __builtin_lround((double)__x); return __builtin_lround((double)__x);
} }
// nearbyint // nearbyint
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float nearbyint(float __x) _NOEXCEPT {return __builtin_nearbyintf(__x);} _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float nearbyint(float __x) _NOEXCEPT {
return __builtin_nearbyintf(__x);
}
template <class = int> template <class = int>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double nearbyint(double __x) _NOEXCEPT { _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double nearbyint(double __x) _NOEXCEPT {
return __builtin_nearbyint(__x); return __builtin_nearbyint(__x);
} }
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double nearbyint(long double __x) _NOEXCEPT {return __builtin_nearbyintl(__x);} _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double nearbyint(long double __x) _NOEXCEPT {
return __builtin_nearbyintl(__x);
}
template <class _A1> template <class _A1>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type
typename enable_if<is_integral<_A1>::value, double>::type nearbyint(_A1 __x) _NOEXCEPT {
nearbyint(_A1 __x) _NOEXCEPT {return __builtin_nearbyint((double)__x);} return __builtin_nearbyint((double)__x);
}
// nextafter // nextafter
inline _LIBCPP_HIDE_FROM_ABI float nextafter(float __x, float __y) _NOEXCEPT {return __builtin_nextafterf(__x, __y);} inline _LIBCPP_HIDE_FROM_ABI float nextafter(float __x, float __y) _NOEXCEPT { return __builtin_nextafterf(__x, __y); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double nextafter(double __x, double __y) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double nextafter(double __x, double __y) _NOEXCEPT {
return __builtin_nextafter(__x, __y); return __builtin_nextafter(__x, __y);
} }
inline _LIBCPP_HIDE_FROM_ABI long double nextafter(long double __x, long double __y) _NOEXCEPT {return __builtin_nextafterl(__x, __y);} inline _LIBCPP_HIDE_FROM_ABI long double nextafter(long double __x, long double __y) _NOEXCEPT {
return __builtin_nextafterl(__x, __y);
}
template <class _A1, class _A2> template <class _A1, class _A2>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename __enable_if_t typename __enable_if_t< is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, __promote<_A1, _A2> >::type
< nextafter(_A1 __x, _A2 __y) _NOEXCEPT {
is_arithmetic<_A1>::value &&
is_arithmetic<_A2>::value,
__promote<_A1, _A2>
>::type
nextafter(_A1 __x, _A2 __y) _NOEXCEPT
{
typedef typename __promote<_A1, _A2>::type __result_type; typedef typename __promote<_A1, _A2>::type __result_type;
static_assert((!(_IsSame<_A1, __result_type>::value && static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value)), "");
_IsSame<_A2, __result_type>::value)), "");
return __math::nextafter((__result_type)__x, (__result_type)__y); return __math::nextafter((__result_type)__x, (__result_type)__y);
} }
// nexttoward // nexttoward
inline _LIBCPP_HIDE_FROM_ABI float nexttoward(float __x, long double __y) _NOEXCEPT {return __builtin_nexttowardf(__x, __y);} inline _LIBCPP_HIDE_FROM_ABI float nexttoward(float __x, long double __y) _NOEXCEPT {
return __builtin_nexttowardf(__x, __y);
}
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double nexttoward(double __x, long double __y) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double nexttoward(double __x, long double __y) _NOEXCEPT {
return __builtin_nexttoward(__x, __y); return __builtin_nexttoward(__x, __y);
} }
inline _LIBCPP_HIDE_FROM_ABI long double nexttoward(long double __x, long double __y) _NOEXCEPT {return __builtin_nexttowardl(__x, __y);} inline _LIBCPP_HIDE_FROM_ABI long double nexttoward(long double __x, long double __y) _NOEXCEPT {
return __builtin_nexttowardl(__x, __y);
}
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type
typename enable_if<is_integral<_A1>::value, double>::type nexttoward(_A1 __x, long double __y) _NOEXCEPT {
nexttoward(_A1 __x, long double __y) _NOEXCEPT {return __builtin_nexttoward((double)__x, __y);} return __builtin_nexttoward((double)__x, __y);
}
// rint // rint
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float rint(float __x) _NOEXCEPT _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float rint(float __x) _NOEXCEPT { return __builtin_rintf(__x); }
{
return __builtin_rintf(__x);
}
template <class = int> template <class = int>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double rint(double __x) _NOEXCEPT { _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double rint(double __x) _NOEXCEPT {
return __builtin_rint(__x); return __builtin_rint(__x);
} }
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double rint(long double __x) _NOEXCEPT _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double rint(long double __x) _NOEXCEPT {
{
return __builtin_rintl(__x); return __builtin_rintl(__x);
} }
template <class _A1> template <class _A1>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type
typename enable_if<is_integral<_A1>::value, double>::type rint(_A1 __x) _NOEXCEPT {
rint(_A1 __x) _NOEXCEPT
{
return __builtin_rint((double)__x); return __builtin_rint((double)__x);
} }
// round // round
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float round(float __x) _NOEXCEPT _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float round(float __x) _NOEXCEPT { return __builtin_round(__x); }
{
return __builtin_round(__x);
}
template <class = int> template <class = int>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double round(double __x) _NOEXCEPT { _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double round(double __x) _NOEXCEPT {
return __builtin_round(__x); return __builtin_round(__x);
} }
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double round(long double __x) _NOEXCEPT _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double round(long double __x) _NOEXCEPT {
{
return __builtin_roundl(__x); return __builtin_roundl(__x);
} }
template <class _A1> template <class _A1>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type
typename enable_if<is_integral<_A1>::value, double>::type round(_A1 __x) _NOEXCEPT {
round(_A1 __x) _NOEXCEPT
{
return __builtin_round((double)__x); return __builtin_round((double)__x);
} }
// trunc // trunc
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float trunc(float __x) _NOEXCEPT _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float trunc(float __x) _NOEXCEPT { return __builtin_trunc(__x); }
{
return __builtin_trunc(__x);
}
template <class = int> template <class = int>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double trunc(double __x) _NOEXCEPT { _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double trunc(double __x) _NOEXCEPT {
return __builtin_trunc(__x); return __builtin_trunc(__x);
} }
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double trunc(long double __x) _NOEXCEPT _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double trunc(long double __x) _NOEXCEPT {
{
return __builtin_truncl(__x); return __builtin_truncl(__x);
} }
template <class _A1> template <class _A1>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type
typename enable_if<is_integral<_A1>::value, double>::type trunc(_A1 __x) _NOEXCEPT {
trunc(_A1 __x) _NOEXCEPT
{
return __builtin_trunc((double)__x); return __builtin_trunc((double)__x);
} }
} // namespace __math } // namespace __math
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MATH_ROUNDING_FUNCTIONS_H #endif // _LIBCPP___MATH_ROUNDING_FUNCTIONS_H

libcxx/include/__math/traits.h

Show All 39 Lines
template <class _A1, __enable_if_t<is_integral<_A1>::value && !is_signed<_A1>::value, int> = 0> template <class _A1, __enable_if_t<is_integral<_A1>::value && !is_signed<_A1>::value, int> = 0>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool signbit(_A1) _NOEXCEPT { _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool signbit(_A1) _NOEXCEPT {
return false; return false;
} }
// isfinite // isfinite
template <class _A1, template <class _A1, __enable_if_t<is_arithmetic<_A1>::value && numeric_limits<_A1>::has_infinity, int> = 0>
__enable_if_t<is_arithmetic<_A1>::value && numeric_limits<_A1>::has_infinity, int> = 0>
_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isfinite(_A1 __x) _NOEXCEPT { _LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isfinite(_A1 __x) _NOEXCEPT {
return __builtin_isfinite((typename __promote<_A1>::type)__x); return __builtin_isfinite((typename __promote<_A1>::type)__x);
} }
template <class _A1, template <class _A1, __enable_if_t<is_arithmetic<_A1>::value && !numeric_limits<_A1>::has_infinity, int> = 0>
__enable_if_t<is_arithmetic<_A1>::value && !numeric_limits<_A1>::has_infinity, int> = 0>
_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isfinite(_A1) _NOEXCEPT { _LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isfinite(_A1) _NOEXCEPT {
return true; return true;
} }
// isinf // isinf
template <class _A1, template <class _A1, __enable_if_t<is_arithmetic<_A1>::value && numeric_limits<_A1>::has_infinity, int> = 0>
__enable_if_t<is_arithmetic<_A1>::value && numeric_limits<_A1>::has_infinity, int> = 0>
_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isinf(_A1 __x) _NOEXCEPT { _LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isinf(_A1 __x) _NOEXCEPT {
return __builtin_isinf((typename __promote<_A1>::type)__x); return __builtin_isinf((typename __promote<_A1>::type)__x);
} }
template <class _A1> template <class _A1>
_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI _LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI
typename enable_if< is_arithmetic<_A1>::value && !numeric_limits<_A1>::has_infinity, bool>::type typename enable_if< is_arithmetic<_A1>::value && !numeric_limits<_A1>::has_infinity, bool>::type
isinf(_A1) _NOEXCEPT { isinf(_A1) _NOEXCEPT {
return false; return false;
} }
# ifdef _LIBCPP_PREFERRED_OVERLOAD #ifdef _LIBCPP_PREFERRED_OVERLOAD
_LIBCPP_NODISCARD_EXT inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isinf(float __x) _NOEXCEPT { _LIBCPP_NODISCARD_EXT inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isinf(float __x) _NOEXCEPT {
return __builtin_isinf(__x); return __builtin_isinf(__x);
} }
_LIBCPP_NODISCARD_EXT inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD bool isinf(double __x) _NOEXCEPT { _LIBCPP_NODISCARD_EXT inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD bool
isinf(double __x) _NOEXCEPT {
return __builtin_isinf(__x); return __builtin_isinf(__x);
} }
_LIBCPP_NODISCARD_EXT inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isinf(long double __x) _NOEXCEPT { _LIBCPP_NODISCARD_EXT inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isinf(long double __x) _NOEXCEPT {
return __builtin_isinf(__x); return __builtin_isinf(__x);
} }
# endif #endif
// isnan // isnan
template <class _A1, __enable_if_t<is_floating_point<_A1>::value, int> = 0> template <class _A1, __enable_if_t<is_floating_point<_A1>::value, int> = 0>
_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnan(_A1 __x) _NOEXCEPT { _LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnan(_A1 __x) _NOEXCEPT {
return __builtin_isnan(__x); return __builtin_isnan(__x);
} }
template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0> template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnan(_A1) _NOEXCEPT { _LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnan(_A1) _NOEXCEPT {
return false; return false;
} }
# ifdef _LIBCPP_PREFERRED_OVERLOAD #ifdef _LIBCPP_PREFERRED_OVERLOAD
_LIBCPP_NODISCARD_EXT inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnan(float __x) _NOEXCEPT { _LIBCPP_NODISCARD_EXT inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnan(float __x) _NOEXCEPT {
return __builtin_isnan(__x); return __builtin_isnan(__x);
} }
_LIBCPP_NODISCARD_EXT inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD bool isnan(double __x) _NOEXCEPT { _LIBCPP_NODISCARD_EXT inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD bool
isnan(double __x) _NOEXCEPT {
return __builtin_isnan(__x); return __builtin_isnan(__x);
} }
_LIBCPP_NODISCARD_EXT inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnan(long double __x) _NOEXCEPT { _LIBCPP_NODISCARD_EXT inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnan(long double __x) _NOEXCEPT {
return __builtin_isnan(__x); return __builtin_isnan(__x);
} }
# endif #endif
// isnormal // isnormal
template <class _A1, __enable_if_t<is_floating_point<_A1>::value, int> = 0> template <class _A1, __enable_if_t<is_floating_point<_A1>::value, int> = 0>
_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnormal(_A1 __x) _NOEXCEPT { _LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnormal(_A1 __x) _NOEXCEPT {
return __builtin_isnormal(__x); return __builtin_isnormal(__x);
} }
template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0> template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnormal(_A1 __x) _NOEXCEPT { _LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnormal(_A1 __x) _NOEXCEPT {
return __x != 0; return __x != 0;
} }
// isgreater // isgreater
template <class _A1, template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
class _A2,
__enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool isgreater(_A1 __x, _A2 __y) _NOEXCEPT { _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool isgreater(_A1 __x, _A2 __y) _NOEXCEPT {
typedef typename __promote<_A1, _A2>::type type; typedef typename __promote<_A1, _A2>::type type;
return __builtin_isgreater((type)__x, (type)__y); return __builtin_isgreater((type)__x, (type)__y);
} }
// isgreaterequal // isgreaterequal
template <class _A1, template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
class _A2,
__enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool isgreaterequal(_A1 __x, _A2 __y) _NOEXCEPT { _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool isgreaterequal(_A1 __x, _A2 __y) _NOEXCEPT {
typedef typename __promote<_A1, _A2>::type type; typedef typename __promote<_A1, _A2>::type type;
return __builtin_isgreaterequal((type)__x, (type)__y); return __builtin_isgreaterequal((type)__x, (type)__y);
} }
// isless // isless
template <class _A1, template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
class _A2,
__enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool isless(_A1 __x, _A2 __y) _NOEXCEPT { _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool isless(_A1 __x, _A2 __y) _NOEXCEPT {
typedef typename __promote<_A1, _A2>::type type; typedef typename __promote<_A1, _A2>::type type;
return __builtin_isless((type)__x, (type)__y); return __builtin_isless((type)__x, (type)__y);
} }
// islessequal // islessequal
template <class _A1, template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
class _A2,
__enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool islessequal(_A1 __x, _A2 __y) _NOEXCEPT { _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool islessequal(_A1 __x, _A2 __y) _NOEXCEPT {
typedef typename __promote<_A1, _A2>::type type; typedef typename __promote<_A1, _A2>::type type;
return __builtin_islessequal((type)__x, (type)__y); return __builtin_islessequal((type)__x, (type)__y);
} }
// islessgreater // islessgreater
template <class _A1, template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
class _A2,
__enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool islessgreater(_A1 __x, _A2 __y) _NOEXCEPT { _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool islessgreater(_A1 __x, _A2 __y) _NOEXCEPT {
typedef typename __promote<_A1, _A2>::type type; typedef typename __promote<_A1, _A2>::type type;
return __builtin_islessgreater((type)__x, (type)__y); return __builtin_islessgreater((type)__x, (type)__y);
} }
// isunordered // isunordered
template <class _A1, template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
class _A2,
__enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool isunordered(_A1 __x, _A2 __y) _NOEXCEPT { _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool isunordered(_A1 __x, _A2 __y) _NOEXCEPT {
typedef typename __promote<_A1, _A2>::type type; typedef typename __promote<_A1, _A2>::type type;
return __builtin_isunordered((type)__x, (type)__y); return __builtin_isunordered((type)__x, (type)__y);
} }
} // namespace __math } // namespace __math
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MATH_TRAITS_H #endif // _LIBCPP___MATH_TRAITS_H

libcxx/include/__math/trigonometric_functions.h

Show All 17 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace __math { namespace __math {
// cos // cos
inline _LIBCPP_HIDE_FROM_ABI float cos(float __x) _NOEXCEPT {return __builtin_cosf(__x);} inline _LIBCPP_HIDE_FROM_ABI float cos(float __x) _NOEXCEPT { return __builtin_cosf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double cos(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double cos(double __x) _NOEXCEPT {
return __builtin_cos(__x); return __builtin_cos(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double cos(long double __x) _NOEXCEPT {return __builtin_cosl(__x);} inline _LIBCPP_HIDE_FROM_ABI long double cos(long double __x) _NOEXCEPT { return __builtin_cosl(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type cos(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_cos((double)__x);
cos(_A1 __x) _NOEXCEPT {return __builtin_cos((double)__x);} }
// sin // sin
inline _LIBCPP_HIDE_FROM_ABI float sin(float __x) _NOEXCEPT {return __builtin_sinf(__x);} inline _LIBCPP_HIDE_FROM_ABI float sin(float __x) _NOEXCEPT { return __builtin_sinf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double sin(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double sin(double __x) _NOEXCEPT {
return __builtin_sin(__x); return __builtin_sin(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double sin(long double __x) _NOEXCEPT {return __builtin_sinl(__x);} inline _LIBCPP_HIDE_FROM_ABI long double sin(long double __x) _NOEXCEPT { return __builtin_sinl(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type sin(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_sin((double)__x);
sin(_A1 __x) _NOEXCEPT {return __builtin_sin((double)__x);} }
// tan // tan
inline _LIBCPP_HIDE_FROM_ABI float tan(float __x) _NOEXCEPT {return __builtin_tanf(__x);} inline _LIBCPP_HIDE_FROM_ABI float tan(float __x) _NOEXCEPT { return __builtin_tanf(__x); }
template <class = int> template <class = int>
_LIBCPP_HIDE_FROM_ABI double tan(double __x) _NOEXCEPT { _LIBCPP_HIDE_FROM_ABI double tan(double __x) _NOEXCEPT {
return __builtin_tan(__x); return __builtin_tan(__x);
} }
inline _LIBCPP_HIDE_FROM_ABI long double tan(long double __x) _NOEXCEPT {return __builtin_tanl(__x);} inline _LIBCPP_HIDE_FROM_ABI long double tan(long double __x) _NOEXCEPT { return __builtin_tanl(__x); }
template <class _A1> template <class _A1>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI typename enable_if<is_integral<_A1>::value, double>::type tan(_A1 __x) _NOEXCEPT {
typename enable_if<is_integral<_A1>::value, double>::type return __builtin_tan((double)__x);
tan(_A1 __x) _NOEXCEPT {return __builtin_tan((double)__x);} }
} // namespace __math } // namespace __math
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MATH_TRIGONOMETRIC_FUNCTIONS_H #endif // _LIBCPP___MATH_TRIGONOMETRIC_FUNCTIONS_H

libcxx/utils/data/ignore_format.txt

Show First 20 Lines • Show All 300 Lines • ▼ Show 20 Lines
libcxx/include/list libcxx/include/list
libcxx/include/__locale libcxx/include/__locale
libcxx/include/locale libcxx/include/locale
libcxx/include/__locale_dir/locale_base_api/bsd_locale_defaults.h libcxx/include/__locale_dir/locale_base_api/bsd_locale_defaults.h
libcxx/include/__locale_dir/locale_base_api/bsd_locale_fallbacks.h libcxx/include/__locale_dir/locale_base_api/bsd_locale_fallbacks.h
libcxx/include/__locale_dir/locale_base_api/locale_guard.h libcxx/include/__locale_dir/locale_base_api/locale_guard.h
libcxx/include/locale.h libcxx/include/locale.h
libcxx/include/map libcxx/include/map
libcxx/include/__math/abs.h
libcxx/include/__math/copysign.h
libcxx/include/__math/error_functions.h
libcxx/include/__math/exponential_functions.h
libcxx/include/__math/fdim.h
libcxx/include/__math/fma.h
libcxx/include/__math/gamma.h
libcxx/include/math.h libcxx/include/math.h
libcxx/include/__math/hyperbolic_functions.h
libcxx/include/__math/hypot.h
libcxx/include/__math/inverse_hyperbolic_functions.h
libcxx/include/__math/inverse_trigonometric_functions.h
libcxx/include/__math/logarithms.h
libcxx/include/__math/min_max.h
libcxx/include/__math/modulo.h
libcxx/include/__math/remainder.h
libcxx/include/__math/roots.h
libcxx/include/__math/rounding_functions.h
libcxx/include/__math/traits.h
libcxx/include/__math/trigonometric_functions.h
libcxx/include/__mbstate_t.h libcxx/include/__mbstate_t.h
libcxx/include/memory libcxx/include/memory
libcxx/include/__memory/addressof.h libcxx/include/__memory/addressof.h
libcxx/include/__memory/aligned_alloc.h libcxx/include/__memory/aligned_alloc.h
libcxx/include/__memory/allocate_at_least.h libcxx/include/__memory/allocate_at_least.h
libcxx/include/__memory/allocation_guard.h libcxx/include/__memory/allocation_guard.h
libcxx/include/__memory/allocator_arg_t.h libcxx/include/__memory/allocator_arg_t.h
libcxx/include/__memory/allocator_destructor.h libcxx/include/__memory/allocator_destructor.h
▲ Show 20 Lines • Show All 269 Lines • Show Last 20 Lines