[libcxx-commits] [libcxx] [libcxx] makes `tanh(complex<float>)` work for large values (PR #122194)
via libcxx-commits
libcxx-commits at lists.llvm.org
Wed Jan 8 15:52:23 PST 2025
github-actions[bot] wrote:
<!--LLVM CODE FORMAT COMMENT: {clang-format}-->
:warning: C/C++ code formatter, clang-format found issues in your code. :warning:
<details>
<summary>
You can test this locally with the following command:
</summary>
``````````bash
git-clang-format --diff b48b99f6253c917a15b698a68c1bf41d15ea6dc6 976a6937eb347c68371a321de843a9dbc03d969c --extensions ,cpp,h -- libcxx/include/complex libcxx/test/std/numerics/complex.number/cases.h libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp libcxx/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp libcxx/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp libcxx/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp libcxx/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp libcxx/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp libcxx/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp libcxx/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp libcxx/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp libcxx/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp libcxx/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp libcxx/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp libcxx/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp libcxx/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp libcxx/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp libcxx/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp libcxx/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp libcxx/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp libcxx/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp libcxx/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp libcxx/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
``````````
</details>
<details>
<summary>
View the diff from clang-format here.
</summary>
``````````diff
diff --git a/libcxx/include/complex b/libcxx/include/complex
index 5f42520610..5f6f41abc3 100644
--- a/libcxx/include/complex
+++ b/libcxx/include/complex
@@ -1236,31 +1236,27 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> cosh(const complex<_Tp>& __x) {
// tanh
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI _Tp __sin2(const _Tp __x) noexcept
-{
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp __sin2(const _Tp __x) noexcept {
static_assert(std::is_arithmetic<_Tp>::value, "requires an arithmetic type");
return 2 * std::sin(__x) * std::cos(__x);
}
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI _Tp __sinh2(const _Tp __x) noexcept
-{
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp __sinh2(const _Tp __x) noexcept {
static_assert(std::is_arithmetic<_Tp>::value, "requires an arithmetic type");
return 2 * std::sinh(__x) * std::cosh(__x);
}
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI _Tp __cos2(const _Tp __x) noexcept
-{
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp __cos2(const _Tp __x) noexcept {
static_assert(std::is_arithmetic<_Tp>::value, "requires an arithmetic type");
const _Tp __cos = std::cos(__x);
return 2 * __cos * __cos - 1;
}
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI _Tp __cosh2(const _Tp __x) noexcept
-{
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp __cosh2(const _Tp __x) noexcept {
static_assert(std::is_arithmetic<_Tp>::value, "requires an arithmetic type");
const _Tp __cosh = std::cosh(__x);
return 2 * __cosh * __cosh - 1;
diff --git a/libcxx/test/std/numerics/complex.number/cases.h b/libcxx/test/std/numerics/complex.number/cases.h
index 37d3274503..172b5fc939 100644
--- a/libcxx/test/std/numerics/complex.number/cases.h
+++ b/libcxx/test/std/numerics/complex.number/cases.h
@@ -20,46 +20,45 @@
#include "test_macros.h"
-template<class T>
-TEST_CONSTEXPR_CXX20 const std::complex<T> testcases[] =
-{
- std::complex<T>( 1.e-6, 1.e-6),
- std::complex<T>(-1.e-6, 1.e-6),
+template <class T>
+TEST_CONSTEXPR_CXX20 const std::complex<T> testcases[] = {
+ std::complex<T>(1.e-6, 1.e-6),
+ std::complex<T>(-1.e-6, 1.e-6),
std::complex<T>(-1.e-6, -1.e-6),
- std::complex<T>( 1.e-6, -1.e-6),
+ std::complex<T>(1.e-6, -1.e-6),
- std::complex<T>( 1.e+6, 1.e-6),
- std::complex<T>(-1.e+6, 1.e-6),
+ std::complex<T>(1.e+6, 1.e-6),
+ std::complex<T>(-1.e+6, 1.e-6),
std::complex<T>(-1.e+6, -1.e-6),
- std::complex<T>( 1.e+6, -1.e-6),
+ std::complex<T>(1.e+6, -1.e-6),
- std::complex<T>( 1.e-6, 1.e+6),
- std::complex<T>(-1.e-6, 1.e+6),
+ std::complex<T>(1.e-6, 1.e+6),
+ std::complex<T>(-1.e-6, 1.e+6),
std::complex<T>(-1.e-6, -1.e+6),
- std::complex<T>( 1.e-6, -1.e+6),
+ std::complex<T>(1.e-6, -1.e+6),
- std::complex<T>( 1.e+6, 1.e+6),
- std::complex<T>(-1.e+6, 1.e+6),
+ std::complex<T>(1.e+6, 1.e+6),
+ std::complex<T>(-1.e+6, 1.e+6),
std::complex<T>(-1.e+6, -1.e+6),
- std::complex<T>( 1.e+6, -1.e+6),
+ std::complex<T>(1.e+6, -1.e+6),
std::complex<T>(-0, -1.e-6),
- std::complex<T>(-0, 1.e-6),
- std::complex<T>(-0, 1.e+6),
+ std::complex<T>(-0, 1.e-6),
+ std::complex<T>(-0, 1.e+6),
std::complex<T>(-0, -1.e+6),
- std::complex<T>( 0, -1.e-6),
- std::complex<T>( 0, 1.e-6),
- std::complex<T>( 0, 1.e+6),
- std::complex<T>( 0, -1.e+6),
+ std::complex<T>(0, -1.e-6),
+ std::complex<T>(0, 1.e-6),
+ std::complex<T>(0, 1.e+6),
+ std::complex<T>(0, -1.e+6),
std::complex<T>(-1.e-6, -0),
- std::complex<T>( 1.e-6, -0),
- std::complex<T>( 1.e+6, -0),
+ std::complex<T>(1.e-6, -0),
+ std::complex<T>(1.e+6, -0),
std::complex<T>(-1.e+6, -0),
- std::complex<T>(-1.e-6, 0),
- std::complex<T>( 1.e-6, 0),
- std::complex<T>( 1.e+6, 0),
- std::complex<T>(-1.e+6, 0),
+ std::complex<T>(-1.e-6, 0),
+ std::complex<T>(1.e-6, 0),
+ std::complex<T>(1.e+6, 0),
+ std::complex<T>(-1.e+6, 0),
std::complex<T>(std::numeric_limits<T>::quiet_NaN(), std::numeric_limits<T>::quiet_NaN()),
std::complex<T>(-std::numeric_limits<T>::infinity(), std::numeric_limits<T>::quiet_NaN()),
@@ -209,7 +208,7 @@ TEST_CONSTEXPR_CXX20 const std::complex<T> testcases[] =
std::complex<T>(std::numeric_limits<T>::lowest(), std::numeric_limits<T>::lowest()),
};
-enum {zero, non_zero, lowest_value, maximum_value, inf, NaN, non_zero_nan};
+enum { zero, non_zero, lowest_value, maximum_value, inf, NaN, non_zero_nan };
template <class T, typename std::enable_if<std::is_floating_point<T>::value, int>::type = 0>
TEST_CONSTEXPR_CXX20 bool test_isinf(T v) {
@@ -245,28 +244,25 @@ classify(const std::complex<T>& x)
return non_zero_nan;
}
if (x.real() == std::numeric_limits<T>::max() || x.imag() == std::numeric_limits<T>::max())
- return maximum_value;
+ return maximum_value;
if (x.real() == std::numeric_limits<T>::lowest() || x.imag() == std::numeric_limits<T>::lowest())
- return lowest_value;
+ return lowest_value;
return non_zero;
}
-template<class T>
-inline
-int
-classify(T x)
-{
- if (x == 0)
- return zero;
- if (std::isinf(x))
- return inf;
- if (std::isnan(x))
- return NaN;
- if (x == std::numeric_limits<T>::max())
- return maximum_value;
- if (x == std::numeric_limits<T>::lowest())
- return lowest_value;
- return non_zero;
+template <class T>
+inline int classify(T x) {
+ if (x == 0)
+ return zero;
+ if (std::isinf(x))
+ return inf;
+ if (std::isnan(x))
+ return NaN;
+ if (x == std::numeric_limits<T>::max())
+ return maximum_value;
+ if (x == std::numeric_limits<T>::lowest())
+ return lowest_value;
+ return non_zero;
}
void is_about(float x, float y)
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 bc0bdd0ec2..b5539f03a6 100644
--- a/libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
@@ -34,11 +34,8 @@ test()
return true;
}
-template<class T>
-TEST_CONSTEXPR_CXX20
-bool
-test_edges()
-{
+template <class T>
+TEST_CONSTEXPR_CXX20 bool test_edges() {
const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
int classification[N];
for (unsigned i=0; i < N; ++i)
@@ -47,7 +44,7 @@ test_edges()
for (unsigned i = 0; i < N; ++i) {
auto const x = testcases<T>[i];
for (unsigned j = 0; j < N; ++j) {
- auto const y = testcases<T>[j];
+ auto const y = testcases<T>[j];
std::complex<T> r = x / y;
switch (classification[i]) {
case zero:
diff --git a/libcxx/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
index 11256f651f..1ab89e13fe 100644
--- a/libcxx/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
@@ -33,103 +33,95 @@ test()
// test edges
-template<class T>
-TEST_CONSTEXPR_CXX20 bool test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- int classification[N];
- for (unsigned i=0; i < N; ++i)
- classification[i] = classify(testcases<T>[i]);
+template <class T>
+TEST_CONSTEXPR_CXX20 bool test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ int classification[N];
+ for (unsigned i = 0; i < N; ++i)
+ classification[i] = classify(testcases<T>[i]);
- for (unsigned i = 0; i < N; ++i)
- {
- for (unsigned j = 0; j < N; ++j)
- {
- std::complex<T> r = testcases<T>[i] * testcases<T>[j];
- switch (classification[i])
- {
- case zero:
- switch (classification[j])
- {
- case lowest_value:
- case maximum_value:
- continue; // not tested
- case zero:
- case non_zero:
- assert(classify(r) == zero);
- break;
- case inf:
- case NaN:
- case non_zero_nan:
- assert(classify(r) == NaN);
- break;
- }
- break;
- case lowest_value:
- case maximum_value:
- continue; // not tested
- case non_zero:
- switch (classification[j])
- {
- case zero:
- assert(classify(r) == zero);
- break;
- case lowest_value:
- case maximum_value:
- continue; // not tested
- case non_zero:
- assert(classify(r) == non_zero);
- break;
- case inf:
- assert(classify(r) == inf);
- break;
- case NaN:
- case non_zero_nan:
- assert(classify(r) == NaN);
- break;
- }
- break;
- case inf:
- switch (classification[j])
- {
- case zero:
- case NaN:
- assert(classify(r) == NaN);
- break;
- case lowest_value:
- case maximum_value:
- continue; // not tested
- case non_zero:
- case inf:
- case non_zero_nan:
- assert(classify(r) == inf);
- break;
- }
- break;
- case NaN:
- assert(classify(r) == NaN);
- break;
- case non_zero_nan:
- switch (classification[j])
- {
- case inf:
- assert(classify(r) == inf);
- break;
- case lowest_value:
- case maximum_value:
- continue; // not tested
- case zero:
- case non_zero:
- case NaN:
- case non_zero_nan:
- assert(classify(r) == NaN);
- break;
- }
- break;
- }
+ for (unsigned i = 0; i < N; ++i) {
+ for (unsigned j = 0; j < N; ++j) {
+ std::complex<T> r = testcases<T>[i] * testcases<T>[j];
+ switch (classification[i]) {
+ case zero:
+ switch (classification[j]) {
+ case lowest_value:
+ case maximum_value:
+ continue; // not tested
+ case zero:
+ case non_zero:
+ assert(classify(r) == zero);
+ break;
+ case inf:
+ case NaN:
+ case non_zero_nan:
+ assert(classify(r) == NaN);
+ break;
+ }
+ break;
+ case lowest_value:
+ case maximum_value:
+ continue; // not tested
+ case non_zero:
+ switch (classification[j]) {
+ case zero:
+ assert(classify(r) == zero);
+ break;
+ case lowest_value:
+ case maximum_value:
+ continue; // not tested
+ case non_zero:
+ assert(classify(r) == non_zero);
+ break;
+ case inf:
+ assert(classify(r) == inf);
+ break;
+ case NaN:
+ case non_zero_nan:
+ assert(classify(r) == NaN);
+ break;
}
+ break;
+ case inf:
+ switch (classification[j]) {
+ case zero:
+ case NaN:
+ assert(classify(r) == NaN);
+ break;
+ case lowest_value:
+ case maximum_value:
+ continue; // not tested
+ case non_zero:
+ case inf:
+ case non_zero_nan:
+ assert(classify(r) == inf);
+ break;
+ }
+ break;
+ case NaN:
+ assert(classify(r) == NaN);
+ break;
+ case non_zero_nan:
+ switch (classification[j]) {
+ case inf:
+ assert(classify(r) == inf);
+ break;
+ case lowest_value:
+ case maximum_value:
+ continue; // not tested
+ case zero:
+ case non_zero:
+ case NaN:
+ case non_zero_nan:
+ assert(classify(r) == NaN);
+ break;
+ }
+ break;
+ }
}
- return true;
+ }
+ return true;
}
int main(int, char**)
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
index 50756f8ff9..dcf53d64c6 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
@@ -32,110 +32,78 @@ test()
test(std::complex<T>(INFINITY, 1), std::complex<T>(0, -INFINITY));
}
-template<class T>
-void test_edges()
-{
- const T pi = std::atan2(+0., -0.);
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = acos(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- is_about(r.real(), pi/2);
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
- }
- else if (testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag()))
- {
- is_about(r.real(), pi/2);
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- is_about(r.real(), pi/2);
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && testcases<T>[i].real() != 0 && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isfinite(testcases<T>[i].imag()))
- {
- is_about(r.real(), pi);
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isfinite(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(!std::signbit(r.real()));
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isinf(testcases<T>[i].imag()))
- {
- is_about(r.real(), T(0.75) * pi);
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isinf(testcases<T>[i].imag()))
- {
- is_about(r.real(), T(0.25) * pi);
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isinf(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (!std::signbit(testcases<T>[i].real()) && !std::signbit(testcases<T>[i].imag()))
- {
- assert(!std::signbit(r.real()));
- assert( std::signbit(r.imag()));
- }
- else if (std::signbit(testcases<T>[i].real()) && !std::signbit(testcases<T>[i].imag()))
- {
- assert(!std::signbit(r.real()));
- assert( std::signbit(r.imag()));
- }
- else if (std::signbit(testcases<T>[i].real()) && std::signbit(testcases<T>[i].imag()))
- {
- assert(!std::signbit(r.real()));
- assert(!std::signbit(r.imag()));
- }
- else if (!std::signbit(testcases<T>[i].real()) && std::signbit(testcases<T>[i].imag()))
- {
- assert(!std::signbit(r.real()));
- assert(!std::signbit(r.imag()));
- }
- else
- {
- assert(!std::isnan(r.real()));
- assert(!std::isnan(r.imag()));
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
+template <class T>
+void test_edges() {
+ const T pi = std::atan2(+0., -0.);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = acos(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ is_about(r.real(), pi / 2);
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
+ } else if (testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag())) {
+ is_about(r.real(), pi / 2);
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ is_about(r.real(), pi / 2);
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && testcases<T>[i].real() != 0 &&
+ std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 &&
+ std::isfinite(testcases<T>[i].imag())) {
+ is_about(r.real(), pi);
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 &&
+ std::isfinite(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(!std::signbit(r.real()));
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isinf(testcases<T>[i].imag())) {
+ is_about(r.real(), T(0.75) * pi);
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isinf(testcases<T>[i].imag())) {
+ is_about(r.real(), T(0.25) * pi);
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isinf(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) != std::signbit(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (!std::signbit(testcases<T>[i].real()) && !std::signbit(testcases<T>[i].imag())) {
+ assert(!std::signbit(r.real()));
+ assert(std::signbit(r.imag()));
+ } else if (std::signbit(testcases<T>[i].real()) && !std::signbit(testcases<T>[i].imag())) {
+ assert(!std::signbit(r.real()));
+ assert(std::signbit(r.imag()));
+ } else if (std::signbit(testcases<T>[i].real()) && std::signbit(testcases<T>[i].imag())) {
+ assert(!std::signbit(r.real()));
+ assert(!std::signbit(r.imag()));
+ } else if (!std::signbit(testcases<T>[i].real()) && std::signbit(testcases<T>[i].imag())) {
+ assert(!std::signbit(r.real()));
+ assert(!std::signbit(r.imag()));
+ } else {
+ assert(!std::isnan(r.real()));
+ assert(!std::isnan(r.imag()));
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
+ }
}
int main(int, char**)
@@ -147,5 +115,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
index ce580bdd50..fe2e0c67ca 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
@@ -32,114 +32,87 @@ test()
test(std::complex<T>(INFINITY, 1), std::complex<T>(INFINITY, 0));
}
-template<class T>
-void test_edges()
-{
- const T pi = std::atan2(+0., -0.);
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = acosh(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- assert(!std::signbit(r.real()));
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi/2);
- else
- is_about(r.imag(), pi/2);
- }
- else if (testcases<T>[i].real() == 1 && testcases<T>[i].imag() == 0)
- {
- assert(r.real() == 0);
- assert(!std::signbit(r.real()));
- assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (testcases<T>[i].real() == -1 && testcases<T>[i].imag() == 0)
- {
- assert(r.real() == 0);
- assert(!std::signbit(r.real()));
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi);
- else
- is_about(r.imag(), pi);
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi/2);
- else
- is_about(r.imag(), pi/2);
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi);
- else
- is_about(r.imag(), pi);
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), T(-0.75) * pi);
- else
- is_about(r.imag(), T( 0.75) * pi);
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), T(-0.25 * pi));
- else
- is_about(r.imag(), T( 0.25 * pi));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else
- {
- assert(!std::signbit(r.real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
+template <class T>
+void test_edges() {
+ const T pi = std::atan2(+0., -0.);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = acosh(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ assert(!std::signbit(r.real()));
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi / 2);
+ else
+ is_about(r.imag(), pi / 2);
+ } else if (testcases<T>[i].real() == 1 && testcases<T>[i].imag() == 0) {
+ assert(r.real() == 0);
+ assert(!std::signbit(r.real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (testcases<T>[i].real() == -1 && testcases<T>[i].imag() == 0) {
+ assert(r.real() == 0);
+ assert(!std::signbit(r.real()));
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi);
+ else
+ is_about(r.imag(), pi);
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi / 2);
+ else
+ is_about(r.imag(), pi / 2);
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 &&
+ std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi);
+ else
+ is_about(r.imag(), pi);
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 &&
+ std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ assert(r.imag() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), T(-0.75) * pi);
+ else
+ is_about(r.imag(), T(0.75) * pi);
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), T(-0.25 * pi));
+ else
+ is_about(r.imag(), T(0.25 * pi));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else {
+ assert(!std::signbit(r.real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
+ }
}
int main(int, char**)
@@ -151,5 +124,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
index 4bd8b4fb18..5694a736b4 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
@@ -32,82 +32,59 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
-template<class T>
-void test_edges()
-{
- const T pi = std::atan2(+0., -0.);
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = asin(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if ( testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- if (testcases<T>[i].real() > 0)
- is_about(r.real(), pi/2);
- else
- is_about(r.real(), - pi/2);
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- if (std::signbit(testcases<T>[i].real()))
- is_about(r.real(), -pi/4);
- else
- is_about(r.real(), pi/4);
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].real()) != std::signbit(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isinf(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else
- {
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
+template <class T>
+void test_edges() {
+ const T pi = std::atan2(+0., -0.);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = asin(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ if (testcases<T>[i].real() > 0)
+ is_about(r.real(), pi / 2);
+ else
+ is_about(r.real(), -pi / 2);
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ if (std::signbit(testcases<T>[i].real()))
+ is_about(r.real(), -pi / 4);
+ else
+ is_about(r.real(), pi / 4);
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].real()) != std::signbit(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isinf(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else {
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
+ }
}
int main(int, char**)
@@ -119,5 +96,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
index 80b2c440c4..e44040dfab 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
@@ -32,91 +32,66 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
-template<class T>
-void test_edges()
-{
- const T pi = std::atan2(+0., -0.);
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = asinh(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (testcases<T>[i].real() == 0 && std::abs(testcases<T>[i].imag()) == 1)
- {
- assert(r.real() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi/2);
- else
- is_about(r.imag(), pi/2);
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi/2);
- else
- is_about(r.imag(), pi/2);
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi/4);
- else
- is_about(r.imag(), pi/4);
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
- {
- assert(std::isnan(r.real()));
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else
- {
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
+template <class T>
+void test_edges() {
+ const T pi = std::atan2(+0., -0.);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = asinh(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (testcases<T>[i].real() == 0 && std::abs(testcases<T>[i].imag()) == 1) {
+ assert(r.real() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi / 2);
+ else
+ is_about(r.imag(), pi / 2);
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi / 2);
+ else
+ is_about(r.imag(), pi / 2);
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi / 4);
+ else
+ is_about(r.imag(), pi / 4);
+ } else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0) {
+ assert(std::isnan(r.real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else {
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
+ }
}
int main(int, char**)
@@ -128,5 +103,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
index 6901069d5e..a8da42b0c0 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
@@ -32,31 +32,27 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = atan(testcases<T>[i]);
- std::complex<T> t1(-imag(testcases<T>[i]), real(testcases<T>[i]));
- std::complex<T> t2 = atanh(t1);
- std::complex<T> z(imag(t2), -real(t2));
- if (std::isnan(real(r)))
- assert(std::isnan(real(z)));
- else
- {
- assert(real(r) == real(z));
- assert(std::signbit(real(r)) == std::signbit(real(z)));
- }
- if (std::isnan(imag(r)))
- assert(std::isnan(imag(z)));
- else
- {
- assert(imag(r) == imag(z));
- assert(std::signbit(imag(r)) == std::signbit(imag(z)));
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = atan(testcases<T>[i]);
+ std::complex<T> t1(-imag(testcases<T>[i]), real(testcases<T>[i]));
+ std::complex<T> t2 = atanh(t1);
+ std::complex<T> z(imag(t2), -real(t2));
+ if (std::isnan(real(r)))
+ assert(std::isnan(real(z)));
+ else {
+ assert(real(r) == real(z));
+ assert(std::signbit(real(r)) == std::signbit(real(z)));
+ }
+ if (std::isnan(imag(r)))
+ assert(std::isnan(imag(z)));
+ else {
+ assert(imag(r) == imag(z));
+ assert(std::signbit(imag(r)) == std::signbit(imag(z)));
}
+ }
}
int main(int, char**)
@@ -68,5 +64,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
index 2b8d79f21b..c75ffad2ef 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
@@ -32,95 +32,70 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
-template<class T>
-void test_edges()
-{
- const T pi = std::atan2(+0., -0.);
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = atanh(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if ( testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::abs(testcases<T>[i].real()) == 1 && testcases<T>[i].imag() == 0)
- {
- assert(std::isinf(r.real()));
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- if (testcases<T>[i].imag() > 0)
- is_about(r.imag(), pi/2);
- else
- is_about(r.imag(), -pi/2);
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi/2);
- else
- is_about(r.imag(), pi/2);
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi/2);
- else
- is_about(r.imag(), pi/2);
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi/2);
- else
- is_about(r.imag(), pi/2);
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else
- {
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
+template <class T>
+void test_edges() {
+ const T pi = std::atan2(+0., -0.);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = atanh(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::abs(testcases<T>[i].real()) == 1 && testcases<T>[i].imag() == 0) {
+ assert(std::isinf(r.real()));
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ if (testcases<T>[i].imag() > 0)
+ is_about(r.imag(), pi / 2);
+ else
+ is_about(r.imag(), -pi / 2);
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi / 2);
+ else
+ is_about(r.imag(), pi / 2);
+ } else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi / 2);
+ else
+ is_about(r.imag(), pi / 2);
+ } else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(std::signbit(testcases<T>[i].real()) == std::signbit(r.real()));
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi / 2);
+ else
+ is_about(r.imag(), pi / 2);
+ } else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else {
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
+ }
}
int main(int, char**)
@@ -132,5 +107,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
index 922b0c8770..9a9b3209e6 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
@@ -32,30 +32,26 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(1, 0));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = cos(testcases<T>[i]);
- std::complex<T> t1(-imag(testcases<T>[i]), real(testcases<T>[i]));
- std::complex<T> z = cosh(t1);
- if (std::isnan(real(r)))
- assert(std::isnan(real(z)));
- else
- {
- assert(real(r) == real(z));
- assert(std::signbit(real(r)) == std::signbit(real(z)));
- }
- if (std::isnan(imag(r)))
- assert(std::isnan(imag(z)));
- else
- {
- assert(imag(r) == imag(z));
- assert(std::signbit(imag(r)) == std::signbit(imag(z)));
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = cos(testcases<T>[i]);
+ std::complex<T> t1(-imag(testcases<T>[i]), real(testcases<T>[i]));
+ std::complex<T> z = cosh(t1);
+ if (std::isnan(real(r)))
+ assert(std::isnan(real(z)));
+ else {
+ assert(real(r) == real(z));
+ assert(std::signbit(real(r)) == std::signbit(real(z)));
+ }
+ if (std::isnan(imag(r)))
+ assert(std::isnan(imag(z)));
+ else {
+ assert(imag(r) == imag(z));
+ assert(std::signbit(imag(r)) == std::signbit(imag(z)));
}
+ }
}
int main(int, char**)
@@ -67,5 +63,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
index 4fbec0cb6a..bdda26c561 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
@@ -32,87 +32,60 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(1, 0));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = cosh(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- assert(r.real() == 1);
- assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (testcases<T>[i].real() == 0 && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(r.imag() == 0);
- }
- else if (testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(r.imag() == 0);
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
- {
- assert(std::isinf(r.real()));
- assert(!std::signbit(r.real()));
- assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::signbit(r.real()) == std::signbit(cos(testcases<T>[i].imag())));
- assert(std::isinf(r.imag()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].real() * sin(testcases<T>[i].imag())));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
- {
- assert(std::isnan(r.real()));
- assert(r.imag() == 0);
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(!std::isnan(r.real()));
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = cosh(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ assert(r.real() == 1);
+ assert(r.imag() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (testcases<T>[i].real() == 0 && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(r.imag() == 0);
+ } else if (testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(r.imag() == 0);
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].imag() == 0) {
+ assert(std::isinf(r.real()));
+ assert(!std::signbit(r.real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::signbit(r.real()) == std::signbit(cos(testcases<T>[i].imag())));
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].real() * sin(testcases<T>[i].imag())));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0) {
+ assert(std::isnan(r.real()));
+ assert(r.imag() == 0);
+ } else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(!std::isnan(r.real()));
- bool const nan_okay = std::isinf(r.real()) && testcases<T>[i].imag() == 0; // inf * 0 == NaN
- assert(!std::isnan(r.imag()) || nan_okay);
- }
+ bool const nan_okay = std::isinf(r.real()) && testcases<T>[i].imag() == 0; // inf * 0 == NaN
+ assert(!std::isnan(r.imag()) || nan_okay);
}
+ }
}
int main(int, char**)
@@ -124,5 +97,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
index efc9b867eb..81686a6a6b 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
@@ -32,82 +32,56 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(1, 0));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = exp(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- assert(r.real() == 1.0);
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && testcases<T>[i].imag() == 0)
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isinf(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(r.imag() == 0);
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isnan(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(r.imag() == 0);
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
- {
- assert(std::isnan(r.real()));
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() != 0)
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].imag()) && std::abs(testcases<T>[i].imag()) <= 1)
- {
- assert(!std::signbit(r.real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isinf(r.real()) && testcases<T>[i].imag() == 0) {
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = exp(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ assert(r.real() == 1.0);
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && testcases<T>[i].imag() == 0) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isinf(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(r.imag() == 0);
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isnan(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(r.imag() == 0);
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0) {
+ assert(std::isnan(r.real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() != 0) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].imag()) && std::abs(testcases<T>[i].imag()) <= 1) {
+ assert(!std::signbit(r.real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isinf(r.real()) && testcases<T>[i].imag() == 0) {
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
}
+ }
}
int main(int, char**)
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
index b1737f0de5..94b348a962 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
@@ -32,95 +32,73 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(-INFINITY, 0));
}
-template<class T>
-void test_edges()
-{
- const T pi = std::atan2(+0., -0.);
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = log(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- if (std::signbit(testcases<T>[i].real()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() < 0);
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi);
- else
- is_about(r.imag(), pi);
- }
- else
- {
- assert(std::isinf(r.real()));
- assert(r.real() < 0);
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- if (testcases<T>[i].imag() > 0)
- is_about(r.imag(), pi/2);
- else
- is_about(r.imag(), -pi/2);
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()) && r.real() > 0);
- if (r.imag() > 0)
- is_about(r.imag(), pi);
- else
- is_about(r.imag(), -pi);
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()) && r.real() > 0);
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (testcases<T>[i].real() == 1 && testcases<T>[i].imag() == 0)
- {
- assert(r.real() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 1)
- {
- assert(r.real() == 0);
- is_about(r.imag(), pi/2);
- }
- else if (testcases<T>[i].real() == -1 && testcases<T>[i].imag() == 0)
- {
- assert(r.real() == 0);
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r.imag(), -pi);
- else
- is_about(r.imag(), pi);
- }
- else if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == -1)
- {
- assert(r.real() == 0);
- is_about(r.imag(), -pi/2);
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()) && abs(testcases<T>[i]) < 1)
- {
- assert( std::signbit(r.real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()) && abs(testcases<T>[i]) > 1)
- {
- assert(!std::signbit(r.real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
+template <class T>
+void test_edges() {
+ const T pi = std::atan2(+0., -0.);
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = log(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ if (std::signbit(testcases<T>[i].real())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() < 0);
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi);
+ else
+ is_about(r.imag(), pi);
+ } else {
+ assert(std::isinf(r.real()));
+ assert(r.real() < 0);
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ }
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ if (testcases<T>[i].imag() > 0)
+ is_about(r.imag(), pi / 2);
+ else
+ is_about(r.imag(), -pi / 2);
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 &&
+ std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()) && r.real() > 0);
+ if (r.imag() > 0)
+ is_about(r.imag(), pi);
+ else
+ is_about(r.imag(), -pi);
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 &&
+ std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()) && r.real() > 0);
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (testcases<T>[i].real() == 1 && testcases<T>[i].imag() == 0) {
+ assert(r.real() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 1) {
+ assert(r.real() == 0);
+ is_about(r.imag(), pi / 2);
+ } else if (testcases<T>[i].real() == -1 && testcases<T>[i].imag() == 0) {
+ assert(r.real() == 0);
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r.imag(), -pi);
+ else
+ is_about(r.imag(), pi);
+ } else if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == -1) {
+ assert(r.real() == 0);
+ is_about(r.imag(), -pi / 2);
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()) &&
+ abs(testcases<T>[i]) < 1) {
+ assert(std::signbit(r.real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()) &&
+ abs(testcases<T>[i]) > 1) {
+ assert(!std::signbit(r.real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
}
+ }
}
int main(int, char**)
@@ -132,5 +110,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
index ae4fa59fb2..3d0219b9a4 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
@@ -32,29 +32,25 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(-INFINITY, 0));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = log10(testcases<T>[i]);
- std::complex<T> z = log(testcases<T>[i])/std::log(T(10));
- if (std::isnan(real(r)))
- assert(std::isnan(real(z)));
- else
- {
- assert(real(r) == real(z));
- assert(std::signbit(real(r)) == std::signbit(real(z)));
- }
- if (std::isnan(imag(r)))
- assert(std::isnan(imag(z)));
- else
- {
- assert(imag(r) == imag(z));
- assert(std::signbit(imag(r)) == std::signbit(imag(z)));
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = log10(testcases<T>[i]);
+ std::complex<T> z = log(testcases<T>[i]) / std::log(T(10));
+ if (std::isnan(real(r)))
+ assert(std::isnan(real(z)));
+ else {
+ assert(real(r) == real(z));
+ assert(std::signbit(real(r)) == std::signbit(real(z)));
+ }
+ if (std::isnan(imag(r)))
+ assert(std::isnan(imag(z)));
+ else {
+ assert(imag(r) == imag(z));
+ assert(std::signbit(imag(r)) == std::signbit(imag(z)));
}
+ }
}
int main(int, char**)
@@ -66,5 +62,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
index 9bddbd0408..f10129466a 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
@@ -34,32 +34,27 @@ test()
test(std::complex<T>(2, 3), std::complex<T>(2, 0), std::complex<T>(-5, 12));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- for (unsigned j = 0; j < N; ++j)
- {
- std::complex<T> r = pow(testcases<T>[i], testcases<T>[j]);
- std::complex<T> z = exp(testcases<T>[j] * log(testcases<T>[i]));
- if (std::isnan(real(r)))
- assert(std::isnan(real(z)));
- else
- {
- assert(real(r) == real(z));
- assert(std::signbit(real(r)) == std::signbit(real(z)));
- }
- if (std::isnan(imag(r)))
- assert(std::isnan(imag(z)));
- else
- {
- assert(imag(r) == imag(z));
- assert(std::signbit(imag(r)) == std::signbit(imag(z)));
- }
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ for (unsigned j = 0; j < N; ++j) {
+ std::complex<T> r = pow(testcases<T>[i], testcases<T>[j]);
+ std::complex<T> z = exp(testcases<T>[j] * log(testcases<T>[i]));
+ if (std::isnan(real(r)))
+ assert(std::isnan(real(z)));
+ else {
+ assert(real(r) == real(z));
+ assert(std::signbit(real(r)) == std::signbit(real(z)));
+ }
+ if (std::isnan(imag(r)))
+ assert(std::isnan(imag(z)));
+ else {
+ assert(imag(r) == imag(z));
+ assert(std::signbit(imag(r)) == std::signbit(imag(z)));
+ }
}
+ }
}
int main(int, char**)
@@ -71,5 +66,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
index 1bbc211a09..919512fb21 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
@@ -34,30 +34,25 @@ test()
test(std::complex<T>(2, 3), T(2), std::complex<T>(-5, 12));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- for (unsigned j = 0; j < N; ++j)
- {
- std::complex<T> r = pow(testcases<T>[i], real(testcases<T>[j]));
- std::complex<T> z = exp(std::complex<T>(real(testcases<T>[j])) * log(testcases<T>[i]));
- if (std::isnan(real(r)))
- assert(std::isnan(real(z)));
- else
- {
- assert(real(r) == real(z));
- }
- if (std::isnan(imag(r)))
- assert(std::isnan(imag(z)));
- else
- {
- assert(imag(r) == imag(z));
- }
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ for (unsigned j = 0; j < N; ++j) {
+ std::complex<T> r = pow(testcases<T>[i], real(testcases<T>[j]));
+ std::complex<T> z = exp(std::complex<T>(real(testcases<T>[j])) * log(testcases<T>[i]));
+ if (std::isnan(real(r)))
+ assert(std::isnan(real(z)));
+ else {
+ assert(real(r) == real(z));
+ }
+ if (std::isnan(imag(r)))
+ assert(std::isnan(imag(z)));
+ else {
+ assert(imag(r) == imag(z));
+ }
}
+ }
}
int main(int, char**)
@@ -69,5 +64,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
index 05bd55ef2a..d41e8defb8 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
@@ -34,30 +34,25 @@ test()
test(T(2), std::complex<T>(2), std::complex<T>(4));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- for (unsigned j = 0; j < N; ++j)
- {
- std::complex<T> r = pow(real(testcases<T>[i]), testcases<T>[j]);
- std::complex<T> z = exp(testcases<T>[j] * log(std::complex<T>(real(testcases<T>[i]))));
- if (std::isnan(real(r)))
- assert(std::isnan(real(z)));
- else
- {
- assert(real(r) == real(z));
- }
- if (std::isnan(imag(r)))
- assert(std::isnan(imag(z)));
- else
- {
- assert(imag(r) == imag(z));
- }
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ for (unsigned j = 0; j < N; ++j) {
+ std::complex<T> r = pow(real(testcases<T>[i]), testcases<T>[j]);
+ std::complex<T> z = exp(testcases<T>[j] * log(std::complex<T>(real(testcases<T>[i]))));
+ if (std::isnan(real(r)))
+ assert(std::isnan(real(z)));
+ else {
+ assert(real(r) == real(z));
+ }
+ if (std::isnan(imag(r)))
+ assert(std::isnan(imag(z)));
+ else {
+ assert(imag(r) == imag(z));
+ }
}
+ }
}
int main(int, char**)
@@ -69,5 +64,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
index d54c745781..1876cf4437 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
@@ -32,31 +32,27 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = sin(testcases<T>[i]);
- std::complex<T> t1(-imag(testcases<T>[i]), real(testcases<T>[i]));
- std::complex<T> t2 = sinh(t1);
- std::complex<T> z(imag(t2), -real(t2));
- if (std::isnan(real(r)))
- assert(std::isnan(real(z)));
- else
- {
- assert(real(r) == real(z));
- assert(std::signbit(real(r)) == std::signbit(real(z)));
- }
- if (std::isnan(imag(r)))
- assert(std::isnan(imag(z)));
- else
- {
- assert(imag(r) == imag(z));
- assert(std::signbit(imag(r)) == std::signbit(imag(z)));
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = sin(testcases<T>[i]);
+ std::complex<T> t1(-imag(testcases<T>[i]), real(testcases<T>[i]));
+ std::complex<T> t2 = sinh(t1);
+ std::complex<T> z(imag(t2), -real(t2));
+ if (std::isnan(real(r)))
+ assert(std::isnan(real(z)));
+ else {
+ assert(real(r) == real(z));
+ assert(std::signbit(real(r)) == std::signbit(real(z)));
+ }
+ if (std::isnan(imag(r)))
+ assert(std::isnan(imag(z)));
+ else {
+ assert(imag(r) == imag(z));
+ assert(std::signbit(imag(r)) == std::signbit(imag(z)));
}
+ }
}
int main(int, char**)
@@ -68,5 +64,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
index d98b173693..cf38b6aa7d 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
@@ -32,88 +32,61 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = sinh(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- assert(r.real() == 0);
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
- assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (testcases<T>[i].real() == 0 && std::isinf(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
- {
- assert(std::isinf(r.real()));
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
- assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real() * cos(testcases<T>[i].imag())));
- assert(std::isinf(r.imag()));
- assert(std::signbit(r.imag()) == std::signbit(sin(testcases<T>[i].imag())));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
- {
- assert(std::isnan(r.real()));
- assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(!std::isnan(r.real()));
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = sinh(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ assert(r.real() == 0);
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (testcases<T>[i].real() == 0 && std::isinf(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (testcases<T>[i].real() == 0 && std::isnan(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].imag() == 0) {
+ assert(std::isinf(r.real()));
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real() * cos(testcases<T>[i].imag())));
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(r.imag()) == std::signbit(sin(testcases<T>[i].imag())));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0) {
+ assert(std::isnan(r.real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(!std::isnan(r.real()));
- bool const nan_okay = std::isinf(r.real()) && testcases<T>[i].imag() == 0; // inf * 0 == NaN
- assert(!std::isnan(r.imag()) || nan_okay);
- }
+ bool const nan_okay = std::isinf(r.real()) && testcases<T>[i].imag() == 0; // inf * 0 == NaN
+ assert(!std::isnan(r.imag()) || nan_okay);
}
+ }
}
int main(int, char**)
@@ -125,5 +98,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
index 64181649e8..58b4ee2545 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
@@ -38,98 +38,73 @@ test()
// cosine calculations for std::arg terminate at different times based on the precision of T,
// and can produce a very small negative number instead of a very small positive one, so we
// should actually check that we're really close to zero instead of positive.
-template<class T>
-bool approaching_zero(const T value)
-{
- auto in_range = [value](const T low, const T high) {
- return low < value && value < high;
- };
- if constexpr (std::is_same_v<T, float>) {
- return value == -0.0f || in_range(-4.38e-5f, 4.38e-5f);
- }
- else if constexpr (std::is_same_v<T, double>) {
- return false;
- }
- else if constexpr (std::is_same_v<T, long double>) {
- return value == -0.0f || in_range(-3.0e-17L, 3.0e-17L);
- }
- else {
- std::abort();
- }
+template <class T>
+bool approaching_zero(const T value) {
+ auto in_range = [value](const T low, const T high) { return low < value && value < high; };
+ if constexpr (std::is_same_v<T, float>) {
+ return value == -0.0f || in_range(-4.38e-5f, 4.38e-5f);
+ } else if constexpr (std::is_same_v<T, double>) {
+ return false;
+ } else if constexpr (std::is_same_v<T, long double>) {
+ return value == -0.0f || in_range(-3.0e-17L, 3.0e-17L);
+ } else {
+ std::abort();
+ }
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = sqrt(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- assert(!std::signbit(r.real()) || approaching_zero(r.real()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- assert(std::isinf(r.imag()));
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isfinite(testcases<T>[i].imag()))
- {
- assert(r.real() == 0);
- assert(!std::signbit(r.real()));
- assert(std::isinf(r.imag()));
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- assert(r.imag() == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isinf(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isinf(r.real()));
- assert(r.real() > 0);
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && (std::isfinite(testcases<T>[i].imag()) || std::isnan(testcases<T>[i].imag())))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::signbit(testcases<T>[i].imag()))
- {
- // FIXME(https://github.com/llvm/llvm-project/issues/122172): move `expected_pass` into
- // assert once #122172 is fixed.
- const bool expected_pass = !std::signbit(r.real()) || approaching_zero(r.real());
- assert((i != 156 || std::is_same<T, double>::value) ? expected_pass : !expected_pass);
- assert(std::signbit(r.imag()));
- }
- else
- {
-
- // FIXME(https://github.com/llvm/llvm-project/issues/122172): move `expected_pass` into
- // assert once #122172 is fixed.
- const bool expected_pass = !std::signbit(r.real()) || approaching_zero(r.real());
- assert((i != 155 || std::is_same<T, double>::value) ? expected_pass : !expected_pass);
- assert(!std::signbit(r.imag()));
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = sqrt(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ assert(!std::signbit(r.real()) || approaching_zero(r.real()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isinf(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 &&
+ std::isfinite(testcases<T>[i].imag())) {
+ assert(r.real() == 0);
+ assert(!std::signbit(r.real()));
+ assert(std::isinf(r.imag()));
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 &&
+ std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ assert(r.imag() == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() < 0 && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isinf(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && testcases<T>[i].real() > 0 && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isinf(r.real()));
+ assert(r.real() > 0);
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) &&
+ (std::isfinite(testcases<T>[i].imag()) || std::isnan(testcases<T>[i].imag()))) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::signbit(testcases<T>[i].imag())) {
+ // FIXME(https://github.com/llvm/llvm-project/issues/122172): move `expected_pass` into
+ // assert once #122172 is fixed.
+ const bool expected_pass = !std::signbit(r.real()) || approaching_zero(r.real());
+ assert((i != 156 || std::is_same<T, double>::value) ? expected_pass : !expected_pass);
+ assert(std::signbit(r.imag()));
+ } else {
+ // FIXME(https://github.com/llvm/llvm-project/issues/122172): move `expected_pass` into
+ // assert once #122172 is fixed.
+ const bool expected_pass = !std::signbit(r.real()) || approaching_zero(r.real());
+ assert((i != 155 || std::is_same<T, double>::value) ? expected_pass : !expected_pass);
+ assert(!std::signbit(r.imag()));
}
+ }
}
int main(int, char**)
@@ -141,5 +116,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
index dc946a7808..5b881fe8f3 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
@@ -33,31 +33,27 @@ test()
test(std::complex<T>(10000, -10000), std::complex<T>(0, -1));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = tan(testcases<T>[i]);
- std::complex<T> t1(-imag(testcases<T>[i]), real(testcases<T>[i]));
- std::complex<T> t2 = tanh(t1);
- std::complex<T> z(imag(t2), -real(t2));
- if (std::isnan(real(r)))
- assert(std::isnan(real(z)));
- else
- {
- assert(real(r) == real(z));
- assert(std::signbit(real(r)) == std::signbit(real(z)));
- }
- if (std::isnan(imag(r)))
- assert(std::isnan(imag(z)));
- else
- {
- assert(imag(r) == imag(z));
- assert(std::signbit(imag(r)) == std::signbit(imag(z)));
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = tan(testcases<T>[i]);
+ std::complex<T> t1(-imag(testcases<T>[i]), real(testcases<T>[i]));
+ std::complex<T> t2 = tanh(t1);
+ std::complex<T> z(imag(t2), -real(t2));
+ if (std::isnan(real(r)))
+ assert(std::isnan(real(z)));
+ else {
+ assert(real(r) == real(z));
+ assert(std::signbit(real(r)) == std::signbit(real(z)));
+ }
+ if (std::isnan(imag(r)))
+ assert(std::isnan(imag(z)));
+ else {
+ assert(imag(r) == imag(z));
+ assert(std::signbit(imag(r)) == std::signbit(imag(z)));
}
+ }
}
int main(int, char**)
@@ -69,5 +65,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
index ebb27f82bf..5d9b649239 100644
--- a/libcxx/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
@@ -32,69 +32,48 @@ test()
test(std::complex<T>(0, 0), std::complex<T>(0, 0));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = tanh(testcases<T>[i]);
- if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0)
- {
- assert(r.real() == 0);
- assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
- assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(r.real() == (testcases<T>[i].real() > 0 ? 1 : -1));
- assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(sin(2 * testcases<T>[i].imag())));
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- assert(r.real() == (testcases<T>[i].real() > 0 ? 1 : -1));
- assert(r.imag() == 0);
- }
- else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(r.real() == (testcases<T>[i].real() > 0 ? 1 : -1));
- assert(r.imag() == 0);
- }
- else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0)
- {
- assert(std::isnan(r.real()));
- assert(r.imag() == 0);
- assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag()))
- {
- assert(std::isnan(r.real()));
- assert(std::isnan(r.imag()));
- }
- else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag()))
- {
- [[maybe_unused]] auto const x = testcases<T>[i];
- assert(!std::isnan(r.real()));
- assert(!std::isnan(r.imag()));
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = tanh(testcases<T>[i]);
+ if (testcases<T>[i].real() == 0 && testcases<T>[i].imag() == 0) {
+ assert(r.real() == 0);
+ assert(std::signbit(r.real()) == std::signbit(testcases<T>[i].real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(r.real() == (testcases<T>[i].real() > 0 ? 1 : -1));
+ assert(r.imag() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(sin(2 * testcases<T>[i].imag())));
+ } else if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ assert(r.real() == (testcases<T>[i].real() > 0 ? 1 : -1));
+ assert(r.imag() == 0);
+ } else if (std::isinf(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(r.real() == (testcases<T>[i].real() > 0 ? 1 : -1));
+ assert(r.imag() == 0);
+ } else if (std::isnan(testcases<T>[i].real()) && testcases<T>[i].imag() == 0) {
+ assert(std::isnan(r.real()));
+ assert(r.imag() == 0);
+ assert(std::signbit(r.imag()) == std::signbit(testcases<T>[i].imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isnan(testcases<T>[i].real()) && std::isnan(testcases<T>[i].imag())) {
+ assert(std::isnan(r.real()));
+ assert(std::isnan(r.imag()));
+ } else if (std::isfinite(testcases<T>[i].real()) && std::isfinite(testcases<T>[i].imag())) {
+ [[maybe_unused]] auto const x = testcases<T>[i];
+ assert(!std::isnan(r.real()));
+ assert(!std::isnan(r.imag()));
}
+ }
}
int main(int, char**)
@@ -106,5 +85,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
index 90e7aed7e2..2f56e7d621 100644
--- a/libcxx/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
@@ -26,47 +26,44 @@ test()
assert(abs(z) == 5);
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- T r = abs(testcases<T>[i]);
- switch (classify(testcases<T>[i]))
- {
- case zero:
- assert(r == 0);
- assert(!std::signbit(r));
- break;
- case lowest_value: {
- // It appears that `lowest<float> - relatively_small_number == lowest<float>`, so we check to
- // make sure that abs was actually effective before asserting that it should be infinity.
- bool const ineffective_abs = testcases<T>[i].real() + testcases<T>[i].imag() == -r;
- assert((std::isinf(r) && r > 0) || ineffective_abs);
- break;
- }
- case maximum_value: {
- // It appears that `max<float> + relatively_small_number == max<float>`, so we check to
- // make sure that abs was actually effective before asserting that it should be infinity.
- bool const ineffective_abs = testcases<T>[i].real() + testcases<T>[i].imag() == r;
- assert((std::isinf(r) && r > 0) || ineffective_abs);
- break;
- }
- case non_zero:
- assert(std::isfinite(r) && r > 0);
- break;
- case inf:
- assert(std::isinf(r) && r > 0);
- break;
- case NaN:
- assert(std::isnan(r));
- break;
- case non_zero_nan:
- assert(std::isnan(r));
- break;
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ T r = abs(testcases<T>[i]);
+ switch (classify(testcases<T>[i])) {
+ case zero:
+ assert(r == 0);
+ assert(!std::signbit(r));
+ break;
+ case lowest_value: {
+ // It appears that `lowest<float> - relatively_small_number == lowest<float>`, so we check to
+ // make sure that abs was actually effective before asserting that it should be infinity.
+ bool const ineffective_abs = testcases<T>[i].real() + testcases<T>[i].imag() == -r;
+ assert((std::isinf(r) && r > 0) || ineffective_abs);
+ break;
+ }
+ case maximum_value: {
+ // It appears that `max<float> + relatively_small_number == max<float>`, so we check to
+ // make sure that abs was actually effective before asserting that it should be infinity.
+ bool const ineffective_abs = testcases<T>[i].real() + testcases<T>[i].imag() == r;
+ assert((std::isinf(r) && r > 0) || ineffective_abs);
+ break;
+ }
+ case non_zero:
+ assert(std::isfinite(r) && r > 0);
+ break;
+ case inf:
+ assert(std::isinf(r) && r > 0);
+ break;
+ case NaN:
+ assert(std::isnan(r));
+ break;
+ case non_zero_nan:
+ assert(std::isnan(r));
+ break;
}
+ }
}
int main(int, char**)
@@ -78,5 +75,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
index 2d7fa5c64f..40e2a4940d 100644
--- a/libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
@@ -26,107 +26,82 @@ test()
assert(arg(z) == 0);
}
-template<class T>
-void test_edges()
-{
- const T pi = std::atan2(T(+0.), T(-0.));
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- T r = arg(testcases<T>[i]);
- if (std::isnan(testcases<T>[i].real()) || std::isnan(testcases<T>[i].imag()))
- assert(std::isnan(r));
+template <class T>
+void test_edges() {
+ const T pi = std::atan2(T(+0.), T(-0.));
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ T r = arg(testcases<T>[i]);
+ if (std::isnan(testcases<T>[i].real()) || std::isnan(testcases<T>[i].imag()))
+ assert(std::isnan(r));
+ else {
+ switch (classify(testcases<T>[i])) {
+ case zero:
+ if (std::signbit(testcases<T>[i].real())) {
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r, -pi);
+ else
+ is_about(r, pi);
+ } else {
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r));
+ }
+ break;
+ case lowest_value:
+ case maximum_value:
+ case non_zero:
+ if (testcases<T>[i].real() == 0) {
+ if (testcases<T>[i].imag() < 0)
+ is_about(r, -pi / 2);
+ else
+ is_about(r, pi / 2);
+ } else if (testcases<T>[i].imag() == 0) {
+ if (testcases<T>[i].real() < 0) {
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r, -pi);
+ else
+ is_about(r, pi);
+ } else {
+ assert(r == 0);
+ assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r));
+ }
+ } else if (testcases<T>[i].imag() > 0)
+ assert(r > 0);
else
- {
- switch (classify(testcases<T>[i]))
- {
- case zero:
- if (std::signbit(testcases<T>[i].real()))
- {
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r, -pi);
- else
- is_about(r, pi);
- }
- else
- {
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r));
- }
- break;
- case lowest_value:
- case maximum_value:
- case non_zero:
- if (testcases<T>[i].real() == 0)
- {
- if (testcases<T>[i].imag() < 0)
- is_about(r, -pi/2);
- else
- is_about(r, pi/2);
- }
- else if (testcases<T>[i].imag() == 0)
- {
- if (testcases<T>[i].real() < 0)
- {
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r, -pi);
- else
- is_about(r, pi);
- }
- else
- {
- assert(r == 0);
- assert(std::signbit(testcases<T>[i].imag()) == std::signbit(r));
- }
- }
- else if (testcases<T>[i].imag() > 0)
- assert(r > 0);
- else
- assert(r < 0);
- break;
- case inf:
- if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag()))
- {
- if (testcases<T>[i].real() < 0)
- {
- if (testcases<T>[i].imag() > 0)
- is_about(r, T( 0.75) * pi);
- else
- is_about(r, T(-0.75) * pi);
- }
- else
- {
- if (testcases<T>[i].imag() > 0)
- is_about(r, T( 0.25) * pi);
- else
- is_about(r, T(-0.25) * pi);
- }
- }
- else if (std::isinf(testcases<T>[i].real()))
- {
- if (testcases<T>[i].real() < 0)
- {
- if (std::signbit(testcases<T>[i].imag()))
- is_about(r, -pi);
- else
- is_about(r, pi);
- }
- else
- {
- assert(r == 0);
- assert(std::signbit(r) == std::signbit(testcases<T>[i].imag()));
- }
- }
- else
- {
- if (testcases<T>[i].imag() < 0)
- is_about(r, -pi/2);
- else
- is_about(r, pi/2);
- }
- break;
- }
+ assert(r < 0);
+ break;
+ case inf:
+ if (std::isinf(testcases<T>[i].real()) && std::isinf(testcases<T>[i].imag())) {
+ if (testcases<T>[i].real() < 0) {
+ if (testcases<T>[i].imag() > 0)
+ is_about(r, T(0.75) * pi);
+ else
+ is_about(r, T(-0.75) * pi);
+ } else {
+ if (testcases<T>[i].imag() > 0)
+ is_about(r, T(0.25) * pi);
+ else
+ is_about(r, T(-0.25) * pi);
+ }
+ } else if (std::isinf(testcases<T>[i].real())) {
+ if (testcases<T>[i].real() < 0) {
+ if (std::signbit(testcases<T>[i].imag()))
+ is_about(r, -pi);
+ else
+ is_about(r, pi);
+ } else {
+ assert(r == 0);
+ assert(std::signbit(r) == std::signbit(testcases<T>[i].imag()));
+ }
+ } else {
+ if (testcases<T>[i].imag() < 0)
+ is_about(r, -pi / 2);
+ else
+ is_about(r, pi / 2);
}
+ break;
+ }
}
+ }
}
int main(int, char**)
@@ -138,5 +113,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
index 2589e8ba6d..f0d481d506 100644
--- a/libcxx/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
@@ -26,35 +26,32 @@ test()
assert(norm(z) == 25);
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- T r = norm(testcases<T>[i]);
- switch (classify(testcases<T>[i]))
- {
- case zero:
- assert(r == 0);
- assert(!std::signbit(r));
- break;
- case non_zero:
- assert(std::isfinite(r) && r > 0);
- break;
- case lowest_value:
- case maximum_value:
- case inf:
- assert(std::isinf(r) && r > 0);
- break;
- case NaN:
- assert(std::isnan(r));
- break;
- case non_zero_nan:
- assert(std::isnan(r));
- break;
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ T r = norm(testcases<T>[i]);
+ switch (classify(testcases<T>[i])) {
+ case zero:
+ assert(r == 0);
+ assert(!std::signbit(r));
+ break;
+ case non_zero:
+ assert(std::isfinite(r) && r > 0);
+ break;
+ case lowest_value:
+ case maximum_value:
+ case inf:
+ assert(std::isinf(r) && r > 0);
+ break;
+ case NaN:
+ assert(std::isnan(r));
+ break;
+ case non_zero_nan:
+ assert(std::isnan(r));
+ break;
}
+ }
}
int main(int, char**)
@@ -66,5 +63,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
index 69f282d666..91c5f439dc 100644
--- a/libcxx/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
@@ -44,66 +44,51 @@ test()
test(T(100), T(0), std::complex<T>(100, 0));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- T r = real(testcases<T>[i]);
- T theta = imag(testcases<T>[i]);
- std::complex<T> z = std::polar(r, theta);
- switch (classify(r))
- {
- case zero:
- if (std::signbit(r) || classify(theta) == inf || classify(theta) == NaN)
- {
- int c = classify(z);
- assert(c == NaN || c == non_zero_nan);
- }
- else
- {
- assert(z == std::complex<T>());
- }
- break;
- case lowest_value:
- case maximum_value:
- case non_zero:
- if (std::signbit(r) || classify(theta) == inf || classify(theta) == NaN)
- {
- int c = classify(z);
- assert(c == NaN || c == non_zero_nan);
- }
- else
- {
- is_about(std::abs(z), r);
- }
- break;
- case inf:
- if (r < 0)
- {
- int c = classify(z);
- assert(c == NaN || c == non_zero_nan);
- }
- else
- {
- assert(classify(z) == inf);
- if (classify(theta) != NaN && classify(theta) != inf)
- {
- assert(classify(real(z)) != NaN);
- assert(classify(imag(z)) != NaN);
- }
- }
- break;
- case NaN:
- case non_zero_nan:
- {
- int c = classify(z);
- assert(c == NaN || c == non_zero_nan);
- }
- break;
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ T r = real(testcases<T>[i]);
+ T theta = imag(testcases<T>[i]);
+ std::complex<T> z = std::polar(r, theta);
+ switch (classify(r)) {
+ case zero:
+ if (std::signbit(r) || classify(theta) == inf || classify(theta) == NaN) {
+ int c = classify(z);
+ assert(c == NaN || c == non_zero_nan);
+ } else {
+ assert(z == std::complex<T>());
+ }
+ break;
+ case lowest_value:
+ case maximum_value:
+ case non_zero:
+ if (std::signbit(r) || classify(theta) == inf || classify(theta) == NaN) {
+ int c = classify(z);
+ assert(c == NaN || c == non_zero_nan);
+ } else {
+ is_about(std::abs(z), r);
+ }
+ break;
+ case inf:
+ if (r < 0) {
+ int c = classify(z);
+ assert(c == NaN || c == non_zero_nan);
+ } else {
+ assert(classify(z) == inf);
+ if (classify(theta) != NaN && classify(theta) != inf) {
+ assert(classify(real(z)) != NaN);
+ assert(classify(imag(z)) != NaN);
}
+ }
+ break;
+ case NaN:
+ case non_zero_nan: {
+ int c = classify(z);
+ assert(c == NaN || c == non_zero_nan);
+ } break;
}
+ }
}
int main(int, char**)
@@ -115,5 +100,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
diff --git a/libcxx/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
index e4b67b21ae..91fc87fc14 100644
--- a/libcxx/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
@@ -35,34 +35,31 @@ test()
test(std::complex<T>(-1, -2), std::complex<T>(-1, -2));
}
-template<class T>
-void test_edges()
-{
- const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
- for (unsigned i = 0; i < N; ++i)
- {
- std::complex<T> r = proj(testcases<T>[i]);
- switch (classify(testcases<T>[i]))
- {
- case zero:
- case non_zero:
- case lowest_value:
- case maximum_value:
- assert(r == testcases<T>[i]);
- assert(std::signbit(real(r)) == std::signbit(real(testcases<T>[i])));
- assert(std::signbit(imag(r)) == std::signbit(imag(testcases<T>[i])));
- break;
- case inf:
- assert(std::isinf(real(r)) && real(r) > 0);
- assert(imag(r) == 0);
- assert(std::signbit(imag(r)) == std::signbit(imag(testcases<T>[i])));
- break;
- case NaN:
- case non_zero_nan:
- assert(classify(r) == classify(testcases<T>[i]));
- break;
- }
+template <class T>
+void test_edges() {
+ const unsigned N = sizeof(testcases<T>) / sizeof(testcases<T>[0]);
+ for (unsigned i = 0; i < N; ++i) {
+ std::complex<T> r = proj(testcases<T>[i]);
+ switch (classify(testcases<T>[i])) {
+ case zero:
+ case non_zero:
+ case lowest_value:
+ case maximum_value:
+ assert(r == testcases<T>[i]);
+ assert(std::signbit(real(r)) == std::signbit(real(testcases<T>[i])));
+ assert(std::signbit(imag(r)) == std::signbit(imag(testcases<T>[i])));
+ break;
+ case inf:
+ assert(std::isinf(real(r)) && real(r) > 0);
+ assert(imag(r) == 0);
+ assert(std::signbit(imag(r)) == std::signbit(imag(testcases<T>[i])));
+ break;
+ case NaN:
+ case non_zero_nan:
+ assert(classify(r) == classify(testcases<T>[i]));
+ break;
}
+ }
}
int main(int, char**)
@@ -74,5 +71,5 @@ int main(int, char**)
test_edges<double>();
test_edges<long double>();
- return 0;
+ return 0;
}
``````````
</details>
https://github.com/llvm/llvm-project/pull/122194
More information about the libcxx-commits
mailing list