Page MenuHomePhabricator
Differential D134584 Diff 465723 libcxx/include/__cmath/angular_functions.h

Changeset View

Standalone View

View Options

libcxx/include/__cmath/angular_functions.h

  • This file was added.
//===----------------------------------------------------------------------===//
ldionneUnsubmitted
Not Done
ReplyInline Actions

This change needs to be split into multiple patches that can be reviewed and validated on their own, especially since cmath and math.h interact with the C library, which makes them even more tricky. You already outlined in your commit message all the different things that this patch does, and I think each of them can be a separate patch. I know this is more work, but I think it's the only way to land this.

ldionne: This change needs to be split into multiple patches that can be reviewed and validated on their…
//
// 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
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CMATH_ANGULAR_FUNCTIONS_H
#define _LIBCPP___CMATH_ANGULAR_FUNCTIONS_H
#include <__config>
#include <__type_traits/enable_if.h>
#include <__type_traits/is_arithmetic.h>
#include <__type_traits/is_integral.h>
#include <__type_traits/promote.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
inline _LIBCPP_HIDE_FROM_ABI float acos(float __v) _NOEXCEPT { return __builtin_acosf(__v); }
template <class = int>
_LIBCPP_HIDE_FROM_ABI double acos(double __v) _NOEXCEPT {
return __builtin_acos(__v);
}
inline _LIBCPP_HIDE_FROM_ABI long double acos(long double __v) _NOEXCEPT { return __builtin_acosl(__v); }
template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI double acos(_Tp __v) _NOEXCEPT {
return __builtin_acos(static_cast<double>(__v));
}
inline _LIBCPP_HIDE_FROM_ABI float asin(float __v) _NOEXCEPT { return __builtin_asinf(__v); }
template <class = int>
_LIBCPP_HIDE_FROM_ABI double asin(double __v) _NOEXCEPT {
return __builtin_asin(__v);
}
inline _LIBCPP_HIDE_FROM_ABI long double asin(long double __v) _NOEXCEPT { return __builtin_asinl(__v); }
template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI double asin(_Tp __v) _NOEXCEPT {
return __builtin_asin(static_cast<double>(__v));
}
inline _LIBCPP_HIDE_FROM_ABI float atan(float __v) _NOEXCEPT { return __builtin_atanf(__v); }
template <class = int>
_LIBCPP_HIDE_FROM_ABI double atan(double __v) _NOEXCEPT {
return __builtin_atan(__v);
}
inline _LIBCPP_HIDE_FROM_ABI long double atan(long double __v) _NOEXCEPT { return __builtin_atanl(__v); }
template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI double atan(_Tp __v) {
return __builtin_atan(static_cast<double>(__v));
}
inline _LIBCPP_HIDE_FROM_ABI float atan2(float __y, float __x) _NOEXCEPT { return __builtin_atan2f(__y, __x); }
template <class = int>
_LIBCPP_HIDE_FROM_ABI double atan2(double __y, double __x) _NOEXCEPT {
return __builtin_atan2(__y, __x);
}
inline _LIBCPP_HIDE_FROM_ABI long double atan2(long double __y, long double __x) _NOEXCEPT {
return __builtin_atan2l(__y, __x);
}
template <class _Tp, class _Up, __enable_if_t<is_arithmetic<_Tp>::value && is_arithmetic<_Tp>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI typename __promote<_Tp, _Up>::type atan2(_Tp __y, _Up __x) _NOEXCEPT {
using __result_type = typename __promote<_Tp, _Up>::type;
return std::atan2(static_cast<__result_type>(__y), static_cast<__result_type>(__x));
}
inline _LIBCPP_HIDE_FROM_ABI float cos(float __v) _NOEXCEPT { return __builtin_cosf(__v); }
template <class = int>
inline _LIBCPP_HIDE_FROM_ABI double cos(double __v) _NOEXCEPT {
return __builtin_cos(__v);
}
inline _LIBCPP_HIDE_FROM_ABI long double cos(long double __v) _NOEXCEPT { return __builtin_cosl(__v); }
template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI double cos(_Tp __v) _NOEXCEPT {
return __builtin_cos(static_cast<double>(__v));
}
inline _LIBCPP_HIDE_FROM_ABI float cosh(float __v) _NOEXCEPT { return __builtin_coshf(__v); }
template <class = int>
_LIBCPP_HIDE_FROM_ABI double cosh(double __v) _NOEXCEPT {
return __builtin_cosh(__v);
}
inline _LIBCPP_HIDE_FROM_ABI long double cosh(long double __v) _NOEXCEPT { return __builtin_coshl(__v); }
template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI double cosh(_Tp __v) _NOEXCEPT {
return __builtin_cosh(static_cast<double>(__v));
}
inline _LIBCPP_HIDE_FROM_ABI float sin(float __v) _NOEXCEPT { return __builtin_sinf(__v); }
template <class = int>
_LIBCPP_HIDE_FROM_ABI double sin(double __v) _NOEXCEPT {
return __builtin_sin(__v);
}
inline _LIBCPP_HIDE_FROM_ABI long double sin(long double __v) _NOEXCEPT { return __builtin_sinl(__v); }
template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI double sin(_Tp __v) _NOEXCEPT {
return __builtin_sin(static_cast<double>(__v));
}
inline _LIBCPP_HIDE_FROM_ABI float sinh(float __v) _NOEXCEPT { return __builtin_sinhf(__v); }
template <class = int>
_LIBCPP_HIDE_FROM_ABI double sinh(double __v) _NOEXCEPT {
return __builtin_sinh(__v);
}
inline _LIBCPP_HIDE_FROM_ABI long double sinh(long double __v) _NOEXCEPT { return __builtin_sinhl(__v); }
template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI double sinh(_Tp __v) _NOEXCEPT {
return __builtin_sinh(__v);
}
inline _LIBCPP_HIDE_FROM_ABI float tan(float __v) _NOEXCEPT { return __builtin_tanf(__v); }
template <class = int>
_LIBCPP_HIDE_FROM_ABI double tan(double __v) _NOEXCEPT {
return __builtin_tan(__v);
}
inline _LIBCPP_HIDE_FROM_ABI long double tan(long double __v) _NOEXCEPT { return __builtin_tanl(__v); }
template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI double tan(_Tp __v) _NOEXCEPT {
return __builtin_tan(__v);
}
inline _LIBCPP_HIDE_FROM_ABI float tanh(float __v) _NOEXCEPT { return __builtin_tanhf(__v); }
template <class = int>
_LIBCPP_HIDE_FROM_ABI double tanh(double __v) _NOEXCEPT {
return __builtin_tanh(__v);
}
inline _LIBCPP_HIDE_FROM_ABI long double tanh(long double __v) _NOEXCEPT { return __builtin_tanhl(__v); }
template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI double tanh(_Tp __v) _NOEXCEPT {
return __builtin_tanh(__v);
}
inline _LIBCPP_HIDE_FROM_ABI float acosh(float __v) _NOEXCEPT { return __builtin_acoshf(__v); }
template <class = int>
_LIBCPP_HIDE_FROM_ABI double acosh(double __v) _NOEXCEPT {
return __builtin_acosh(__v);
}
inline _LIBCPP_HIDE_FROM_ABI long double acosh(long double __v) _NOEXCEPT { return __builtin_acoshl(__v); }
template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI double acosh(_Tp __v) _NOEXCEPT {
return __builtin_acosh(__v);
}
inline _LIBCPP_HIDE_FROM_ABI float asinh(float __v) _NOEXCEPT { return __builtin_asinhf(__v); }
template <class = int>
_LIBCPP_HIDE_FROM_ABI double asinh(double __v) _NOEXCEPT {
return __builtin_asinh(__v);
}
inline _LIBCPP_HIDE_FROM_ABI long double asinh(long double __v) _NOEXCEPT { return __builtin_asinhl(__v); }
template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI double asinh(_Tp __v) _NOEXCEPT {
return __builtin_asinh(__v);
}
inline _LIBCPP_HIDE_FROM_ABI float atanh(float __v) _NOEXCEPT { return __builtin_atanhf(__v); }
template <class = int>
_LIBCPP_HIDE_FROM_ABI double atanh(double __v) _NOEXCEPT {
return __builtin_atanh(__v);
}
inline _LIBCPP_HIDE_FROM_ABI long double atanh(long double __v) _NOEXCEPT { return __builtin_atanhl(__v); }
template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI double atanh(_Tp __v) _NOEXCEPT {
return __builtin_atanh(__v);
}
_LIBCPP_END_NAMESPACE_STD
using std::acos;
using std::acosh;
using std::asin;
using std::asinh;
using std::atan;
using std::atan2;
using std::atanh;
using std::cos;
using std::cosh;
using std::sin;
using std::sinh;
using std::tan;
using std::tanh;
#endif // _LIBCPP___CMATH_ANGULAR_FUNCTIONS_H