[libcxx-commits] [libcxx] [libc++] Use libc functions for complex calculations when available (PR #99677)
Nikolas Klauser via libcxx-commits
libcxx-commits at lists.llvm.org
Fri Jul 19 11:06:46 PDT 2024
https://github.com/philnik777 created https://github.com/llvm/llvm-project/pull/99677
The C implementations are often significantly more accurate than the simple implementation we provide. This patch forwards to the libc functions when they exist instead.
Fixes #21878
Fixes #27567
Fixes #78738
>From e7dd12d0e3ef72310be97ebb8749e9e540bf0684 Mon Sep 17 00:00:00 2001
From: Nikolas Klauser <nikolasklauser at berlin.de>
Date: Fri, 19 Jul 2024 19:56:47 +0200
Subject: [PATCH] [libc++] Use libc functions for complex calculations when
available
---
libcxx/include/complex | 318 +++++++++++++++++++++++++++--------------
1 file changed, 208 insertions(+), 110 deletions(-)
diff --git a/libcxx/include/complex b/libcxx/include/complex
index 22271acaf7358..85cd2a66adb1a 100644
--- a/libcxx/include/complex
+++ b/libcxx/include/complex
@@ -930,6 +930,14 @@ imag(_Tp) {
// abs
+_LIBCPP_HIDE_FROM_ABI inline float abs(const std::complex<float> __c) { return __builtin_cabsf(__c.__builtin()); }
+
+_LIBCPP_HIDE_FROM_ABI inline double abs(const std::complex<double> __c) { return __builtin_cabs(__c.__builtin()); }
+
+_LIBCPP_HIDE_FROM_ABI inline long double abs(const std::complex<long double> __c) {
+ return __builtin_cabsl(__c.__builtin());
+}
+
template <class _Tp>
inline _LIBCPP_HIDE_FROM_ABI _Tp abs(const complex<_Tp>& __c) {
return std::hypot(__c.real(), __c.imag());
@@ -937,6 +945,12 @@ inline _LIBCPP_HIDE_FROM_ABI _Tp abs(const complex<_Tp>& __c) {
// arg
+inline _LIBCPP_HIDE_FROM_ABI float arg(const complex<float>& __c) { return __builtin_cargf(__c.__builtin()); }
+inline _LIBCPP_HIDE_FROM_ABI double arg(const complex<double>& __c) { return __builtin_carg(__c.__builtin()); }
+inline _LIBCPP_HIDE_FROM_ABI long double arg(const complex<long double>& __c) {
+ return __builtin_cargl(__c.__builtin());
+}
+
template <class _Tp>
inline _LIBCPP_HIDE_FROM_ABI _Tp arg(const complex<_Tp>& __c) {
return std::atan2(__c.imag(), __c.real());
@@ -1039,6 +1053,18 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> polar(const _Tp& __rho, const _Tp& __theta =
// log
+inline _LIBCPP_HIDE_FROM_ABI complex<float> log(const complex<float>& __value) {
+ return complex<float>(__from_builtin_tag(), __builtin_clogf(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<double> log(const complex<double>& __value) {
+ return complex<double>(__from_builtin_tag(), __builtin_clog(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<long double> log(const complex<long double>& __value) {
+ return complex<long double>(__from_builtin_tag(), __builtin_clogl(__value.__builtin()));
+}
+
template <class _Tp>
inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> log(const complex<_Tp>& __x) {
return complex<_Tp>(std::log(std::abs(__x)), std::arg(__x));
@@ -1053,44 +1079,62 @@ inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> log10(const complex<_Tp>& __x) {
// sqrt
+inline _LIBCPP_HIDE_FROM_ABI complex<float> sqrt(const complex<float>& __value) {
+ return complex<float>(__from_builtin_tag(), __builtin_csqrtf(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<double> sqrt(const complex<double>& __value) {
+ return complex<double>(__from_builtin_tag(), __builtin_csqrt(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<long double> sqrt(const complex<long double>& __value) {
+ return complex<long double>(__from_builtin_tag(), __builtin_csqrtl(__value.__builtin()));
+}
+
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI complex<_Tp> sqrt(const complex<_Tp>& __x) {
- if (std::__constexpr_isinf(__x.imag()))
- return complex<_Tp>(_Tp(INFINITY), __x.imag());
- if (std::__constexpr_isinf(__x.real())) {
- if (__x.real() > _Tp(0))
- return complex<_Tp>(
- __x.real(), std::__constexpr_isnan(__x.imag()) ? __x.imag() : std::copysign(_Tp(0), __x.imag()));
- return complex<_Tp>(
- std::__constexpr_isnan(__x.imag()) ? __x.imag() : _Tp(0), std::copysign(__x.real(), __x.imag()));
- }
return std::polar(std::sqrt(std::abs(__x)), std::arg(__x) / _Tp(2));
}
// exp
+inline _LIBCPP_HIDE_FROM_ABI complex<float> exp(const complex<float>& __value) {
+ return complex<float>(__from_builtin_tag(), __builtin_cexpf(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<double> exp(const complex<double>& __value) {
+ return complex<double>(__from_builtin_tag(), __builtin_cexp(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<long double> exp(const complex<long double>& __value) {
+ return complex<long double>(__from_builtin_tag(), __builtin_cexpl(__value.__builtin()));
+}
+
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI complex<_Tp> exp(const complex<_Tp>& __x) {
_Tp __i = __x.imag();
if (__i == 0) {
return complex<_Tp>(std::exp(__x.real()), std::copysign(_Tp(0), __x.imag()));
}
- if (std::__constexpr_isinf(__x.real())) {
- if (__x.real() < _Tp(0)) {
- if (!std::__constexpr_isfinite(__i))
- __i = _Tp(1);
- } else if (__i == 0 || !std::__constexpr_isfinite(__i)) {
- if (std::__constexpr_isinf(__i))
- __i = _Tp(NAN);
- return complex<_Tp>(__x.real(), __i);
- }
- }
_Tp __e = std::exp(__x.real());
return complex<_Tp>(__e * std::cos(__i), __e * std::sin(__i));
}
// pow
+inline _LIBCPP_HIDE_FROM_ABI complex<float> pow(const complex<float>& __lhs, const complex<float>& __rhs) {
+ return complex<float>(__from_builtin_tag(), __builtin_cpowf(__lhs.__builtin(), __rhs.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<double> pow(const complex<double>& __lhs, const complex<double>& __rhs) {
+ return complex<double>(__from_builtin_tag(), __builtin_cpow(__lhs.__builtin(), __rhs.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<long double>
+pow(const complex<long double>& __lhs, const complex<long double>& __rhs) {
+ return complex<long double>(__from_builtin_tag(), __builtin_cpowl(__lhs.__builtin(), __rhs.__builtin()));
+}
+
template <class _Tp>
inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> pow(const complex<_Tp>& __x, const complex<_Tp>& __y) {
return std::exp(__y * std::log(__x));
@@ -1124,77 +1168,63 @@ inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> __sqr(const complex<_Tp>& __x) {
// asinh
+inline _LIBCPP_HIDE_FROM_ABI complex<float> asinh(const complex<float>& __value) {
+ return complex<float>(__from_builtin_tag(), __builtin_casinhf(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<double> asinh(const complex<double>& __value) {
+ return complex<double>(__from_builtin_tag(), __builtin_casinh(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<long double> asinh(const complex<long double>& __value) {
+ return complex<long double>(__from_builtin_tag(), __builtin_casinhl(__value.__builtin()));
+}
+
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI complex<_Tp> asinh(const complex<_Tp>& __x) {
const _Tp __pi(atan2(+0., -0.));
- if (std::__constexpr_isinf(__x.real())) {
- if (std::__constexpr_isnan(__x.imag()))
- return __x;
- if (std::__constexpr_isinf(__x.imag()))
- return complex<_Tp>(__x.real(), std::copysign(__pi * _Tp(0.25), __x.imag()));
- return complex<_Tp>(__x.real(), std::copysign(_Tp(0), __x.imag()));
- }
- if (std::__constexpr_isnan(__x.real())) {
- if (std::__constexpr_isinf(__x.imag()))
- return complex<_Tp>(__x.imag(), __x.real());
- if (__x.imag() == 0)
- return __x;
- return complex<_Tp>(__x.real(), __x.real());
- }
- if (std::__constexpr_isinf(__x.imag()))
- return complex<_Tp>(std::copysign(__x.imag(), __x.real()), std::copysign(__pi / _Tp(2), __x.imag()));
complex<_Tp> __z = std::log(__x + std::sqrt(std::__sqr(__x) + _Tp(1)));
return complex<_Tp>(std::copysign(__z.real(), __x.real()), std::copysign(__z.imag(), __x.imag()));
}
// acosh
+inline _LIBCPP_HIDE_FROM_ABI complex<float> acosh(const complex<float>& __value) {
+ return complex<float>(__from_builtin_tag(), __builtin_cacoshf(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<double> acosh(const complex<double>& __value) {
+ return complex<double>(__from_builtin_tag(), __builtin_cacosh(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<long double> acosh(const complex<long double>& __value) {
+ return complex<long double>(__from_builtin_tag(), __builtin_cacoshl(__value.__builtin()));
+}
+
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI complex<_Tp> acosh(const complex<_Tp>& __x) {
const _Tp __pi(atan2(+0., -0.));
- if (std::__constexpr_isinf(__x.real())) {
- if (std::__constexpr_isnan(__x.imag()))
- return complex<_Tp>(std::abs(__x.real()), __x.imag());
- if (std::__constexpr_isinf(__x.imag())) {
- if (__x.real() > 0)
- return complex<_Tp>(__x.real(), std::copysign(__pi * _Tp(0.25), __x.imag()));
- else
- return complex<_Tp>(-__x.real(), std::copysign(__pi * _Tp(0.75), __x.imag()));
- }
- if (__x.real() < 0)
- return complex<_Tp>(-__x.real(), std::copysign(__pi, __x.imag()));
- return complex<_Tp>(__x.real(), std::copysign(_Tp(0), __x.imag()));
- }
- if (std::__constexpr_isnan(__x.real())) {
- if (std::__constexpr_isinf(__x.imag()))
- return complex<_Tp>(std::abs(__x.imag()), __x.real());
- return complex<_Tp>(__x.real(), __x.real());
- }
- if (std::__constexpr_isinf(__x.imag()))
- return complex<_Tp>(std::abs(__x.imag()), std::copysign(__pi / _Tp(2), __x.imag()));
complex<_Tp> __z = std::log(__x + std::sqrt(std::__sqr(__x) - _Tp(1)));
return complex<_Tp>(std::copysign(__z.real(), _Tp(0)), std::copysign(__z.imag(), __x.imag()));
}
// atanh
+inline _LIBCPP_HIDE_FROM_ABI complex<float> atanh(const complex<float>& __value) {
+ return complex<float>(__from_builtin_tag(), __builtin_catanhf(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<double> atanh(const complex<double>& __value) {
+ return complex<double>(__from_builtin_tag(), __builtin_catanh(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<long double> atanh(const complex<long double>& __value) {
+ return complex<long double>(__from_builtin_tag(), __builtin_catanhl(__value.__builtin()));
+}
+
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI complex<_Tp> atanh(const complex<_Tp>& __x) {
const _Tp __pi(atan2(+0., -0.));
- if (std::__constexpr_isinf(__x.imag())) {
- return complex<_Tp>(std::copysign(_Tp(0), __x.real()), std::copysign(__pi / _Tp(2), __x.imag()));
- }
- if (std::__constexpr_isnan(__x.imag())) {
- if (std::__constexpr_isinf(__x.real()) || __x.real() == 0)
- return complex<_Tp>(std::copysign(_Tp(0), __x.real()), __x.imag());
- return complex<_Tp>(__x.imag(), __x.imag());
- }
- if (std::__constexpr_isnan(__x.real())) {
- return complex<_Tp>(__x.real(), __x.real());
- }
- if (std::__constexpr_isinf(__x.real())) {
- return complex<_Tp>(std::copysign(_Tp(0), __x.real()), std::copysign(__pi / _Tp(2), __x.imag()));
- }
if (std::abs(__x.real()) == _Tp(1) && __x.imag() == _Tp(0)) {
return complex<_Tp>(std::copysign(_Tp(INFINITY), __x.real()), std::copysign(_Tp(0), __x.imag()));
}
@@ -1204,54 +1234,81 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> atanh(const complex<_Tp>& __x) {
// sinh
+inline _LIBCPP_HIDE_FROM_ABI complex<float> sinh(const complex<float>& __value) {
+ return complex<float>(__from_builtin_tag(), __builtin_csinhf(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<double> sinh(const complex<double>& __value) {
+ return complex<double>(__from_builtin_tag(), __builtin_csinh(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<long double> sinh(const complex<long double>& __value) {
+ return complex<long double>(__from_builtin_tag(), __builtin_csinhl(__value.__builtin()));
+}
+
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI complex<_Tp> sinh(const complex<_Tp>& __x) {
- if (std::__constexpr_isinf(__x.real()) && !std::__constexpr_isfinite(__x.imag()))
- return complex<_Tp>(__x.real(), _Tp(NAN));
- if (__x.real() == 0 && !std::__constexpr_isfinite(__x.imag()))
- return complex<_Tp>(__x.real(), _Tp(NAN));
- if (__x.imag() == 0 && !std::__constexpr_isfinite(__x.real()))
- return __x;
return complex<_Tp>(std::sinh(__x.real()) * std::cos(__x.imag()), std::cosh(__x.real()) * std::sin(__x.imag()));
}
// cosh
+inline _LIBCPP_HIDE_FROM_ABI complex<float> cosh(const complex<float>& __value) {
+ return complex<float>(__from_builtin_tag(), __builtin_ccoshf(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<double> cosh(const complex<double>& __value) {
+ return complex<double>(__from_builtin_tag(), __builtin_ccosh(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<long double> cosh(const complex<long double>& __value) {
+ return complex<long double>(__from_builtin_tag(), __builtin_ccoshl(__value.__builtin()));
+}
+
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI complex<_Tp> cosh(const complex<_Tp>& __x) {
- if (std::__constexpr_isinf(__x.real()) && !std::__constexpr_isfinite(__x.imag()))
- return complex<_Tp>(std::abs(__x.real()), _Tp(NAN));
- if (__x.real() == 0 && !std::__constexpr_isfinite(__x.imag()))
- return complex<_Tp>(_Tp(NAN), __x.real());
if (__x.real() == 0 && __x.imag() == 0)
return complex<_Tp>(_Tp(1), __x.imag());
- if (__x.imag() == 0 && !std::__constexpr_isfinite(__x.real()))
- return complex<_Tp>(std::abs(__x.real()), __x.imag());
return complex<_Tp>(std::cosh(__x.real()) * std::cos(__x.imag()), std::sinh(__x.real()) * std::sin(__x.imag()));
}
// tanh
+inline _LIBCPP_HIDE_FROM_ABI complex<float> tanh(const complex<float>& __value) {
+ return complex<float>(__from_builtin_tag(), __builtin_ctanhf(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<double> tanh(const complex<double>& __value) {
+ return complex<double>(__from_builtin_tag(), __builtin_ctanh(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<long double> tanh(const complex<long double>& __value) {
+ return complex<long double>(__from_builtin_tag(), __builtin_ctanhl(__value.__builtin()));
+}
+
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI complex<_Tp> tanh(const complex<_Tp>& __x) {
- if (std::__constexpr_isinf(__x.real())) {
- if (!std::__constexpr_isfinite(__x.imag()))
- return complex<_Tp>(std::copysign(_Tp(1), __x.real()), _Tp(0));
- return complex<_Tp>(std::copysign(_Tp(1), __x.real()), std::copysign(_Tp(0), std::sin(_Tp(2) * __x.imag())));
- }
- if (std::__constexpr_isnan(__x.real()) && __x.imag() == 0)
- return __x;
_Tp __2r(_Tp(2) * __x.real());
_Tp __2i(_Tp(2) * __x.imag());
_Tp __d(std::cosh(__2r) + std::cos(__2i));
_Tp __2rsh(std::sinh(__2r));
- if (std::__constexpr_isinf(__2rsh) && std::__constexpr_isinf(__d))
- return complex<_Tp>(__2rsh > _Tp(0) ? _Tp(1) : _Tp(-1), __2i > _Tp(0) ? _Tp(0) : _Tp(-0.));
return complex<_Tp>(__2rsh / __d, std::sin(__2i) / __d);
}
// asin
+inline _LIBCPP_HIDE_FROM_ABI complex<float> asin(const complex<float>& __value) {
+ return complex<float>(__from_builtin_tag(), __builtin_casinf(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<double> asin(const complex<double>& __value) {
+ return complex<double>(__from_builtin_tag(), __builtin_casin(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<long double> asin(const complex<long double>& __value) {
+ return complex<long double>(__from_builtin_tag(), __builtin_casinl(__value.__builtin()));
+}
+
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI complex<_Tp> asin(const complex<_Tp>& __x) {
complex<_Tp> __z = std::asinh(complex<_Tp>(-__x.imag(), __x.real()));
@@ -1260,29 +1317,22 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> asin(const complex<_Tp>& __x) {
// acos
+_LIBCPP_HIDE_FROM_ABI inline complex<float> acos(const complex<float>& __x) {
+ return complex<float>(__from_builtin_tag(), __builtin_cacosf(__x.__builtin()));
+}
+
+_LIBCPP_HIDE_FROM_ABI inline complex<double> acos(const complex<double>& __x) {
+ return complex<double>(__from_builtin_tag(), __builtin_cacos(__x.__builtin()));
+}
+
+_LIBCPP_HIDE_FROM_ABI inline complex<long double> acos(const complex<long double>& __x) {
+ return complex<long double>(__from_builtin_tag(), __builtin_cacosl(__x.__builtin()));
+}
+
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI complex<_Tp> acos(const complex<_Tp>& __x) {
const _Tp __pi(atan2(+0., -0.));
- if (std::__constexpr_isinf(__x.real())) {
- if (std::__constexpr_isnan(__x.imag()))
- return complex<_Tp>(__x.imag(), __x.real());
- if (std::__constexpr_isinf(__x.imag())) {
- if (__x.real() < _Tp(0))
- return complex<_Tp>(_Tp(0.75) * __pi, -__x.imag());
- return complex<_Tp>(_Tp(0.25) * __pi, -__x.imag());
- }
- if (__x.real() < _Tp(0))
- return complex<_Tp>(__pi, std::signbit(__x.imag()) ? -__x.real() : __x.real());
- return complex<_Tp>(_Tp(0), std::signbit(__x.imag()) ? __x.real() : -__x.real());
- }
- if (std::__constexpr_isnan(__x.real())) {
- if (std::__constexpr_isinf(__x.imag()))
- return complex<_Tp>(__x.real(), -__x.imag());
- return complex<_Tp>(__x.real(), __x.real());
- }
- if (std::__constexpr_isinf(__x.imag()))
- return complex<_Tp>(__pi / _Tp(2), -__x.imag());
- if (__x.real() == 0 && (__x.imag() == 0 || std::isnan(__x.imag())))
+ if (__x.real() == 0 && (__x.imag() == 0))
return complex<_Tp>(__pi / _Tp(2), -__x.imag());
complex<_Tp> __z = std::log(__x + std::sqrt(std::__sqr(__x) - _Tp(1)));
if (std::signbit(__x.imag()))
@@ -1292,6 +1342,18 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> acos(const complex<_Tp>& __x) {
// atan
+inline _LIBCPP_HIDE_FROM_ABI complex<float> atan(const complex<float>& __value) {
+ return complex<float>(__from_builtin_tag(), __builtin_catanf(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<double> atan(const complex<double>& __value) {
+ return complex<double>(__from_builtin_tag(), __builtin_catan(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<long double> atan(const complex<long double>& __value) {
+ return complex<long double>(__from_builtin_tag(), __builtin_catanl(__value.__builtin()));
+}
+
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI complex<_Tp> atan(const complex<_Tp>& __x) {
complex<_Tp> __z = std::atanh(complex<_Tp>(-__x.imag(), __x.real()));
@@ -1300,6 +1362,18 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> atan(const complex<_Tp>& __x) {
// sin
+inline _LIBCPP_HIDE_FROM_ABI complex<float> sin(const complex<float>& __value) {
+ return complex<float>(__from_builtin_tag(), __builtin_csinf(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<double> sin(const complex<double>& __value) {
+ return complex<double>(__from_builtin_tag(), __builtin_csin(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<long double> sin(const complex<long double>& __value) {
+ return complex<long double>(__from_builtin_tag(), __builtin_csinl(__value.__builtin()));
+}
+
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI complex<_Tp> sin(const complex<_Tp>& __x) {
complex<_Tp> __z = std::sinh(complex<_Tp>(-__x.imag(), __x.real()));
@@ -1308,6 +1382,18 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> sin(const complex<_Tp>& __x) {
// cos
+inline _LIBCPP_HIDE_FROM_ABI complex<float> cos(const complex<float>& __value) {
+ return complex<float>(__from_builtin_tag(), __builtin_ccosf(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<double> cos(const complex<double>& __value) {
+ return complex<double>(__from_builtin_tag(), __builtin_ccos(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<long double> cos(const complex<long double>& __value) {
+ return complex<long double>(__from_builtin_tag(), __builtin_ccosl(__value.__builtin()));
+}
+
template <class _Tp>
inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> cos(const complex<_Tp>& __x) {
return std::cosh(complex<_Tp>(-__x.imag(), __x.real()));
@@ -1315,6 +1401,18 @@ inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> cos(const complex<_Tp>& __x) {
// tan
+inline _LIBCPP_HIDE_FROM_ABI complex<float> tan(const complex<float>& __value) {
+ return complex<float>(__from_builtin_tag(), __builtin_ctanf(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<double> tan(const complex<double>& __value) {
+ return complex<double>(__from_builtin_tag(), __builtin_ctan(__value.__builtin()));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI complex<long double> tan(const complex<long double>& __value) {
+ return complex<long double>(__from_builtin_tag(), __builtin_ctanl(__value.__builtin()));
+}
+
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI complex<_Tp> tan(const complex<_Tp>& __x) {
complex<_Tp> __z = std::tanh(complex<_Tp>(-__x.imag(), __x.real()));
More information about the libcxx-commits
mailing list