maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/libcxx/include/math.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1764 lines
52 KiB
C
Raw Normal View History

Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// -*- C++ -*-
[runtimes][NFC] Remove filenames at the top of the license notice We've stopped doing it in libc++ for a while now because these names would end up rotting as we move things around and copy/paste stuff. This cleans up all the existing files so as to stop the spreading as people copy-paste headers around.
2021-11-18 05:25:01 +08:00
//===----------------------------------------------------------------------===//
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
//
Update more file headers across all of the LLVM projects in the monorepo to reflect the new license. These used slightly different spellings that defeated my regular expressions. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351648
2019-01-19 18:56:40 +08:00
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_MATH_H
#define _LIBCPP_MATH_H
/*
math.h synopsis
Macros:
HUGE_VAL
HUGE_VALF // C99
HUGE_VALL // C99
INFINITY // C99
NAN // C99
FP_INFINITE // C99
FP_NAN // C99
FP_NORMAL // C99
FP_SUBNORMAL // C99
FP_ZERO // C99
FP_FAST_FMA // C99
FP_FAST_FMAF // C99
FP_FAST_FMAL // C99
FP_ILOGB0 // C99
FP_ILOGBNAN // C99
MATH_ERRNO // C99
MATH_ERREXCEPT // C99
math_errhandling // C99
Types:
float_t // C99
double_t // C99
// C90
floating_point abs(floating_point x);
floating_point acos (arithmetic x);
float acosf(float x);
long double acosl(long double x);
floating_point asin (arithmetic x);
float asinf(float x);
long double asinl(long double x);
floating_point atan (arithmetic x);
float atanf(float x);
long double atanl(long double x);
floating_point atan2 (arithmetic y, arithmetic x);
float atan2f(float y, float x);
long double atan2l(long double y, long double x);
floating_point ceil (arithmetic x);
float ceilf(float x);
long double ceill(long double x);
floating_point cos (arithmetic x);
float cosf(float x);
long double cosl(long double x);
floating_point cosh (arithmetic x);
float coshf(float x);
long double coshl(long double x);
floating_point exp (arithmetic x);
float expf(float x);
long double expl(long double x);
floating_point fabs (arithmetic x);
float fabsf(float x);
long double fabsl(long double x);
floating_point floor (arithmetic x);
float floorf(float x);
long double floorl(long double x);
floating_point fmod (arithmetic x, arithmetic y);
float fmodf(float x, float y);
long double fmodl(long double x, long double y);
floating_point frexp (arithmetic value, int* exp);
float frexpf(float value, int* exp);
long double frexpl(long double value, int* exp);
floating_point ldexp (arithmetic value, int exp);
float ldexpf(float value, int exp);
long double ldexpl(long double value, int exp);
floating_point log (arithmetic x);
float logf(float x);
long double logl(long double x);
floating_point log10 (arithmetic x);
float log10f(float x);
long double log10l(long double x);
floating_point modf (floating_point value, floating_point* iptr);
float modff(float value, float* iptr);
long double modfl(long double value, long double* iptr);
floating_point pow (arithmetic x, arithmetic y);
float powf(float x, float y);
long double powl(long double x, long double y);
floating_point sin (arithmetic x);
float sinf(float x);
long double sinl(long double x);
floating_point sinh (arithmetic x);
float sinhf(float x);
long double sinhl(long double x);
floating_point sqrt (arithmetic x);
float sqrtf(float x);
long double sqrtl(long double x);
floating_point tan (arithmetic x);
float tanf(float x);
long double tanl(long double x);
floating_point tanh (arithmetic x);
float tanhf(float x);
long double tanhl(long double x);
// C99
bool signbit(arithmetic x);
int fpclassify(arithmetic x);
bool isfinite(arithmetic x);
bool isinf(arithmetic x);
bool isnan(arithmetic x);
bool isnormal(arithmetic x);
bool isgreater(arithmetic x, arithmetic y);
bool isgreaterequal(arithmetic x, arithmetic y);
bool isless(arithmetic x, arithmetic y);
bool islessequal(arithmetic x, arithmetic y);
bool islessgreater(arithmetic x, arithmetic y);
bool isunordered(arithmetic x, arithmetic y);
floating_point acosh (arithmetic x);
float acoshf(float x);
long double acoshl(long double x);
floating_point asinh (arithmetic x);
float asinhf(float x);
long double asinhl(long double x);
floating_point atanh (arithmetic x);
float atanhf(float x);
long double atanhl(long double x);
floating_point cbrt (arithmetic x);
float cbrtf(float x);
long double cbrtl(long double x);
floating_point copysign (arithmetic x, arithmetic y);
float copysignf(float x, float y);
long double copysignl(long double x, long double y);
floating_point erf (arithmetic x);
float erff(float x);
long double erfl(long double x);
floating_point erfc (arithmetic x);
float erfcf(float x);
long double erfcl(long double x);
floating_point exp2 (arithmetic x);
float exp2f(float x);
long double exp2l(long double x);
floating_point expm1 (arithmetic x);
float expm1f(float x);
long double expm1l(long double x);
floating_point fdim (arithmetic x, arithmetic y);
float fdimf(float x, float y);
long double fdiml(long double x, long double y);
floating_point fma (arithmetic x, arithmetic y, arithmetic z);
float fmaf(float x, float y, float z);
long double fmal(long double x, long double y, long double z);
floating_point fmax (arithmetic x, arithmetic y);
float fmaxf(float x, float y);
long double fmaxl(long double x, long double y);
floating_point fmin (arithmetic x, arithmetic y);
float fminf(float x, float y);
long double fminl(long double x, long double y);
floating_point hypot (arithmetic x, arithmetic y);
float hypotf(float x, float y);
long double hypotl(long double x, long double y);
int ilogb (arithmetic x);
int ilogbf(float x);
int ilogbl(long double x);
floating_point lgamma (arithmetic x);
float lgammaf(float x);
long double lgammal(long double x);
long long llrint (arithmetic x);
long long llrintf(float x);
long long llrintl(long double x);
long long llround (arithmetic x);
long long llroundf(float x);
long long llroundl(long double x);
floating_point log1p (arithmetic x);
float log1pf(float x);
long double log1pl(long double x);
floating_point log2 (arithmetic x);
float log2f(float x);
long double log2l(long double x);
floating_point logb (arithmetic x);
float logbf(float x);
long double logbl(long double x);
long lrint (arithmetic x);
long lrintf(float x);
long lrintl(long double x);
long lround (arithmetic x);
long lroundf(float x);
long lroundl(long double x);
double nan (const char* str);
float nanf(const char* str);
long double nanl(const char* str);
floating_point nearbyint (arithmetic x);
float nearbyintf(float x);
long double nearbyintl(long double x);
floating_point nextafter (arithmetic x, arithmetic y);
float nextafterf(float x, float y);
long double nextafterl(long double x, long double y);
floating_point nexttoward (arithmetic x, long double y);
float nexttowardf(float x, long double y);
long double nexttowardl(long double x, long double y);
floating_point remainder (arithmetic x, arithmetic y);
float remainderf(float x, float y);
long double remainderl(long double x, long double y);
floating_point remquo (arithmetic x, arithmetic y, int* pquo);
float remquof(float x, float y, int* pquo);
long double remquol(long double x, long double y, int* pquo);
floating_point rint (arithmetic x);
float rintf(float x);
long double rintl(long double x);
floating_point round (arithmetic x);
float roundf(float x);
long double roundl(long double x);
floating_point scalbln (arithmetic x, long ex);
float scalblnf(float x, long ex);
long double scalblnl(long double x, long ex);
floating_point scalbn (arithmetic x, int ex);
float scalbnf(float x, int ex);
long double scalbnl(long double x, int ex);
floating_point tgamma (arithmetic x);
float tgammaf(float x);
long double tgammal(long double x);
floating_point trunc (arithmetic x);
float truncf(float x);
long double truncl(long double x);
*/
#include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
[libcxx] Do not include the C math.h header before __config Summary: Certain C libraries require configuration macros defined in __config to provide the correct functionality for libc++. This patch ensures that the C header math.h is always included after the __config header. It also adds a Windows-specific #if guard for the case when the C math.h file is included the second time, as suggested by Marshall in https://reviews.llvm.org/rL323490. Fixes PR36382. Reviewers: mclow.lists, EricWF Reviewed By: mclow.lists Subscribers: cfe-commits, pcc, christof, rogfer01 Differential Revision: https://reviews.llvm.org/D43579 llvm-svn: 325760
2018-02-22 17:34:08 +08:00
#include_next <math.h>
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#ifdef __cplusplus
// We support including .h headers inside 'extern "C"' contexts, so switch
// back to C++ linkage before including these C++ headers.
extern "C++" {
[libc++] Alphabetize header #includes. NFCI. The NFC part of D116809. We still want to enforce this in CI, but the mechanism for that is still to-be-determined. Differential Revision: https://reviews.llvm.org/D116809
2022-01-07 22:45:05 +08:00
#include <limits>
Reland [libc++] Move abs and div into stdlib.h to fix header cycle. This commit should will break libc++ without local submodule visibility, but the LLVM+modules bots are now all using this mode. Before the Green Dragon LLDB bot was failing to compile with a libc++ built with this commit as LSV was disabled on macOS. Original summary: libc++ is careful to not fracture overload sets. When one overload is visible to a user, all of them should be. Anything less causes subtle bugs and ODR violations. Previously, in order to support ::abs and ::div being supplied by both <cmath> and <cstdlib> we had to do awful things that make <math.h> and <stdlib.h> have header cycles and be non-modular. This really breaks with modules. Specifically the problem was that in C++ ::abs introduces overloads for floating point numbers, these overloads forward to ::fabs, which are defined in math.h. Therefore ::abs needed to be in math.h too. But this required stdlib.h to include math.h and math.h to include stdlib.h. To avoid these problems the definitions have been moved to stddef.h (which math includes), and the floating point overloads of ::abs have been changed to call __builtin_fabs, which both Clang and GCC support.
2020-02-16 07:55:07 +08:00
#include <stdlib.h>
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#include <type_traits>
// signbit
#ifdef signbit
template <class _A1>
[libc++] Take 2: Replace uses of _LIBCPP_ALWAYS_INLINE by _LIBCPP_INLINE_VISIBILITY Summary: We never actually mean to always inline a function -- all the uses of the macro I could find are actually attempts to control the visibility of symbols. This is better described by _LIBCPP_INLINE_VISIBILITY, which is actually always defined the same. This change is orthogonal to the decision of what we're actually going to do with _LIBCPP_INLINE_VISIBILITY -- it just simplifies things by having one canonical way of doing things. Note that this commit had originally been applied in r336369 and then reverted in r336382 because of unforeseen problems. Both of these problems have now been fixed. Reviewers: EricWF, mclow.lists Subscribers: christof, dexonsmith, erikvanderpoel Differential Revision: https://reviews.llvm.org/D48892 llvm-svn: 336866
2018-07-12 07:14:33 +08:00
_LIBCPP_INLINE_VISIBILITY
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
bool
__libcpp_signbit(_A1 __lcpp_x) _NOEXCEPT
{
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
#if __has_builtin(__builtin_signbit)
return __builtin_signbit(__lcpp_x);
#else
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
return signbit(__lcpp_x);
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
#endif
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
}
#undef signbit
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
cmath: Skip Libc for integral types in isinf, etc. For std::isinf, the standard requires effectively calling isinf as double from Libc for integral types. But integral types are never infinite; we don't need to call Libc to return false. Also short-circuit other functions where Libc won't have interesting answers: signbit, fpclassify, isfinite, isnan, and isnormal. I added correctness tests for integral types since we're no longer deferring to Libc. In review it was pointed out that in future revisions of the C++ standard we may add more types to std::is_arithmetic (e.g., std::is_fixed_point). I'll leave it to a future commit to hack this to allow using math functions on those. We'll need to change things like __libcpp_fpclassify anyway, so I'm not sure anything here would really be future-proof. https://reviews.llvm.org/D31561 rdar://problem/31361223 llvm-svn: 301060
2017-04-22 07:14:55 +08:00
typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
signbit(_A1 __lcpp_x) _NOEXCEPT
{
return __libcpp_signbit((typename std::__promote<_A1>::type)__lcpp_x);
}
cmath: Skip Libc for integral types in isinf, etc. For std::isinf, the standard requires effectively calling isinf as double from Libc for integral types. But integral types are never infinite; we don't need to call Libc to return false. Also short-circuit other functions where Libc won't have interesting answers: signbit, fpclassify, isfinite, isnan, and isnormal. I added correctness tests for integral types since we're no longer deferring to Libc. In review it was pointed out that in future revisions of the C++ standard we may add more types to std::is_arithmetic (e.g., std::is_fixed_point). I'll leave it to a future commit to hack this to allow using math functions on those. We'll need to change things like __libcpp_fpclassify anyway, so I'm not sure anything here would really be future-proof. https://reviews.llvm.org/D31561 rdar://problem/31361223 llvm-svn: 301060
2017-04-22 07:14:55 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<
std::is_integral<_A1>::value && std::is_signed<_A1>::value, bool>::type
signbit(_A1 __lcpp_x) _NOEXCEPT
{ return __lcpp_x < 0; }
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<
std::is_integral<_A1>::value && !std::is_signed<_A1>::value, bool>::type
signbit(_A1) _NOEXCEPT
{ return false; }
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#elif defined(_LIBCPP_MSVCRT)
math: add type promoting template definition on MSVCRT When building with MSVCRT, we need to manually provide the type promoting overloads to allow the correct type deduced invocation for signbit(Int) and fpclassify(int). llvm-svn: 295559
2017-02-19 03:28:38 +08:00
template <typename _A1>
inline _LIBCPP_INLINE_VISIBILITY
cmath: Skip Libc for integral types in isinf, etc. For std::isinf, the standard requires effectively calling isinf as double from Libc for integral types. But integral types are never infinite; we don't need to call Libc to return false. Also short-circuit other functions where Libc won't have interesting answers: signbit, fpclassify, isfinite, isnan, and isnormal. I added correctness tests for integral types since we're no longer deferring to Libc. In review it was pointed out that in future revisions of the C++ standard we may add more types to std::is_arithmetic (e.g., std::is_fixed_point). I'll leave it to a future commit to hack this to allow using math functions on those. We'll need to change things like __libcpp_fpclassify anyway, so I'm not sure anything here would really be future-proof. https://reviews.llvm.org/D31561 rdar://problem/31361223 llvm-svn: 301060
2017-04-22 07:14:55 +08:00
typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
math: add type promoting template definition on MSVCRT When building with MSVCRT, we need to manually provide the type promoting overloads to allow the correct type deduced invocation for signbit(Int) and fpclassify(int). llvm-svn: 295559
2017-02-19 03:28:38 +08:00
signbit(_A1 __lcpp_x) _NOEXCEPT
{
return ::signbit(static_cast<typename std::__promote<_A1>::type>(__lcpp_x));
}
cmath: Skip Libc for integral types in isinf, etc. For std::isinf, the standard requires effectively calling isinf as double from Libc for integral types. But integral types are never infinite; we don't need to call Libc to return false. Also short-circuit other functions where Libc won't have interesting answers: signbit, fpclassify, isfinite, isnan, and isnormal. I added correctness tests for integral types since we're no longer deferring to Libc. In review it was pointed out that in future revisions of the C++ standard we may add more types to std::is_arithmetic (e.g., std::is_fixed_point). I'll leave it to a future commit to hack this to allow using math functions on those. We'll need to change things like __libcpp_fpclassify anyway, so I'm not sure anything here would really be future-proof. https://reviews.llvm.org/D31561 rdar://problem/31361223 llvm-svn: 301060
2017-04-22 07:14:55 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<
std::is_integral<_A1>::value && std::is_signed<_A1>::value, bool>::type
signbit(_A1 __lcpp_x) _NOEXCEPT
{ return __lcpp_x < 0; }
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<
std::is_integral<_A1>::value && !std::is_signed<_A1>::value, bool>::type
signbit(_A1) _NOEXCEPT
{ return false; }
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-21 00:03:32 +08:00
#endif // signbit
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// fpclassify
#ifdef fpclassify
template <class _A1>
[libc++] Take 2: Replace uses of _LIBCPP_ALWAYS_INLINE by _LIBCPP_INLINE_VISIBILITY Summary: We never actually mean to always inline a function -- all the uses of the macro I could find are actually attempts to control the visibility of symbols. This is better described by _LIBCPP_INLINE_VISIBILITY, which is actually always defined the same. This change is orthogonal to the decision of what we're actually going to do with _LIBCPP_INLINE_VISIBILITY -- it just simplifies things by having one canonical way of doing things. Note that this commit had originally been applied in r336369 and then reverted in r336382 because of unforeseen problems. Both of these problems have now been fixed. Reviewers: EricWF, mclow.lists Subscribers: christof, dexonsmith, erikvanderpoel Differential Revision: https://reviews.llvm.org/D48892 llvm-svn: 336866
2018-07-12 07:14:33 +08:00
_LIBCPP_INLINE_VISIBILITY
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
int
__libcpp_fpclassify(_A1 __lcpp_x) _NOEXCEPT
{
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
#if __has_builtin(__builtin_fpclassify)
return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL,
FP_ZERO, __lcpp_x);
#else
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
return fpclassify(__lcpp_x);
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
#endif
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
}
#undef fpclassify
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
cmath: Skip Libc for integral types in isinf, etc. For std::isinf, the standard requires effectively calling isinf as double from Libc for integral types. But integral types are never infinite; we don't need to call Libc to return false. Also short-circuit other functions where Libc won't have interesting answers: signbit, fpclassify, isfinite, isnan, and isnormal. I added correctness tests for integral types since we're no longer deferring to Libc. In review it was pointed out that in future revisions of the C++ standard we may add more types to std::is_arithmetic (e.g., std::is_fixed_point). I'll leave it to a future commit to hack this to allow using math functions on those. We'll need to change things like __libcpp_fpclassify anyway, so I'm not sure anything here would really be future-proof. https://reviews.llvm.org/D31561 rdar://problem/31361223 llvm-svn: 301060
2017-04-22 07:14:55 +08:00
typename std::enable_if<std::is_floating_point<_A1>::value, int>::type
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
fpclassify(_A1 __lcpp_x) _NOEXCEPT
{
return __libcpp_fpclassify((typename std::__promote<_A1>::type)__lcpp_x);
}
cmath: Skip Libc for integral types in isinf, etc. For std::isinf, the standard requires effectively calling isinf as double from Libc for integral types. But integral types are never infinite; we don't need to call Libc to return false. Also short-circuit other functions where Libc won't have interesting answers: signbit, fpclassify, isfinite, isnan, and isnormal. I added correctness tests for integral types since we're no longer deferring to Libc. In review it was pointed out that in future revisions of the C++ standard we may add more types to std::is_arithmetic (e.g., std::is_fixed_point). I'll leave it to a future commit to hack this to allow using math functions on those. We'll need to change things like __libcpp_fpclassify anyway, so I'm not sure anything here would really be future-proof. https://reviews.llvm.org/D31561 rdar://problem/31361223 llvm-svn: 301060
2017-04-22 07:14:55 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, int>::type
fpclassify(_A1 __lcpp_x) _NOEXCEPT
{ return __lcpp_x == 0 ? FP_ZERO : FP_NORMAL; }
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#elif defined(_LIBCPP_MSVCRT)
math: add type promoting template definition on MSVCRT When building with MSVCRT, we need to manually provide the type promoting overloads to allow the correct type deduced invocation for signbit(Int) and fpclassify(int). llvm-svn: 295559
2017-02-19 03:28:38 +08:00
template <typename _A1>
inline _LIBCPP_INLINE_VISIBILITY
cmath: Skip Libc for integral types in isinf, etc. For std::isinf, the standard requires effectively calling isinf as double from Libc for integral types. But integral types are never infinite; we don't need to call Libc to return false. Also short-circuit other functions where Libc won't have interesting answers: signbit, fpclassify, isfinite, isnan, and isnormal. I added correctness tests for integral types since we're no longer deferring to Libc. In review it was pointed out that in future revisions of the C++ standard we may add more types to std::is_arithmetic (e.g., std::is_fixed_point). I'll leave it to a future commit to hack this to allow using math functions on those. We'll need to change things like __libcpp_fpclassify anyway, so I'm not sure anything here would really be future-proof. https://reviews.llvm.org/D31561 rdar://problem/31361223 llvm-svn: 301060
2017-04-22 07:14:55 +08:00
typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
math: add type promoting template definition on MSVCRT When building with MSVCRT, we need to manually provide the type promoting overloads to allow the correct type deduced invocation for signbit(Int) and fpclassify(int). llvm-svn: 295559
2017-02-19 03:28:38 +08:00
fpclassify(_A1 __lcpp_x) _NOEXCEPT
{
return ::fpclassify(static_cast<typename std::__promote<_A1>::type>(__lcpp_x));
}
cmath: Skip Libc for integral types in isinf, etc. For std::isinf, the standard requires effectively calling isinf as double from Libc for integral types. But integral types are never infinite; we don't need to call Libc to return false. Also short-circuit other functions where Libc won't have interesting answers: signbit, fpclassify, isfinite, isnan, and isnormal. I added correctness tests for integral types since we're no longer deferring to Libc. In review it was pointed out that in future revisions of the C++ standard we may add more types to std::is_arithmetic (e.g., std::is_fixed_point). I'll leave it to a future commit to hack this to allow using math functions on those. We'll need to change things like __libcpp_fpclassify anyway, so I'm not sure anything here would really be future-proof. https://reviews.llvm.org/D31561 rdar://problem/31361223 llvm-svn: 301060
2017-04-22 07:14:55 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, int>::type
fpclassify(_A1 __lcpp_x) _NOEXCEPT
{ return __lcpp_x == 0 ? FP_ZERO : FP_NORMAL; }
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-21 00:03:32 +08:00
#endif // fpclassify
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// isfinite
#ifdef isfinite
template <class _A1>
[libc++] Take 2: Replace uses of _LIBCPP_ALWAYS_INLINE by _LIBCPP_INLINE_VISIBILITY Summary: We never actually mean to always inline a function -- all the uses of the macro I could find are actually attempts to control the visibility of symbols. This is better described by _LIBCPP_INLINE_VISIBILITY, which is actually always defined the same. This change is orthogonal to the decision of what we're actually going to do with _LIBCPP_INLINE_VISIBILITY -- it just simplifies things by having one canonical way of doing things. Note that this commit had originally been applied in r336369 and then reverted in r336382 because of unforeseen problems. Both of these problems have now been fixed. Reviewers: EricWF, mclow.lists Subscribers: christof, dexonsmith, erikvanderpoel Differential Revision: https://reviews.llvm.org/D48892 llvm-svn: 336866
2018-07-12 07:14:33 +08:00
_LIBCPP_INLINE_VISIBILITY
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
bool
__libcpp_isfinite(_A1 __lcpp_x) _NOEXCEPT
{
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
#if __has_builtin(__builtin_isfinite)
return __builtin_isfinite(__lcpp_x);
#else
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
return isfinite(__lcpp_x);
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
#endif
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
}
#undef isfinite
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
cmath: Skip Libc for integral types in isinf, etc. For std::isinf, the standard requires effectively calling isinf as double from Libc for integral types. But integral types are never infinite; we don't need to call Libc to return false. Also short-circuit other functions where Libc won't have interesting answers: signbit, fpclassify, isfinite, isnan, and isnormal. I added correctness tests for integral types since we're no longer deferring to Libc. In review it was pointed out that in future revisions of the C++ standard we may add more types to std::is_arithmetic (e.g., std::is_fixed_point). I'll leave it to a future commit to hack this to allow using math functions on those. We'll need to change things like __libcpp_fpclassify anyway, so I'm not sure anything here would really be future-proof. https://reviews.llvm.org/D31561 rdar://problem/31361223 llvm-svn: 301060
2017-04-22 07:14:55 +08:00
typename std::enable_if<
std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity,
bool>::type
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
isfinite(_A1 __lcpp_x) _NOEXCEPT
{
return __libcpp_isfinite((typename std::__promote<_A1>::type)__lcpp_x);
}
cmath: Skip Libc for integral types in isinf, etc. For std::isinf, the standard requires effectively calling isinf as double from Libc for integral types. But integral types are never infinite; we don't need to call Libc to return false. Also short-circuit other functions where Libc won't have interesting answers: signbit, fpclassify, isfinite, isnan, and isnormal. I added correctness tests for integral types since we're no longer deferring to Libc. In review it was pointed out that in future revisions of the C++ standard we may add more types to std::is_arithmetic (e.g., std::is_fixed_point). I'll leave it to a future commit to hack this to allow using math functions on those. We'll need to change things like __libcpp_fpclassify anyway, so I'm not sure anything here would really be future-proof. https://reviews.llvm.org/D31561 rdar://problem/31361223 llvm-svn: 301060
2017-04-22 07:14:55 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<
std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity,
bool>::type
isfinite(_A1) _NOEXCEPT
{ return true; }
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-21 00:03:32 +08:00
#endif // isfinite
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// isinf
#ifdef isinf
template <class _A1>
[libc++] Take 2: Replace uses of _LIBCPP_ALWAYS_INLINE by _LIBCPP_INLINE_VISIBILITY Summary: We never actually mean to always inline a function -- all the uses of the macro I could find are actually attempts to control the visibility of symbols. This is better described by _LIBCPP_INLINE_VISIBILITY, which is actually always defined the same. This change is orthogonal to the decision of what we're actually going to do with _LIBCPP_INLINE_VISIBILITY -- it just simplifies things by having one canonical way of doing things. Note that this commit had originally been applied in r336369 and then reverted in r336382 because of unforeseen problems. Both of these problems have now been fixed. Reviewers: EricWF, mclow.lists Subscribers: christof, dexonsmith, erikvanderpoel Differential Revision: https://reviews.llvm.org/D48892 llvm-svn: 336866
2018-07-12 07:14:33 +08:00
_LIBCPP_INLINE_VISIBILITY
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
bool
__libcpp_isinf(_A1 __lcpp_x) _NOEXCEPT
{
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
#if __has_builtin(__builtin_isinf)
return __builtin_isinf(__lcpp_x);
#else
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
return isinf(__lcpp_x);
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
#endif
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
}
#undef isinf
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
cmath: Skip Libc for integral types in isinf, etc. For std::isinf, the standard requires effectively calling isinf as double from Libc for integral types. But integral types are never infinite; we don't need to call Libc to return false. Also short-circuit other functions where Libc won't have interesting answers: signbit, fpclassify, isfinite, isnan, and isnormal. I added correctness tests for integral types since we're no longer deferring to Libc. In review it was pointed out that in future revisions of the C++ standard we may add more types to std::is_arithmetic (e.g., std::is_fixed_point). I'll leave it to a future commit to hack this to allow using math functions on those. We'll need to change things like __libcpp_fpclassify anyway, so I'm not sure anything here would really be future-proof. https://reviews.llvm.org/D31561 rdar://problem/31361223 llvm-svn: 301060
2017-04-22 07:14:55 +08:00
typename std::enable_if<
std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity,
bool>::type
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
isinf(_A1 __lcpp_x) _NOEXCEPT
{
return __libcpp_isinf((typename std::__promote<_A1>::type)__lcpp_x);
}
cmath: Skip Libc for integral types in isinf, etc. For std::isinf, the standard requires effectively calling isinf as double from Libc for integral types. But integral types are never infinite; we don't need to call Libc to return false. Also short-circuit other functions where Libc won't have interesting answers: signbit, fpclassify, isfinite, isnan, and isnormal. I added correctness tests for integral types since we're no longer deferring to Libc. In review it was pointed out that in future revisions of the C++ standard we may add more types to std::is_arithmetic (e.g., std::is_fixed_point). I'll leave it to a future commit to hack this to allow using math functions on those. We'll need to change things like __libcpp_fpclassify anyway, so I'm not sure anything here would really be future-proof. https://reviews.llvm.org/D31561 rdar://problem/31361223 llvm-svn: 301060
2017-04-22 07:14:55 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<
std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity,
bool>::type
isinf(_A1) _NOEXCEPT
{ return false; }
Fix return type of isinf(double) and isnan(double) where possible. When using an old version of glibc, a ::isinf(double) and ::isnan(double) function is provided, rather than just the macro required by C and C++. Displace this function using _LIBCPP_PREFERRED_OVERLOAD where possible. The only remaining case where we should get the wrong return type is now glibc + libc++ + a non-clang compiler. llvm-svn: 331241
2018-05-01 11:05:40 +08:00
#ifdef _LIBCPP_PREFERRED_OVERLOAD
inline _LIBCPP_INLINE_VISIBILITY
bool
isinf(float __lcpp_x) _NOEXCEPT { return __libcpp_isinf(__lcpp_x); }
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
bool
isinf(double __lcpp_x) _NOEXCEPT { return __libcpp_isinf(__lcpp_x); }
inline _LIBCPP_INLINE_VISIBILITY
bool
isinf(long double __lcpp_x) _NOEXCEPT { return __libcpp_isinf(__lcpp_x); }
#endif
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-21 00:03:32 +08:00
#endif // isinf
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// isnan
#ifdef isnan
template <class _A1>
[libc++] Take 2: Replace uses of _LIBCPP_ALWAYS_INLINE by _LIBCPP_INLINE_VISIBILITY Summary: We never actually mean to always inline a function -- all the uses of the macro I could find are actually attempts to control the visibility of symbols. This is better described by _LIBCPP_INLINE_VISIBILITY, which is actually always defined the same. This change is orthogonal to the decision of what we're actually going to do with _LIBCPP_INLINE_VISIBILITY -- it just simplifies things by having one canonical way of doing things. Note that this commit had originally been applied in r336369 and then reverted in r336382 because of unforeseen problems. Both of these problems have now been fixed. Reviewers: EricWF, mclow.lists Subscribers: christof, dexonsmith, erikvanderpoel Differential Revision: https://reviews.llvm.org/D48892 llvm-svn: 336866
2018-07-12 07:14:33 +08:00
_LIBCPP_INLINE_VISIBILITY
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
bool
__libcpp_isnan(_A1 __lcpp_x) _NOEXCEPT
{
[libcxx] use __builtin_isnan in std::isnan. Summary: This allows std::isnan to be fully inlined, instead of generating calls. Reviewers: EricWF Reviewed By: EricWF Subscribers: christof, ldionne Differential Revision: https://reviews.llvm.org/D69806
2019-11-16 01:29:02 +08:00
#if __has_builtin(__builtin_isnan)
return __builtin_isnan(__lcpp_x);
#else
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
return isnan(__lcpp_x);
[libcxx] use __builtin_isnan in std::isnan. Summary: This allows std::isnan to be fully inlined, instead of generating calls. Reviewers: EricWF Reviewed By: EricWF Subscribers: christof, ldionne Differential Revision: https://reviews.llvm.org/D69806
2019-11-16 01:29:02 +08:00
#endif
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
}
#undef isnan
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
cmath: Skip Libc for integral types in isinf, etc. For std::isinf, the standard requires effectively calling isinf as double from Libc for integral types. But integral types are never infinite; we don't need to call Libc to return false. Also short-circuit other functions where Libc won't have interesting answers: signbit, fpclassify, isfinite, isnan, and isnormal. I added correctness tests for integral types since we're no longer deferring to Libc. In review it was pointed out that in future revisions of the C++ standard we may add more types to std::is_arithmetic (e.g., std::is_fixed_point). I'll leave it to a future commit to hack this to allow using math functions on those. We'll need to change things like __libcpp_fpclassify anyway, so I'm not sure anything here would really be future-proof. https://reviews.llvm.org/D31561 rdar://problem/31361223 llvm-svn: 301060
2017-04-22 07:14:55 +08:00
typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
isnan(_A1 __lcpp_x) _NOEXCEPT
{
return __libcpp_isnan((typename std::__promote<_A1>::type)__lcpp_x);
}
cmath: Skip Libc for integral types in isinf, etc. For std::isinf, the standard requires effectively calling isinf as double from Libc for integral types. But integral types are never infinite; we don't need to call Libc to return false. Also short-circuit other functions where Libc won't have interesting answers: signbit, fpclassify, isfinite, isnan, and isnormal. I added correctness tests for integral types since we're no longer deferring to Libc. In review it was pointed out that in future revisions of the C++ standard we may add more types to std::is_arithmetic (e.g., std::is_fixed_point). I'll leave it to a future commit to hack this to allow using math functions on those. We'll need to change things like __libcpp_fpclassify anyway, so I'm not sure anything here would really be future-proof. https://reviews.llvm.org/D31561 rdar://problem/31361223 llvm-svn: 301060
2017-04-22 07:14:55 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, bool>::type
isnan(_A1) _NOEXCEPT
{ return false; }
Fix return type of isinf(double) and isnan(double) where possible. When using an old version of glibc, a ::isinf(double) and ::isnan(double) function is provided, rather than just the macro required by C and C++. Displace this function using _LIBCPP_PREFERRED_OVERLOAD where possible. The only remaining case where we should get the wrong return type is now glibc + libc++ + a non-clang compiler. llvm-svn: 331241
2018-05-01 11:05:40 +08:00
#ifdef _LIBCPP_PREFERRED_OVERLOAD
inline _LIBCPP_INLINE_VISIBILITY
bool
isnan(float __lcpp_x) _NOEXCEPT { return __libcpp_isnan(__lcpp_x); }
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
bool
isnan(double __lcpp_x) _NOEXCEPT { return __libcpp_isnan(__lcpp_x); }
inline _LIBCPP_INLINE_VISIBILITY
bool
isnan(long double __lcpp_x) _NOEXCEPT { return __libcpp_isnan(__lcpp_x); }
#endif
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-21 00:03:32 +08:00
#endif // isnan
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// isnormal
#ifdef isnormal
template <class _A1>
[libc++] Take 2: Replace uses of _LIBCPP_ALWAYS_INLINE by _LIBCPP_INLINE_VISIBILITY Summary: We never actually mean to always inline a function -- all the uses of the macro I could find are actually attempts to control the visibility of symbols. This is better described by _LIBCPP_INLINE_VISIBILITY, which is actually always defined the same. This change is orthogonal to the decision of what we're actually going to do with _LIBCPP_INLINE_VISIBILITY -- it just simplifies things by having one canonical way of doing things. Note that this commit had originally been applied in r336369 and then reverted in r336382 because of unforeseen problems. Both of these problems have now been fixed. Reviewers: EricWF, mclow.lists Subscribers: christof, dexonsmith, erikvanderpoel Differential Revision: https://reviews.llvm.org/D48892 llvm-svn: 336866
2018-07-12 07:14:33 +08:00
_LIBCPP_INLINE_VISIBILITY
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
bool
__libcpp_isnormal(_A1 __lcpp_x) _NOEXCEPT
{
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
#if __has_builtin(__builtin_isnormal)
return __builtin_isnormal(__lcpp_x);
#else
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
return isnormal(__lcpp_x);
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
#endif
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
}
#undef isnormal
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
cmath: Skip Libc for integral types in isinf, etc. For std::isinf, the standard requires effectively calling isinf as double from Libc for integral types. But integral types are never infinite; we don't need to call Libc to return false. Also short-circuit other functions where Libc won't have interesting answers: signbit, fpclassify, isfinite, isnan, and isnormal. I added correctness tests for integral types since we're no longer deferring to Libc. In review it was pointed out that in future revisions of the C++ standard we may add more types to std::is_arithmetic (e.g., std::is_fixed_point). I'll leave it to a future commit to hack this to allow using math functions on those. We'll need to change things like __libcpp_fpclassify anyway, so I'm not sure anything here would really be future-proof. https://reviews.llvm.org/D31561 rdar://problem/31361223 llvm-svn: 301060
2017-04-22 07:14:55 +08:00
typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
isnormal(_A1 __lcpp_x) _NOEXCEPT
{
return __libcpp_isnormal((typename std::__promote<_A1>::type)__lcpp_x);
}
cmath: Skip Libc for integral types in isinf, etc. For std::isinf, the standard requires effectively calling isinf as double from Libc for integral types. But integral types are never infinite; we don't need to call Libc to return false. Also short-circuit other functions where Libc won't have interesting answers: signbit, fpclassify, isfinite, isnan, and isnormal. I added correctness tests for integral types since we're no longer deferring to Libc. In review it was pointed out that in future revisions of the C++ standard we may add more types to std::is_arithmetic (e.g., std::is_fixed_point). I'll leave it to a future commit to hack this to allow using math functions on those. We'll need to change things like __libcpp_fpclassify anyway, so I'm not sure anything here would really be future-proof. https://reviews.llvm.org/D31561 rdar://problem/31361223 llvm-svn: 301060
2017-04-22 07:14:55 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, bool>::type
isnormal(_A1 __lcpp_x) _NOEXCEPT
{ return __lcpp_x != 0; }
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-21 00:03:32 +08:00
#endif // isnormal
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// isgreater
#ifdef isgreater
template <class _A1, class _A2>
[libc++] Take 2: Replace uses of _LIBCPP_ALWAYS_INLINE by _LIBCPP_INLINE_VISIBILITY Summary: We never actually mean to always inline a function -- all the uses of the macro I could find are actually attempts to control the visibility of symbols. This is better described by _LIBCPP_INLINE_VISIBILITY, which is actually always defined the same. This change is orthogonal to the decision of what we're actually going to do with _LIBCPP_INLINE_VISIBILITY -- it just simplifies things by having one canonical way of doing things. Note that this commit had originally been applied in r336369 and then reverted in r336382 because of unforeseen problems. Both of these problems have now been fixed. Reviewers: EricWF, mclow.lists Subscribers: christof, dexonsmith, erikvanderpoel Differential Revision: https://reviews.llvm.org/D48892 llvm-svn: 336866
2018-07-12 07:14:33 +08:00
_LIBCPP_INLINE_VISIBILITY
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
bool
__libcpp_isgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
return isgreater(__lcpp_x, __lcpp_y);
}
#undef isgreater
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if
<
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
bool
>::type
isgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type type;
return __libcpp_isgreater((type)__lcpp_x, (type)__lcpp_y);
}
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-21 00:03:32 +08:00
#endif // isgreater
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// isgreaterequal
#ifdef isgreaterequal
template <class _A1, class _A2>
[libc++] Take 2: Replace uses of _LIBCPP_ALWAYS_INLINE by _LIBCPP_INLINE_VISIBILITY Summary: We never actually mean to always inline a function -- all the uses of the macro I could find are actually attempts to control the visibility of symbols. This is better described by _LIBCPP_INLINE_VISIBILITY, which is actually always defined the same. This change is orthogonal to the decision of what we're actually going to do with _LIBCPP_INLINE_VISIBILITY -- it just simplifies things by having one canonical way of doing things. Note that this commit had originally been applied in r336369 and then reverted in r336382 because of unforeseen problems. Both of these problems have now been fixed. Reviewers: EricWF, mclow.lists Subscribers: christof, dexonsmith, erikvanderpoel Differential Revision: https://reviews.llvm.org/D48892 llvm-svn: 336866
2018-07-12 07:14:33 +08:00
_LIBCPP_INLINE_VISIBILITY
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
bool
__libcpp_isgreaterequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
return isgreaterequal(__lcpp_x, __lcpp_y);
}
#undef isgreaterequal
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if
<
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
bool
>::type
isgreaterequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type type;
return __libcpp_isgreaterequal((type)__lcpp_x, (type)__lcpp_y);
}
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-21 00:03:32 +08:00
#endif // isgreaterequal
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// isless
#ifdef isless
template <class _A1, class _A2>
[libc++] Take 2: Replace uses of _LIBCPP_ALWAYS_INLINE by _LIBCPP_INLINE_VISIBILITY Summary: We never actually mean to always inline a function -- all the uses of the macro I could find are actually attempts to control the visibility of symbols. This is better described by _LIBCPP_INLINE_VISIBILITY, which is actually always defined the same. This change is orthogonal to the decision of what we're actually going to do with _LIBCPP_INLINE_VISIBILITY -- it just simplifies things by having one canonical way of doing things. Note that this commit had originally been applied in r336369 and then reverted in r336382 because of unforeseen problems. Both of these problems have now been fixed. Reviewers: EricWF, mclow.lists Subscribers: christof, dexonsmith, erikvanderpoel Differential Revision: https://reviews.llvm.org/D48892 llvm-svn: 336866
2018-07-12 07:14:33 +08:00
_LIBCPP_INLINE_VISIBILITY
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
bool
__libcpp_isless(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
return isless(__lcpp_x, __lcpp_y);
}
#undef isless
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if
<
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
bool
>::type
isless(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type type;
return __libcpp_isless((type)__lcpp_x, (type)__lcpp_y);
}
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-21 00:03:32 +08:00
#endif // isless
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// islessequal
#ifdef islessequal
template <class _A1, class _A2>
[libc++] Take 2: Replace uses of _LIBCPP_ALWAYS_INLINE by _LIBCPP_INLINE_VISIBILITY Summary: We never actually mean to always inline a function -- all the uses of the macro I could find are actually attempts to control the visibility of symbols. This is better described by _LIBCPP_INLINE_VISIBILITY, which is actually always defined the same. This change is orthogonal to the decision of what we're actually going to do with _LIBCPP_INLINE_VISIBILITY -- it just simplifies things by having one canonical way of doing things. Note that this commit had originally been applied in r336369 and then reverted in r336382 because of unforeseen problems. Both of these problems have now been fixed. Reviewers: EricWF, mclow.lists Subscribers: christof, dexonsmith, erikvanderpoel Differential Revision: https://reviews.llvm.org/D48892 llvm-svn: 336866
2018-07-12 07:14:33 +08:00
_LIBCPP_INLINE_VISIBILITY
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
bool
__libcpp_islessequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
return islessequal(__lcpp_x, __lcpp_y);
}
#undef islessequal
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if
<
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
bool
>::type
islessequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type type;
return __libcpp_islessequal((type)__lcpp_x, (type)__lcpp_y);
}
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-21 00:03:32 +08:00
#endif // islessequal
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// islessgreater
#ifdef islessgreater
template <class _A1, class _A2>
[libc++] Take 2: Replace uses of _LIBCPP_ALWAYS_INLINE by _LIBCPP_INLINE_VISIBILITY Summary: We never actually mean to always inline a function -- all the uses of the macro I could find are actually attempts to control the visibility of symbols. This is better described by _LIBCPP_INLINE_VISIBILITY, which is actually always defined the same. This change is orthogonal to the decision of what we're actually going to do with _LIBCPP_INLINE_VISIBILITY -- it just simplifies things by having one canonical way of doing things. Note that this commit had originally been applied in r336369 and then reverted in r336382 because of unforeseen problems. Both of these problems have now been fixed. Reviewers: EricWF, mclow.lists Subscribers: christof, dexonsmith, erikvanderpoel Differential Revision: https://reviews.llvm.org/D48892 llvm-svn: 336866
2018-07-12 07:14:33 +08:00
_LIBCPP_INLINE_VISIBILITY
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
bool
__libcpp_islessgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
return islessgreater(__lcpp_x, __lcpp_y);
}
#undef islessgreater
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if
<
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
bool
>::type
islessgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type type;
return __libcpp_islessgreater((type)__lcpp_x, (type)__lcpp_y);
}
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-21 00:03:32 +08:00
#endif // islessgreater
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// isunordered
#ifdef isunordered
template <class _A1, class _A2>
[libc++] Take 2: Replace uses of _LIBCPP_ALWAYS_INLINE by _LIBCPP_INLINE_VISIBILITY Summary: We never actually mean to always inline a function -- all the uses of the macro I could find are actually attempts to control the visibility of symbols. This is better described by _LIBCPP_INLINE_VISIBILITY, which is actually always defined the same. This change is orthogonal to the decision of what we're actually going to do with _LIBCPP_INLINE_VISIBILITY -- it just simplifies things by having one canonical way of doing things. Note that this commit had originally been applied in r336369 and then reverted in r336382 because of unforeseen problems. Both of these problems have now been fixed. Reviewers: EricWF, mclow.lists Subscribers: christof, dexonsmith, erikvanderpoel Differential Revision: https://reviews.llvm.org/D48892 llvm-svn: 336866
2018-07-12 07:14:33 +08:00
_LIBCPP_INLINE_VISIBILITY
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
bool
__libcpp_isunordered(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
return isunordered(__lcpp_x, __lcpp_y);
}
#undef isunordered
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if
<
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
bool
>::type
isunordered(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type type;
return __libcpp_isunordered((type)__lcpp_x, (type)__lcpp_y);
}
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-21 00:03:32 +08:00
#endif // isunordered
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// abs
Reland [libc++] Move abs and div into stdlib.h to fix header cycle. This commit should will break libc++ without local submodule visibility, but the LLVM+modules bots are now all using this mode. Before the Green Dragon LLDB bot was failing to compile with a libc++ built with this commit as LSV was disabled on macOS. Original summary: libc++ is careful to not fracture overload sets. When one overload is visible to a user, all of them should be. Anything less causes subtle bugs and ODR violations. Previously, in order to support ::abs and ::div being supplied by both <cmath> and <cstdlib> we had to do awful things that make <math.h> and <stdlib.h> have header cycles and be non-modular. This really breaks with modules. Specifically the problem was that in C++ ::abs introduces overloads for floating point numbers, these overloads forward to ::fabs, which are defined in math.h. Therefore ::abs needed to be in math.h too. But this required stdlib.h to include math.h and math.h to include stdlib.h. To avoid these problems the definitions have been moved to stddef.h (which math includes), and the floating point overloads of ::abs have been changed to call __builtin_fabs, which both Clang and GCC support.
2020-02-16 07:55:07 +08:00
//
// handled in stdlib.h
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
Fix implementation of ::abs and std::abs LWG 2192. Summary: All overloads of `::abs` and `std::abs` must be present in both `<cmath>` and `<cstdlib>`. This is problematic to implement because C defines `fabs` in `math.h` and `labs` in `stdlib.h`. This introduces a circular dependency between the two headers. This patch implements that requirement by moving `abs` into `math.h` and making `stdlib.h` include `math.h`. In order to get the underlying C declarations from the "real" `stdlib.h` inside our `math.h` we need some trickery. Specifically we need to make `stdlib.h` include next itself. Suggestions for a cleaner implementation are welcome. Reviewers: mclow.lists, ldionne Reviewed By: ldionne Subscribers: krytarowski, fedor.sergeev, dexonsmith, jdoerfert, jsji, libcxx-commits Differential Revision: https://reviews.llvm.org/D60097 llvm-svn: 359020
2019-04-24 02:01:58 +08:00
// div
Reland [libc++] Move abs and div into stdlib.h to fix header cycle. This commit should will break libc++ without local submodule visibility, but the LLVM+modules bots are now all using this mode. Before the Green Dragon LLDB bot was failing to compile with a libc++ built with this commit as LSV was disabled on macOS. Original summary: libc++ is careful to not fracture overload sets. When one overload is visible to a user, all of them should be. Anything less causes subtle bugs and ODR violations. Previously, in order to support ::abs and ::div being supplied by both <cmath> and <cstdlib> we had to do awful things that make <math.h> and <stdlib.h> have header cycles and be non-modular. This really breaks with modules. Specifically the problem was that in C++ ::abs introduces overloads for floating point numbers, these overloads forward to ::fabs, which are defined in math.h. Therefore ::abs needed to be in math.h too. But this required stdlib.h to include math.h and math.h to include stdlib.h. To avoid these problems the definitions have been moved to stddef.h (which math includes), and the floating point overloads of ::abs have been changed to call __builtin_fabs, which both Clang and GCC support.
2020-02-16 07:55:07 +08:00
//
// handled in stdlib.h
Fix implementation of ::abs and std::abs LWG 2192. Summary: All overloads of `::abs` and `std::abs` must be present in both `<cmath>` and `<cstdlib>`. This is problematic to implement because C defines `fabs` in `math.h` and `labs` in `stdlib.h`. This introduces a circular dependency between the two headers. This patch implements that requirement by moving `abs` into `math.h` and making `stdlib.h` include `math.h`. In order to get the underlying C declarations from the "real" `stdlib.h` inside our `math.h` we need some trickery. Specifically we need to make `stdlib.h` include next itself. Suggestions for a cleaner implementation are welcome. Reviewers: mclow.lists, ldionne Reviewed By: ldionne Subscribers: krytarowski, fedor.sergeev, dexonsmith, jdoerfert, jsji, libcxx-commits Differential Revision: https://reviews.llvm.org/D60097 llvm-svn: 359020
2019-04-24 02:01:58 +08:00
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// acos
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float acos(float __lcpp_x) _NOEXCEPT {return ::acosf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double acos(long double __lcpp_x) _NOEXCEPT {return ::acosl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
acos(_A1 __lcpp_x) _NOEXCEPT {return ::acos((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// asin
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float asin(float __lcpp_x) _NOEXCEPT {return ::asinf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double asin(long double __lcpp_x) _NOEXCEPT {return ::asinl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
asin(_A1 __lcpp_x) _NOEXCEPT {return ::asin((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// atan
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float atan(float __lcpp_x) _NOEXCEPT {return ::atanf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double atan(long double __lcpp_x) _NOEXCEPT {return ::atanl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
atan(_A1 __lcpp_x) _NOEXCEPT {return ::atan((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// atan2
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float atan2(float __lcpp_y, float __lcpp_x) _NOEXCEPT {return ::atan2f(__lcpp_y, __lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double atan2(long double __lcpp_y, long double __lcpp_x) _NOEXCEPT {return ::atan2l(__lcpp_y, __lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
typename std::__enable_if_t
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
<
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
std::__promote<_A1, _A2>
>::type
atan2(_A1 __lcpp_y, _A2 __lcpp_x) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type __result_type;
Apply new meta-programming traits throughout the library. The new meta-programming primitives are lower cost than the old versions. This patch removes those old versions and switches libc++ to use the new ones. llvm-svn: 364160
2019-06-24 04:28:29 +08:00
static_assert((!(std::_IsSame<_A1, __result_type>::value &&
std::_IsSame<_A2, __result_type>::value)), "");
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
return ::atan2((__result_type)__lcpp_y, (__result_type)__lcpp_x);
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
}
// ceil
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float ceil(float __lcpp_x) _NOEXCEPT {return ::ceilf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double ceil(long double __lcpp_x) _NOEXCEPT {return ::ceill(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
ceil(_A1 __lcpp_x) _NOEXCEPT {return ::ceil((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// cos
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float cos(float __lcpp_x) _NOEXCEPT {return ::cosf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double cos(long double __lcpp_x) _NOEXCEPT {return ::cosl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
cos(_A1 __lcpp_x) _NOEXCEPT {return ::cos((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// cosh
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float cosh(float __lcpp_x) _NOEXCEPT {return ::coshf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double cosh(long double __lcpp_x) _NOEXCEPT {return ::coshl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
cosh(_A1 __lcpp_x) _NOEXCEPT {return ::cosh((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// exp
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float exp(float __lcpp_x) _NOEXCEPT {return ::expf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double exp(long double __lcpp_x) _NOEXCEPT {return ::expl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
exp(_A1 __lcpp_x) _NOEXCEPT {return ::exp((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// fabs
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float fabs(float __lcpp_x) _NOEXCEPT {return ::fabsf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double fabs(long double __lcpp_x) _NOEXCEPT {return ::fabsl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
fabs(_A1 __lcpp_x) _NOEXCEPT {return ::fabs((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// floor
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float floor(float __lcpp_x) _NOEXCEPT {return ::floorf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double floor(long double __lcpp_x) _NOEXCEPT {return ::floorl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
floor(_A1 __lcpp_x) _NOEXCEPT {return ::floor((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// fmod
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float fmod(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::fmodf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double fmod(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fmodl(__lcpp_x, __lcpp_y);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
typename std::__enable_if_t
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
<
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
std::__promote<_A1, _A2>
>::type
fmod(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type __result_type;
Apply new meta-programming traits throughout the library. The new meta-programming primitives are lower cost than the old versions. This patch removes those old versions and switches libc++ to use the new ones. llvm-svn: 364160
2019-06-24 04:28:29 +08:00
static_assert((!(std::_IsSame<_A1, __result_type>::value &&
std::_IsSame<_A2, __result_type>::value)), "");
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
return ::fmod((__result_type)__lcpp_x, (__result_type)__lcpp_y);
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
}
// frexp
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float frexp(float __lcpp_x, int* __lcpp_e) _NOEXCEPT {return ::frexpf(__lcpp_x, __lcpp_e);}
inline _LIBCPP_INLINE_VISIBILITY long double frexp(long double __lcpp_x, int* __lcpp_e) _NOEXCEPT {return ::frexpl(__lcpp_x, __lcpp_e);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
frexp(_A1 __lcpp_x, int* __lcpp_e) _NOEXCEPT {return ::frexp((double)__lcpp_x, __lcpp_e);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// ldexp
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float ldexp(float __lcpp_x, int __lcpp_e) _NOEXCEPT {return ::ldexpf(__lcpp_x, __lcpp_e);}
inline _LIBCPP_INLINE_VISIBILITY long double ldexp(long double __lcpp_x, int __lcpp_e) _NOEXCEPT {return ::ldexpl(__lcpp_x, __lcpp_e);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
ldexp(_A1 __lcpp_x, int __lcpp_e) _NOEXCEPT {return ::ldexp((double)__lcpp_x, __lcpp_e);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// log
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float log(float __lcpp_x) _NOEXCEPT {return ::logf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double log(long double __lcpp_x) _NOEXCEPT {return ::logl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
log(_A1 __lcpp_x) _NOEXCEPT {return ::log((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// log10
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float log10(float __lcpp_x) _NOEXCEPT {return ::log10f(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double log10(long double __lcpp_x) _NOEXCEPT {return ::log10l(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
log10(_A1 __lcpp_x) _NOEXCEPT {return ::log10((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// modf
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float modf(float __lcpp_x, float* __lcpp_y) _NOEXCEPT {return ::modff(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double modf(long double __lcpp_x, long double* __lcpp_y) _NOEXCEPT {return ::modfl(__lcpp_x, __lcpp_y);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
// pow
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float pow(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::powf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double pow(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::powl(__lcpp_x, __lcpp_y);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
typename std::__enable_if_t
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
<
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
std::__promote<_A1, _A2>
>::type
pow(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type __result_type;
Apply new meta-programming traits throughout the library. The new meta-programming primitives are lower cost than the old versions. This patch removes those old versions and switches libc++ to use the new ones. llvm-svn: 364160
2019-06-24 04:28:29 +08:00
static_assert((!(std::_IsSame<_A1, __result_type>::value &&
std::_IsSame<_A2, __result_type>::value)), "");
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
return ::pow((__result_type)__lcpp_x, (__result_type)__lcpp_y);
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
}
// sin
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float sin(float __lcpp_x) _NOEXCEPT {return ::sinf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double sin(long double __lcpp_x) _NOEXCEPT {return ::sinl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
sin(_A1 __lcpp_x) _NOEXCEPT {return ::sin((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// sinh
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float sinh(float __lcpp_x) _NOEXCEPT {return ::sinhf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double sinh(long double __lcpp_x) _NOEXCEPT {return ::sinhl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
sinh(_A1 __lcpp_x) _NOEXCEPT {return ::sinh((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// sqrt
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float sqrt(float __lcpp_x) _NOEXCEPT {return ::sqrtf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double sqrt(long double __lcpp_x) _NOEXCEPT {return ::sqrtl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
sqrt(_A1 __lcpp_x) _NOEXCEPT {return ::sqrt((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// tan
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float tan(float __lcpp_x) _NOEXCEPT {return ::tanf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double tan(long double __lcpp_x) _NOEXCEPT {return ::tanl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
tan(_A1 __lcpp_x) _NOEXCEPT {return ::tan((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// tanh
[libc++] Drop support for CRTs older than VS 2015 LLVM dropped support for Visual Studio versions older than 2015 quite some time ago, so I consider it safe to drop libc++'s support for older CRTs. The CRT in Visual Studio 2015 provides a lot of previously missing functions, so targeting it requires less special casing. Differential Revision: https://reviews.llvm.org/D31798 llvm-svn: 299743
2017-04-07 10:20:52 +08:00
#if !(defined(_AIX) || defined(__sun__))
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float tanh(float __lcpp_x) _NOEXCEPT {return ::tanhf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double tanh(long double __lcpp_x) _NOEXCEPT {return ::tanhl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
#endif
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
tanh(_A1 __lcpp_x) _NOEXCEPT {return ::tanh((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// acosh
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float acosh(float __lcpp_x) _NOEXCEPT {return ::acoshf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double acosh(long double __lcpp_x) _NOEXCEPT {return ::acoshl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
acosh(_A1 __lcpp_x) _NOEXCEPT {return ::acosh((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// asinh
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float asinh(float __lcpp_x) _NOEXCEPT {return ::asinhf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double asinh(long double __lcpp_x) _NOEXCEPT {return ::asinhl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
asinh(_A1 __lcpp_x) _NOEXCEPT {return ::asinh((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// atanh
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float atanh(float __lcpp_x) _NOEXCEPT {return ::atanhf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double atanh(long double __lcpp_x) _NOEXCEPT {return ::atanhl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
atanh(_A1 __lcpp_x) _NOEXCEPT {return ::atanh((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// cbrt
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float cbrt(float __lcpp_x) _NOEXCEPT {return ::cbrtf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double cbrt(long double __lcpp_x) _NOEXCEPT {return ::cbrtl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
cbrt(_A1 __lcpp_x) _NOEXCEPT {return ::cbrt((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// copysign
[libc++] Add `__libcpp_copysign` conditionally constexpr overloads. This is a spin-off from D79555 review, that with this patch will be able to use `__libcpp_copysign` instead of adhoc `__copysign_constexpr` helper. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D106364
2021-07-21 21:58:17 +08:00
#if __has_builtin(__builtin_copysignf)
_LIBCPP_CONSTEXPR
#endif
inline _LIBCPP_INLINE_VISIBILITY float __libcpp_copysign(float __lcpp_x, float __lcpp_y) _NOEXCEPT {
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
#if __has_builtin(__builtin_copysignf)
return __builtin_copysignf(__lcpp_x, __lcpp_y);
#else
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
return ::copysignf(__lcpp_x, __lcpp_y);
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
#endif
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
}
[libc++] Add `__libcpp_copysign` conditionally constexpr overloads. This is a spin-off from D79555 review, that with this patch will be able to use `__libcpp_copysign` instead of adhoc `__copysign_constexpr` helper. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D106364
2021-07-21 21:58:17 +08:00
#if __has_builtin(__builtin_copysign)
_LIBCPP_CONSTEXPR
#endif
inline _LIBCPP_INLINE_VISIBILITY double __libcpp_copysign(double __lcpp_x, double __lcpp_y) _NOEXCEPT {
#if __has_builtin(__builtin_copysign)
return __builtin_copysign(__lcpp_x, __lcpp_y);
#else
return ::copysign(__lcpp_x, __lcpp_y);
#endif
}
#if __has_builtin(__builtin_copysignl)
_LIBCPP_CONSTEXPR
#endif
inline _LIBCPP_INLINE_VISIBILITY long double __libcpp_copysign(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
#if __has_builtin(__builtin_copysignl)
return __builtin_copysignl(__lcpp_x, __lcpp_y);
#else
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
return ::copysignl(__lcpp_x, __lcpp_y);
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
#endif
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
}
template <class _A1, class _A2>
[libc++] Add `__libcpp_copysign` conditionally constexpr overloads. This is a spin-off from D79555 review, that with this patch will be able to use `__libcpp_copysign` instead of adhoc `__copysign_constexpr` helper. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D106364
2021-07-21 21:58:17 +08:00
#if __has_builtin(__builtin_copysign)
_LIBCPP_CONSTEXPR
#endif
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
inline _LIBCPP_INLINE_VISIBILITY
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
typename std::__enable_if_t
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
<
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
std::__promote<_A1, _A2>
>::type
[libc++] Add `__libcpp_copysign` conditionally constexpr overloads. This is a spin-off from D79555 review, that with this patch will be able to use `__libcpp_copysign` instead of adhoc `__copysign_constexpr` helper. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D106364
2021-07-21 21:58:17 +08:00
__libcpp_copysign(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT {
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
typedef typename std::__promote<_A1, _A2>::type __result_type;
Apply new meta-programming traits throughout the library. The new meta-programming primitives are lower cost than the old versions. This patch removes those old versions and switches libc++ to use the new ones. llvm-svn: 364160
2019-06-24 04:28:29 +08:00
static_assert((!(std::_IsSame<_A1, __result_type>::value &&
std::_IsSame<_A2, __result_type>::value)), "");
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
#if __has_builtin(__builtin_copysign)
return __builtin_copysign((__result_type)__lcpp_x, (__result_type)__lcpp_y);
#else
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
return ::copysign((__result_type)__lcpp_x, (__result_type)__lcpp_y);
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
#endif
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
}
[libc++] Add `__libcpp_copysign` conditionally constexpr overloads. This is a spin-off from D79555 review, that with this patch will be able to use `__libcpp_copysign` instead of adhoc `__copysign_constexpr` helper. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D106364
2021-07-21 21:58:17 +08:00
inline _LIBCPP_INLINE_VISIBILITY float copysign(float __lcpp_x, float __lcpp_y) _NOEXCEPT {
return ::__libcpp_copysign(__lcpp_x, __lcpp_y);
}
inline _LIBCPP_INLINE_VISIBILITY long double copysign(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {
return ::__libcpp_copysign(__lcpp_x, __lcpp_y);
}
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
typename std::__enable_if_t
[libc++] Add `__libcpp_copysign` conditionally constexpr overloads. This is a spin-off from D79555 review, that with this patch will be able to use `__libcpp_copysign` instead of adhoc `__copysign_constexpr` helper. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D106364
2021-07-21 21:58:17 +08:00
<
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
std::__promote<_A1, _A2>
>::type
copysign(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT {
return ::__libcpp_copysign(__lcpp_x, __lcpp_y);
}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// erf
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float erf(float __lcpp_x) _NOEXCEPT {return ::erff(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double erf(long double __lcpp_x) _NOEXCEPT {return ::erfl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
erf(_A1 __lcpp_x) _NOEXCEPT {return ::erf((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// erfc
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float erfc(float __lcpp_x) _NOEXCEPT {return ::erfcf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double erfc(long double __lcpp_x) _NOEXCEPT {return ::erfcl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
erfc(_A1 __lcpp_x) _NOEXCEPT {return ::erfc((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// exp2
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float exp2(float __lcpp_x) _NOEXCEPT {return ::exp2f(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double exp2(long double __lcpp_x) _NOEXCEPT {return ::exp2l(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
exp2(_A1 __lcpp_x) _NOEXCEPT {return ::exp2((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// expm1
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float expm1(float __lcpp_x) _NOEXCEPT {return ::expm1f(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double expm1(long double __lcpp_x) _NOEXCEPT {return ::expm1l(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
expm1(_A1 __lcpp_x) _NOEXCEPT {return ::expm1((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// fdim
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float fdim(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::fdimf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double fdim(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fdiml(__lcpp_x, __lcpp_y);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
typename std::__enable_if_t
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
<
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
std::__promote<_A1, _A2>
>::type
fdim(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type __result_type;
Apply new meta-programming traits throughout the library. The new meta-programming primitives are lower cost than the old versions. This patch removes those old versions and switches libc++ to use the new ones. llvm-svn: 364160
2019-06-24 04:28:29 +08:00
static_assert((!(std::_IsSame<_A1, __result_type>::value &&
std::_IsSame<_A2, __result_type>::value)), "");
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
return ::fdim((__result_type)__lcpp_x, (__result_type)__lcpp_y);
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
}
// fma
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
inline _LIBCPP_INLINE_VISIBILITY float fma(float __lcpp_x, float __lcpp_y, float __lcpp_z) _NOEXCEPT
{
#if __has_builtin(__builtin_fmaf)
return __builtin_fmaf(__lcpp_x, __lcpp_y, __lcpp_z);
#else
return ::fmaf(__lcpp_x, __lcpp_y, __lcpp_z);
#endif
}
inline _LIBCPP_INLINE_VISIBILITY long double fma(long double __lcpp_x, long double __lcpp_y, long double __lcpp_z) _NOEXCEPT
{
#if __has_builtin(__builtin_fmal)
return __builtin_fmal(__lcpp_x, __lcpp_y, __lcpp_z);
#else
return ::fmal(__lcpp_x, __lcpp_y, __lcpp_z);
#endif
}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1, class _A2, class _A3>
inline _LIBCPP_INLINE_VISIBILITY
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
typename std::__enable_if_t
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
<
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value &&
std::is_arithmetic<_A3>::value,
std::__promote<_A1, _A2, _A3>
>::type
fma(_A1 __lcpp_x, _A2 __lcpp_y, _A3 __lcpp_z) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2, _A3>::type __result_type;
Apply new meta-programming traits throughout the library. The new meta-programming primitives are lower cost than the old versions. This patch removes those old versions and switches libc++ to use the new ones. llvm-svn: 364160
2019-06-24 04:28:29 +08:00
static_assert((!(std::_IsSame<_A1, __result_type>::value &&
std::_IsSame<_A2, __result_type>::value &&
std::_IsSame<_A3, __result_type>::value)), "");
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
#if __has_builtin(__builtin_fma)
return __builtin_fma((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z);
#else
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
return ::fma((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z);
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
#endif
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
}
// fmax
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float fmax(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::fmaxf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double fmax(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fmaxl(__lcpp_x, __lcpp_y);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
typename std::__enable_if_t
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
<
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
std::__promote<_A1, _A2>
>::type
fmax(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type __result_type;
Apply new meta-programming traits throughout the library. The new meta-programming primitives are lower cost than the old versions. This patch removes those old versions and switches libc++ to use the new ones. llvm-svn: 364160
2019-06-24 04:28:29 +08:00
static_assert((!(std::_IsSame<_A1, __result_type>::value &&
std::_IsSame<_A2, __result_type>::value)), "");
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
return ::fmax((__result_type)__lcpp_x, (__result_type)__lcpp_y);
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
}
// fmin
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float fmin(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::fminf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double fmin(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fminl(__lcpp_x, __lcpp_y);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
typename std::__enable_if_t
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
<
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
std::__promote<_A1, _A2>
>::type
fmin(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type __result_type;
Apply new meta-programming traits throughout the library. The new meta-programming primitives are lower cost than the old versions. This patch removes those old versions and switches libc++ to use the new ones. llvm-svn: 364160
2019-06-24 04:28:29 +08:00
static_assert((!(std::_IsSame<_A1, __result_type>::value &&
std::_IsSame<_A2, __result_type>::value)), "");
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
return ::fmin((__result_type)__lcpp_x, (__result_type)__lcpp_y);
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
}
// hypot
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float hypot(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::hypotf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double hypot(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::hypotl(__lcpp_x, __lcpp_y);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
typename std::__enable_if_t
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
<
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
std::__promote<_A1, _A2>
>::type
hypot(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type __result_type;
Apply new meta-programming traits throughout the library. The new meta-programming primitives are lower cost than the old versions. This patch removes those old versions and switches libc++ to use the new ones. llvm-svn: 364160
2019-06-24 04:28:29 +08:00
static_assert((!(std::_IsSame<_A1, __result_type>::value &&
std::_IsSame<_A2, __result_type>::value)), "");
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
return ::hypot((__result_type)__lcpp_x, (__result_type)__lcpp_y);
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
}
// ilogb
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY int ilogb(float __lcpp_x) _NOEXCEPT {return ::ilogbf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY int ilogb(long double __lcpp_x) _NOEXCEPT {return ::ilogbl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, int>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
ilogb(_A1 __lcpp_x) _NOEXCEPT {return ::ilogb((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// lgamma
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float lgamma(float __lcpp_x) _NOEXCEPT {return ::lgammaf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double lgamma(long double __lcpp_x) _NOEXCEPT {return ::lgammal(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
lgamma(_A1 __lcpp_x) _NOEXCEPT {return ::lgamma((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// llrint
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
inline _LIBCPP_INLINE_VISIBILITY long long llrint(float __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_llrintf)
return __builtin_llrintf(__lcpp_x);
#else
return ::llrintf(__lcpp_x);
#endif
}
inline _LIBCPP_INLINE_VISIBILITY long long llrint(long double __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_llrintl)
return __builtin_llrintl(__lcpp_x);
#else
return ::llrintl(__lcpp_x);
#endif
}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, long long>::type
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
llrint(_A1 __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_llrint)
return __builtin_llrint((double)__lcpp_x);
#else
return ::llrint((double)__lcpp_x);
#endif
}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// llround
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
inline _LIBCPP_INLINE_VISIBILITY long long llround(float __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_llroundf)
return __builtin_llroundf(__lcpp_x);
#else
return ::llroundf(__lcpp_x);
#endif
}
inline _LIBCPP_INLINE_VISIBILITY long long llround(long double __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_llroundl)
return __builtin_llroundl(__lcpp_x);
#else
return ::llroundl(__lcpp_x);
#endif
}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, long long>::type
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
llround(_A1 __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_llround)
return __builtin_llround((double)__lcpp_x);
#else
return ::llround((double)__lcpp_x);
#endif
}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// log1p
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float log1p(float __lcpp_x) _NOEXCEPT {return ::log1pf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double log1p(long double __lcpp_x) _NOEXCEPT {return ::log1pl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
log1p(_A1 __lcpp_x) _NOEXCEPT {return ::log1p((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// log2
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float log2(float __lcpp_x) _NOEXCEPT {return ::log2f(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double log2(long double __lcpp_x) _NOEXCEPT {return ::log2l(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
log2(_A1 __lcpp_x) _NOEXCEPT {return ::log2((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// logb
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float logb(float __lcpp_x) _NOEXCEPT {return ::logbf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double logb(long double __lcpp_x) _NOEXCEPT {return ::logbl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
logb(_A1 __lcpp_x) _NOEXCEPT {return ::logb((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// lrint
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
inline _LIBCPP_INLINE_VISIBILITY long lrint(float __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_lrintf)
return __builtin_lrintf(__lcpp_x);
#else
return ::lrintf(__lcpp_x);
#endif
}
inline _LIBCPP_INLINE_VISIBILITY long lrint(long double __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_lrintl)
return __builtin_lrintl(__lcpp_x);
#else
return ::lrintl(__lcpp_x);
#endif
}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, long>::type
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
lrint(_A1 __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_lrint)
return __builtin_lrint((double)__lcpp_x);
#else
return ::lrint((double)__lcpp_x);
#endif
}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// lround
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
inline _LIBCPP_INLINE_VISIBILITY long lround(float __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_lroundf)
return __builtin_lroundf(__lcpp_x);
#else
return ::lroundf(__lcpp_x);
#endif
}
inline _LIBCPP_INLINE_VISIBILITY long lround(long double __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_lroundl)
return __builtin_lroundl(__lcpp_x);
#else
return ::lroundl(__lcpp_x);
#endif
}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, long>::type
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
lround(_A1 __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_lround)
return __builtin_lround((double)__lcpp_x);
#else
return ::lround((double)__lcpp_x);
#endif
}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// nan
// nearbyint
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float nearbyint(float __lcpp_x) _NOEXCEPT {return ::nearbyintf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double nearbyint(long double __lcpp_x) _NOEXCEPT {return ::nearbyintl(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
nearbyint(_A1 __lcpp_x) _NOEXCEPT {return ::nearbyint((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// nextafter
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float nextafter(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::nextafterf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double nextafter(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nextafterl(__lcpp_x, __lcpp_y);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
typename std::__enable_if_t
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
<
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
std::__promote<_A1, _A2>
>::type
nextafter(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type __result_type;
Apply new meta-programming traits throughout the library. The new meta-programming primitives are lower cost than the old versions. This patch removes those old versions and switches libc++ to use the new ones. llvm-svn: 364160
2019-06-24 04:28:29 +08:00
static_assert((!(std::_IsSame<_A1, __result_type>::value &&
std::_IsSame<_A2, __result_type>::value)), "");
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
return ::nextafter((__result_type)__lcpp_x, (__result_type)__lcpp_y);
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
}
// nexttoward
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float nexttoward(float __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nexttowardf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double nexttoward(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nexttowardl(__lcpp_x, __lcpp_y);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
nexttoward(_A1 __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nexttoward((double)__lcpp_x, __lcpp_y);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// remainder
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float remainder(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::remainderf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double remainder(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::remainderl(__lcpp_x, __lcpp_y);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
typename std::__enable_if_t
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
<
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
std::__promote<_A1, _A2>
>::type
remainder(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type __result_type;
Apply new meta-programming traits throughout the library. The new meta-programming primitives are lower cost than the old versions. This patch removes those old versions and switches libc++ to use the new ones. llvm-svn: 364160
2019-06-24 04:28:29 +08:00
static_assert((!(std::_IsSame<_A1, __result_type>::value &&
std::_IsSame<_A2, __result_type>::value)), "");
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
return ::remainder((__result_type)__lcpp_x, (__result_type)__lcpp_y);
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
}
// remquo
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float remquo(float __lcpp_x, float __lcpp_y, int* __lcpp_z) _NOEXCEPT {return ::remquof(__lcpp_x, __lcpp_y, __lcpp_z);}
inline _LIBCPP_INLINE_VISIBILITY long double remquo(long double __lcpp_x, long double __lcpp_y, int* __lcpp_z) _NOEXCEPT {return ::remquol(__lcpp_x, __lcpp_y, __lcpp_z);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
typename std::__enable_if_t
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
<
std::is_arithmetic<_A1>::value &&
std::is_arithmetic<_A2>::value,
std::__promote<_A1, _A2>
>::type
remquo(_A1 __lcpp_x, _A2 __lcpp_y, int* __lcpp_z) _NOEXCEPT
{
typedef typename std::__promote<_A1, _A2>::type __result_type;
Apply new meta-programming traits throughout the library. The new meta-programming primitives are lower cost than the old versions. This patch removes those old versions and switches libc++ to use the new ones. llvm-svn: 364160
2019-06-24 04:28:29 +08:00
static_assert((!(std::_IsSame<_A1, __result_type>::value &&
std::_IsSame<_A2, __result_type>::value)), "");
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
return ::remquo((__result_type)__lcpp_x, (__result_type)__lcpp_y, __lcpp_z);
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
}
// rint
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
inline _LIBCPP_INLINE_VISIBILITY float rint(float __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_rintf)
return __builtin_rintf(__lcpp_x);
#else
return ::rintf(__lcpp_x);
#endif
}
inline _LIBCPP_INLINE_VISIBILITY long double rint(long double __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_rintl)
return __builtin_rintl(__lcpp_x);
#else
return ::rintl(__lcpp_x);
#endif
}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
rint(_A1 __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_rint)
return __builtin_rint((double)__lcpp_x);
#else
return ::rint((double)__lcpp_x);
#endif
}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// round
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
inline _LIBCPP_INLINE_VISIBILITY float round(float __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_round)
return __builtin_round(__lcpp_x);
#else
return ::round(__lcpp_x);
#endif
}
inline _LIBCPP_INLINE_VISIBILITY long double round(long double __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_roundl)
return __builtin_roundl(__lcpp_x);
#else
return ::roundl(__lcpp_x);
#endif
}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
round(_A1 __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_round)
return __builtin_round((double)__lcpp_x);
#else
return ::round((double)__lcpp_x);
#endif
}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// scalbln
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float scalbln(float __lcpp_x, long __lcpp_y) _NOEXCEPT {return ::scalblnf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double scalbln(long double __lcpp_x, long __lcpp_y) _NOEXCEPT {return ::scalblnl(__lcpp_x, __lcpp_y);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
scalbln(_A1 __lcpp_x, long __lcpp_y) _NOEXCEPT {return ::scalbln((double)__lcpp_x, __lcpp_y);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// scalbn
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float scalbn(float __lcpp_x, int __lcpp_y) _NOEXCEPT {return ::scalbnf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double scalbn(long double __lcpp_x, int __lcpp_y) _NOEXCEPT {return ::scalbnl(__lcpp_x, __lcpp_y);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
scalbn(_A1 __lcpp_x, int __lcpp_y) _NOEXCEPT {return ::scalbn((double)__lcpp_x, __lcpp_y);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// tgamma
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
inline _LIBCPP_INLINE_VISIBILITY float tgamma(float __lcpp_x) _NOEXCEPT {return ::tgammaf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double tgamma(long double __lcpp_x) _NOEXCEPT {return ::tgammal(__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
Fully qualify (preprend ::) calls to math functions from libc Summary: This can cause a compile failure in cases like: double log(double); namespace foo { namespace log {} } using namespace foo; void bar(int i) { log((double)i); } Reviewers: EricWF, mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D29804 llvm-svn: 294696
2017-02-10 10:44:23 +08:00
tgamma(_A1 __lcpp_x) _NOEXCEPT {return ::tgamma((double)__lcpp_x);}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
// trunc
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
inline _LIBCPP_INLINE_VISIBILITY float trunc(float __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_trunc)
return __builtin_trunc(__lcpp_x);
#else
return ::trunc(__lcpp_x);
#endif
}
inline _LIBCPP_INLINE_VISIBILITY long double trunc(long double __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_truncl)
return __builtin_truncl(__lcpp_x);
#else
return ::truncl(__lcpp_x);
#endif
}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
typename std::enable_if<std::is_integral<_A1>::value, double>::type
[libc++] Use builtins in more math.h functions. Not using builtins doesn't always imply worse code, but for e. g. isinf, this is 30%+ faster. Before: name time/op BM_isinf 2.14ns ± 2% After: name time/op BM_isinf 1.33ns ± 2% Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D88854
2021-02-11 02:05:19 +08:00
trunc(_A1 __lcpp_x) _NOEXCEPT
{
#if __has_builtin(__builtin_trunc)
return __builtin_trunc((double)__lcpp_x);
#else
return ::trunc((double)__lcpp_x);
#endif
}
Split <math.h> out of <cmath>. llvm-svn: 249742
2015-10-09 04:40:34 +08:00
} // extern "C++"
#endif // __cplusplus
[libcxx] Do not include the C math.h header before __config Summary: Certain C libraries require configuration macros defined in __config to provide the correct functionality for libc++. This patch ensures that the C header math.h is always included after the __config header. It also adds a Windows-specific #if guard for the case when the C math.h file is included the second time, as suggested by Marshall in https://reviews.llvm.org/rL323490. Fixes PR36382. Reviewers: mclow.lists, EricWF Reviewed By: mclow.lists Subscribers: cfe-commits, pcc, christof, rogfer01 Differential Revision: https://reviews.llvm.org/D43579 llvm-svn: 325760
2018-02-22 17:34:08 +08:00
#else // _LIBCPP_MATH_H
// This include lives outside the header guard in order to support an MSVC
// extension which allows users to do:
//
// #define _USE_MATH_DEFINES
// #include <math.h>
//
// and receive the definitions of mathematical constants, even if <math.h>
// has previously been included.
#if defined(_LIBCPP_MSVCRT) && defined(_USE_MATH_DEFINES)
#include_next <math.h>
#endif
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-21 00:03:32 +08:00
#endif // _LIBCPP_MATH_H