[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 15:49:03 PST 2025
https://github.com/cjdb created https://github.com/llvm/llvm-project/pull/122194
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.
>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/2] [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/2] 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])));
More information about the libcxx-commits
mailing list