[libcxx-commits] [libcxx] [libcxx] makes `tanh(complex<float>)` work for large values (PR #122194)
Christopher Di Bella via libcxx-commits
libcxx-commits at lists.llvm.org
Wed Jan 8 16:02:33 PST 2025
https://github.com/cjdb updated https://github.com/llvm/llvm-project/pull/122194
>From 3554b852e6cbcf47cff99d21f11860f29eedd341 Mon Sep 17 00:00:00 2001
From: Christopher Di Bella <cjdb at google.com>
Date: Mon, 6 Jan 2025 23:38:09 +0000
Subject: [PATCH 1/4] [libcxx] makes `tanh(complex<float>)` work for large
values
By attempting to compute `sin(2x)` and `cos(2x)`, we were inadvertently
producing `complex<float>(NaN, NaN)` for any `|x| > 2^127`, since `2x`
would be computed as `inf`, and `sin(inf) == cos(inf) == NaN`.
This commit relies on trig identities to sidestep this issue and always
produce a valid answer for large values of `tanh`. The test cases only
handled `double`, so they have been expanded to test `float` and `long
double` as well.
---
libcxx/include/complex | 40 +-
.../test/std/numerics/complex.number/cases.h | 355 +++++++++---------
.../complex_divide_complex.pass.cpp | 29 +-
.../complex_times_complex.pass.cpp | 25 +-
.../complex.transcendentals/acos.pass.cpp | 68 ++--
.../complex.transcendentals/acosh.pass.cpp | 63 ++--
.../complex.transcendentals/asin.pass.cpp | 55 +--
.../complex.transcendentals/asinh.pass.cpp | 61 +--
.../complex.transcendentals/atan.pass.cpp | 15 +-
.../complex.transcendentals/atanh.pass.cpp | 65 ++--
.../complex.transcendentals/cos.pass.cpp | 13 +-
.../complex.transcendentals/cosh.pass.cpp | 48 ++-
.../complex.transcendentals/exp.pass.cpp | 45 +--
.../complex.transcendentals/log.pass.cpp | 51 +--
.../complex.transcendentals/log10.pass.cpp | 11 +-
.../pow_complex_complex.pass.cpp | 11 +-
.../pow_complex_scalar.pass.cpp | 11 +-
.../pow_scalar_complex.pass.cpp | 11 +-
.../complex.transcendentals/sin.pass.cpp | 15 +-
.../complex.transcendentals/sinh.pass.cpp | 56 +--
.../complex.transcendentals/sqrt.pass.cpp | 65 +++-
.../complex.transcendentals/tan.pass.cpp | 15 +-
.../complex.transcendentals/tanh.pass.cpp | 47 ++-
.../complex.value.ops/abs.pass.cpp | 18 +-
.../complex.value.ops/arg.pass.cpp | 62 +--
.../complex.value.ops/norm.pass.cpp | 12 +-
.../complex.value.ops/polar.pass.cpp | 16 +-
.../complex.value.ops/proj.pass.cpp | 22 +-
28 files changed, 757 insertions(+), 548 deletions(-)
diff --git a/libcxx/include/complex b/libcxx/include/complex
index df18159595b34d..5f425206100ce2 100644
--- a/libcxx/include/complex
+++ b/libcxx/include/complex
@@ -1236,6 +1236,36 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> cosh(const complex<_Tp>& __x) {
// tanh
+template<class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp __sin2(const _Tp __x) noexcept
+{
+ static_assert(std::is_arithmetic<_Tp>::value, "requires an arithmetic type");
+ return 2 * std::sin(__x) * std::cos(__x);
+}
+
+template<class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp __sinh2(const _Tp __x) noexcept
+{
+ static_assert(std::is_arithmetic<_Tp>::value, "requires an arithmetic type");
+ return 2 * std::sinh(__x) * std::cosh(__x);
+}
+
+template<class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp __cos2(const _Tp __x) noexcept
+{
+ static_assert(std::is_arithmetic<_Tp>::value, "requires an arithmetic type");
+ const _Tp __cos = std::cos(__x);
+ return 2 * __cos * __cos - 1;
+}
+
+template<class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp __cosh2(const _Tp __x) noexcept
+{
+ static_assert(std::is_arithmetic<_Tp>::value, "requires an arithmetic type");
+ const _Tp __cosh = std::cosh(__x);
+ return 2 * __cosh * __cosh - 1;
+}
+
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI complex<_Tp> tanh(const complex<_Tp>& __x) {
if (std::isinf(__x.real())) {
@@ -1245,13 +1275,11 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> tanh(const complex<_Tp>& __x) {
}
if (std::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));
+ _Tp __d(std::__cosh2(__x.real()) + std::__cos2(__x.imag()));
+ _Tp __2rsh(std::__sinh2(__x.real()));
if (std::isinf(__2rsh) && std::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);
+ return complex<_Tp>(__2rsh > _Tp(0) ? _Tp(1) : _Tp(-1), __x.imag() > _Tp(0) ? _Tp(0) : _Tp(-0.));
+ return complex<_Tp>(__2rsh / __d, std::__sin2(__x.imag()) / __d);
}
// asin
diff --git a/libcxx/test/std/numerics/complex.number/cases.h b/libcxx/test/std/numerics/complex.number/cases.h
index b360e1423ff576..61096dd875fc4b 100644
--- a/libcxx/test/std/numerics/complex.number/cases.h
+++ b/libcxx/test/std/numerics/complex.number/cases.h
@@ -15,184 +15,190 @@
#include <cassert>
#include <complex>
+#include <limits>
#include <type_traits>
#include "test_macros.h"
-TEST_CONSTEXPR_CXX20 const std::complex<double> testcases[] =
+template<class T>
+TEST_CONSTEXPR_CXX20 const std::complex<T> testcases[] =
{
- std::complex<double>( 1.e-6, 1.e-6),
- std::complex<double>(-1.e-6, 1.e-6),
- std::complex<double>(-1.e-6, -1.e-6),
- std::complex<double>( 1.e-6, -1.e-6),
-
- std::complex<double>( 1.e+6, 1.e-6),
- std::complex<double>(-1.e+6, 1.e-6),
- std::complex<double>(-1.e+6, -1.e-6),
- std::complex<double>( 1.e+6, -1.e-6),
-
- std::complex<double>( 1.e-6, 1.e+6),
- std::complex<double>(-1.e-6, 1.e+6),
- std::complex<double>(-1.e-6, -1.e+6),
- std::complex<double>( 1.e-6, -1.e+6),
-
- std::complex<double>( 1.e+6, 1.e+6),
- std::complex<double>(-1.e+6, 1.e+6),
- std::complex<double>(-1.e+6, -1.e+6),
- std::complex<double>( 1.e+6, -1.e+6),
-
- std::complex<double>(-0, -1.e-6),
- std::complex<double>(-0, 1.e-6),
- std::complex<double>(-0, 1.e+6),
- std::complex<double>(-0, -1.e+6),
- std::complex<double>( 0, -1.e-6),
- std::complex<double>( 0, 1.e-6),
- std::complex<double>( 0, 1.e+6),
- std::complex<double>( 0, -1.e+6),
-
- std::complex<double>(-1.e-6, -0),
- std::complex<double>( 1.e-6, -0),
- std::complex<double>( 1.e+6, -0),
- std::complex<double>(-1.e+6, -0),
- std::complex<double>(-1.e-6, 0),
- std::complex<double>( 1.e-6, 0),
- std::complex<double>( 1.e+6, 0),
- std::complex<double>(-1.e+6, 0),
-
- std::complex<double>(std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()),
- std::complex<double>(-std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN()),
- std::complex<double>(-2, std::numeric_limits<double>::quiet_NaN()),
- std::complex<double>(-1, std::numeric_limits<double>::quiet_NaN()),
- std::complex<double>(-0.5, std::numeric_limits<double>::quiet_NaN()),
- std::complex<double>(-0., std::numeric_limits<double>::quiet_NaN()),
- std::complex<double>(+0., std::numeric_limits<double>::quiet_NaN()),
- std::complex<double>(0.5, std::numeric_limits<double>::quiet_NaN()),
- std::complex<double>(1, std::numeric_limits<double>::quiet_NaN()),
- std::complex<double>(2, std::numeric_limits<double>::quiet_NaN()),
- std::complex<double>(std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN()),
-
- std::complex<double>(std::numeric_limits<double>::quiet_NaN(), -std::numeric_limits<double>::infinity()),
- std::complex<double>(-std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity()),
- std::complex<double>(-2, -std::numeric_limits<double>::infinity()),
- std::complex<double>(-1, -std::numeric_limits<double>::infinity()),
- std::complex<double>(-0.5, -std::numeric_limits<double>::infinity()),
- std::complex<double>(-0., -std::numeric_limits<double>::infinity()),
- std::complex<double>(+0., -std::numeric_limits<double>::infinity()),
- std::complex<double>(0.5, -std::numeric_limits<double>::infinity()),
- std::complex<double>(1, -std::numeric_limits<double>::infinity()),
- std::complex<double>(2, -std::numeric_limits<double>::infinity()),
- std::complex<double>(std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity()),
-
- std::complex<double>(std::numeric_limits<double>::quiet_NaN(), -2),
- std::complex<double>(-std::numeric_limits<double>::infinity(), -2),
- std::complex<double>(-2, -2),
- std::complex<double>(-1, -2),
- std::complex<double>(-0.5, -2),
- std::complex<double>(-0., -2),
- std::complex<double>(+0., -2),
- std::complex<double>(0.5, -2),
- std::complex<double>(1, -2),
- std::complex<double>(2, -2),
- std::complex<double>(std::numeric_limits<double>::infinity(), -2),
-
- std::complex<double>(std::numeric_limits<double>::quiet_NaN(), -1),
- std::complex<double>(-std::numeric_limits<double>::infinity(), -1),
- std::complex<double>(-2, -1),
- std::complex<double>(-1, -1),
- std::complex<double>(-0.5, -1),
- std::complex<double>(-0., -1),
- std::complex<double>(+0., -1),
- std::complex<double>(0.5, -1),
- std::complex<double>(1, -1),
- std::complex<double>(2, -1),
- std::complex<double>(std::numeric_limits<double>::infinity(), -1),
-
- std::complex<double>(std::numeric_limits<double>::quiet_NaN(), -0.5),
- std::complex<double>(-std::numeric_limits<double>::infinity(), -0.5),
- std::complex<double>(-2, -0.5),
- std::complex<double>(-1, -0.5),
- std::complex<double>(-0.5, -0.5),
- std::complex<double>(-0., -0.5),
- std::complex<double>(+0., -0.5),
- std::complex<double>(0.5, -0.5),
- std::complex<double>(1, -0.5),
- std::complex<double>(2, -0.5),
- std::complex<double>(std::numeric_limits<double>::infinity(), -0.5),
-
- std::complex<double>(std::numeric_limits<double>::quiet_NaN(), -0.),
- std::complex<double>(-std::numeric_limits<double>::infinity(), -0.),
- std::complex<double>(-2, -0.),
- std::complex<double>(-1, -0.),
- std::complex<double>(-0.5, -0.),
- std::complex<double>(-0., -0.),
- std::complex<double>(+0., -0.),
- std::complex<double>(0.5, -0.),
- std::complex<double>(1, -0.),
- std::complex<double>(2, -0.),
- std::complex<double>(std::numeric_limits<double>::infinity(), -0.),
-
- std::complex<double>(std::numeric_limits<double>::quiet_NaN(), +0.),
- std::complex<double>(-std::numeric_limits<double>::infinity(), +0.),
- std::complex<double>(-2, +0.),
- std::complex<double>(-1, +0.),
- std::complex<double>(-0.5, +0.),
- std::complex<double>(-0., +0.),
- std::complex<double>(+0., +0.),
- std::complex<double>(0.5, +0.),
- std::complex<double>(1, +0.),
- std::complex<double>(2, +0.),
- std::complex<double>(std::numeric_limits<double>::infinity(), +0.),
-
- std::complex<double>(std::numeric_limits<double>::quiet_NaN(), 0.5),
- std::complex<double>(-std::numeric_limits<double>::infinity(), 0.5),
- std::complex<double>(-2, 0.5),
- std::complex<double>(-1, 0.5),
- std::complex<double>(-0.5, 0.5),
- std::complex<double>(-0., 0.5),
- std::complex<double>(+0., 0.5),
- std::complex<double>(0.5, 0.5),
- std::complex<double>(1, 0.5),
- std::complex<double>(2, 0.5),
- std::complex<double>(std::numeric_limits<double>::infinity(), 0.5),
-
- std::complex<double>(std::numeric_limits<double>::quiet_NaN(), 1),
- std::complex<double>(-std::numeric_limits<double>::infinity(), 1),
- std::complex<double>(-2, 1),
- std::complex<double>(-1, 1),
- std::complex<double>(-0.5, 1),
- std::complex<double>(-0., 1),
- std::complex<double>(+0., 1),
- std::complex<double>(0.5, 1),
- std::complex<double>(1, 1),
- std::complex<double>(2, 1),
- std::complex<double>(std::numeric_limits<double>::infinity(), 1),
-
- std::complex<double>(std::numeric_limits<double>::quiet_NaN(), 2),
- std::complex<double>(-std::numeric_limits<double>::infinity(), 2),
- std::complex<double>(-2, 2),
- std::complex<double>(-1, 2),
- std::complex<double>(-0.5, 2),
- std::complex<double>(-0., 2),
- std::complex<double>(+0., 2),
- std::complex<double>(0.5, 2),
- std::complex<double>(1, 2),
- std::complex<double>(2, 2),
- std::complex<double>(std::numeric_limits<double>::infinity(), 2),
-
- std::complex<double>(std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::infinity()),
- std::complex<double>(-std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity()),
- std::complex<double>(-2, std::numeric_limits<double>::infinity()),
- std::complex<double>(-1, std::numeric_limits<double>::infinity()),
- std::complex<double>(-0.5, std::numeric_limits<double>::infinity()),
- std::complex<double>(-0., std::numeric_limits<double>::infinity()),
- std::complex<double>(+0., std::numeric_limits<double>::infinity()),
- std::complex<double>(0.5, std::numeric_limits<double>::infinity()),
- std::complex<double>(1, std::numeric_limits<double>::infinity()),
- std::complex<double>(2, std::numeric_limits<double>::infinity()),
- std::complex<double>(std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity())
+ std::complex<T>( 1.e-6, 1.e-6),
+ std::complex<T>(-1.e-6, 1.e-6),
+ std::complex<T>(-1.e-6, -1.e-6),
+ std::complex<T>( 1.e-6, -1.e-6),
+
+ std::complex<T>( 1.e+6, 1.e-6),
+ std::complex<T>(-1.e+6, 1.e-6),
+ std::complex<T>(-1.e+6, -1.e-6),
+ std::complex<T>( 1.e+6, -1.e-6),
+
+ std::complex<T>( 1.e-6, 1.e+6),
+ std::complex<T>(-1.e-6, 1.e+6),
+ std::complex<T>(-1.e-6, -1.e+6),
+ std::complex<T>( 1.e-6, -1.e+6),
+
+ std::complex<T>( 1.e+6, 1.e+6),
+ std::complex<T>(-1.e+6, 1.e+6),
+ std::complex<T>(-1.e+6, -1.e+6),
+ std::complex<T>( 1.e+6, -1.e+6),
+
+ std::complex<T>(-0, -1.e-6),
+ std::complex<T>(-0, 1.e-6),
+ std::complex<T>(-0, 1.e+6),
+ std::complex<T>(-0, -1.e+6),
+ std::complex<T>( 0, -1.e-6),
+ std::complex<T>( 0, 1.e-6),
+ std::complex<T>( 0, 1.e+6),
+ std::complex<T>( 0, -1.e+6),
+
+ std::complex<T>(-1.e-6, -0),
+ std::complex<T>( 1.e-6, -0),
+ std::complex<T>( 1.e+6, -0),
+ std::complex<T>(-1.e+6, -0),
+ std::complex<T>(-1.e-6, 0),
+ std::complex<T>( 1.e-6, 0),
+ std::complex<T>( 1.e+6, 0),
+ std::complex<T>(-1.e+6, 0),
+
+ std::complex<T>(std::numeric_limits<T>::quiet_NaN(), std::numeric_limits<T>::quiet_NaN()),
+ std::complex<T>(-std::numeric_limits<T>::infinity(), std::numeric_limits<T>::quiet_NaN()),
+ std::complex<T>(-2, std::numeric_limits<T>::quiet_NaN()),
+ std::complex<T>(-1, std::numeric_limits<T>::quiet_NaN()),
+ std::complex<T>(-0.5, std::numeric_limits<T>::quiet_NaN()),
+ std::complex<T>(-0., std::numeric_limits<T>::quiet_NaN()),
+ std::complex<T>(+0., std::numeric_limits<T>::quiet_NaN()),
+ std::complex<T>(0.5, std::numeric_limits<T>::quiet_NaN()),
+ std::complex<T>(1, std::numeric_limits<T>::quiet_NaN()),
+ std::complex<T>(2, std::numeric_limits<T>::quiet_NaN()),
+ std::complex<T>(std::numeric_limits<T>::infinity(), std::numeric_limits<T>::quiet_NaN()),
+
+ std::complex<T>(std::numeric_limits<T>::quiet_NaN(), -std::numeric_limits<T>::infinity()),
+ std::complex<T>(-std::numeric_limits<T>::infinity(), -std::numeric_limits<T>::infinity()),
+ std::complex<T>(-2, -std::numeric_limits<T>::infinity()),
+ std::complex<T>(-1, -std::numeric_limits<T>::infinity()),
+ std::complex<T>(-0.5, -std::numeric_limits<T>::infinity()),
+ std::complex<T>(-0., -std::numeric_limits<T>::infinity()),
+ std::complex<T>(+0., -std::numeric_limits<T>::infinity()),
+ std::complex<T>(0.5, -std::numeric_limits<T>::infinity()),
+ std::complex<T>(1, -std::numeric_limits<T>::infinity()),
+ std::complex<T>(2, -std::numeric_limits<T>::infinity()),
+ std::complex<T>(std::numeric_limits<T>::infinity(), -std::numeric_limits<T>::infinity()),
+
+ std::complex<T>(std::numeric_limits<T>::quiet_NaN(), -2),
+ std::complex<T>(-std::numeric_limits<T>::infinity(), -2),
+ std::complex<T>(-2, -2),
+ std::complex<T>(-1, -2),
+ std::complex<T>(-0.5, -2),
+ std::complex<T>(-0., -2),
+ std::complex<T>(+0., -2),
+ std::complex<T>(0.5, -2),
+ std::complex<T>(1, -2),
+ std::complex<T>(2, -2),
+ std::complex<T>(std::numeric_limits<T>::infinity(), -2),
+
+ std::complex<T>(std::numeric_limits<T>::quiet_NaN(), -1),
+ std::complex<T>(-std::numeric_limits<T>::infinity(), -1),
+ std::complex<T>(-2, -1),
+ std::complex<T>(-1, -1),
+ std::complex<T>(-0.5, -1),
+ std::complex<T>(-0., -1),
+ std::complex<T>(+0., -1),
+ std::complex<T>(0.5, -1),
+ std::complex<T>(1, -1),
+ std::complex<T>(2, -1),
+ std::complex<T>(std::numeric_limits<T>::infinity(), -1),
+
+ std::complex<T>(std::numeric_limits<T>::quiet_NaN(), -0.5),
+ std::complex<T>(-std::numeric_limits<T>::infinity(), -0.5),
+ std::complex<T>(-2, -0.5),
+ std::complex<T>(-1, -0.5),
+ std::complex<T>(-0.5, -0.5),
+ std::complex<T>(-0., -0.5),
+ std::complex<T>(+0., -0.5),
+ std::complex<T>(0.5, -0.5),
+ std::complex<T>(1, -0.5),
+ std::complex<T>(2, -0.5),
+ std::complex<T>(std::numeric_limits<T>::infinity(), -0.5),
+
+ std::complex<T>(std::numeric_limits<T>::quiet_NaN(), -0.),
+ std::complex<T>(-std::numeric_limits<T>::infinity(), -0.),
+ std::complex<T>(-2, -0.),
+ std::complex<T>(-1, -0.),
+ std::complex<T>(-0.5, -0.),
+ std::complex<T>(-0., -0.),
+ std::complex<T>(+0., -0.),
+ std::complex<T>(0.5, -0.),
+ std::complex<T>(1, -0.),
+ std::complex<T>(2, -0.),
+ std::complex<T>(std::numeric_limits<T>::infinity(), -0.),
+
+ std::complex<T>(std::numeric_limits<T>::quiet_NaN(), +0.),
+ std::complex<T>(-std::numeric_limits<T>::infinity(), +0.),
+ std::complex<T>(-2, +0.),
+ std::complex<T>(-1, +0.),
+ std::complex<T>(-0.5, +0.),
+ std::complex<T>(-0., +0.),
+ std::complex<T>(+0., +0.),
+ std::complex<T>(0.5, +0.),
+ std::complex<T>(1, +0.),
+ std::complex<T>(2, +0.),
+ std::complex<T>(std::numeric_limits<T>::infinity(), +0.),
+
+ std::complex<T>(std::numeric_limits<T>::quiet_NaN(), 0.5),
+ std::complex<T>(-std::numeric_limits<T>::infinity(), 0.5),
+ std::complex<T>(-2, 0.5),
+ std::complex<T>(-1, 0.5),
+ std::complex<T>(-0.5, 0.5),
+ std::complex<T>(-0., 0.5),
+ std::complex<T>(+0., 0.5),
+ std::complex<T>(0.5, 0.5),
+ std::complex<T>(1, 0.5),
+ std::complex<T>(2, 0.5),
+ std::complex<T>(std::numeric_limits<T>::infinity(), 0.5),
+
+ std::complex<T>(std::numeric_limits<T>::quiet_NaN(), 1),
+ std::complex<T>(-std::numeric_limits<T>::infinity(), 1),
+ std::complex<T>(-2, 1),
+ std::complex<T>(-1, 1),
+ std::complex<T>(-0.5, 1),
+ std::complex<T>(-0., 1),
+ std::complex<T>(+0., 1),
+ std::complex<T>(0.5, 1),
+ std::complex<T>(1, 1),
+ std::complex<T>(2, 1),
+ std::complex<T>(std::numeric_limits<T>::infinity(), 1),
+
+ std::complex<T>(std::numeric_limits<T>::quiet_NaN(), 2),
+ std::complex<T>(-std::numeric_limits<T>::infinity(), 2),
+ std::complex<T>(-2, 2),
+ std::complex<T>(-1, 2),
+ std::complex<T>(-0.5, 2),
+ std::complex<T>(-0., 2),
+ std::complex<T>(+0., 2),
+ std::complex<T>(0.5, 2),
+ std::complex<T>(1, 2),
+ std::complex<T>(2, 2),
+ std::complex<T>(std::numeric_limits<T>::infinity(), 2),
+
+ std::complex<T>(std::numeric_limits<T>::quiet_NaN(), std::numeric_limits<T>::infinity()),
+ std::complex<T>(-std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity()),
+ std::complex<T>(-2, std::numeric_limits<T>::infinity()),
+ std::complex<T>(-1, std::numeric_limits<T>::infinity()),
+ std::complex<T>(-0.5, std::numeric_limits<T>::infinity()),
+ std::complex<T>(-0., std::numeric_limits<T>::infinity()),
+ std::complex<T>(+0., std::numeric_limits<T>::infinity()),
+ std::complex<T>(0.5, std::numeric_limits<T>::infinity()),
+ std::complex<T>(1, std::numeric_limits<T>::infinity()),
+ std::complex<T>(2, std::numeric_limits<T>::infinity()),
+ std::complex<T>(std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity()),
+
+ std::complex<T>(std::numeric_limits<T>::max(), 1),
+ std::complex<T>(1, std::numeric_limits<T>::max()),
+ std::complex<T>(std::numeric_limits<T>::max(), std::numeric_limits<T>::max()),
};
-enum {zero, non_zero, inf, NaN, non_zero_nan};
+enum {zero, non_zero, maximum_value, inf, NaN, non_zero_nan};
template <class T, typename std::enable_if<std::is_floating_point<T>::value, int>::type = 0>
TEST_CONSTEXPR_CXX20 bool test_isinf(T v) {
@@ -227,12 +233,15 @@ classify(const std::complex<T>& x)
return NaN;
return non_zero_nan;
}
+ if (x.real() == std::numeric_limits<T>::max() || x.imag() == std::numeric_limits<T>::max())
+ return maximum_value;
return non_zero;
}
+template<class T>
inline
int
-classify(double x)
+classify(T x)
{
if (x == 0)
return zero;
@@ -240,6 +249,8 @@ classify(double x)
return inf;
if (std::isnan(x))
return NaN;
+ if (x == std::numeric_limits<T>::max())
+ return maximum_value;
return non_zero;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
index d12dfd994b0ae9..9f4b139574b029 100644
--- a/libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
@@ -34,24 +34,29 @@ test()
return true;
}
+template<class T>
TEST_CONSTEXPR_CXX20
bool
test_edges()
{
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
int classification[N];
for (unsigned i=0; i < N; ++i)
- classification[i] = classify(testcases[i]);
+ classification[i] = classify(testcases<T>[i]);
for (unsigned i = 0; i < N; ++i) {
+ auto const x = testcases<T>[i];
for (unsigned j = 0; j < N; ++j) {
- std::complex<double> r = testcases[i] / testcases[j];
+ auto const y = testcases<T>[j];
+ std::complex<T> r = x / y;
switch (classification[i]) {
case zero:
switch (classification[j]) {
case zero:
assert(classify(r) == NaN);
break;
+ case maximum_value:
+ continue; // not tested
case non_zero:
assert(classify(r) == zero);
break;
@@ -66,11 +71,15 @@ test_edges()
break;
}
break;
+ case maximum_value:
+ continue; // not tested
case non_zero:
switch (classification[j]) {
case zero:
assert(classify(r) == inf);
break;
+ case maximum_value:
+ continue; // not tested
case non_zero:
assert(classify(r) == non_zero);
break;
@@ -90,6 +99,8 @@ test_edges()
case zero:
assert(classify(r) == inf);
break;
+ case maximum_value:
+ continue; // not tested
case non_zero:
assert(classify(r) == inf);
break;
@@ -109,6 +120,8 @@ test_edges()
case zero:
assert(classify(r) == NaN);
break;
+ case maximum_value:
+ continue; // not tested
case non_zero:
assert(classify(r) == NaN);
break;
@@ -128,6 +141,8 @@ test_edges()
case zero:
assert(classify(r) == inf);
break;
+ case maximum_value:
+ continue; // not tested
case non_zero:
assert(classify(r) == NaN);
break;
@@ -153,13 +168,17 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
#if TEST_STD_VER > 17
static_assert(test<float>());
static_assert(test<double>());
static_assert(test<long double>());
- static_assert(test_edges());
+ static_assert(test_edges<float>());
+ static_assert(test_edges<double>());
+ static_assert(test_edges<long double>());
#endif
return 0;
diff --git a/libcxx/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
index 817d6cdf492d30..ebc5f03e58ed98 100644
--- a/libcxx/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
@@ -33,23 +33,26 @@ test()
// test edges
+template<class T>
TEST_CONSTEXPR_CXX20 bool test_edges()
{
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
int classification[N];
for (unsigned i=0; i < N; ++i)
- classification[i] = classify(testcases[i]);
+ classification[i] = classify(testcases<T>[i]);
for (unsigned i = 0; i < N; ++i)
{
for (unsigned j = 0; j < N; ++j)
{
- std::complex<double> r = testcases[i] * testcases[j];
+ std::complex<T> r = testcases<T>[i] * testcases<T>[j];
switch (classification[i])
{
case zero:
switch (classification[j])
{
+ case maximum_value:
+ continue; // not tested
case zero:
case non_zero:
assert(classify(r) == zero);
@@ -61,12 +64,16 @@ TEST_CONSTEXPR_CXX20 bool test_edges()
break;
}
break;
+ case maximum_value:
+ continue; // not tested
case non_zero:
switch (classification[j])
{
case zero:
assert(classify(r) == zero);
break;
+ case maximum_value:
+ continue; // not tested
case non_zero:
assert(classify(r) == non_zero);
break;
@@ -86,6 +93,8 @@ TEST_CONSTEXPR_CXX20 bool test_edges()
case NaN:
assert(classify(r) == NaN);
break;
+ case maximum_value:
+ continue; // not tested
case non_zero:
case inf:
case non_zero_nan:
@@ -102,6 +111,8 @@ TEST_CONSTEXPR_CXX20 bool test_edges()
case inf:
assert(classify(r) == inf);
break;
+ case maximum_value:
+ continue; // not tested
case zero:
case non_zero:
case NaN:
@@ -121,13 +132,17 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
#if TEST_STD_VER > 17
static_assert(test<float>());
static_assert(test<double>());
static_assert(test<long double>());
- static_assert(test_edges());
+ static_assert(test_edges<float>());
+ static_assert(test_edges<double>());
+ static_assert(test_edges<long double>());
#endif
return 0;
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
index 3158a3bc33d1c5..50756f8ff9a53c 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
@@ -32,101 +32,109 @@ test()
test(std::complex<T>(INFINITY, 1), std::complex<T>(0, -INFINITY));
}
+template<class T>
void test_edges()
{
- const double pi = std::atan2(+0., -0.);
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const T pi = std::atan2(+0., -0.);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- std::complex<double> r = acos(testcases[i]);
- if (testcases[i].real() == 0 && testcases[i].imag() == 0)
+ std::complex<T> r = acos(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
{
is_about(r.real(), pi/2);
assert(r.imag() == 0);
- assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
}
- else if (testcases[i].real() == 0 && std::isnan(testcases[i].imag()))
+ else if (testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag()))
{
is_about(r.real(), pi/2);
assert(std::isnan(r.imag()));
}
- else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
is_about(r.real(), pi/2);
assert(std::isinf(r.imag()));
- assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
}
- else if (std::isfinite(testcases[i].real()) && testcases[i].real() != 0 && std::isnan(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && testcases<T>[i].real() != 0 && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isfinite(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isfinite(testcases<T>[i].imag()))
{
is_about(r.real(), pi);
assert(std::isinf(r.imag()));
- assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isfinite(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isfinite(testcases<T>[i].imag()))
{
assert(r.real() == 0);
assert(!std::signbit(r.real()));
assert(std::isinf(r.imag()));
- assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isinf(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isinf(testcases<T>[i].imag()))
{
- is_about(r.real(), 0.75 * pi);
+ is_about(r.real(), T(0.75) * pi);
assert(std::isinf(r.imag()));
- assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isinf(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isinf(testcases<T>[i].imag()))
{
- is_about(r.real(), 0.25 * pi);
+ is_about(r.real(), T(0.25) * pi);
assert(std::isinf(r.imag()));
- assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isinf(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isinf(r.imag()));
- assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (!std::signbit(testcases[i].real()) && !std::signbit(testcases[i].imag()))
+ else if (!std::signbit(testcases<T>[i].real()) && !std::signbit(testcases<T>[i].imag()))
{
assert(!std::signbit(r.real()));
assert( std::signbit(r.imag()));
}
- else if (std::signbit(testcases[i].real()) && !std::signbit(testcases[i].imag()))
+ else if (std::signbit(testcases<T>[i].real()) && !std::signbit(testcases<T>[i].imag()))
{
assert(!std::signbit(r.real()));
assert( std::signbit(r.imag()));
}
- else if (std::signbit(testcases[i].real()) && std::signbit(testcases[i].imag()))
+ else if (std::signbit(testcases<T>[i].real()) && std::signbit(testcases<T>[i].imag()))
{
assert(!std::signbit(r.real()));
assert(!std::signbit(r.imag()));
}
- else if (!std::signbit(testcases[i].real()) && std::signbit(testcases[i].imag()))
+ else if (!std::signbit(testcases<T>[i].real()) && std::signbit(testcases<T>[i].imag()))
{
assert(!std::signbit(r.real()));
assert(!std::signbit(r.imag()));
}
+ else
+ {
+ assert(!std::isnan(r.real()));
+ assert(!std::isnan(r.imag()));
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ }
}
}
@@ -135,7 +143,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
index 424a3b1b82e1a0..ce580bdd507f80 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
@@ -32,103 +32,104 @@ test()
test(std::complex<T>(INFINITY, 1), std::complex<T>(INFINITY, 0));
}
+template<class T>
void test_edges()
{
- const double pi = std::atan2(+0., -0.);
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const T pi = std::atan2(+0., -0.);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- std::complex<double> r = acosh(testcases[i]);
- if (testcases[i].real() == 0 && testcases[i].imag() == 0)
+ std::complex<T> r = acosh(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
{
assert(!std::signbit(r.real()));
- if (std::signbit(testcases[i].imag()))
+ if (std::signbit(testcases<T>[i].imag()))
is_about(r.imag(), -pi/2);
else
is_about(r.imag(), pi/2);
}
- else if (testcases[i].real() == 1 && testcases[i].imag() == 0)
+ else if (testcases<T>[i].real() == 1 && testcases<T>[i].imag() == 0)
{
assert(r.real() == 0);
assert(!std::signbit(r.real()));
assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
- else if (testcases[i].real() == -1 && testcases[i].imag() == 0)
+ else if (testcases<T>[i].real() == -1 && testcases<T>[i].imag() == 0)
{
assert(r.real() == 0);
assert(!std::signbit(r.real()));
- if (std::signbit(testcases[i].imag()))
+ if (std::signbit(testcases<T>[i].imag()))
is_about(r.imag(), -pi);
else
is_about(r.imag(), pi);
}
- else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
assert(r.real() > 0);
- if (std::signbit(testcases[i].imag()))
+ if (std::signbit(testcases<T>[i].imag()))
is_about(r.imag(), -pi/2);
else
is_about(r.imag(), pi/2);
}
- else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isfinite(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isfinite(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
assert(r.real() > 0);
- if (std::signbit(testcases[i].imag()))
+ if (std::signbit(testcases<T>[i].imag()))
is_about(r.imag(), -pi);
else
is_about(r.imag(), pi);
}
- else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isfinite(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isfinite(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
assert(r.real() > 0);
assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
- else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isinf(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isinf(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
assert(r.real() > 0);
- if (std::signbit(testcases[i].imag()))
- is_about(r.imag(), -0.75 * pi);
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), T(-0.75) * pi);
else
- is_about(r.imag(), 0.75 * pi);
+ is_about(r.imag(), T( 0.75) * pi);
}
- else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isinf(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isinf(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
assert(r.real() > 0);
- if (std::signbit(testcases[i].imag()))
- is_about(r.imag(), -0.25 * pi);
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), T(-0.25 * pi));
else
- is_about(r.imag(), 0.25 * pi);
+ is_about(r.imag(), T( 0.25 * pi));
}
- else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
assert(r.real() > 0);
assert(std::isnan(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
assert(r.real() > 0);
assert(std::isnan(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
@@ -136,7 +137,7 @@ void test_edges()
else
{
assert(!std::signbit(r.real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
}
}
@@ -146,7 +147,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
index 51da1c002a294c..4bd8b4fb186229 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
@@ -32,79 +32,80 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
+template<class T>
void test_edges()
{
- const double pi = std::atan2(+0., -0.);
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const T pi = std::atan2(+0., -0.);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- std::complex<double> r = asin(testcases[i]);
- if (testcases[i].real() == 0 && testcases[i].imag() == 0)
+ std::complex<T> r = asin(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
{
- assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
- else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
assert(r.real() == 0);
- assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
assert(std::isinf(r.imag()));
- assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
}
- else if ( testcases[i].real() == 0 && std::isnan(testcases[i].imag()))
+ else if ( testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag()))
{
assert(r.real() == 0);
- assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
{
- if (testcases[i].real() > 0)
+ if (testcases<T>[i].real() > 0)
is_about(r.real(), pi/2);
else
is_about(r.real(), - pi/2);
assert(std::isinf(r.imag()));
- assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
- if (std::signbit(testcases[i].real()))
+ if (std::signbit(testcases<T>[i].real()))
is_about(r.real(), -pi/4);
else
is_about(r.real(), pi/4);
assert(std::isinf(r.imag()));
- assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isinf(r.imag()));
- assert(std::signbit(testcases[i].real()) != std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].real()) != std::signbit(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isinf(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
else
{
- assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
}
}
@@ -114,7 +115,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
index b53509242c378e..80b2c440c4a890 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
@@ -32,88 +32,89 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
+template<class T>
void test_edges()
{
- const double pi = std::atan2(+0., -0.);
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const T pi = std::atan2(+0., -0.);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- std::complex<double> r = asinh(testcases[i]);
- if (testcases[i].real() == 0 && testcases[i].imag() == 0)
+ std::complex<T> r = asinh(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
{
- assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
- else if (testcases[i].real() == 0 && std::abs(testcases[i].imag()) == 1)
+ else if (testcases<T>[i].real() == 0 && std::abs(testcases<T>[i].imag()) == 1)
{
assert(r.real() == 0);
- assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
- if (std::signbit(testcases[i].imag()))
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ if (std::signbit(testcases<T>[i].imag()))
is_about(r.imag(), -pi/2);
else
is_about(r.imag(), pi/2);
}
- else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
- assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
- if (std::signbit(testcases[i].imag()))
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ if (std::signbit(testcases<T>[i].imag()))
is_about(r.imag(), -pi/2);
else
is_about(r.imag(), pi/2);
}
- else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
- assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
assert(r.imag() == 0);
- assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
- assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
- if (std::signbit(testcases[i].imag()))
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ if (std::signbit(testcases<T>[i].imag()))
is_about(r.imag(), -pi/4);
else
is_about(r.imag(), pi/4);
}
- else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
- assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && testcases[i].imag() == 0)
+ else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
{
assert(std::isnan(r.real()));
assert(r.imag() == 0);
- assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
else
{
- assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
}
}
@@ -123,7 +124,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
index f0c801649509d5..6901069d5e2848 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
@@ -32,15 +32,16 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
+template<class T>
void test_edges()
{
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- std::complex<double> r = atan(testcases[i]);
- std::complex<double> t1(-imag(testcases[i]), real(testcases[i]));
- std::complex<double> t2 = atanh(t1);
- std::complex<double> z(imag(t2), -real(t2));
+ std::complex<T> r = atan(testcases<T>[i]);
+ std::complex<T> t1(-imag(testcases<T>[i]), real(testcases<T>[i]));
+ std::complex<T> t2 = atanh(t1);
+ std::complex<T> z(imag(t2), -real(t2));
if (std::isnan(real(r)))
assert(std::isnan(real(z)));
else
@@ -63,7 +64,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
index a126032bf8c240..2b8d79f21baf06 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
@@ -32,92 +32,93 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
+template<class T>
void test_edges()
{
- const double pi = std::atan2(+0., -0.);
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const T pi = std::atan2(+0., -0.);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- std::complex<double> r = atanh(testcases[i]);
- if (testcases[i].real() == 0 && testcases[i].imag() == 0)
+ std::complex<T> r = atanh(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
{
- assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
- else if ( testcases[i].real() == 0 && std::isnan(testcases[i].imag()))
+ else if ( testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag()))
{
assert(r.real() == 0);
- assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::abs(testcases[i].real()) == 1 && testcases[i].imag() == 0)
+ else if (std::abs(testcases<T>[i].real()) == 1 && testcases<T>[i].imag() == 0)
{
assert(std::isinf(r.real()));
- assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
assert(r.imag() == 0);
- assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
}
- else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
assert(r.real() == 0);
- assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
- if (testcases[i].imag() > 0)
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ if (testcases<T>[i].imag() > 0)
is_about(r.imag(), pi/2);
else
is_about(r.imag(), -pi/2);
}
- else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
{
assert(r.real() == 0);
- assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
- if (std::signbit(testcases[i].imag()))
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ if (std::signbit(testcases<T>[i].imag()))
is_about(r.imag(), -pi/2);
else
is_about(r.imag(), pi/2);
}
- else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
assert(r.real() == 0);
- assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
- if (std::signbit(testcases[i].imag()))
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ if (std::signbit(testcases<T>[i].imag()))
is_about(r.imag(), -pi/2);
else
is_about(r.imag(), pi/2);
}
- else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(r.real() == 0);
- assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
assert(r.real() == 0);
- assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
- if (std::signbit(testcases[i].imag()))
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ if (std::signbit(testcases<T>[i].imag()))
is_about(r.imag(), -pi/2);
else
is_about(r.imag(), pi/2);
}
- else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
else
{
- assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
}
}
@@ -127,7 +128,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
index 0571363de50c3b..922b0c87706b4c 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
@@ -32,14 +32,15 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(1, 0));
}
+template<class T>
void test_edges()
{
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- std::complex<double> r = cos(testcases[i]);
- std::complex<double> t1(-imag(testcases[i]), real(testcases[i]));
- std::complex<double> z = cosh(t1);
+ std::complex<T> r = cos(testcases<T>[i]);
+ std::complex<T> t1(-imag(testcases<T>[i]), real(testcases<T>[i]));
+ std::complex<T> z = cosh(t1);
if (std::isnan(real(r)))
assert(std::isnan(real(z)));
else
@@ -62,7 +63,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
index ad437bf44b996d..4fbec0cb6a6b00 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
@@ -32,78 +32,86 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(1, 0));
}
+template<class T>
void test_edges()
{
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- std::complex<double> r = cosh(testcases[i]);
- if (testcases[i].real() == 0 && testcases[i].imag() == 0)
+ std::complex<T> r = cosh(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
{
assert(r.real() == 1);
assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
- else if (testcases[i].real() == 0 && std::isinf(testcases[i].imag()))
+ else if (testcases<T>[i].real() == 0 && std::isinf(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(r.imag() == 0);
}
- else if (testcases[i].real() == 0 && std::isnan(testcases[i].imag()))
+ else if (testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(r.imag() == 0);
}
- else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && testcases[i].imag() == 0)
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
{
assert(std::isinf(r.real()));
assert(!std::signbit(r.real()));
assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
- else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
- assert(std::signbit(r.real()) == std::signbit(cos(testcases[i].imag())));
+ assert(std::signbit(r.real()) == std::signbit(cos(testcases<T>[i].imag())));
assert(std::isinf(r.imag()));
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].real() * sin(testcases[i].imag())));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].real() * sin(testcases<T>[i].imag())));
}
- else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
assert(r.real() > 0);
assert(std::isnan(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && testcases[i].imag() == 0)
+ else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
{
assert(std::isnan(r.real()));
assert(r.imag() == 0);
}
- else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
+ else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
+ {
+ assert(!std::isnan(r.real()));
+
+ bool const nan_okay = std::isinf(r.real()) && testcases<T>[i].imag() == 0; // inf * 0 == NaN
+ assert(!std::isnan(r.imag()) || nan_okay);
+ }
}
}
@@ -112,7 +120,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
index 5c9574e6399d97..efc9b867ebe1ef 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
@@ -32,79 +32,80 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(1, 0));
}
+template<class T>
void test_edges()
{
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- std::complex<double> r = exp(testcases[i]);
- if (testcases[i].real() == 0 && testcases[i].imag() == 0)
+ std::complex<T> r = exp(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
{
assert(r.real() == 1.0);
assert(r.imag() == 0);
- assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
}
- else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && testcases[i].imag() == 0)
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && testcases<T>[i].imag() == 0)
{
assert(std::isinf(r.real()));
assert(r.real() > 0);
assert(r.imag() == 0);
- assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isinf(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isinf(testcases<T>[i].imag()))
{
assert(r.real() == 0);
assert(r.imag() == 0);
}
- else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isinf(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isinf(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isnan(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isnan(testcases<T>[i].imag()))
{
assert(r.real() == 0);
assert(r.imag() == 0);
}
- else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isnan(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isnan(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && testcases[i].imag() == 0)
+ else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
{
assert(std::isnan(r.real()));
assert(r.imag() == 0);
- assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && testcases[i].imag() != 0)
+ else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() != 0)
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isfinite(testcases[i].imag()) && std::abs(testcases[i].imag()) <= 1)
+ else if (std::isfinite(testcases<T>[i].imag()) && std::abs(testcases<T>[i].imag()) <= 1)
{
assert(!std::signbit(r.real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
- else if (std::isinf(r.real()) && testcases[i].imag() == 0) {
+ else if (std::isinf(r.real()) && testcases<T>[i].imag() == 0) {
assert(r.imag() == 0);
- assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
}
}
}
@@ -114,7 +115,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
index 562d125e05323e..b1737f0de54ac4 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
@@ -32,20 +32,21 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(-INFINITY, 0));
}
+template<class T>
void test_edges()
{
- const double pi = std::atan2(+0., -0.);
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const T pi = std::atan2(+0., -0.);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- std::complex<double> r = log(testcases[i]);
- if (testcases[i].real() == 0 && testcases[i].imag() == 0)
+ std::complex<T> r = log(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
{
- if (std::signbit(testcases[i].real()))
+ if (std::signbit(testcases<T>[i].real()))
{
assert(std::isinf(r.real()));
assert(r.real() < 0);
- if (std::signbit(testcases[i].imag()))
+ if (std::signbit(testcases<T>[i].imag()))
is_about(r.imag(), -pi);
else
is_about(r.imag(), pi);
@@ -55,24 +56,24 @@ void test_edges()
assert(std::isinf(r.real()));
assert(r.real() < 0);
assert(r.imag() == 0);
- assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
}
}
- else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
assert(r.real() > 0);
- if (testcases[i].imag() > 0)
+ if (testcases<T>[i].imag() > 0)
is_about(r.imag(), pi/2);
else
is_about(r.imag(), -pi/2);
}
- else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isfinite(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isfinite(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()) && r.real() > 0);
if (r.imag() > 0)
@@ -80,44 +81,44 @@ void test_edges()
else
is_about(r.imag(), -pi);
}
- else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isfinite(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isfinite(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()) && r.real() > 0);
assert(r.imag() == 0);
- assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
}
- else if (testcases[i].real() == 1 && testcases[i].imag() == 0)
+ else if (testcases<T>[i].real() == 1 && testcases<T>[i].imag() == 0)
{
assert(r.real() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
- else if (testcases[i].real() == 0 && testcases[i].imag() == 1)
+ else if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 1)
{
assert(r.real() == 0);
is_about(r.imag(), pi/2);
}
- else if (testcases[i].real() == -1 && testcases[i].imag() == 0)
+ else if (testcases<T>[i].real() == -1 && testcases<T>[i].imag() == 0)
{
assert(r.real() == 0);
- if (std::signbit(testcases[i].imag()))
+ if (std::signbit(testcases<T>[i].imag()))
is_about(r.imag(), -pi);
else
is_about(r.imag(), pi);
}
- else if (testcases[i].real() == 0 && testcases[i].imag() == -1)
+ else if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == -1)
{
assert(r.real() == 0);
is_about(r.imag(), -pi/2);
}
- else if (std::isfinite(testcases[i].real()) && std::isfinite(testcases[i].imag()) && abs(testcases[i]) < 1)
+ else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()) && abs(testcases<T>[i]) < 1)
{
assert( std::signbit(r.real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
- else if (std::isfinite(testcases[i].real()) && std::isfinite(testcases[i].imag()) && abs(testcases[i]) > 1)
+ else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()) && abs(testcases<T>[i]) > 1)
{
assert(!std::signbit(r.real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
}
}
@@ -127,7 +128,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
index 78818f0de15b2b..ae4fa59fb2c981 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
@@ -32,13 +32,14 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(-INFINITY, 0));
}
+template<class T>
void test_edges()
{
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- std::complex<double> r = log10(testcases[i]);
- std::complex<double> z = log(testcases[i])/std::log(10);
+ std::complex<T> r = log10(testcases<T>[i]);
+ std::complex<T> z = log(testcases<T>[i])/std::log(T(10));
if (std::isnan(real(r)))
assert(std::isnan(real(z)));
else
@@ -61,7 +62,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
index 91754fac4d0a80..9bddbd0408a38d 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
@@ -34,15 +34,16 @@ test()
test(std::complex<T>(2, 3), std::complex<T>(2, 0), std::complex<T>(-5, 12));
}
+template<class T>
void test_edges()
{
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
for (unsigned j = 0; j < N; ++j)
{
- std::complex<double> r = pow(testcases[i], testcases[j]);
- std::complex<double> z = exp(testcases[j] * log(testcases[i]));
+ std::complex<T> r = pow(testcases<T>[i], testcases<T>[j]);
+ std::complex<T> z = exp(testcases<T>[j] * log(testcases<T>[i]));
if (std::isnan(real(r)))
assert(std::isnan(real(z)));
else
@@ -66,7 +67,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
index 4b1aef23281db1..1bbc211a09c3ae 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
@@ -34,15 +34,16 @@ test()
test(std::complex<T>(2, 3), T(2), std::complex<T>(-5, 12));
}
+template<class T>
void test_edges()
{
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
for (unsigned j = 0; j < N; ++j)
{
- std::complex<double> r = pow(testcases[i], real(testcases[j]));
- std::complex<double> z = exp(std::complex<double>(real(testcases[j])) * log(testcases[i]));
+ std::complex<T> r = pow(testcases<T>[i], real(testcases<T>[j]));
+ std::complex<T> z = exp(std::complex<T>(real(testcases<T>[j])) * log(testcases<T>[i]));
if (std::isnan(real(r)))
assert(std::isnan(real(z)));
else
@@ -64,7 +65,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
index 6022fddfaa7558..05bd55ef2a72a8 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
@@ -34,15 +34,16 @@ test()
test(T(2), std::complex<T>(2), std::complex<T>(4));
}
+template<class T>
void test_edges()
{
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
for (unsigned j = 0; j < N; ++j)
{
- std::complex<double> r = pow(real(testcases[i]), testcases[j]);
- std::complex<double> z = exp(testcases[j] * log(std::complex<double>(real(testcases[i]))));
+ std::complex<T> r = pow(real(testcases<T>[i]), testcases<T>[j]);
+ std::complex<T> z = exp(testcases<T>[j] * log(std::complex<T>(real(testcases<T>[i]))));
if (std::isnan(real(r)))
assert(std::isnan(real(z)));
else
@@ -64,7 +65,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
index ceececa46f7cfd..d54c745781bee5 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
@@ -32,15 +32,16 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
+template<class T>
void test_edges()
{
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- std::complex<double> r = sin(testcases[i]);
- std::complex<double> t1(-imag(testcases[i]), real(testcases[i]));
- std::complex<double> t2 = sinh(t1);
- std::complex<double> z(imag(t2), -real(t2));
+ std::complex<T> r = sin(testcases<T>[i]);
+ std::complex<T> t1(-imag(testcases<T>[i]), real(testcases<T>[i]));
+ std::complex<T> t2 = sinh(t1);
+ std::complex<T> z(imag(t2), -real(t2));
if (std::isnan(real(r)))
assert(std::isnan(real(z)));
else
@@ -63,7 +64,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
index 933ff71d8a09bb..62693f18b46225 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
@@ -32,79 +32,89 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
+#include <print>
+
+template<class T>
void test_edges()
{
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- std::complex<double> r = sinh(testcases[i]);
- if (testcases[i].real() == 0 && testcases[i].imag() == 0)
+ std::complex<T> r = sinh(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
{
assert(r.real() == 0);
- assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
- else if (testcases[i].real() == 0 && std::isinf(testcases[i].imag()))
+ else if (testcases<T>[i].real() == 0 && std::isinf(testcases<T>[i].imag()))
{
assert(r.real() == 0);
assert(std::isnan(r.imag()));
}
- else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (testcases[i].real() == 0 && std::isnan(testcases[i].imag()))
+ else if (testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag()))
{
assert(r.real() == 0);
assert(std::isnan(r.imag()));
}
- else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && testcases[i].imag() == 0)
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
{
assert(std::isinf(r.real()));
- assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
- else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
- assert(std::signbit(r.real()) == std::signbit(testcases[i].real() * cos(testcases[i].imag())));
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real() * cos(testcases<T>[i].imag())));
assert(std::isinf(r.imag()));
- assert(std::signbit(r.imag()) == std::signbit(sin(testcases[i].imag())));
+ assert(std::signbit(r.imag()) == std::signbit(sin(testcases<T>[i].imag())));
}
- else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && testcases[i].imag() == 0)
+ else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
{
assert(std::isnan(r.real()));
assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
- else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
+ else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
+ {
+ assert(!std::isnan(r.real()));
+
+ bool const nan_okay = std::isinf(r.real()) && testcases<T>[i].imag() == 0; // inf * 0 == NaN
+ assert(!std::isnan(r.imag()) || nan_okay);
+ }
}
}
@@ -113,7 +123,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
index 12fd9a2c0440a1..1f2f9e9af4e576 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
@@ -14,6 +14,7 @@
#include <complex>
#include <cassert>
+#include <type_traits>
#include "test_macros.h"
#include "../cases.h"
@@ -34,67 +35,91 @@ test()
test(std::complex<T>(64, 0), std::complex<T>(8, 0));
}
+// cosine calculations for std::arg terminate at different times based on the precision of T,
+// and can produce a very small negative number instead of a very small positive one, so we
+// should actually check that we're really close to zero instead of positive.
+template<class T>
+bool approaching_zero(const T value)
+{
+ auto in_range = [value](const T low, const T high) {
+ return low < value && value < high;
+ };
+ if constexpr (std::is_same_v<T, float>) {
+ return value == -0.0f || in_range(-4.38e-5f, 4.38e-5f);
+ }
+ else if constexpr (std::is_same_v<T, double>) {
+ return false;
+ }
+ else if constexpr (std::is_same_v<T, long double>) {
+ return value == -0.0f || in_range(-3.0e-17L, 3.0e-17L);
+ }
+ else {
+ std::abort();
+ }
+}
+
+template<class T>
void test_edges()
{
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- std::complex<double> r = sqrt(testcases[i]);
- if (testcases[i].real() == 0 && testcases[i].imag() == 0)
+ std::complex<T> r = sqrt(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
{
- assert(!std::signbit(r.real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(!std::signbit(r.real()) || approaching_zero(r.real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
- else if (std::isinf(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
assert(r.real() > 0);
assert(std::isinf(r.imag()));
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
- else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isfinite(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isfinite(testcases<T>[i].imag()))
{
assert(r.real() == 0);
assert(!std::signbit(r.real()));
assert(std::isinf(r.imag()));
- assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isfinite(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isfinite(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
assert(r.real() > 0);
assert(r.imag() == 0);
- assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isnan(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isinf(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isnan(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isnan(testcases<T>[i].imag()))
{
assert(std::isinf(r.real()));
assert(r.real() > 0);
assert(std::isnan(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && (std::isfinite(testcases[i].imag()) || std::isnan(testcases[i].imag())))
+ else if (std::isnan(testcases<T>[i].real()) && (std::isfinite(testcases<T>[i].imag()) || std::isnan(testcases<T>[i].imag())))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::signbit(testcases[i].imag()))
+ else if (std::signbit(testcases<T>[i].imag()))
{
- assert(!std::signbit(r.real()));
+ assert(!std::signbit(r.real()) || approaching_zero(r.real()));
assert(std::signbit(r.imag()));
}
else
{
- assert(!std::signbit(r.real()));
+ assert(!std::signbit(r.real()) || approaching_zero(r.real()));
assert(!std::signbit(r.imag()));
}
}
@@ -105,7 +130,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
index 5c1f61ef644d3a..dc946a7808b628 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
@@ -33,15 +33,16 @@ test()
test(std::complex<T>(10000, -10000), std::complex<T>(0, -1));
}
+template<class T>
void test_edges()
{
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- std::complex<double> r = tan(testcases[i]);
- std::complex<double> t1(-imag(testcases[i]), real(testcases[i]));
- std::complex<double> t2 = tanh(t1);
- std::complex<double> z(imag(t2), -real(t2));
+ std::complex<T> r = tan(testcases<T>[i]);
+ std::complex<T> t1(-imag(testcases<T>[i]), real(testcases<T>[i]));
+ std::complex<T> t2 = tanh(t1);
+ std::complex<T> z(imag(t2), -real(t2));
if (std::isnan(real(r)))
assert(std::isnan(real(z)));
else
@@ -64,7 +65,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
index f48cc88c6a38de..ebb27f82bf114f 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
@@ -32,61 +32,68 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
+template<class T>
void test_edges()
{
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- std::complex<double> r = tanh(testcases[i]);
- if (testcases[i].real() == 0 && testcases[i].imag() == 0)
+ std::complex<T> r = tanh(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
{
assert(r.real() == 0);
- assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
- else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
{
- assert(r.real() == (testcases[i].real() > 0 ? 1 : -1));
+ assert(r.real() == (testcases<T>[i].real() > 0 ? 1 : -1));
assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(sin(2 * testcases[i].imag())));
+ assert(std::signbit(r.imag()) == std::signbit(sin(2 * testcases<T>[i].imag())));
}
- else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
- assert(r.real() == (testcases[i].real() > 0 ? 1 : -1));
+ assert(r.real() == (testcases<T>[i].real() > 0 ? 1 : -1));
assert(r.imag() == 0);
}
- else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
- assert(r.real() == (testcases[i].real() > 0 ? 1 : -1));
+ assert(r.real() == (testcases<T>[i].real() > 0 ? 1 : -1));
assert(r.imag() == 0);
}
- else if (std::isnan(testcases[i].real()) && testcases[i].imag() == 0)
+ else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
{
assert(std::isnan(r.real()));
assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
- else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
- else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
+ else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
{
assert(std::isnan(r.real()));
assert(std::isnan(r.imag()));
}
+ else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
+ {
+ [[maybe_unused]] auto const x = testcases<T>[i];
+ assert(!std::isnan(r.real()));
+ assert(!std::isnan(r.imag()));
+ }
}
}
@@ -95,7 +102,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
index d5ed2a6ba148cf..486596c2e923a4 100644
--- a/libcxx/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
@@ -26,18 +26,26 @@ test()
assert(abs(z) == 5);
}
+template<class T>
void test_edges()
{
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- double r = abs(testcases[i]);
- switch (classify(testcases[i]))
+ T r = abs(testcases<T>[i]);
+ switch (classify(testcases<T>[i]))
{
case zero:
assert(r == 0);
assert(!std::signbit(r));
break;
+ case maximum_value: {
+ // It appears that `max<float> + relatively_small_number == max<float>`, so we check to
+ // make sure that abs was actually effective before asserting that it should be infinity.
+ bool const ineffective_abs = (testcases<T>[i].real() + testcases<T>[i].imag()) == r;
+ assert((std::isinf(r) && r > 0) || ineffective_abs);
+ break;
+ }
case non_zero:
assert(std::isfinite(r) && r > 0);
break;
@@ -59,7 +67,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
index 49c54372a8e002..6367f20a635953 100644
--- a/libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
@@ -26,45 +26,47 @@ test()
assert(arg(z) == 0);
}
+template<class T>
void test_edges()
{
- const double pi = std::atan2(+0., -0.);
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const T pi = std::atan2(T(+0.), T(-0.));
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- double r = arg(testcases[i]);
- if (std::isnan(testcases[i].real()) || std::isnan(testcases[i].imag()))
+ T r = arg(testcases<T>[i]);
+ if (std::isnan(testcases<T>[i].real()) || std::isnan(testcases<T>[i].imag()))
assert(std::isnan(r));
else
{
- switch (classify(testcases[i]))
+ switch (classify(testcases<T>[i]))
{
case zero:
- if (std::signbit(testcases[i].real()))
+ if (std::signbit(testcases<T>[i].real()))
{
- if (std::signbit(testcases[i].imag()))
+ if (std::signbit(testcases<T>[i].imag()))
is_about(r, -pi);
else
is_about(r, pi);
}
else
{
- assert(std::signbit(testcases[i].imag()) == std::signbit(r));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r));
}
break;
+ case maximum_value:
case non_zero:
- if (testcases[i].real() == 0)
+ if (testcases<T>[i].real() == 0)
{
- if (testcases[i].imag() < 0)
+ if (testcases<T>[i].imag() < 0)
is_about(r, -pi/2);
else
is_about(r, pi/2);
}
- else if (testcases[i].imag() == 0)
+ else if (testcases<T>[i].imag() == 0)
{
- if (testcases[i].real() < 0)
+ if (testcases<T>[i].real() < 0)
{
- if (std::signbit(testcases[i].imag()))
+ if (std::signbit(testcases<T>[i].imag()))
is_about(r, -pi);
else
is_about(r, pi);
@@ -72,37 +74,37 @@ void test_edges()
else
{
assert(r == 0);
- assert(std::signbit(testcases[i].imag()) == std::signbit(r));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r));
}
}
- else if (testcases[i].imag() > 0)
+ else if (testcases<T>[i].imag() > 0)
assert(r > 0);
else
assert(r < 0);
break;
case inf:
- if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
+ if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
{
- if (testcases[i].real() < 0)
+ if (testcases<T>[i].real() < 0)
{
- if (testcases[i].imag() > 0)
- is_about(r, 0.75 * pi);
+ if (testcases<T>[i].imag() > 0)
+ is_about(r, T( 0.75) * pi);
else
- is_about(r, -0.75 * pi);
+ is_about(r, T(-0.75) * pi);
}
else
{
- if (testcases[i].imag() > 0)
- is_about(r, 0.25 * pi);
+ if (testcases<T>[i].imag() > 0)
+ is_about(r, T( 0.25) * pi);
else
- is_about(r, -0.25 * pi);
+ is_about(r, T(-0.25) * pi);
}
}
- else if (std::isinf(testcases[i].real()))
+ else if (std::isinf(testcases<T>[i].real()))
{
- if (testcases[i].real() < 0)
+ if (testcases<T>[i].real() < 0)
{
- if (std::signbit(testcases[i].imag()))
+ if (std::signbit(testcases<T>[i].imag()))
is_about(r, -pi);
else
is_about(r, pi);
@@ -110,12 +112,12 @@ void test_edges()
else
{
assert(r == 0);
- assert(std::signbit(r) == std::signbit(testcases[i].imag()));
+ assert(std::signbit(r) == std::signbit(testcases<T>[i].imag()));
}
}
else
{
- if (testcases[i].imag() < 0)
+ if (testcases<T>[i].imag() < 0)
is_about(r, -pi/2);
else
is_about(r, pi/2);
@@ -131,7 +133,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
index 6e6dc10f1928d3..b1a699e1113a3e 100644
--- a/libcxx/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
@@ -26,13 +26,14 @@ test()
assert(norm(z) == 25);
}
+template<class T>
void test_edges()
{
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- double r = norm(testcases[i]);
- switch (classify(testcases[i]))
+ T r = norm(testcases<T>[i]);
+ switch (classify(testcases<T>[i]))
{
case zero:
assert(r == 0);
@@ -41,6 +42,7 @@ void test_edges()
case non_zero:
assert(std::isfinite(r) && r > 0);
break;
+ case maximum_value:
case inf:
assert(std::isinf(r) && r > 0);
break;
@@ -59,7 +61,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
index 2b9c764abb591b..343ba9dbc51b4f 100644
--- a/libcxx/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
@@ -44,14 +44,15 @@ test()
test(T(100), T(0), std::complex<T>(100, 0));
}
+template<class T>
void test_edges()
{
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- double r = real(testcases[i]);
- double theta = imag(testcases[i]);
- std::complex<double> z = std::polar(r, theta);
+ T r = real(testcases<T>[i]);
+ T theta = imag(testcases<T>[i]);
+ std::complex<T> z = std::polar(r, theta);
switch (classify(r))
{
case zero:
@@ -62,9 +63,10 @@ void test_edges()
}
else
{
- assert(z == std::complex<double>());
+ assert(z == std::complex<T>());
}
break;
+ case maximum_value:
case non_zero:
if (std::signbit(r) || classify(theta) == inf || classify(theta) == NaN)
{
@@ -108,7 +110,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
index e118613b8dd31e..d523d49d8cdc87 100644
--- a/libcxx/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
@@ -35,28 +35,30 @@ test()
test(std::complex<T>(-1, -2), std::complex<T>(-1, -2));
}
+template<class T>
void test_edges()
{
- const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
for (unsigned i = 0; i < N; ++i)
{
- std::complex<double> r = proj(testcases[i]);
- switch (classify(testcases[i]))
+ std::complex<T> r = proj(testcases<T>[i]);
+ switch (classify(testcases<T>[i]))
{
case zero:
case non_zero:
- assert(r == testcases[i]);
- assert(std::signbit(real(r)) == std::signbit(real(testcases[i])));
- assert(std::signbit(imag(r)) == std::signbit(imag(testcases[i])));
+ case maximum_value:
+ assert(r == testcases<T>[i]);
+ assert(std::signbit(real(r)) == std::signbit(real(testcases<T>[i])));
+ assert(std::signbit(imag(r)) == std::signbit(imag(testcases<T>[i])));
break;
case inf:
assert(std::isinf(real(r)) && real(r) > 0);
assert(imag(r) == 0);
- assert(std::signbit(imag(r)) == std::signbit(imag(testcases[i])));
+ assert(std::signbit(imag(r)) == std::signbit(imag(testcases<T>[i])));
break;
case NaN:
case non_zero_nan:
- assert(classify(r) == classify(testcases[i]));
+ assert(classify(r) == classify(testcases<T>[i]));
break;
}
}
@@ -67,7 +69,9 @@ int main(int, char**)
test<float>();
test<double>();
test<long double>();
- test_edges();
+ test_edges<float>();
+ test_edges<double>();
+ test_edges<long double>();
return 0;
}
>From 976a6937eb347c68371a321de843a9dbc03d969c Mon Sep 17 00:00:00 2001
From: Christopher Di Bella <cjdb at google.com>
Date: Wed, 8 Jan 2025 23:45:09 +0000
Subject: [PATCH 2/4] adds tests for lowest floating-point values
---
libcxx/test/std/numerics/complex.number/cases.h | 17 ++++++++++++++++-
.../complex.ops/complex_divide_complex.pass.cpp | 8 +++++++-
.../complex.ops/complex_times_complex.pass.cpp | 7 ++++++-
.../complex.transcendentals/sinh.pass.cpp | 2 --
.../complex.transcendentals/sqrt.pass.cpp | 11 +++++++++--
.../complex.value.ops/abs.pass.cpp | 9 ++++++++-
.../complex.value.ops/arg.pass.cpp | 1 +
.../complex.value.ops/norm.pass.cpp | 1 +
.../complex.value.ops/polar.pass.cpp | 1 +
.../complex.value.ops/proj.pass.cpp | 1 +
10 files changed, 50 insertions(+), 8 deletions(-)
diff --git a/libcxx/test/std/numerics/complex.number/cases.h b/libcxx/test/std/numerics/complex.number/cases.h
index 61096dd875fc4b..37d327450311ae 100644
--- a/libcxx/test/std/numerics/complex.number/cases.h
+++ b/libcxx/test/std/numerics/complex.number/cases.h
@@ -194,11 +194,22 @@ TEST_CONSTEXPR_CXX20 const std::complex<T> testcases[] =
std::complex<T>(std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity()),
std::complex<T>(std::numeric_limits<T>::max(), 1),
+ std::complex<T>(std::numeric_limits<T>::max(), -1),
+ std::complex<T>(std::numeric_limits<T>::lowest(), 1),
+ std::complex<T>(std::numeric_limits<T>::lowest(), -1),
+
std::complex<T>(1, std::numeric_limits<T>::max()),
+ std::complex<T>(1, std::numeric_limits<T>::lowest()),
+ std::complex<T>(-1, std::numeric_limits<T>::max()),
+ std::complex<T>(-1, std::numeric_limits<T>::lowest()),
+
std::complex<T>(std::numeric_limits<T>::max(), std::numeric_limits<T>::max()),
+ std::complex<T>(std::numeric_limits<T>::max(), std::numeric_limits<T>::lowest()),
+ std::complex<T>(std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max()),
+ std::complex<T>(std::numeric_limits<T>::lowest(), std::numeric_limits<T>::lowest()),
};
-enum {zero, non_zero, maximum_value, inf, NaN, non_zero_nan};
+enum {zero, non_zero, lowest_value, maximum_value, inf, NaN, non_zero_nan};
template <class T, typename std::enable_if<std::is_floating_point<T>::value, int>::type = 0>
TEST_CONSTEXPR_CXX20 bool test_isinf(T v) {
@@ -235,6 +246,8 @@ classify(const std::complex<T>& x)
}
if (x.real() == std::numeric_limits<T>::max() || x.imag() == std::numeric_limits<T>::max())
return maximum_value;
+ if (x.real() == std::numeric_limits<T>::lowest() || x.imag() == std::numeric_limits<T>::lowest())
+ return lowest_value;
return non_zero;
}
@@ -251,6 +264,8 @@ classify(T x)
return NaN;
if (x == std::numeric_limits<T>::max())
return maximum_value;
+ if (x == std::numeric_limits<T>::lowest())
+ return lowest_value;
return non_zero;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
index 9f4b139574b029..bc0bdd0ec261dd 100644
--- a/libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
@@ -12,7 +12,7 @@
// complex<T>
// operator/(const complex<T>& lhs, const complex<T>& rhs); // constexpr in C++20
-// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=2000000
+// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=2131685
#include <cassert>
#include <complex>
@@ -55,6 +55,7 @@ test_edges()
case zero:
assert(classify(r) == NaN);
break;
+ case lowest_value:
case maximum_value:
continue; // not tested
case non_zero:
@@ -71,6 +72,7 @@ test_edges()
break;
}
break;
+ case lowest_value:
case maximum_value:
continue; // not tested
case non_zero:
@@ -78,6 +80,7 @@ test_edges()
case zero:
assert(classify(r) == inf);
break;
+ case lowest_value:
case maximum_value:
continue; // not tested
case non_zero:
@@ -99,6 +102,7 @@ test_edges()
case zero:
assert(classify(r) == inf);
break;
+ case lowest_value:
case maximum_value:
continue; // not tested
case non_zero:
@@ -120,6 +124,7 @@ test_edges()
case zero:
assert(classify(r) == NaN);
break;
+ case lowest_value:
case maximum_value:
continue; // not tested
case non_zero:
@@ -141,6 +146,7 @@ test_edges()
case zero:
assert(classify(r) == inf);
break;
+ case lowest_value:
case maximum_value:
continue; // not tested
case non_zero:
diff --git a/libcxx/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
index ebc5f03e58ed98..11256f651ffa78 100644
--- a/libcxx/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
@@ -12,7 +12,7 @@
// complex<T>
// operator*(const complex<T>& lhs, const complex<T>& rhs); // constexpr in C++20
-// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=2000000
+// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=2131685
#include <complex>
#include <cassert>
@@ -51,6 +51,7 @@ TEST_CONSTEXPR_CXX20 bool test_edges()
case zero:
switch (classification[j])
{
+ case lowest_value:
case maximum_value:
continue; // not tested
case zero:
@@ -64,6 +65,7 @@ TEST_CONSTEXPR_CXX20 bool test_edges()
break;
}
break;
+ case lowest_value:
case maximum_value:
continue; // not tested
case non_zero:
@@ -72,6 +74,7 @@ TEST_CONSTEXPR_CXX20 bool test_edges()
case zero:
assert(classify(r) == zero);
break;
+ case lowest_value:
case maximum_value:
continue; // not tested
case non_zero:
@@ -93,6 +96,7 @@ TEST_CONSTEXPR_CXX20 bool test_edges()
case NaN:
assert(classify(r) == NaN);
break;
+ case lowest_value:
case maximum_value:
continue; // not tested
case non_zero:
@@ -111,6 +115,7 @@ TEST_CONSTEXPR_CXX20 bool test_edges()
case inf:
assert(classify(r) == inf);
break;
+ case lowest_value:
case maximum_value:
continue; // not tested
case zero:
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
index 62693f18b46225..d98b1736930634 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
@@ -32,8 +32,6 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
-#include <print>
-
template<class T>
void test_edges()
{
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
index 1f2f9e9af4e576..64181649e8ba87 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
@@ -114,12 +114,19 @@ void test_edges()
}
else if (std::signbit(testcases<T>[i].imag()))
{
- assert(!std::signbit(r.real()) || approaching_zero(r.real()));
+ // FIXME(https://github.com/llvm/llvm-project/issues/122172): move `expected_pass` into
+ // assert once #122172 is fixed.
+ const bool expected_pass = !std::signbit(r.real()) || approaching_zero(r.real());
+ assert((i != 156 || std::is_same<T, double>::value) ? expected_pass : !expected_pass);
assert(std::signbit(r.imag()));
}
else
{
- assert(!std::signbit(r.real()) || approaching_zero(r.real()));
+
+ // FIXME(https://github.com/llvm/llvm-project/issues/122172): move `expected_pass` into
+ // assert once #122172 is fixed.
+ const bool expected_pass = !std::signbit(r.real()) || approaching_zero(r.real());
+ assert((i != 155 || std::is_same<T, double>::value) ? expected_pass : !expected_pass);
assert(!std::signbit(r.imag()));
}
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
index 486596c2e923a4..90e7aed7e2a486 100644
--- a/libcxx/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
@@ -39,10 +39,17 @@ void test_edges()
assert(r == 0);
assert(!std::signbit(r));
break;
+ case lowest_value: {
+ // It appears that `lowest<float> - relatively_small_number == lowest<float>`, so we check to
+ // make sure that abs was actually effective before asserting that it should be infinity.
+ bool const ineffective_abs = testcases<T>[i].real() + testcases<T>[i].imag() == -r;
+ assert((std::isinf(r) && r > 0) || ineffective_abs);
+ break;
+ }
case maximum_value: {
// It appears that `max<float> + relatively_small_number == max<float>`, so we check to
// make sure that abs was actually effective before asserting that it should be infinity.
- bool const ineffective_abs = (testcases<T>[i].real() + testcases<T>[i].imag()) == r;
+ bool const ineffective_abs = testcases<T>[i].real() + testcases<T>[i].imag() == r;
assert((std::isinf(r) && r > 0) || ineffective_abs);
break;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
index 6367f20a635953..2d7fa5c64fb516 100644
--- a/libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
@@ -53,6 +53,7 @@ void test_edges()
assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r));
}
break;
+ case lowest_value:
case maximum_value:
case non_zero:
if (testcases<T>[i].real() == 0)
diff --git a/libcxx/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
index b1a699e1113a3e..2589e8ba6d9d47 100644
--- a/libcxx/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
@@ -42,6 +42,7 @@ void test_edges()
case non_zero:
assert(std::isfinite(r) && r > 0);
break;
+ case lowest_value:
case maximum_value:
case inf:
assert(std::isinf(r) && r > 0);
diff --git a/libcxx/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
index 343ba9dbc51b4f..69f282d666c0b1 100644
--- a/libcxx/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
@@ -66,6 +66,7 @@ void test_edges()
assert(z == std::complex<T>());
}
break;
+ case lowest_value:
case maximum_value:
case non_zero:
if (std::signbit(r) || classify(theta) == inf || classify(theta) == NaN)
diff --git a/libcxx/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
index d523d49d8cdc87..e4b67b21ae5b30 100644
--- a/libcxx/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
@@ -46,6 +46,7 @@ void test_edges()
{
case zero:
case non_zero:
+ case lowest_value:
case maximum_value:
assert(r == testcases<T>[i]);
assert(std::signbit(real(r)) == std::signbit(real(testcases<T>[i])));
>From 2e9b0625d072981460d2f730dafedbda3891ac90 Mon Sep 17 00:00:00 2001
From: Christopher Di Bella <cjdb at google.com>
Date: Wed, 8 Jan 2025 23:53:35 +0000
Subject: [PATCH 3/4] applies clang-format
---
.../complex_divide_complex.pass.cpp | 9 +-
.../complex_times_complex.pass.cpp | 180 ++++++++---------
.../complex.transcendentals/acos.pass.cpp | 176 +++++++---------
.../complex.transcendentals/acosh.pass.cpp | 189 ++++++++----------
.../complex.transcendentals/asin.pass.cpp | 129 +++++-------
.../complex.transcendentals/asinh.pass.cpp | 145 ++++++--------
.../complex.transcendentals/atan.pass.cpp | 46 ++---
.../complex.transcendentals/atanh.pass.cpp | 153 ++++++--------
.../complex.transcendentals/cos.pass.cpp | 44 ++--
.../complex.transcendentals/cosh.pass.cpp | 133 +++++-------
.../complex.transcendentals/exp.pass.cpp | 124 +++++-------
.../complex.transcendentals/log.pass.cpp | 156 +++++++--------
.../complex.transcendentals/log10.pass.cpp | 42 ++--
.../pow_complex_complex.pass.cpp | 47 ++---
.../pow_complex_scalar.pass.cpp | 43 ++--
.../pow_scalar_complex.pass.cpp | 43 ++--
.../complex.transcendentals/sin.pass.cpp | 46 ++---
.../complex.transcendentals/sinh.pass.cpp | 135 +++++--------
.../complex.transcendentals/sqrt.pass.cpp | 155 ++++++--------
.../complex.transcendentals/tan.pass.cpp | 46 ++---
.../complex.transcendentals/tanh.pass.cpp | 105 ++++------
.../complex.value.ops/abs.pass.cpp | 79 ++++----
.../complex.value.ops/arg.pass.cpp | 173 +++++++---------
.../complex.value.ops/norm.pass.cpp | 55 +++--
.../complex.value.ops/polar.pass.cpp | 103 ++++------
.../complex.value.ops/proj.pass.cpp | 53 +++--
26 files changed, 1117 insertions(+), 1492 deletions(-)
diff --git a/libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
index bc0bdd0ec261dd..b5539f03a6dff1 100644
--- a/libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
@@ -34,11 +34,8 @@ test()
return true;
}
-template<class T>
-TEST_CONSTEXPR_CXX20
-bool
-test_edges()
-{
+template <class T>
+TEST_CONSTEXPR_CXX20 bool test_edges() {
const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
int classification[N];
for (unsigned i=0; i < N; ++i)
@@ -47,7 +44,7 @@ test_edges()
for (unsigned i = 0; i < N; ++i) {
auto const x = testcases<T>[i];
for (unsigned j = 0; j < N; ++j) {
- auto const y = testcases<T>[j];
+ auto const y = testcases<T>[j];
std::complex<T> r = x / y;
switch (classification[i]) {
case zero:
diff --git a/libcxx/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
index 11256f651ffa78..1ab89e13feb027 100644
--- a/libcxx/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
@@ -33,103 +33,95 @@ test()
// test edges
-template<class T>
-TEST_CONSTEXPR_CXX20 bool test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- int classification[N];
- for (unsigned i=0; i < N; ++i)
- classification[i] = classify(testcases<T>[i]);
+template <class T>
+TEST_CONSTEXPR_CXX20 bool test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ int classification[N];
+ for (unsigned i = 0; i < N; ++i)
+ classification[i] = classify(testcases<T>[i]);
- for (unsigned i = 0; i < N; ++i)
- {
- for (unsigned j = 0; j < N; ++j)
- {
- std::complex<T> r = testcases<T>[i] * testcases<T>[j];
- switch (classification[i])
- {
- case zero:
- switch (classification[j])
- {
- case lowest_value:
- case maximum_value:
- continue; // not tested
- case zero:
- case non_zero:
- assert(classify(r) == zero);
- break;
- case inf:
- case NaN:
- case non_zero_nan:
- assert(classify(r) == NaN);
- break;
- }
- break;
- case lowest_value:
- case maximum_value:
- continue; // not tested
- case non_zero:
- switch (classification[j])
- {
- case zero:
- assert(classify(r) == zero);
- break;
- case lowest_value:
- case maximum_value:
- continue; // not tested
- case non_zero:
- assert(classify(r) == non_zero);
- break;
- case inf:
- assert(classify(r) == inf);
- break;
- case NaN:
- case non_zero_nan:
- assert(classify(r) == NaN);
- break;
- }
- break;
- case inf:
- switch (classification[j])
- {
- case zero:
- case NaN:
- assert(classify(r) == NaN);
- break;
- case lowest_value:
- case maximum_value:
- continue; // not tested
- case non_zero:
- case inf:
- case non_zero_nan:
- assert(classify(r) == inf);
- break;
- }
- break;
- case NaN:
- assert(classify(r) == NaN);
- break;
- case non_zero_nan:
- switch (classification[j])
- {
- case inf:
- assert(classify(r) == inf);
- break;
- case lowest_value:
- case maximum_value:
- continue; // not tested
- case zero:
- case non_zero:
- case NaN:
- case non_zero_nan:
- assert(classify(r) == NaN);
- break;
- }
- break;
- }
+ for (unsigned i = 0; i < N; ++i) {
+ for (unsigned j = 0; j < N; ++j) {
+ std::complex<T> r = testcases<T>[i] * testcases<T>[j];
+ switch (classification[i]) {
+ case zero:
+ switch (classification[j]) {
+ case lowest_value:
+ case maximum_value:
+ continue; // not tested
+ case zero:
+ case non_zero:
+ assert(classify(r) == zero);
+ break;
+ case inf:
+ case NaN:
+ case non_zero_nan:
+ assert(classify(r) == NaN);
+ break;
+ }
+ break;
+ case lowest_value:
+ case maximum_value:
+ continue; // not tested
+ case non_zero:
+ switch (classification[j]) {
+ case zero:
+ assert(classify(r) == zero);
+ break;
+ case lowest_value:
+ case maximum_value:
+ continue; // not tested
+ case non_zero:
+ assert(classify(r) == non_zero);
+ break;
+ case inf:
+ assert(classify(r) == inf);
+ break;
+ case NaN:
+ case non_zero_nan:
+ assert(classify(r) == NaN);
+ break;
}
+ break;
+ case inf:
+ switch (classification[j]) {
+ case zero:
+ case NaN:
+ assert(classify(r) == NaN);
+ break;
+ case lowest_value:
+ case maximum_value:
+ continue; // not tested
+ case non_zero:
+ case inf:
+ case non_zero_nan:
+ assert(classify(r) == inf);
+ break;
+ }
+ break;
+ case NaN:
+ assert(classify(r) == NaN);
+ break;
+ case non_zero_nan:
+ switch (classification[j]) {
+ case inf:
+ assert(classify(r) == inf);
+ break;
+ case lowest_value:
+ case maximum_value:
+ continue; // not tested
+ case zero:
+ case non_zero:
+ case NaN:
+ case non_zero_nan:
+ assert(classify(r) == NaN);
+ break;
+ }
+ break;
+ }
}
- return true;
+ }
+ return true;
}
int main(int, char**)
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
index 50756f8ff9a53c..dcf53d64c66dac 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
@@ -32,110 +32,78 @@ test()
test(std::complex<T>(INFINITY, 1), std::complex<T>(0, -INFINITY));
}
-template<class T>
-void test_edges()
-{
- const T pi = std::atan2(+0., -0.);
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = acos(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- is_about(r.real(), pi/2);
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
- }
- else if (testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag()))
- {
- is_about(r.real(), pi/2);
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- is_about(r.real(), pi/2);
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && testcases<T>[i].real() != 0 && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isfinite(testcases<T>[i].imag()))
- {
- is_about(r.real(), pi);
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isfinite(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(!std::signbit(r.real()));
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isinf(testcases<T>[i].imag()))
- {
- is_about(r.real(), T(0.75) * pi);
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isinf(testcases<T>[i].imag()))
- {
- is_about(r.real(), T(0.25) * pi);
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isinf(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (!std::signbit(testcases<T>[i].real()) && !std::signbit(testcases<T>[i].imag()))
- {
- assert(!std::signbit(r.real()));
- assert( std::signbit(r.imag()));
- }
- else if (std::signbit(testcases<T>[i].real()) && !std::signbit(testcases<T>[i].imag()))
- {
- assert(!std::signbit(r.real()));
- assert( std::signbit(r.imag()));
- }
- else if (std::signbit(testcases<T>[i].real()) && std::signbit(testcases<T>[i].imag()))
- {
- assert(!std::signbit(r.real()));
- assert(!std::signbit(r.imag()));
- }
- else if (!std::signbit(testcases<T>[i].real()) && std::signbit(testcases<T>[i].imag()))
- {
- assert(!std::signbit(r.real()));
- assert(!std::signbit(r.imag()));
- }
- else
- {
- assert(!std::isnan(r.real()));
- assert(!std::isnan(r.imag()));
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
+template <class T>
+void test_edges() {
+ const T pi = std::atan2(+0., -0.);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = acos(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ is_about(r.real(), pi / 2);
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
+ } else if (testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag())) {
+ is_about(r.real(), pi / 2);
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ is_about(r.real(), pi / 2);
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && testcases<T>[i].real() != 0 &&
+ std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 &&
+ std::isfinite(testcases<T>[i].imag())) {
+ is_about(r.real(), pi);
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 &&
+ std::isfinite(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(!std::signbit(r.real()));
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isinf(testcases<T>[i].imag())) {
+ is_about(r.real(), T(0.75) * pi);
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isinf(testcases<T>[i].imag())) {
+ is_about(r.real(), T(0.25) * pi);
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isinf(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (!std::signbit(testcases<T>[i].real()) && !std::signbit(testcases<T>[i].imag())) {
+ assert(!std::signbit(r.real()));
+ assert(std::signbit(r.imag()));
+ } else if (std::signbit(testcases<T>[i].real()) && !std::signbit(testcases<T>[i].imag())) {
+ assert(!std::signbit(r.real()));
+ assert(std::signbit(r.imag()));
+ } else if (std::signbit(testcases<T>[i].real()) && std::signbit(testcases<T>[i].imag())) {
+ assert(!std::signbit(r.real()));
+ assert(!std::signbit(r.imag()));
+ } else if (!std::signbit(testcases<T>[i].real()) && std::signbit(testcases<T>[i].imag())) {
+ assert(!std::signbit(r.real()));
+ assert(!std::signbit(r.imag()));
+ } else {
+ assert(!std::isnan(r.real()));
+ assert(!std::isnan(r.imag()));
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
+ }
}
int main(int, char**)
@@ -147,5 +115,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
index ce580bdd507f80..fe2e0c67cade05 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
@@ -32,114 +32,87 @@ test()
test(std::complex<T>(INFINITY, 1), std::complex<T>(INFINITY, 0));
}
-template<class T>
-void test_edges()
-{
- const T pi = std::atan2(+0., -0.);
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = acosh(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- assert(!std::signbit(r.real()));
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi/2);
- else
- is_about(r.imag(), pi/2);
- }
- else if (testcases<T>[i].real() == 1 && testcases<T>[i].imag() == 0)
- {
- assert(r.real() == 0);
- assert(!std::signbit(r.real()));
- assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (testcases<T>[i].real() == -1 && testcases<T>[i].imag() == 0)
- {
- assert(r.real() == 0);
- assert(!std::signbit(r.real()));
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi);
- else
- is_about(r.imag(), pi);
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi/2);
- else
- is_about(r.imag(), pi/2);
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi);
- else
- is_about(r.imag(), pi);
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), T(-0.75) * pi);
- else
- is_about(r.imag(), T( 0.75) * pi);
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), T(-0.25 * pi));
- else
- is_about(r.imag(), T( 0.25 * pi));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else
- {
- assert(!std::signbit(r.real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
+template <class T>
+void test_edges() {
+ const T pi = std::atan2(+0., -0.);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = acosh(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ assert(!std::signbit(r.real()));
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi / 2);
+ else
+ is_about(r.imag(), pi / 2);
+ } else if (testcases<T>[i].real() == 1 && testcases<T>[i].imag() == 0) {
+ assert(r.real() == 0);
+ assert(!std::signbit(r.real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (testcases<T>[i].real() == -1 && testcases<T>[i].imag() == 0) {
+ assert(r.real() == 0);
+ assert(!std::signbit(r.real()));
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi);
+ else
+ is_about(r.imag(), pi);
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi / 2);
+ else
+ is_about(r.imag(), pi / 2);
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 &&
+ std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi);
+ else
+ is_about(r.imag(), pi);
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 &&
+ std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ assert(r.imag() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), T(-0.75) * pi);
+ else
+ is_about(r.imag(), T(0.75) * pi);
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), T(-0.25 * pi));
+ else
+ is_about(r.imag(), T(0.25 * pi));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else {
+ assert(!std::signbit(r.real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
+ }
}
int main(int, char**)
@@ -151,5 +124,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
index 4bd8b4fb186229..5694a736b4ece2 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
@@ -32,82 +32,59 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
-template<class T>
-void test_edges()
-{
- const T pi = std::atan2(+0., -0.);
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = asin(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if ( testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- if (testcases<T>[i].real() > 0)
- is_about(r.real(), pi/2);
- else
- is_about(r.real(), - pi/2);
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- if (std::signbit(testcases<T>[i].real()))
- is_about(r.real(), -pi/4);
- else
- is_about(r.real(), pi/4);
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].real()) != std::signbit(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isinf(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else
- {
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
+template <class T>
+void test_edges() {
+ const T pi = std::atan2(+0., -0.);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = asin(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ if (testcases<T>[i].real() > 0)
+ is_about(r.real(), pi / 2);
+ else
+ is_about(r.real(), -pi / 2);
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ if (std::signbit(testcases<T>[i].real()))
+ is_about(r.real(), -pi / 4);
+ else
+ is_about(r.real(), pi / 4);
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].real()) != std::signbit(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isinf(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else {
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
+ }
}
int main(int, char**)
@@ -119,5 +96,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
index 80b2c440c4a890..e44040dfabb7a5 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
@@ -32,91 +32,66 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
-template<class T>
-void test_edges()
-{
- const T pi = std::atan2(+0., -0.);
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = asinh(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (testcases<T>[i].real() == 0 && std::abs(testcases<T>[i].imag()) == 1)
- {
- assert(r.real() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi/2);
- else
- is_about(r.imag(), pi/2);
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi/2);
- else
- is_about(r.imag(), pi/2);
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi/4);
- else
- is_about(r.imag(), pi/4);
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
- {
- assert(std::isnan(r.real()));
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else
- {
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
+template <class T>
+void test_edges() {
+ const T pi = std::atan2(+0., -0.);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = asinh(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (testcases<T>[i].real() == 0 && std::abs(testcases<T>[i].imag()) == 1) {
+ assert(r.real() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi / 2);
+ else
+ is_about(r.imag(), pi / 2);
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi / 2);
+ else
+ is_about(r.imag(), pi / 2);
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi / 4);
+ else
+ is_about(r.imag(), pi / 4);
+ } else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0) {
+ assert(std::isnan(r.real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else {
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
+ }
}
int main(int, char**)
@@ -128,5 +103,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
index 6901069d5e2848..a8da42b0c03516 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
@@ -32,31 +32,27 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = atan(testcases<T>[i]);
- std::complex<T> t1(-imag(testcases<T>[i]), real(testcases<T>[i]));
- std::complex<T> t2 = atanh(t1);
- std::complex<T> z(imag(t2), -real(t2));
- if (std::isnan(real(r)))
- assert(std::isnan(real(z)));
- else
- {
- assert(real(r) == real(z));
- assert(std::signbit(real(r)) == std::signbit(real(z)));
- }
- if (std::isnan(imag(r)))
- assert(std::isnan(imag(z)));
- else
- {
- assert(imag(r) == imag(z));
- assert(std::signbit(imag(r)) == std::signbit(imag(z)));
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = atan(testcases<T>[i]);
+ std::complex<T> t1(-imag(testcases<T>[i]), real(testcases<T>[i]));
+ std::complex<T> t2 = atanh(t1);
+ std::complex<T> z(imag(t2), -real(t2));
+ if (std::isnan(real(r)))
+ assert(std::isnan(real(z)));
+ else {
+ assert(real(r) == real(z));
+ assert(std::signbit(real(r)) == std::signbit(real(z)));
+ }
+ if (std::isnan(imag(r)))
+ assert(std::isnan(imag(z)));
+ else {
+ assert(imag(r) == imag(z));
+ assert(std::signbit(imag(r)) == std::signbit(imag(z)));
}
+ }
}
int main(int, char**)
@@ -68,5 +64,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
index 2b8d79f21baf06..c75ffad2ef51f0 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
@@ -32,95 +32,70 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
-template<class T>
-void test_edges()
-{
- const T pi = std::atan2(+0., -0.);
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = atanh(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if ( testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::abs(testcases<T>[i].real()) == 1 && testcases<T>[i].imag() == 0)
- {
- assert(std::isinf(r.real()));
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- if (testcases<T>[i].imag() > 0)
- is_about(r.imag(), pi/2);
- else
- is_about(r.imag(), -pi/2);
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi/2);
- else
- is_about(r.imag(), pi/2);
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi/2);
- else
- is_about(r.imag(), pi/2);
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi/2);
- else
- is_about(r.imag(), pi/2);
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else
- {
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
+template <class T>
+void test_edges() {
+ const T pi = std::atan2(+0., -0.);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = atanh(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::abs(testcases<T>[i].real()) == 1 && testcases<T>[i].imag() == 0) {
+ assert(std::isinf(r.real()));
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ if (testcases<T>[i].imag() > 0)
+ is_about(r.imag(), pi / 2);
+ else
+ is_about(r.imag(), -pi / 2);
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi / 2);
+ else
+ is_about(r.imag(), pi / 2);
+ } else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi / 2);
+ else
+ is_about(r.imag(), pi / 2);
+ } else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi / 2);
+ else
+ is_about(r.imag(), pi / 2);
+ } else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else {
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
+ }
}
int main(int, char**)
@@ -132,5 +107,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
index 922b0c87706b4c..9a9b3209e61be6 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
@@ -32,30 +32,26 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(1, 0));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = cos(testcases<T>[i]);
- std::complex<T> t1(-imag(testcases<T>[i]), real(testcases<T>[i]));
- std::complex<T> z = cosh(t1);
- if (std::isnan(real(r)))
- assert(std::isnan(real(z)));
- else
- {
- assert(real(r) == real(z));
- assert(std::signbit(real(r)) == std::signbit(real(z)));
- }
- if (std::isnan(imag(r)))
- assert(std::isnan(imag(z)));
- else
- {
- assert(imag(r) == imag(z));
- assert(std::signbit(imag(r)) == std::signbit(imag(z)));
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = cos(testcases<T>[i]);
+ std::complex<T> t1(-imag(testcases<T>[i]), real(testcases<T>[i]));
+ std::complex<T> z = cosh(t1);
+ if (std::isnan(real(r)))
+ assert(std::isnan(real(z)));
+ else {
+ assert(real(r) == real(z));
+ assert(std::signbit(real(r)) == std::signbit(real(z)));
+ }
+ if (std::isnan(imag(r)))
+ assert(std::isnan(imag(z)));
+ else {
+ assert(imag(r) == imag(z));
+ assert(std::signbit(imag(r)) == std::signbit(imag(z)));
}
+ }
}
int main(int, char**)
@@ -67,5 +63,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
index 4fbec0cb6a6b00..bdda26c561db3f 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
@@ -32,87 +32,60 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(1, 0));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = cosh(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- assert(r.real() == 1);
- assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (testcases<T>[i].real() == 0 && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(r.imag() == 0);
- }
- else if (testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(r.imag() == 0);
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
- {
- assert(std::isinf(r.real()));
- assert(!std::signbit(r.real()));
- assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::signbit(r.real()) == std::signbit(cos(testcases<T>[i].imag())));
- assert(std::isinf(r.imag()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].real() * sin(testcases<T>[i].imag())));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
- {
- assert(std::isnan(r.real()));
- assert(r.imag() == 0);
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(!std::isnan(r.real()));
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = cosh(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ assert(r.real() == 1);
+ assert(r.imag() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (testcases<T>[i].real() == 0 && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(r.imag() == 0);
+ } else if (testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(r.imag() == 0);
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].imag() == 0) {
+ assert(std::isinf(r.real()));
+ assert(!std::signbit(r.real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::signbit(r.real()) == std::signbit(cos(testcases<T>[i].imag())));
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].real() * sin(testcases<T>[i].imag())));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0) {
+ assert(std::isnan(r.real()));
+ assert(r.imag() == 0);
+ } else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(!std::isnan(r.real()));
- bool const nan_okay = std::isinf(r.real()) && testcases<T>[i].imag() == 0; // inf * 0 == NaN
- assert(!std::isnan(r.imag()) || nan_okay);
- }
+ bool const nan_okay = std::isinf(r.real()) && testcases<T>[i].imag() == 0; // inf * 0 == NaN
+ assert(!std::isnan(r.imag()) || nan_okay);
}
+ }
}
int main(int, char**)
@@ -124,5 +97,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
index efc9b867ebe1ef..81686a6a6b8689 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
@@ -32,82 +32,56 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(1, 0));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = exp(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- assert(r.real() == 1.0);
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && testcases<T>[i].imag() == 0)
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isinf(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(r.imag() == 0);
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isnan(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(r.imag() == 0);
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
- {
- assert(std::isnan(r.real()));
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() != 0)
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].imag()) && std::abs(testcases<T>[i].imag()) <= 1)
- {
- assert(!std::signbit(r.real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isinf(r.real()) && testcases<T>[i].imag() == 0) {
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = exp(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ assert(r.real() == 1.0);
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && testcases<T>[i].imag() == 0) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isinf(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(r.imag() == 0);
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isnan(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(r.imag() == 0);
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0) {
+ assert(std::isnan(r.real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() != 0) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].imag()) && std::abs(testcases<T>[i].imag()) <= 1) {
+ assert(!std::signbit(r.real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isinf(r.real()) && testcases<T>[i].imag() == 0) {
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
}
+ }
}
int main(int, char**)
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
index b1737f0de54ac4..94b348a962f1d1 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
@@ -32,95 +32,73 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(-INFINITY, 0));
}
-template<class T>
-void test_edges()
-{
- const T pi = std::atan2(+0., -0.);
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = log(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- if (std::signbit(testcases<T>[i].real()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() < 0);
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi);
- else
- is_about(r.imag(), pi);
- }
- else
- {
- assert(std::isinf(r.real()));
- assert(r.real() < 0);
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- if (testcases<T>[i].imag() > 0)
- is_about(r.imag(), pi/2);
- else
- is_about(r.imag(), -pi/2);
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()) && r.real() > 0);
- if (r.imag() > 0)
- is_about(r.imag(), pi);
- else
- is_about(r.imag(), -pi);
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()) && r.real() > 0);
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (testcases<T>[i].real() == 1 && testcases<T>[i].imag() == 0)
- {
- assert(r.real() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 1)
- {
- assert(r.real() == 0);
- is_about(r.imag(), pi/2);
- }
- else if (testcases<T>[i].real() == -1 && testcases<T>[i].imag() == 0)
- {
- assert(r.real() == 0);
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi);
- else
- is_about(r.imag(), pi);
- }
- else if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == -1)
- {
- assert(r.real() == 0);
- is_about(r.imag(), -pi/2);
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()) && abs(testcases<T>[i]) < 1)
- {
- assert( std::signbit(r.real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()) && abs(testcases<T>[i]) > 1)
- {
- assert(!std::signbit(r.real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
+template <class T>
+void test_edges() {
+ const T pi = std::atan2(+0., -0.);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = log(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ if (std::signbit(testcases<T>[i].real())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() < 0);
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi);
+ else
+ is_about(r.imag(), pi);
+ } else {
+ assert(std::isinf(r.real()));
+ assert(r.real() < 0);
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ }
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ if (testcases<T>[i].imag() > 0)
+ is_about(r.imag(), pi / 2);
+ else
+ is_about(r.imag(), -pi / 2);
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 &&
+ std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()) && r.real() > 0);
+ if (r.imag() > 0)
+ is_about(r.imag(), pi);
+ else
+ is_about(r.imag(), -pi);
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 &&
+ std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()) && r.real() > 0);
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (testcases<T>[i].real() == 1 && testcases<T>[i].imag() == 0) {
+ assert(r.real() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 1) {
+ assert(r.real() == 0);
+ is_about(r.imag(), pi / 2);
+ } else if (testcases<T>[i].real() == -1 && testcases<T>[i].imag() == 0) {
+ assert(r.real() == 0);
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi);
+ else
+ is_about(r.imag(), pi);
+ } else if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == -1) {
+ assert(r.real() == 0);
+ is_about(r.imag(), -pi / 2);
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()) &&
+ abs(testcases<T>[i]) < 1) {
+ assert(std::signbit(r.real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()) &&
+ abs(testcases<T>[i]) > 1) {
+ assert(!std::signbit(r.real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
+ }
}
int main(int, char**)
@@ -132,5 +110,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
index ae4fa59fb2c981..3d0219b9a42c15 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
@@ -32,29 +32,25 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(-INFINITY, 0));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = log10(testcases<T>[i]);
- std::complex<T> z = log(testcases<T>[i])/std::log(T(10));
- if (std::isnan(real(r)))
- assert(std::isnan(real(z)));
- else
- {
- assert(real(r) == real(z));
- assert(std::signbit(real(r)) == std::signbit(real(z)));
- }
- if (std::isnan(imag(r)))
- assert(std::isnan(imag(z)));
- else
- {
- assert(imag(r) == imag(z));
- assert(std::signbit(imag(r)) == std::signbit(imag(z)));
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = log10(testcases<T>[i]);
+ std::complex<T> z = log(testcases<T>[i]) / std::log(T(10));
+ if (std::isnan(real(r)))
+ assert(std::isnan(real(z)));
+ else {
+ assert(real(r) == real(z));
+ assert(std::signbit(real(r)) == std::signbit(real(z)));
+ }
+ if (std::isnan(imag(r)))
+ assert(std::isnan(imag(z)));
+ else {
+ assert(imag(r) == imag(z));
+ assert(std::signbit(imag(r)) == std::signbit(imag(z)));
}
+ }
}
int main(int, char**)
@@ -66,5 +62,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
index 9bddbd0408a38d..f10129466a1143 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
@@ -34,32 +34,27 @@ test()
test(std::complex<T>(2, 3), std::complex<T>(2, 0), std::complex<T>(-5, 12));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- for (unsigned j = 0; j < N; ++j)
- {
- std::complex<T> r = pow(testcases<T>[i], testcases<T>[j]);
- std::complex<T> z = exp(testcases<T>[j] * log(testcases<T>[i]));
- if (std::isnan(real(r)))
- assert(std::isnan(real(z)));
- else
- {
- assert(real(r) == real(z));
- assert(std::signbit(real(r)) == std::signbit(real(z)));
- }
- if (std::isnan(imag(r)))
- assert(std::isnan(imag(z)));
- else
- {
- assert(imag(r) == imag(z));
- assert(std::signbit(imag(r)) == std::signbit(imag(z)));
- }
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ for (unsigned j = 0; j < N; ++j) {
+ std::complex<T> r = pow(testcases<T>[i], testcases<T>[j]);
+ std::complex<T> z = exp(testcases<T>[j] * log(testcases<T>[i]));
+ if (std::isnan(real(r)))
+ assert(std::isnan(real(z)));
+ else {
+ assert(real(r) == real(z));
+ assert(std::signbit(real(r)) == std::signbit(real(z)));
+ }
+ if (std::isnan(imag(r)))
+ assert(std::isnan(imag(z)));
+ else {
+ assert(imag(r) == imag(z));
+ assert(std::signbit(imag(r)) == std::signbit(imag(z)));
+ }
}
+ }
}
int main(int, char**)
@@ -71,5 +66,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
index 1bbc211a09c3ae..919512fb21a6b0 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
@@ -34,30 +34,25 @@ test()
test(std::complex<T>(2, 3), T(2), std::complex<T>(-5, 12));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- for (unsigned j = 0; j < N; ++j)
- {
- std::complex<T> r = pow(testcases<T>[i], real(testcases<T>[j]));
- std::complex<T> z = exp(std::complex<T>(real(testcases<T>[j])) * log(testcases<T>[i]));
- if (std::isnan(real(r)))
- assert(std::isnan(real(z)));
- else
- {
- assert(real(r) == real(z));
- }
- if (std::isnan(imag(r)))
- assert(std::isnan(imag(z)));
- else
- {
- assert(imag(r) == imag(z));
- }
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ for (unsigned j = 0; j < N; ++j) {
+ std::complex<T> r = pow(testcases<T>[i], real(testcases<T>[j]));
+ std::complex<T> z = exp(std::complex<T>(real(testcases<T>[j])) * log(testcases<T>[i]));
+ if (std::isnan(real(r)))
+ assert(std::isnan(real(z)));
+ else {
+ assert(real(r) == real(z));
+ }
+ if (std::isnan(imag(r)))
+ assert(std::isnan(imag(z)));
+ else {
+ assert(imag(r) == imag(z));
+ }
}
+ }
}
int main(int, char**)
@@ -69,5 +64,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
index 05bd55ef2a72a8..d41e8defb8a61e 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
@@ -34,30 +34,25 @@ test()
test(T(2), std::complex<T>(2), std::complex<T>(4));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- for (unsigned j = 0; j < N; ++j)
- {
- std::complex<T> r = pow(real(testcases<T>[i]), testcases<T>[j]);
- std::complex<T> z = exp(testcases<T>[j] * log(std::complex<T>(real(testcases<T>[i]))));
- if (std::isnan(real(r)))
- assert(std::isnan(real(z)));
- else
- {
- assert(real(r) == real(z));
- }
- if (std::isnan(imag(r)))
- assert(std::isnan(imag(z)));
- else
- {
- assert(imag(r) == imag(z));
- }
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ for (unsigned j = 0; j < N; ++j) {
+ std::complex<T> r = pow(real(testcases<T>[i]), testcases<T>[j]);
+ std::complex<T> z = exp(testcases<T>[j] * log(std::complex<T>(real(testcases<T>[i]))));
+ if (std::isnan(real(r)))
+ assert(std::isnan(real(z)));
+ else {
+ assert(real(r) == real(z));
+ }
+ if (std::isnan(imag(r)))
+ assert(std::isnan(imag(z)));
+ else {
+ assert(imag(r) == imag(z));
+ }
}
+ }
}
int main(int, char**)
@@ -69,5 +64,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
index d54c745781bee5..1876cf44379841 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
@@ -32,31 +32,27 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = sin(testcases<T>[i]);
- std::complex<T> t1(-imag(testcases<T>[i]), real(testcases<T>[i]));
- std::complex<T> t2 = sinh(t1);
- std::complex<T> z(imag(t2), -real(t2));
- if (std::isnan(real(r)))
- assert(std::isnan(real(z)));
- else
- {
- assert(real(r) == real(z));
- assert(std::signbit(real(r)) == std::signbit(real(z)));
- }
- if (std::isnan(imag(r)))
- assert(std::isnan(imag(z)));
- else
- {
- assert(imag(r) == imag(z));
- assert(std::signbit(imag(r)) == std::signbit(imag(z)));
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = sin(testcases<T>[i]);
+ std::complex<T> t1(-imag(testcases<T>[i]), real(testcases<T>[i]));
+ std::complex<T> t2 = sinh(t1);
+ std::complex<T> z(imag(t2), -real(t2));
+ if (std::isnan(real(r)))
+ assert(std::isnan(real(z)));
+ else {
+ assert(real(r) == real(z));
+ assert(std::signbit(real(r)) == std::signbit(real(z)));
+ }
+ if (std::isnan(imag(r)))
+ assert(std::isnan(imag(z)));
+ else {
+ assert(imag(r) == imag(z));
+ assert(std::signbit(imag(r)) == std::signbit(imag(z)));
}
+ }
}
int main(int, char**)
@@ -68,5 +64,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
index d98b1736930634..cf38b6aa7d91c6 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
@@ -32,88 +32,61 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = sinh(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- assert(r.real() == 0);
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
- assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (testcases<T>[i].real() == 0 && std::isinf(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
- {
- assert(std::isinf(r.real()));
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
- assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real() * cos(testcases<T>[i].imag())));
- assert(std::isinf(r.imag()));
- assert(std::signbit(r.imag()) == std::signbit(sin(testcases<T>[i].imag())));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
- {
- assert(std::isnan(r.real()));
- assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(!std::isnan(r.real()));
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = sinh(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ assert(r.real() == 0);
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (testcases<T>[i].real() == 0 && std::isinf(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].imag() == 0) {
+ assert(std::isinf(r.real()));
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real() * cos(testcases<T>[i].imag())));
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(r.imag()) == std::signbit(sin(testcases<T>[i].imag())));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0) {
+ assert(std::isnan(r.real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(!std::isnan(r.real()));
- bool const nan_okay = std::isinf(r.real()) && testcases<T>[i].imag() == 0; // inf * 0 == NaN
- assert(!std::isnan(r.imag()) || nan_okay);
- }
+ bool const nan_okay = std::isinf(r.real()) && testcases<T>[i].imag() == 0; // inf * 0 == NaN
+ assert(!std::isnan(r.imag()) || nan_okay);
}
+ }
}
int main(int, char**)
@@ -125,5 +98,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
index 64181649e8ba87..58b4ee25458523 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
@@ -38,98 +38,73 @@ test()
// cosine calculations for std::arg terminate at different times based on the precision of T,
// and can produce a very small negative number instead of a very small positive one, so we
// should actually check that we're really close to zero instead of positive.
-template<class T>
-bool approaching_zero(const T value)
-{
- auto in_range = [value](const T low, const T high) {
- return low < value && value < high;
- };
- if constexpr (std::is_same_v<T, float>) {
- return value == -0.0f || in_range(-4.38e-5f, 4.38e-5f);
- }
- else if constexpr (std::is_same_v<T, double>) {
- return false;
- }
- else if constexpr (std::is_same_v<T, long double>) {
- return value == -0.0f || in_range(-3.0e-17L, 3.0e-17L);
- }
- else {
- std::abort();
- }
+template <class T>
+bool approaching_zero(const T value) {
+ auto in_range = [value](const T low, const T high) { return low < value && value < high; };
+ if constexpr (std::is_same_v<T, float>) {
+ return value == -0.0f || in_range(-4.38e-5f, 4.38e-5f);
+ } else if constexpr (std::is_same_v<T, double>) {
+ return false;
+ } else if constexpr (std::is_same_v<T, long double>) {
+ return value == -0.0f || in_range(-3.0e-17L, 3.0e-17L);
+ } else {
+ std::abort();
+ }
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = sqrt(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- assert(!std::signbit(r.real()) || approaching_zero(r.real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- assert(std::isinf(r.imag()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isfinite(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(!std::signbit(r.real()));
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isinf(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && (std::isfinite(testcases<T>[i].imag()) || std::isnan(testcases<T>[i].imag())))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::signbit(testcases<T>[i].imag()))
- {
- // FIXME(https://github.com/llvm/llvm-project/issues/122172): move `expected_pass` into
- // assert once #122172 is fixed.
- const bool expected_pass = !std::signbit(r.real()) || approaching_zero(r.real());
- assert((i != 156 || std::is_same<T, double>::value) ? expected_pass : !expected_pass);
- assert(std::signbit(r.imag()));
- }
- else
- {
-
- // FIXME(https://github.com/llvm/llvm-project/issues/122172): move `expected_pass` into
- // assert once #122172 is fixed.
- const bool expected_pass = !std::signbit(r.real()) || approaching_zero(r.real());
- assert((i != 155 || std::is_same<T, double>::value) ? expected_pass : !expected_pass);
- assert(!std::signbit(r.imag()));
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = sqrt(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ assert(!std::signbit(r.real()) || approaching_zero(r.real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 &&
+ std::isfinite(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(!std::signbit(r.real()));
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 &&
+ std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isinf(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) &&
+ (std::isfinite(testcases<T>[i].imag()) || std::isnan(testcases<T>[i].imag()))) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::signbit(testcases<T>[i].imag())) {
+ // FIXME(https://github.com/llvm/llvm-project/issues/122172): move `expected_pass` into
+ // assert once #122172 is fixed.
+ const bool expected_pass = !std::signbit(r.real()) || approaching_zero(r.real());
+ assert((i != 156 || std::is_same<T, double>::value) ? expected_pass : !expected_pass);
+ assert(std::signbit(r.imag()));
+ } else {
+ // FIXME(https://github.com/llvm/llvm-project/issues/122172): move `expected_pass` into
+ // assert once #122172 is fixed.
+ const bool expected_pass = !std::signbit(r.real()) || approaching_zero(r.real());
+ assert((i != 155 || std::is_same<T, double>::value) ? expected_pass : !expected_pass);
+ assert(!std::signbit(r.imag()));
}
+ }
}
int main(int, char**)
@@ -141,5 +116,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
index dc946a7808b628..5b881fe8f3f07c 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
@@ -33,31 +33,27 @@ test()
test(std::complex<T>(10000, -10000), std::complex<T>(0, -1));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = tan(testcases<T>[i]);
- std::complex<T> t1(-imag(testcases<T>[i]), real(testcases<T>[i]));
- std::complex<T> t2 = tanh(t1);
- std::complex<T> z(imag(t2), -real(t2));
- if (std::isnan(real(r)))
- assert(std::isnan(real(z)));
- else
- {
- assert(real(r) == real(z));
- assert(std::signbit(real(r)) == std::signbit(real(z)));
- }
- if (std::isnan(imag(r)))
- assert(std::isnan(imag(z)));
- else
- {
- assert(imag(r) == imag(z));
- assert(std::signbit(imag(r)) == std::signbit(imag(z)));
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = tan(testcases<T>[i]);
+ std::complex<T> t1(-imag(testcases<T>[i]), real(testcases<T>[i]));
+ std::complex<T> t2 = tanh(t1);
+ std::complex<T> z(imag(t2), -real(t2));
+ if (std::isnan(real(r)))
+ assert(std::isnan(real(z)));
+ else {
+ assert(real(r) == real(z));
+ assert(std::signbit(real(r)) == std::signbit(real(z)));
+ }
+ if (std::isnan(imag(r)))
+ assert(std::isnan(imag(z)));
+ else {
+ assert(imag(r) == imag(z));
+ assert(std::signbit(imag(r)) == std::signbit(imag(z)));
}
+ }
}
int main(int, char**)
@@ -69,5 +65,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
index ebb27f82bf114f..5d9b64923938ba 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
@@ -32,69 +32,48 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = tanh(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- assert(r.real() == 0);
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
- assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(r.real() == (testcases<T>[i].real() > 0 ? 1 : -1));
- assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(sin(2 * testcases<T>[i].imag())));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(r.real() == (testcases<T>[i].real() > 0 ? 1 : -1));
- assert(r.imag() == 0);
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(r.real() == (testcases<T>[i].real() > 0 ? 1 : -1));
- assert(r.imag() == 0);
- }
- else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
- {
- assert(std::isnan(r.real()));
- assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- [[maybe_unused]] auto const x = testcases<T>[i];
- assert(!std::isnan(r.real()));
- assert(!std::isnan(r.imag()));
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = tanh(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ assert(r.real() == 0);
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(r.real() == (testcases<T>[i].real() > 0 ? 1 : -1));
+ assert(r.imag() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(sin(2 * testcases<T>[i].imag())));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(r.real() == (testcases<T>[i].real() > 0 ? 1 : -1));
+ assert(r.imag() == 0);
+ } else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(r.real() == (testcases<T>[i].real() > 0 ? 1 : -1));
+ assert(r.imag() == 0);
+ } else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0) {
+ assert(std::isnan(r.real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ [[maybe_unused]] auto const x = testcases<T>[i];
+ assert(!std::isnan(r.real()));
+ assert(!std::isnan(r.imag()));
}
+ }
}
int main(int, char**)
@@ -106,5 +85,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
index 90e7aed7e2a486..2f56e7d621c566 100644
--- a/libcxx/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
@@ -26,47 +26,44 @@ test()
assert(abs(z) == 5);
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- T r = abs(testcases<T>[i]);
- switch (classify(testcases<T>[i]))
- {
- case zero:
- assert(r == 0);
- assert(!std::signbit(r));
- break;
- case lowest_value: {
- // It appears that `lowest<float> - relatively_small_number == lowest<float>`, so we check to
- // make sure that abs was actually effective before asserting that it should be infinity.
- bool const ineffective_abs = testcases<T>[i].real() + testcases<T>[i].imag() == -r;
- assert((std::isinf(r) && r > 0) || ineffective_abs);
- break;
- }
- case maximum_value: {
- // It appears that `max<float> + relatively_small_number == max<float>`, so we check to
- // make sure that abs was actually effective before asserting that it should be infinity.
- bool const ineffective_abs = testcases<T>[i].real() + testcases<T>[i].imag() == r;
- assert((std::isinf(r) && r > 0) || ineffective_abs);
- break;
- }
- case non_zero:
- assert(std::isfinite(r) && r > 0);
- break;
- case inf:
- assert(std::isinf(r) && r > 0);
- break;
- case NaN:
- assert(std::isnan(r));
- break;
- case non_zero_nan:
- assert(std::isnan(r));
- break;
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ T r = abs(testcases<T>[i]);
+ switch (classify(testcases<T>[i])) {
+ case zero:
+ assert(r == 0);
+ assert(!std::signbit(r));
+ break;
+ case lowest_value: {
+ // It appears that `lowest<float> - relatively_small_number == lowest<float>`, so we check to
+ // make sure that abs was actually effective before asserting that it should be infinity.
+ bool const ineffective_abs = testcases<T>[i].real() + testcases<T>[i].imag() == -r;
+ assert((std::isinf(r) && r > 0) || ineffective_abs);
+ break;
+ }
+ case maximum_value: {
+ // It appears that `max<float> + relatively_small_number == max<float>`, so we check to
+ // make sure that abs was actually effective before asserting that it should be infinity.
+ bool const ineffective_abs = testcases<T>[i].real() + testcases<T>[i].imag() == r;
+ assert((std::isinf(r) && r > 0) || ineffective_abs);
+ break;
+ }
+ case non_zero:
+ assert(std::isfinite(r) && r > 0);
+ break;
+ case inf:
+ assert(std::isinf(r) && r > 0);
+ break;
+ case NaN:
+ assert(std::isnan(r));
+ break;
+ case non_zero_nan:
+ assert(std::isnan(r));
+ break;
}
+ }
}
int main(int, char**)
@@ -78,5 +75,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
index 2d7fa5c64fb516..40e2a4940d273d 100644
--- a/libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
@@ -26,107 +26,82 @@ test()
assert(arg(z) == 0);
}
-template<class T>
-void test_edges()
-{
- const T pi = std::atan2(T(+0.), T(-0.));
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- T r = arg(testcases<T>[i]);
- if (std::isnan(testcases<T>[i].real()) || std::isnan(testcases<T>[i].imag()))
- assert(std::isnan(r));
+template <class T>
+void test_edges() {
+ const T pi = std::atan2(T(+0.), T(-0.));
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ T r = arg(testcases<T>[i]);
+ if (std::isnan(testcases<T>[i].real()) || std::isnan(testcases<T>[i].imag()))
+ assert(std::isnan(r));
+ else {
+ switch (classify(testcases<T>[i])) {
+ case zero:
+ if (std::signbit(testcases<T>[i].real())) {
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r, -pi);
+ else
+ is_about(r, pi);
+ } else {
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r));
+ }
+ break;
+ case lowest_value:
+ case maximum_value:
+ case non_zero:
+ if (testcases<T>[i].real() == 0) {
+ if (testcases<T>[i].imag() < 0)
+ is_about(r, -pi / 2);
+ else
+ is_about(r, pi / 2);
+ } else if (testcases<T>[i].imag() == 0) {
+ if (testcases<T>[i].real() < 0) {
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r, -pi);
+ else
+ is_about(r, pi);
+ } else {
+ assert(r == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r));
+ }
+ } else if (testcases<T>[i].imag() > 0)
+ assert(r > 0);
else
- {
- switch (classify(testcases<T>[i]))
- {
- case zero:
- if (std::signbit(testcases<T>[i].real()))
- {
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r, -pi);
- else
- is_about(r, pi);
- }
- else
- {
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r));
- }
- break;
- case lowest_value:
- case maximum_value:
- case non_zero:
- if (testcases<T>[i].real() == 0)
- {
- if (testcases<T>[i].imag() < 0)
- is_about(r, -pi/2);
- else
- is_about(r, pi/2);
- }
- else if (testcases<T>[i].imag() == 0)
- {
- if (testcases<T>[i].real() < 0)
- {
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r, -pi);
- else
- is_about(r, pi);
- }
- else
- {
- assert(r == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r));
- }
- }
- else if (testcases<T>[i].imag() > 0)
- assert(r > 0);
- else
- assert(r < 0);
- break;
- case inf:
- if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- if (testcases<T>[i].real() < 0)
- {
- if (testcases<T>[i].imag() > 0)
- is_about(r, T( 0.75) * pi);
- else
- is_about(r, T(-0.75) * pi);
- }
- else
- {
- if (testcases<T>[i].imag() > 0)
- is_about(r, T( 0.25) * pi);
- else
- is_about(r, T(-0.25) * pi);
- }
- }
- else if (std::isinf(testcases<T>[i].real()))
- {
- if (testcases<T>[i].real() < 0)
- {
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r, -pi);
- else
- is_about(r, pi);
- }
- else
- {
- assert(r == 0);
- assert(std::signbit(r) == std::signbit(testcases<T>[i].imag()));
- }
- }
- else
- {
- if (testcases<T>[i].imag() < 0)
- is_about(r, -pi/2);
- else
- is_about(r, pi/2);
- }
- break;
- }
+ assert(r < 0);
+ break;
+ case inf:
+ if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ if (testcases<T>[i].real() < 0) {
+ if (testcases<T>[i].imag() > 0)
+ is_about(r, T(0.75) * pi);
+ else
+ is_about(r, T(-0.75) * pi);
+ } else {
+ if (testcases<T>[i].imag() > 0)
+ is_about(r, T(0.25) * pi);
+ else
+ is_about(r, T(-0.25) * pi);
+ }
+ } else if (std::isinf(testcases<T>[i].real())) {
+ if (testcases<T>[i].real() < 0) {
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r, -pi);
+ else
+ is_about(r, pi);
+ } else {
+ assert(r == 0);
+ assert(std::signbit(r) == std::signbit(testcases<T>[i].imag()));
+ }
+ } else {
+ if (testcases<T>[i].imag() < 0)
+ is_about(r, -pi / 2);
+ else
+ is_about(r, pi / 2);
}
+ break;
+ }
}
+ }
}
int main(int, char**)
@@ -138,5 +113,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
index 2589e8ba6d9d47..f0d481d50617e2 100644
--- a/libcxx/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
@@ -26,35 +26,32 @@ test()
assert(norm(z) == 25);
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- T r = norm(testcases<T>[i]);
- switch (classify(testcases<T>[i]))
- {
- case zero:
- assert(r == 0);
- assert(!std::signbit(r));
- break;
- case non_zero:
- assert(std::isfinite(r) && r > 0);
- break;
- case lowest_value:
- case maximum_value:
- case inf:
- assert(std::isinf(r) && r > 0);
- break;
- case NaN:
- assert(std::isnan(r));
- break;
- case non_zero_nan:
- assert(std::isnan(r));
- break;
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ T r = norm(testcases<T>[i]);
+ switch (classify(testcases<T>[i])) {
+ case zero:
+ assert(r == 0);
+ assert(!std::signbit(r));
+ break;
+ case non_zero:
+ assert(std::isfinite(r) && r > 0);
+ break;
+ case lowest_value:
+ case maximum_value:
+ case inf:
+ assert(std::isinf(r) && r > 0);
+ break;
+ case NaN:
+ assert(std::isnan(r));
+ break;
+ case non_zero_nan:
+ assert(std::isnan(r));
+ break;
}
+ }
}
int main(int, char**)
@@ -66,5 +63,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
index 69f282d666c0b1..91c5f439dcfdd6 100644
--- a/libcxx/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
@@ -44,66 +44,51 @@ test()
test(T(100), T(0), std::complex<T>(100, 0));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- T r = real(testcases<T>[i]);
- T theta = imag(testcases<T>[i]);
- std::complex<T> z = std::polar(r, theta);
- switch (classify(r))
- {
- case zero:
- if (std::signbit(r) || classify(theta) == inf || classify(theta) == NaN)
- {
- int c = classify(z);
- assert(c == NaN || c == non_zero_nan);
- }
- else
- {
- assert(z == std::complex<T>());
- }
- break;
- case lowest_value:
- case maximum_value:
- case non_zero:
- if (std::signbit(r) || classify(theta) == inf || classify(theta) == NaN)
- {
- int c = classify(z);
- assert(c == NaN || c == non_zero_nan);
- }
- else
- {
- is_about(std::abs(z), r);
- }
- break;
- case inf:
- if (r < 0)
- {
- int c = classify(z);
- assert(c == NaN || c == non_zero_nan);
- }
- else
- {
- assert(classify(z) == inf);
- if (classify(theta) != NaN && classify(theta) != inf)
- {
- assert(classify(real(z)) != NaN);
- assert(classify(imag(z)) != NaN);
- }
- }
- break;
- case NaN:
- case non_zero_nan:
- {
- int c = classify(z);
- assert(c == NaN || c == non_zero_nan);
- }
- break;
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ T r = real(testcases<T>[i]);
+ T theta = imag(testcases<T>[i]);
+ std::complex<T> z = std::polar(r, theta);
+ switch (classify(r)) {
+ case zero:
+ if (std::signbit(r) || classify(theta) == inf || classify(theta) == NaN) {
+ int c = classify(z);
+ assert(c == NaN || c == non_zero_nan);
+ } else {
+ assert(z == std::complex<T>());
+ }
+ break;
+ case lowest_value:
+ case maximum_value:
+ case non_zero:
+ if (std::signbit(r) || classify(theta) == inf || classify(theta) == NaN) {
+ int c = classify(z);
+ assert(c == NaN || c == non_zero_nan);
+ } else {
+ is_about(std::abs(z), r);
+ }
+ break;
+ case inf:
+ if (r < 0) {
+ int c = classify(z);
+ assert(c == NaN || c == non_zero_nan);
+ } else {
+ assert(classify(z) == inf);
+ if (classify(theta) != NaN && classify(theta) != inf) {
+ assert(classify(real(z)) != NaN);
+ assert(classify(imag(z)) != NaN);
}
+ }
+ break;
+ case NaN:
+ case non_zero_nan: {
+ int c = classify(z);
+ assert(c == NaN || c == non_zero_nan);
+ } break;
}
+ }
}
int main(int, char**)
@@ -115,5 +100,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
index e4b67b21ae5b30..91fc87fc14cc93 100644
--- a/libcxx/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
@@ -35,34 +35,31 @@ test()
test(std::complex<T>(-1, -2), std::complex<T>(-1, -2));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = proj(testcases<T>[i]);
- switch (classify(testcases<T>[i]))
- {
- case zero:
- case non_zero:
- case lowest_value:
- case maximum_value:
- assert(r == testcases<T>[i]);
- assert(std::signbit(real(r)) == std::signbit(real(testcases<T>[i])));
- assert(std::signbit(imag(r)) == std::signbit(imag(testcases<T>[i])));
- break;
- case inf:
- assert(std::isinf(real(r)) && real(r) > 0);
- assert(imag(r) == 0);
- assert(std::signbit(imag(r)) == std::signbit(imag(testcases<T>[i])));
- break;
- case NaN:
- case non_zero_nan:
- assert(classify(r) == classify(testcases<T>[i]));
- break;
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = proj(testcases<T>[i]);
+ switch (classify(testcases<T>[i])) {
+ case zero:
+ case non_zero:
+ case lowest_value:
+ case maximum_value:
+ assert(r == testcases<T>[i]);
+ assert(std::signbit(real(r)) == std::signbit(real(testcases<T>[i])));
+ assert(std::signbit(imag(r)) == std::signbit(imag(testcases<T>[i])));
+ break;
+ case inf:
+ assert(std::isinf(real(r)) && real(r) > 0);
+ assert(imag(r) == 0);
+ assert(std::signbit(imag(r)) == std::signbit(imag(testcases<T>[i])));
+ break;
+ case NaN:
+ case non_zero_nan:
+ assert(classify(r) == classify(testcases<T>[i]));
+ break;
}
+ }
}
int main(int, char**)
@@ -74,5 +71,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
>From 657cfdaf0ec6420a782d78756d257c158bcaf56b Mon Sep 17 00:00:00 2001
From: Christopher Di Bella <cjdb at google.com>
Date: Thu, 9 Jan 2025 00:02:14 +0000
Subject: [PATCH 4/4] finishes clang-format
---
libcxx/include/complex | 20 ++---
.../test/std/numerics/complex.number/cases.h | 88 +++++++++----------
2 files changed, 50 insertions(+), 58 deletions(-)
diff --git a/libcxx/include/complex b/libcxx/include/complex
index 5f425206100ce2..5f6f41abc3d16f 100644
--- a/libcxx/include/complex
+++ b/libcxx/include/complex
@@ -1236,31 +1236,27 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> cosh(const complex<_Tp>& __x) {
// tanh
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI _Tp __sin2(const _Tp __x) noexcept
-{
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp __sin2(const _Tp __x) noexcept {
static_assert(std::is_arithmetic<_Tp>::value, "requires an arithmetic type");
return 2 * std::sin(__x) * std::cos(__x);
}
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI _Tp __sinh2(const _Tp __x) noexcept
-{
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp __sinh2(const _Tp __x) noexcept {
static_assert(std::is_arithmetic<_Tp>::value, "requires an arithmetic type");
return 2 * std::sinh(__x) * std::cosh(__x);
}
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI _Tp __cos2(const _Tp __x) noexcept
-{
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp __cos2(const _Tp __x) noexcept {
static_assert(std::is_arithmetic<_Tp>::value, "requires an arithmetic type");
const _Tp __cos = std::cos(__x);
return 2 * __cos * __cos - 1;
}
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI _Tp __cosh2(const _Tp __x) noexcept
-{
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp __cosh2(const _Tp __x) noexcept {
static_assert(std::is_arithmetic<_Tp>::value, "requires an arithmetic type");
const _Tp __cosh = std::cosh(__x);
return 2 * __cosh * __cosh - 1;
diff --git a/libcxx/test/std/numerics/complex.number/cases.h b/libcxx/test/std/numerics/complex.number/cases.h
index 37d327450311ae..172b5fc939da2a 100644
--- a/libcxx/test/std/numerics/complex.number/cases.h
+++ b/libcxx/test/std/numerics/complex.number/cases.h
@@ -20,46 +20,45 @@
#include "test_macros.h"
-template<class T>
-TEST_CONSTEXPR_CXX20 const std::complex<T> testcases[] =
-{
- std::complex<T>( 1.e-6, 1.e-6),
- std::complex<T>(-1.e-6, 1.e-6),
+template <class T>
+TEST_CONSTEXPR_CXX20 const std::complex<T> testcases[] = {
+ std::complex<T>(1.e-6, 1.e-6),
+ std::complex<T>(-1.e-6, 1.e-6),
std::complex<T>(-1.e-6, -1.e-6),
- std::complex<T>( 1.e-6, -1.e-6),
+ std::complex<T>(1.e-6, -1.e-6),
- std::complex<T>( 1.e+6, 1.e-6),
- std::complex<T>(-1.e+6, 1.e-6),
+ std::complex<T>(1.e+6, 1.e-6),
+ std::complex<T>(-1.e+6, 1.e-6),
std::complex<T>(-1.e+6, -1.e-6),
- std::complex<T>( 1.e+6, -1.e-6),
+ std::complex<T>(1.e+6, -1.e-6),
- std::complex<T>( 1.e-6, 1.e+6),
- std::complex<T>(-1.e-6, 1.e+6),
+ std::complex<T>(1.e-6, 1.e+6),
+ std::complex<T>(-1.e-6, 1.e+6),
std::complex<T>(-1.e-6, -1.e+6),
- std::complex<T>( 1.e-6, -1.e+6),
+ std::complex<T>(1.e-6, -1.e+6),
- std::complex<T>( 1.e+6, 1.e+6),
- std::complex<T>(-1.e+6, 1.e+6),
+ std::complex<T>(1.e+6, 1.e+6),
+ std::complex<T>(-1.e+6, 1.e+6),
std::complex<T>(-1.e+6, -1.e+6),
- std::complex<T>( 1.e+6, -1.e+6),
+ std::complex<T>(1.e+6, -1.e+6),
std::complex<T>(-0, -1.e-6),
- std::complex<T>(-0, 1.e-6),
- std::complex<T>(-0, 1.e+6),
+ std::complex<T>(-0, 1.e-6),
+ std::complex<T>(-0, 1.e+6),
std::complex<T>(-0, -1.e+6),
- std::complex<T>( 0, -1.e-6),
- std::complex<T>( 0, 1.e-6),
- std::complex<T>( 0, 1.e+6),
- std::complex<T>( 0, -1.e+6),
+ std::complex<T>(0, -1.e-6),
+ std::complex<T>(0, 1.e-6),
+ std::complex<T>(0, 1.e+6),
+ std::complex<T>(0, -1.e+6),
std::complex<T>(-1.e-6, -0),
- std::complex<T>( 1.e-6, -0),
- std::complex<T>( 1.e+6, -0),
+ std::complex<T>(1.e-6, -0),
+ std::complex<T>(1.e+6, -0),
std::complex<T>(-1.e+6, -0),
- std::complex<T>(-1.e-6, 0),
- std::complex<T>( 1.e-6, 0),
- std::complex<T>( 1.e+6, 0),
- std::complex<T>(-1.e+6, 0),
+ std::complex<T>(-1.e-6, 0),
+ std::complex<T>(1.e-6, 0),
+ std::complex<T>(1.e+6, 0),
+ std::complex<T>(-1.e+6, 0),
std::complex<T>(std::numeric_limits<T>::quiet_NaN(), std::numeric_limits<T>::quiet_NaN()),
std::complex<T>(-std::numeric_limits<T>::infinity(), std::numeric_limits<T>::quiet_NaN()),
@@ -209,7 +208,7 @@ TEST_CONSTEXPR_CXX20 const std::complex<T> testcases[] =
std::complex<T>(std::numeric_limits<T>::lowest(), std::numeric_limits<T>::lowest()),
};
-enum {zero, non_zero, lowest_value, maximum_value, inf, NaN, non_zero_nan};
+enum { zero, non_zero, lowest_value, maximum_value, inf, NaN, non_zero_nan };
template <class T, typename std::enable_if<std::is_floating_point<T>::value, int>::type = 0>
TEST_CONSTEXPR_CXX20 bool test_isinf(T v) {
@@ -245,28 +244,25 @@ classify(const std::complex<T>& x)
return non_zero_nan;
}
if (x.real() == std::numeric_limits<T>::max() || x.imag() == std::numeric_limits<T>::max())
- return maximum_value;
+ return maximum_value;
if (x.real() == std::numeric_limits<T>::lowest() || x.imag() == std::numeric_limits<T>::lowest())
- return lowest_value;
+ return lowest_value;
return non_zero;
}
-template<class T>
-inline
-int
-classify(T x)
-{
- if (x == 0)
- return zero;
- if (std::isinf(x))
- return inf;
- if (std::isnan(x))
- return NaN;
- if (x == std::numeric_limits<T>::max())
- return maximum_value;
- if (x == std::numeric_limits<T>::lowest())
- return lowest_value;
- return non_zero;
+template <class T>
+inline int classify(T x) {
+ if (x == 0)
+ return zero;
+ if (std::isinf(x))
+ return inf;
+ if (std::isnan(x))
+ return NaN;
+ if (x == std::numeric_limits<T>::max())
+ return maximum_value;
+ if (x == std::numeric_limits<T>::lowest())
+ return lowest_value;
+ return non_zero;
}
void is_about(float x, float y)
More information about the libcxx-commits
mailing list