This is an archive of the discontinued LLVM Phabricator instance.

Differential D20922

[libcxx] [test] Rename global "x" to "testcases" in complex.number/cases.h and make it const for safety.
ClosedPublic

Authored by STL_MSFT on Jun 2 2016, 9:48 AM.

Details

Reviewers
mclow.lists
EricWF
Summary

Rename global "x" to "testcases" in complex.number/cases.h and make it const for safety.

Fixes MSVC warning C4459 "declaration of 'x' hides global declaration".

NOTE: As the addition of const is a semantic change, please double-check that the tests are passing. With MSVC I observe that this fixes the compiler warnings, but I still have unrelated runtime failures.

Diff Detail

Event Timeline

STL_MSFT updated this revision to Diff 59407.Jun 2 2016, 9:48 AM
STL_MSFT retitled this revision from to [libcxx] [test] Rename global "x" to "testcases" in complex.number/cases.h and make it const for safety..
STL_MSFT updated this object.
STL_MSFT added reviewers: EricWF, mclow.lists.
STL_MSFT added a subscriber: cfe-commits.
mclow.lists accepted this revision.Jun 6 2016, 11:30 AM
mclow.lists edited edge metadata.

Landed as revision 271919

This revision is now accepted and ready to land.Jun 6 2016, 11:30 AM
STL_MSFT closed this revision.Jun 7 2016, 12:14 PM

Marshall checked this in, so I'm closing this.

Revision Contents

PathSize
test/
std/
numerics/
complex.number/
2 lines
complex.ops/
16 lines
16 lines
complex.transcendentals/
50 lines
44 lines
50 lines
48 lines
6 lines
58 lines
6 lines
36 lines
36 lines
44 lines
6 lines
6 lines
6 lines
6 lines
6 lines
42 lines
30 lines
6 lines
30 lines
complex.value.ops/
6 lines
46 lines
6 lines
6 lines
16 lines

Diff 59407

test/std/numerics/complex.number/cases.h

Show All 11 Lines
// test cases // test cases
#ifndef CASES_H #ifndef CASES_H
#define CASES_H #define CASES_H
#include <complex> #include <complex>
#include <cassert> #include <cassert>
std::complex<double> x[] = const std::complex<double> testcases[] =
{ {
std::complex<double>( 1.e-6, 1.e-6), std::complex<double>( 1.e-6, 1.e-6),
std::complex<double>(-1.e-6, 1.e-6), std::complex<double>(-1.e-6, 1.e-6),
std::complex<double>(-1.e-6, -1.e-6), std::complex<double>(-1.e-6, -1.e-6),
std::complex<double>( 1.e-6, -1.e-6), std::complex<double>( 1.e-6, -1.e-6),
std::complex<double>( 1.e+6, 1.e-6), std::complex<double>( 1.e+6, 1.e-6),
std::complex<double>(-1.e+6, 1.e-6), std::complex<double>(-1.e+6, 1.e-6),
▲ Show 20 Lines • Show All 202 Lines • Show Last 20 Lines

test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp

Show All 31 Linestest()
std::complex<T> lhs(-4.0, 7.5); std::complex<T> lhs(-4.0, 7.5);
std::complex<T> rhs(1.5, 2.5); std::complex<T> rhs(1.5, 2.5);
std::complex<T> x(1.5, 2.5); std::complex<T> x(1.5, 2.5);
test(lhs, rhs, x); test(lhs, rhs, x);
} }
void test_edges() void test_edges()
{ {
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
for (unsigned j = 0; j < N; ++j) for (unsigned j = 0; j < N; ++j)
{ {
std::complex<double> r = x[i] / x[j]; std::complex<double> r = testcases[i] / testcases[j];
switch (classify(x[i])) switch (classify(testcases[i]))
{ {
case zero: case zero:
switch (classify(x[j])) switch (classify(testcases[j]))
{ {
case zero: case zero:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case non_zero: case non_zero:
assert(classify(r) == zero); assert(classify(r) == zero);
break; break;
case inf: case inf:
assert(classify(r) == zero); assert(classify(r) == zero);
break; break;
case NaN: case NaN:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case non_zero_nan: case non_zero_nan:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
} }
break; break;
case non_zero: case non_zero:
switch (classify(x[j])) switch (classify(testcases[j]))
{ {
case zero: case zero:
assert(classify(r) == inf); assert(classify(r) == inf);
break; break;
case non_zero: case non_zero:
assert(classify(r) == non_zero); assert(classify(r) == non_zero);
break; break;
case inf: case inf:
assert(classify(r) == zero); assert(classify(r) == zero);
break; break;
case NaN: case NaN:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case non_zero_nan: case non_zero_nan:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
} }
break; break;
case inf: case inf:
switch (classify(x[j])) switch (classify(testcases[j]))
{ {
case zero: case zero:
assert(classify(r) == inf); assert(classify(r) == inf);
break; break;
case non_zero: case non_zero:
assert(classify(r) == inf); assert(classify(r) == inf);
break; break;
case inf: case inf:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case NaN: case NaN:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case non_zero_nan: case non_zero_nan:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
} }
break; break;
case NaN: case NaN:
switch (classify(x[j])) switch (classify(testcases[j]))
{ {
case zero: case zero:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case non_zero: case non_zero:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case inf: case inf:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case NaN: case NaN:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case non_zero_nan: case non_zero_nan:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
} }
break; break;
case non_zero_nan: case non_zero_nan:
switch (classify(x[j])) switch (classify(testcases[j]))
{ {
case zero: case zero:
assert(classify(r) == inf); assert(classify(r) == inf);
break; break;
case non_zero: case non_zero:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case inf: case inf:
Show All 22 Lines

test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp

Show All 33 Linestest()
std::complex<T> x(-4.0, 7.5); std::complex<T> x(-4.0, 7.5);
test(lhs, rhs, x); test(lhs, rhs, x);
} }
// test edges // test edges
void test_edges() void test_edges()
{ {
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
for (unsigned j = 0; j < N; ++j) for (unsigned j = 0; j < N; ++j)
{ {
std::complex<double> r = x[i] * x[j]; std::complex<double> r = testcases[i] * testcases[j];
switch (classify(x[i])) switch (classify(testcases[i]))
{ {
case zero: case zero:
switch (classify(x[j])) switch (classify(testcases[j]))
{ {
case zero: case zero:
assert(classify(r) == zero); assert(classify(r) == zero);
break; break;
case non_zero: case non_zero:
assert(classify(r) == zero); assert(classify(r) == zero);
break; break;
case inf: case inf:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case NaN: case NaN:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case non_zero_nan: case non_zero_nan:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
} }
break; break;
case non_zero: case non_zero:
switch (classify(x[j])) switch (classify(testcases[j]))
{ {
case zero: case zero:
assert(classify(r) == zero); assert(classify(r) == zero);
break; break;
case non_zero: case non_zero:
assert(classify(r) == non_zero); assert(classify(r) == non_zero);
break; break;
case inf: case inf:
assert(classify(r) == inf); assert(classify(r) == inf);
break; break;
case NaN: case NaN:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case non_zero_nan: case non_zero_nan:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
} }
break; break;
case inf: case inf:
switch (classify(x[j])) switch (classify(testcases[j]))
{ {
case zero: case zero:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case non_zero: case non_zero:
assert(classify(r) == inf); assert(classify(r) == inf);
break; break;
case inf: case inf:
assert(classify(r) == inf); assert(classify(r) == inf);
break; break;
case NaN: case NaN:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case non_zero_nan: case non_zero_nan:
assert(classify(r) == inf); assert(classify(r) == inf);
break; break;
} }
break; break;
case NaN: case NaN:
switch (classify(x[j])) switch (classify(testcases[j]))
{ {
case zero: case zero:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case non_zero: case non_zero:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case inf: case inf:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case NaN: case NaN:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case non_zero_nan: case non_zero_nan:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
} }
break; break;
case non_zero_nan: case non_zero_nan:
switch (classify(x[j])) switch (classify(testcases[j]))
{ {
case zero: case zero:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case non_zero: case non_zero:
assert(classify(r) == NaN); assert(classify(r) == NaN);
break; break;
case inf: case inf:
Show All 22 Lines

test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp

Show All 30 Lines
{ {
test(std::complex<T>(INFINITY, 1), std::complex<T>(0, -INFINITY)); test(std::complex<T>(INFINITY, 1), std::complex<T>(0, -INFINITY));
} }
void test_edges() void test_edges()
{ {
typedef std::complex<double> C; typedef std::complex<double> C;
const double pi = std::atan2(+0., -0.); const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
std::complex<double> r = acos(x[i]); std::complex<double> r = acos(testcases[i]);
if (x[i].real() == 0 && x[i].imag() == 0) if (testcases[i].real() == 0 && testcases[i].imag() == 0)
{ {
is_about(r.real(), pi/2); is_about(r.real(), pi/2);
assert(r.imag() == 0); assert(r.imag() == 0);
assert(std::signbit(x[i].imag()) != std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
} }
else if (x[i].real() == 0 && std::isnan(x[i].imag())) else if (testcases[i].real() == 0 && std::isnan(testcases[i].imag()))
{ {
is_about(r.real(), pi/2); is_about(r.real(), pi/2);
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag())) else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
is_about(r.real(), pi/2); is_about(r.real(), pi/2);
assert(std::isinf(r.imag())); assert(std::isinf(r.imag()));
assert(std::signbit(x[i].imag()) != std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
} }
else if (std::isfinite(x[i].real()) && x[i].real() != 0 && std::isnan(x[i].imag())) else if (std::isfinite(testcases[i].real()) && testcases[i].real() != 0 && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isfinite(x[i].imag())) else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isfinite(testcases[i].imag()))
{ {
is_about(r.real(), pi); is_about(r.real(), pi);
assert(std::isinf(r.imag())); assert(std::isinf(r.imag()));
assert(std::signbit(x[i].imag()) != std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
} }
else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isfinite(x[i].imag())) else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isfinite(testcases[i].imag()))
{ {
assert(r.real() == 0); assert(r.real() == 0);
assert(!std::signbit(r.real())); assert(!std::signbit(r.real()));
assert(std::isinf(r.imag())); assert(std::isinf(r.imag()));
assert(std::signbit(x[i].imag()) != std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
} }
else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isinf(x[i].imag())) else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isinf(testcases[i].imag()))
{ {
is_about(r.real(), 0.75 * pi); is_about(r.real(), 0.75 * pi);
assert(std::isinf(r.imag())); assert(std::isinf(r.imag()));
assert(std::signbit(x[i].imag()) != std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
} }
else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isinf(x[i].imag())) else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isinf(testcases[i].imag()))
{ {
is_about(r.real(), 0.25 * pi); is_about(r.real(), 0.25 * pi);
assert(std::isinf(r.imag())); assert(std::isinf(r.imag()));
assert(std::signbit(x[i].imag()) != std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
} }
else if (std::isinf(x[i].real()) && std::isnan(x[i].imag())) else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isinf(r.imag())); assert(std::isinf(r.imag()));
} }
else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isnan(x[i].real()) && std::isinf(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isinf(r.imag())); assert(std::isinf(r.imag()));
assert(std::signbit(x[i].imag()) != std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
} }
else if (std::isnan(x[i].real()) && std::isnan(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (!std::signbit(x[i].real()) && !std::signbit(x[i].imag())) else if (!std::signbit(testcases[i].real()) && !std::signbit(testcases[i].imag()))
{ {
assert(!std::signbit(r.real())); assert(!std::signbit(r.real()));
assert( std::signbit(r.imag())); assert( std::signbit(r.imag()));
} }
else if (std::signbit(x[i].real()) && !std::signbit(x[i].imag())) else if (std::signbit(testcases[i].real()) && !std::signbit(testcases[i].imag()))
{ {
assert(!std::signbit(r.real())); assert(!std::signbit(r.real()));
assert( std::signbit(r.imag())); assert( std::signbit(r.imag()));
} }
else if (std::signbit(x[i].real()) && std::signbit(x[i].imag())) else if (std::signbit(testcases[i].real()) && std::signbit(testcases[i].imag()))
{ {
assert(!std::signbit(r.real())); assert(!std::signbit(r.real()));
assert(!std::signbit(r.imag())); assert(!std::signbit(r.imag()));
} }
else if (!std::signbit(x[i].real()) && std::signbit(x[i].imag())) else if (!std::signbit(testcases[i].real()) && std::signbit(testcases[i].imag()))
{ {
assert(!std::signbit(r.real())); assert(!std::signbit(r.real()));
assert(!std::signbit(r.imag())); assert(!std::signbit(r.imag()));
} }
} }
} }
int main() int main()
{ {
test<float>(); test<float>();
test<double>(); test<double>();
test<long double>(); test<long double>();
test_edges(); test_edges();
} }

test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp

Show All 30 Lines
{ {
test(std::complex<T>(INFINITY, 1), std::complex<T>(INFINITY, 0)); test(std::complex<T>(INFINITY, 1), std::complex<T>(INFINITY, 0));
} }
void test_edges() void test_edges()
{ {
typedef std::complex<double> C; typedef std::complex<double> C;
const double pi = std::atan2(+0., -0.); const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
std::complex<double> r = acosh(x[i]); std::complex<double> r = acosh(testcases[i]);
if (x[i].real() == 0 && x[i].imag() == 0) if (testcases[i].real() == 0 && testcases[i].imag() == 0)
{ {
assert(!std::signbit(r.real())); assert(!std::signbit(r.real()));
if (std::signbit(x[i].imag())) if (std::signbit(testcases[i].imag()))
is_about(r.imag(), -pi/2); is_about(r.imag(), -pi/2);
else else
is_about(r.imag(), pi/2); is_about(r.imag(), pi/2);
} }
else if (x[i].real() == 1 && x[i].imag() == 0) else if (testcases[i].real() == 1 && testcases[i].imag() == 0)
{ {
assert(r.real() == 0); assert(r.real() == 0);
assert(!std::signbit(r.real())); assert(!std::signbit(r.real()));
assert(r.imag() == 0); assert(r.imag() == 0);
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag())) else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(r.real() > 0); assert(r.real() > 0);
if (std::signbit(x[i].imag())) if (std::signbit(testcases[i].imag()))
is_about(r.imag(), -pi/2); is_about(r.imag(), -pi/2);
else else
is_about(r.imag(), pi/2); is_about(r.imag(), pi/2);
} }
else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag())) else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isfinite(x[i].imag())) else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isfinite(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(r.real() > 0); assert(r.real() > 0);
if (std::signbit(x[i].imag())) if (std::signbit(testcases[i].imag()))
is_about(r.imag(), -pi); is_about(r.imag(), -pi);
else else
is_about(r.imag(), pi); is_about(r.imag(), pi);
} }
else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isfinite(x[i].imag())) else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isfinite(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(r.real() > 0); assert(r.real() > 0);
assert(r.imag() == 0); assert(r.imag() == 0);
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isinf(x[i].imag())) else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isinf(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(r.real() > 0); assert(r.real() > 0);
if (std::signbit(x[i].imag())) if (std::signbit(testcases[i].imag()))
is_about(r.imag(), -0.75 * pi); is_about(r.imag(), -0.75 * pi);
else else
is_about(r.imag(), 0.75 * pi); is_about(r.imag(), 0.75 * pi);
} }
else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isinf(x[i].imag())) else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isinf(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(r.real() > 0); assert(r.real() > 0);
if (std::signbit(x[i].imag())) if (std::signbit(testcases[i].imag()))
is_about(r.imag(), -0.25 * pi); is_about(r.imag(), -0.25 * pi);
else else
is_about(r.imag(), 0.25 * pi); is_about(r.imag(), 0.25 * pi);
} }
else if (std::isinf(x[i].real()) && std::isnan(x[i].imag())) else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(r.real() > 0); assert(r.real() > 0);
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isnan(x[i].real()) && std::isinf(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(r.real() > 0); assert(r.real() > 0);
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isnan(x[i].real()) && std::isnan(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else else
{ {
assert(!std::signbit(r.real())); assert(!std::signbit(r.real()));
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
} }
} }
int main() int main()
{ {
test<float>(); test<float>();
test<double>(); test<double>();
test<long double>(); test<long double>();
test_edges(); test_edges();
} }

test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp

Show All 30 Lines
{ {
test(std::complex<T>(0, 0), std::complex<T>(0, 0)); test(std::complex<T>(0, 0), std::complex<T>(0, 0));
} }
void test_edges() void test_edges()
{ {
typedef std::complex<double> C; typedef std::complex<double> C;
const double pi = std::atan2(+0., -0.); const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
std::complex<double> r = asin(x[i]); std::complex<double> r = asin(testcases[i]);
if (x[i].real() == 0 && x[i].imag() == 0) if (testcases[i].real() == 0 && testcases[i].imag() == 0)
{ {
assert(std::signbit(r.real()) == std::signbit(x[i].real())); assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag())) else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
assert(r.real() == 0); assert(r.real() == 0);
assert(std::signbit(x[i].real()) == std::signbit(r.real())); assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
assert(std::isinf(r.imag())); assert(std::isinf(r.imag()));
assert(std::signbit(x[i].imag()) == std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
} }
else if ( x[i].real() == 0 && std::isnan(x[i].imag())) else if ( testcases[i].real() == 0 && std::isnan(testcases[i].imag()))
{ {
assert(r.real() == 0); assert(r.real() == 0);
assert(std::signbit(x[i].real()) == std::signbit(r.real())); assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag())) else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isinf(x[i].real()) && std::isfinite(x[i].imag())) else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
{ {
if (x[i].real() > 0) if (testcases[i].real() > 0)
is_about(r.real(), pi/2); is_about(r.real(), pi/2);
else else
is_about(r.real(), - pi/2); is_about(r.real(), - pi/2);
assert(std::isinf(r.imag())); assert(std::isinf(r.imag()));
assert(std::signbit(x[i].imag()) == std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
} }
else if (std::isinf(x[i].real()) && std::isinf(x[i].imag())) else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
if (std::signbit(x[i].real())) if (std::signbit(testcases[i].real()))
is_about(r.real(), -pi/4); is_about(r.real(), -pi/4);
else else
is_about(r.real(), pi/4); is_about(r.real(), pi/4);
assert(std::isinf(r.imag())); assert(std::isinf(r.imag()));
assert(std::signbit(x[i].imag()) == std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
} }
else if (std::isinf(x[i].real()) && std::isnan(x[i].imag())) else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isinf(r.imag())); assert(std::isinf(r.imag()));
assert(std::signbit(x[i].real()) != std::signbit(r.imag())); assert(std::signbit(testcases[i].real()) != std::signbit(r.imag()));
} }
else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
assert(std::signbit(x[i].imag()) == std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
} }
else if (std::isnan(x[i].real()) && std::isinf(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isinf(r.imag())); assert(std::isinf(r.imag()));
} }
else if (std::isnan(x[i].real()) && std::isnan(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else else
{ {
assert(std::signbit(r.real()) == std::signbit(x[i].real())); assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
} }
} }
int main() int main()
{ {
test<float>(); test<float>();
test<double>(); test<double>();
test<long double>(); test<long double>();
test_edges(); test_edges();
} }

test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp

Show All 30 Lines
{ {
test(std::complex<T>(0, 0), std::complex<T>(0, 0)); test(std::complex<T>(0, 0), std::complex<T>(0, 0));
} }
void test_edges() void test_edges()
{ {
typedef std::complex<double> C; typedef std::complex<double> C;
const double pi = std::atan2(+0., -0.); const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
std::complex<double> r = asinh(x[i]); std::complex<double> r = asinh(testcases[i]);
if (x[i].real() == 0 && x[i].imag() == 0) if (testcases[i].real() == 0 && testcases[i].imag() == 0)
{ {
assert(std::signbit(r.real()) == std::signbit(x[i].real())); assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag())) else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(std::signbit(x[i].real()) == std::signbit(r.real())); assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
if (std::signbit(x[i].imag())) if (std::signbit(testcases[i].imag()))
is_about(r.imag(), -pi/2); is_about(r.imag(), -pi/2);
else else
is_about(r.imag(), pi/2); is_about(r.imag(), pi/2);
} }
else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag())) else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isinf(x[i].real()) && std::isfinite(x[i].imag())) else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(std::signbit(x[i].real()) == std::signbit(r.real())); assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
assert(r.imag() == 0); assert(r.imag() == 0);
assert(std::signbit(x[i].imag()) == std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
} }
else if (std::isinf(x[i].real()) && std::isinf(x[i].imag())) else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(std::signbit(x[i].real()) == std::signbit(r.real())); assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
if (std::signbit(x[i].imag())) if (std::signbit(testcases[i].imag()))
is_about(r.imag(), -pi/4); is_about(r.imag(), -pi/4);
else else
is_about(r.imag(), pi/4); is_about(r.imag(), pi/4);
} }
else if (std::isinf(x[i].real()) && std::isnan(x[i].imag())) else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(std::signbit(x[i].real()) == std::signbit(r.real())); assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isnan(x[i].real()) && x[i].imag() == 0) else if (std::isnan(testcases[i].real()) && testcases[i].imag() == 0)
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(r.imag() == 0); assert(r.imag() == 0);
assert(std::signbit(x[i].imag()) == std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
} }
else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isnan(x[i].real()) && std::isinf(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isnan(x[i].real()) && std::isnan(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else else
{ {
assert(std::signbit(r.real()) == std::signbit(x[i].real())); assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
} }
} }
int main() int main()
{ {
test<float>(); test<float>();
test<double>(); test<double>();
test<long double>(); test<long double>();
test_edges(); test_edges();
} }

test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp

Show All 29 Lines
test() test()
{ {
test(std::complex<T>(0, 0), std::complex<T>(0, 0)); test(std::complex<T>(0, 0), std::complex<T>(0, 0));
} }
void test_edges() void test_edges()
{ {
typedef std::complex<double> C; typedef std::complex<double> C;
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
std::complex<double> r = atan(x[i]); std::complex<double> r = atan(testcases[i]);
std::complex<double> t1(-imag(x[i]), real(x[i])); std::complex<double> t1(-imag(testcases[i]), real(testcases[i]));
std::complex<double> t2 = atanh(t1); std::complex<double> t2 = atanh(t1);
std::complex<double> z(imag(t2), -real(t2)); std::complex<double> z(imag(t2), -real(t2));
if (std::isnan(real(r))) if (std::isnan(real(r)))
assert(std::isnan(real(z))); assert(std::isnan(real(z)));
else else
{ {
assert(real(r) == real(z)); assert(real(r) == real(z));
assert(std::signbit(real(r)) == std::signbit(real(z))); assert(std::signbit(real(r)) == std::signbit(real(z)));
Show All 18 Lines

test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp

Show All 30 Lines
{ {
test(std::complex<T>(0, 0), std::complex<T>(0, 0)); test(std::complex<T>(0, 0), std::complex<T>(0, 0));
} }
void test_edges() void test_edges()
{ {
typedef std::complex<double> C; typedef std::complex<double> C;
const double pi = std::atan2(+0., -0.); const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
std::complex<double> r = atanh(x[i]); std::complex<double> r = atanh(testcases[i]);
if (x[i].real() == 0 && x[i].imag() == 0) if (testcases[i].real() == 0 && testcases[i].imag() == 0)
{ {
assert(std::signbit(r.real()) == std::signbit(x[i].real())); assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
else if ( x[i].real() == 0 && std::isnan(x[i].imag())) else if ( testcases[i].real() == 0 && std::isnan(testcases[i].imag()))
{ {
assert(r.real() == 0); assert(r.real() == 0);
assert(std::signbit(x[i].real()) == std::signbit(r.real())); assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::abs(x[i].real()) == 1 && x[i].imag() == 0) else if (std::abs(testcases[i].real()) == 1 && testcases[i].imag() == 0)
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(std::signbit(x[i].real()) == std::signbit(r.real())); assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
assert(r.imag() == 0); assert(r.imag() == 0);
assert(std::signbit(x[i].imag()) == std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
} }
else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag())) else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
assert(r.real() == 0); assert(r.real() == 0);
assert(std::signbit(x[i].real()) == std::signbit(r.real())); assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
if (x[i].imag() > 0) if (testcases[i].imag() > 0)
is_about(r.imag(), pi/2); is_about(r.imag(), pi/2);
else else
is_about(r.imag(), -pi/2); is_about(r.imag(), -pi/2);
} }
else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag())) else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isinf(x[i].real()) && std::isfinite(x[i].imag())) else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
{ {
assert(r.real() == 0); assert(r.real() == 0);
assert(std::signbit(x[i].real()) == std::signbit(r.real())); assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
if (std::signbit(x[i].imag())) if (std::signbit(testcases[i].imag()))
is_about(r.imag(), -pi/2); is_about(r.imag(), -pi/2);
else else
is_about(r.imag(), pi/2); is_about(r.imag(), pi/2);
} }
else if (std::isinf(x[i].real()) && std::isinf(x[i].imag())) else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
assert(r.real() == 0); assert(r.real() == 0);
assert(std::signbit(x[i].real()) == std::signbit(r.real())); assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
if (std::signbit(x[i].imag())) if (std::signbit(testcases[i].imag()))
is_about(r.imag(), -pi/2); is_about(r.imag(), -pi/2);
else else
is_about(r.imag(), pi/2); is_about(r.imag(), pi/2);
} }
else if (std::isinf(x[i].real()) && std::isnan(x[i].imag())) else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(r.real() == 0); assert(r.real() == 0);
assert(std::signbit(x[i].real()) == std::signbit(r.real())); assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isnan(x[i].real()) && std::isinf(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
assert(r.real() == 0); assert(r.real() == 0);
assert(std::signbit(x[i].real()) == std::signbit(r.real())); assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
if (std::signbit(x[i].imag())) if (std::signbit(testcases[i].imag()))
is_about(r.imag(), -pi/2); is_about(r.imag(), -pi/2);
else else
is_about(r.imag(), pi/2); is_about(r.imag(), pi/2);
} }
else if (std::isnan(x[i].real()) && std::isnan(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else else
{ {
assert(std::signbit(r.real()) == std::signbit(x[i].real())); assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
} }
} }
int main() int main()
{ {
test<float>(); test<float>();
test<double>(); test<double>();
test<long double>(); test<long double>();
test_edges(); test_edges();
} }

test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp

Show All 30 Lines
{ {
test(std::complex<T>(0, 0), std::complex<T>(1, 0)); test(std::complex<T>(0, 0), std::complex<T>(1, 0));
} }
void test_edges() void test_edges()
{ {
typedef std::complex<double> C; typedef std::complex<double> C;
const double pi = std::atan2(+0., -0.); const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
std::complex<double> r = cos(x[i]); std::complex<double> r = cos(testcases[i]);
std::complex<double> t1(-imag(x[i]), real(x[i])); std::complex<double> t1(-imag(testcases[i]), real(testcases[i]));
std::complex<double> z = cosh(t1); std::complex<double> z = cosh(t1);
if (std::isnan(real(r))) if (std::isnan(real(r)))
assert(std::isnan(real(z))); assert(std::isnan(real(z)));
else else
{ {
assert(real(r) == real(z)); assert(real(r) == real(z));
assert(std::signbit(real(r)) == std::signbit(real(z))); assert(std::signbit(real(r)) == std::signbit(real(z)));
} }
Show All 17 Lines

test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp

Show All 30 Lines
{ {
test(std::complex<T>(0, 0), std::complex<T>(1, 0)); test(std::complex<T>(0, 0), std::complex<T>(1, 0));
} }
void test_edges() void test_edges()
{ {
typedef std::complex<double> C; typedef std::complex<double> C;
const double pi = std::atan2(+0., -0.); const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
std::complex<double> r = cosh(x[i]); std::complex<double> r = cosh(testcases[i]);
if (x[i].real() == 0 && x[i].imag() == 0) if (testcases[i].real() == 0 && testcases[i].imag() == 0)
{ {
assert(r.real() == 1); assert(r.real() == 1);
assert(r.imag() == 0); assert(r.imag() == 0);
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
else if (x[i].real() == 0 && std::isinf(x[i].imag())) else if (testcases[i].real() == 0 && std::isinf(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(r.imag() == 0); assert(r.imag() == 0);
} }
else if (x[i].real() == 0 && std::isnan(x[i].imag())) else if (testcases[i].real() == 0 && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(r.imag() == 0); assert(r.imag() == 0);
} }
else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag())) else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag())) else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isinf(x[i].real()) && x[i].imag() == 0) else if (std::isinf(testcases[i].real()) && testcases[i].imag() == 0)
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(!std::signbit(r.real())); assert(!std::signbit(r.real()));
assert(r.imag() == 0); assert(r.imag() == 0);
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
else if (std::isinf(x[i].real()) && std::isfinite(x[i].imag())) else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(std::signbit(r.real()) == std::signbit(cos(x[i].imag()))); assert(std::signbit(r.real()) == std::signbit(cos(testcases[i].imag())));
assert(std::isinf(r.imag())); assert(std::isinf(r.imag()));
assert(std::signbit(r.imag()) == std::signbit(x[i].real() * sin(x[i].imag()))); assert(std::signbit(r.imag()) == std::signbit(testcases[i].real() * sin(testcases[i].imag())));
} }
else if (std::isinf(x[i].real()) && std::isinf(x[i].imag())) else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isinf(x[i].real()) && std::isnan(x[i].imag())) else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(r.real() > 0); assert(r.real() > 0);
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isnan(x[i].real()) && x[i].imag() == 0) else if (std::isnan(testcases[i].real()) && testcases[i].imag() == 0)
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(r.imag() == 0); assert(r.imag() == 0);
} }
else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isnan(x[i].real()) && std::isnan(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
} }
} }
int main() int main()
{ {
test<float>(); test<float>();
test<double>(); test<double>();
test<long double>(); test<long double>();
test_edges(); test_edges();
} }

test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp

Show All 28 Lines
void void
test() test()
{ {
test(std::complex<T>(0, 0), std::complex<T>(1, 0)); test(std::complex<T>(0, 0), std::complex<T>(1, 0));
} }
void test_edges() void test_edges()
{ {
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
std::complex<double> r = exp(x[i]); std::complex<double> r = exp(testcases[i]);
if (x[i].real() == 0 && x[i].imag() == 0) if (testcases[i].real() == 0 && testcases[i].imag() == 0)
{ {
assert(r.real() == 1.0); assert(r.real() == 1.0);
assert(r.imag() == 0); assert(r.imag() == 0);
assert(std::signbit(x[i].imag()) == std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
} }
else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag())) else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag())) else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isinf(x[i].real()) && x[i].real() > 0 && x[i].imag() == 0) else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && testcases[i].imag() == 0)
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(r.real() > 0); assert(r.real() > 0);
assert(r.imag() == 0); assert(r.imag() == 0);
assert(std::signbit(x[i].imag()) == std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
} }
else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isinf(x[i].imag())) else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isinf(testcases[i].imag()))
{ {
assert(r.real() == 0); assert(r.real() == 0);
assert(r.imag() == 0); assert(r.imag() == 0);
} }
else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isinf(x[i].imag())) else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isinf(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isnan(x[i].imag())) else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isnan(testcases[i].imag()))
{ {
assert(r.real() == 0); assert(r.real() == 0);
assert(r.imag() == 0); assert(r.imag() == 0);
} }
else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isnan(x[i].imag())) else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isnan(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isnan(x[i].real()) && x[i].imag() == 0) else if (std::isnan(testcases[i].real()) && testcases[i].imag() == 0)
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(r.imag() == 0); assert(r.imag() == 0);
assert(std::signbit(x[i].imag()) == std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
} }
else if (std::isnan(x[i].real()) && x[i].imag() != 0) else if (std::isnan(testcases[i].real()) && testcases[i].imag() != 0)
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isnan(x[i].real()) && std::isnan(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isfinite(x[i].imag()) && std::abs(x[i].imag()) <= 1) else if (std::isfinite(testcases[i].imag()) && std::abs(testcases[i].imag()) <= 1)
{ {
assert(!std::signbit(r.real())); assert(!std::signbit(r.real()));
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
} }
} }
int main() int main()
{ {
test<float>(); test<float>();
test<double>(); test<double>();
test<long double>(); test<long double>();
test_edges(); test_edges();
} }

test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp

Show All 29 Lines
test() test()
{ {
test(std::complex<T>(0, 0), std::complex<T>(-INFINITY, 0)); test(std::complex<T>(0, 0), std::complex<T>(-INFINITY, 0));
} }
void test_edges() void test_edges()
{ {
const double pi = std::atan2(+0., -0.); const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
std::complex<double> r = log(x[i]); std::complex<double> r = log(testcases[i]);
if (x[i].real() == 0 && x[i].imag() == 0) if (testcases[i].real() == 0 && testcases[i].imag() == 0)
{ {
if (std::signbit(x[i].real())) if (std::signbit(testcases[i].real()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(r.real() < 0); assert(r.real() < 0);
if (std::signbit(x[i].imag())) if (std::signbit(testcases[i].imag()))
is_about(r.imag(), -pi); is_about(r.imag(), -pi);
else else
is_about(r.imag(), pi); is_about(r.imag(), pi);
} }
else else
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(r.real() < 0); assert(r.real() < 0);
assert(r.imag() == 0); assert(r.imag() == 0);
assert(std::signbit(x[i].imag()) == std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
} }
} }
else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag())) else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(r.real() > 0); assert(r.real() > 0);
if (x[i].imag() > 0) if (testcases[i].imag() > 0)
is_about(r.imag(), pi/2); is_about(r.imag(), pi/2);
else else
is_about(r.imag(), -pi/2); is_about(r.imag(), -pi/2);
} }
else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag())) else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isfinite(x[i].imag())) else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isfinite(testcases[i].imag()))
{ {
assert(std::isinf(r.real()) && r.real() > 0); assert(std::isinf(r.real()) && r.real() > 0);
if (r.imag() > 0) if (r.imag() > 0)
is_about(r.imag(), pi); is_about(r.imag(), pi);
else else
is_about(r.imag(), -pi); is_about(r.imag(), -pi);
} }
else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isfinite(x[i].imag())) else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isfinite(testcases[i].imag()))
{ {
assert(std::isinf(r.real()) && r.real() > 0); assert(std::isinf(r.real()) && r.real() > 0);
assert(r.imag() == 0); assert(r.imag() == 0);
assert(std::signbit(x[i].imag()) == std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
} }
else if (x[i].real() == 1 && x[i].imag() == 0) else if (testcases[i].real() == 1 && testcases[i].imag() == 0)
{ {
assert(r.real() == 0); assert(r.real() == 0);
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
else if (x[i].real() == 0 && x[i].imag() == 1) else if (testcases[i].real() == 0 && testcases[i].imag() == 1)
{ {
assert(r.real() == 0); assert(r.real() == 0);
is_about(r.imag(), pi/2); is_about(r.imag(), pi/2);
} }
else if (x[i].real() == -1 && x[i].imag() == 0) else if (testcases[i].real() == -1 && testcases[i].imag() == 0)
{ {
assert(r.real() == 0); assert(r.real() == 0);
if (std::signbit(x[i].imag())) if (std::signbit(testcases[i].imag()))
is_about(r.imag(), -pi); is_about(r.imag(), -pi);
else else
is_about(r.imag(), pi); is_about(r.imag(), pi);
} }
else if (x[i].real() == 0 && x[i].imag() == -1) else if (testcases[i].real() == 0 && testcases[i].imag() == -1)
{ {
assert(r.real() == 0); assert(r.real() == 0);
is_about(r.imag(), -pi/2); is_about(r.imag(), -pi/2);
} }
else if (std::isfinite(x[i].real()) && std::isfinite(x[i].imag()) && abs(x[i]) < 1) else if (std::isfinite(testcases[i].real()) && std::isfinite(testcases[i].imag()) && abs(testcases[i]) < 1)
{ {
assert( std::signbit(r.real())); assert( std::signbit(r.real()));
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
else if (std::isfinite(x[i].real()) && std::isfinite(x[i].imag()) && abs(x[i]) > 1) else if (std::isfinite(testcases[i].real()) && std::isfinite(testcases[i].imag()) && abs(testcases[i]) > 1)
{ {
assert(!std::signbit(r.real())); assert(!std::signbit(r.real()));
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
} }
} }
int main() int main()
{ {
test<float>(); test<float>();
test<double>(); test<double>();
test<long double>(); test<long double>();
test_edges(); test_edges();
} }

test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp

Show All 29 Lines
test() test()
{ {
test(std::complex<T>(0, 0), std::complex<T>(-INFINITY, 0)); test(std::complex<T>(0, 0), std::complex<T>(-INFINITY, 0));
} }
void test_edges() void test_edges()
{ {
const double pi = std::atan2(+0., -0.); const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
std::complex<double> r = log10(x[i]); std::complex<double> r = log10(testcases[i]);
std::complex<double> z = log(x[i])/std::log(10); std::complex<double> z = log(testcases[i])/std::log(10);
if (std::isnan(real(r))) if (std::isnan(real(r)))
assert(std::isnan(real(z))); assert(std::isnan(real(z)));
else else
{ {
assert(real(r) == real(z)); assert(real(r) == real(z));
assert(std::signbit(real(r)) == std::signbit(real(z))); assert(std::signbit(real(r)) == std::signbit(real(z)));
} }
if (std::isnan(imag(r))) if (std::isnan(imag(r)))
Show All 16 Lines

test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp

Show All 31 Lines
test() test()
{ {
test(std::complex<T>(2, 3), std::complex<T>(2, 0), std::complex<T>(-5, 12)); test(std::complex<T>(2, 3), std::complex<T>(2, 0), std::complex<T>(-5, 12));
} }
void test_edges() void test_edges()
{ {
const double pi = std::atan2(+0., -0.); const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
for (unsigned j = 0; j < N; ++j) for (unsigned j = 0; j < N; ++j)
{ {
std::complex<double> r = pow(x[i], x[j]); std::complex<double> r = pow(testcases[i], testcases[j]);
std::complex<double> z = exp(x[j] * log(x[i])); std::complex<double> z = exp(testcases[j] * log(testcases[i]));
if (std::isnan(real(r))) if (std::isnan(real(r)))
assert(std::isnan(real(z))); assert(std::isnan(real(z)));
else else
{ {
assert(real(r) == real(z)); assert(real(r) == real(z));
assert(std::signbit(real(r)) == std::signbit(real(z))); assert(std::signbit(real(r)) == std::signbit(real(z)));
} }
if (std::isnan(imag(r))) if (std::isnan(imag(r)))
Show All 17 Lines

test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp

Show All 31 Lines
test() test()
{ {
test(std::complex<T>(2, 3), T(2), std::complex<T>(-5, 12)); test(std::complex<T>(2, 3), T(2), std::complex<T>(-5, 12));
} }
void test_edges() void test_edges()
{ {
const double pi = std::atan2(+0., -0.); const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
for (unsigned j = 0; j < N; ++j) for (unsigned j = 0; j < N; ++j)
{ {
std::complex<double> r = pow(x[i], real(x[j])); std::complex<double> r = pow(testcases[i], real(testcases[j]));
std::complex<double> z = exp(std::complex<double>(real(x[j])) * log(x[i])); std::complex<double> z = exp(std::complex<double>(real(testcases[j])) * log(testcases[i]));
if (std::isnan(real(r))) if (std::isnan(real(r)))
assert(std::isnan(real(z))); assert(std::isnan(real(z)));
else else
{ {
assert(real(r) == real(z)); assert(real(r) == real(z));
} }
if (std::isnan(imag(r))) if (std::isnan(imag(r)))
assert(std::isnan(imag(z))); assert(std::isnan(imag(z)));
Show All 15 Lines

test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp

Show All 31 Lines
test() test()
{ {
test(T(2), std::complex<T>(2), std::complex<T>(4)); test(T(2), std::complex<T>(2), std::complex<T>(4));
} }
void test_edges() void test_edges()
{ {
const double pi = std::atan2(+0., -0.); const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
for (unsigned j = 0; j < N; ++j) for (unsigned j = 0; j < N; ++j)
{ {
std::complex<double> r = pow(real(x[i]), x[j]); std::complex<double> r = pow(real(testcases[i]), testcases[j]);
std::complex<double> z = exp(x[j] * log(std::complex<double>(real(x[i])))); std::complex<double> z = exp(testcases[j] * log(std::complex<double>(real(testcases[i]))));
if (std::isnan(real(r))) if (std::isnan(real(r)))
assert(std::isnan(real(z))); assert(std::isnan(real(z)));
else else
{ {
assert(real(r) == real(z)); assert(real(r) == real(z));
} }
if (std::isnan(imag(r))) if (std::isnan(imag(r)))
assert(std::isnan(imag(z))); assert(std::isnan(imag(z)));
Show All 15 Lines

test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp

Show All 30 Lines
{ {
test(std::complex<T>(0, 0), std::complex<T>(0, 0)); test(std::complex<T>(0, 0), std::complex<T>(0, 0));
} }
void test_edges() void test_edges()
{ {
typedef std::complex<double> C; typedef std::complex<double> C;
const double pi = std::atan2(+0., -0.); const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
std::complex<double> r = sin(x[i]); std::complex<double> r = sin(testcases[i]);
std::complex<double> t1(-imag(x[i]), real(x[i])); std::complex<double> t1(-imag(testcases[i]), real(testcases[i]));
std::complex<double> t2 = sinh(t1); std::complex<double> t2 = sinh(t1);
std::complex<double> z(imag(t2), -real(t2)); std::complex<double> z(imag(t2), -real(t2));
if (std::isnan(real(r))) if (std::isnan(real(r)))
assert(std::isnan(real(z))); assert(std::isnan(real(z)));
else else
{ {
assert(real(r) == real(z)); assert(real(r) == real(z));
assert(std::signbit(real(r)) == std::signbit(real(z))); assert(std::signbit(real(r)) == std::signbit(real(z)));
Show All 18 Lines

test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp

Show All 30 Lines
{ {
test(std::complex<T>(0, 0), std::complex<T>(0, 0)); test(std::complex<T>(0, 0), std::complex<T>(0, 0));
} }
void test_edges() void test_edges()
{ {
typedef std::complex<double> C; typedef std::complex<double> C;
const double pi = std::atan2(+0., -0.); const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
std::complex<double> r = sinh(x[i]); std::complex<double> r = sinh(testcases[i]);
if (x[i].real() == 0 && x[i].imag() == 0) if (testcases[i].real() == 0 && testcases[i].imag() == 0)
{ {
assert(r.real() == 0); assert(r.real() == 0);
assert(std::signbit(r.real()) == std::signbit(x[i].real())); assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
assert(r.imag() == 0); assert(r.imag() == 0);
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
else if (x[i].real() == 0 && std::isinf(x[i].imag())) else if (testcases[i].real() == 0 && std::isinf(testcases[i].imag()))
{ {
assert(r.real() == 0); assert(r.real() == 0);
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag())) else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (x[i].real() == 0 && std::isnan(x[i].imag())) else if (testcases[i].real() == 0 && std::isnan(testcases[i].imag()))
{ {
assert(r.real() == 0); assert(r.real() == 0);
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag())) else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isinf(x[i].real()) && x[i].imag() == 0) else if (std::isinf(testcases[i].real()) && testcases[i].imag() == 0)
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(std::signbit(r.real()) == std::signbit(x[i].real())); assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
assert(r.imag() == 0); assert(r.imag() == 0);
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
else if (std::isinf(x[i].real()) && std::isfinite(x[i].imag())) else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(std::signbit(r.real()) == std::signbit(x[i].real() * cos(x[i].imag()))); assert(std::signbit(r.real()) == std::signbit(testcases[i].real() * cos(testcases[i].imag())));
assert(std::isinf(r.imag())); assert(std::isinf(r.imag()));
assert(std::signbit(r.imag()) == std::signbit(sin(x[i].imag()))); assert(std::signbit(r.imag()) == std::signbit(sin(testcases[i].imag())));
} }
else if (std::isinf(x[i].real()) && std::isinf(x[i].imag())) else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isinf(x[i].real()) && std::isnan(x[i].imag())) else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isnan(x[i].real()) && x[i].imag() == 0) else if (std::isnan(testcases[i].real()) && testcases[i].imag() == 0)
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(r.imag() == 0); assert(r.imag() == 0);
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isnan(x[i].real()) && std::isnan(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
} }
} }
int main() int main()
{ {
test<float>(); test<float>();
test<double>(); test<double>();
test<long double>(); test<long double>();
test_edges(); test_edges();
} }

test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp

Show All 30 Lines
void void
test() test()
{ {
test(std::complex<T>(64, 0), std::complex<T>(8, 0)); test(std::complex<T>(64, 0), std::complex<T>(8, 0));
} }
void test_edges() void test_edges()
{ {
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
std::complex<double> r = sqrt(x[i]); std::complex<double> r = sqrt(testcases[i]);
if (x[i].real() == 0 && x[i].imag() == 0) if (testcases[i].real() == 0 && testcases[i].imag() == 0)
{ {
assert(!std::signbit(r.real())); assert(!std::signbit(r.real()));
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
else if (std::isinf(x[i].imag())) else if (std::isinf(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(r.real() > 0); assert(r.real() > 0);
assert(std::isinf(r.imag())); assert(std::isinf(r.imag()));
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag())) else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isfinite(x[i].imag())) else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isfinite(testcases[i].imag()))
{ {
assert(r.real() == 0); assert(r.real() == 0);
assert(!std::signbit(r.real())); assert(!std::signbit(r.real()));
assert(std::isinf(r.imag())); assert(std::isinf(r.imag()));
assert(std::signbit(x[i].imag()) == std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
} }
else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isfinite(x[i].imag())) else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isfinite(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(r.real() > 0); assert(r.real() > 0);
assert(r.imag() == 0); assert(r.imag() == 0);
assert(std::signbit(x[i].imag()) == std::signbit(r.imag())); assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
} }
else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isnan(x[i].imag())) else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isinf(r.imag())); assert(std::isinf(r.imag()));
} }
else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isnan(x[i].imag())) else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isnan(testcases[i].imag()))
{ {
assert(std::isinf(r.real())); assert(std::isinf(r.real()));
assert(r.real() > 0); assert(r.real() > 0);
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isnan(x[i].real()) && (std::isfinite(x[i].imag()) || std::isnan(x[i].imag()))) else if (std::isnan(testcases[i].real()) && (std::isfinite(testcases[i].imag()) || std::isnan(testcases[i].imag())))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::signbit(x[i].imag())) else if (std::signbit(testcases[i].imag()))
{ {
assert(!std::signbit(r.real())); assert(!std::signbit(r.real()));
assert(std::signbit(r.imag())); assert(std::signbit(r.imag()));
} }
else else
{ {
assert(!std::signbit(r.real())); assert(!std::signbit(r.real()));
assert(!std::signbit(r.imag())); assert(!std::signbit(r.imag()));
Show All 11 Lines

test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp

Show All 31 Linestest()
test(std::complex<T>(0, 0), std::complex<T>(0, 0)); test(std::complex<T>(0, 0), std::complex<T>(0, 0));
test(std::complex<T>(10000, -10000), std::complex<T>(0, -1)); test(std::complex<T>(10000, -10000), std::complex<T>(0, -1));
} }
void test_edges() void test_edges()
{ {
typedef std::complex<double> C; typedef std::complex<double> C;
const double pi = std::atan2(+0., -0.); const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
std::complex<double> r = tan(x[i]); std::complex<double> r = tan(testcases[i]);
std::complex<double> t1(-imag(x[i]), real(x[i])); std::complex<double> t1(-imag(testcases[i]), real(testcases[i]));
std::complex<double> t2 = tanh(t1); std::complex<double> t2 = tanh(t1);
std::complex<double> z(imag(t2), -real(t2)); std::complex<double> z(imag(t2), -real(t2));
if (std::isnan(real(r))) if (std::isnan(real(r)))
assert(std::isnan(real(z))); assert(std::isnan(real(z)));
else else
{ {
assert(real(r) == real(z)); assert(real(r) == real(z));
assert(std::signbit(real(r)) == std::signbit(real(z))); assert(std::signbit(real(r)) == std::signbit(real(z)));
Show All 18 Lines

test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp

Show All 30 Lines
{ {
test(std::complex<T>(0, 0), std::complex<T>(0, 0)); test(std::complex<T>(0, 0), std::complex<T>(0, 0));
} }
void test_edges() void test_edges()
{ {
typedef std::complex<double> C; typedef std::complex<double> C;
const double pi = std::atan2(+0., -0.); const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
std::complex<double> r = tanh(x[i]); std::complex<double> r = tanh(testcases[i]);
if (x[i].real() == 0 && x[i].imag() == 0) if (testcases[i].real() == 0 && testcases[i].imag() == 0)
{ {
assert(r.real() == 0); assert(r.real() == 0);
assert(std::signbit(r.real()) == std::signbit(x[i].real())); assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
assert(r.imag() == 0); assert(r.imag() == 0);
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag())) else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag())) else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isinf(x[i].real()) && std::isfinite(x[i].imag())) else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
{ {
assert(r.real() == 1); assert(r.real() == 1);
assert(r.imag() == 0); assert(r.imag() == 0);
assert(std::signbit(r.imag()) == std::signbit(sin(2*x[i].imag()))); assert(std::signbit(r.imag()) == std::signbit(sin(2*testcases[i].imag())));
} }
else if (std::isinf(x[i].real()) && std::isinf(x[i].imag())) else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
assert(r.real() == 1); assert(r.real() == 1);
assert(r.imag() == 0); assert(r.imag() == 0);
} }
else if (std::isinf(x[i].real()) && std::isnan(x[i].imag())) else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(r.real() == 1); assert(r.real() == 1);
assert(r.imag() == 0); assert(r.imag() == 0);
} }
else if (std::isnan(x[i].real()) && x[i].imag() == 0) else if (std::isnan(testcases[i].real()) && testcases[i].imag() == 0)
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(r.imag() == 0); assert(r.imag() == 0);
assert(std::signbit(r.imag()) == std::signbit(x[i].imag())); assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
} }
else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
else if (std::isnan(x[i].real()) && std::isnan(x[i].imag())) else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
{ {
assert(std::isnan(r.real())); assert(std::isnan(r.real()));
assert(std::isnan(r.imag())); assert(std::isnan(r.imag()));
} }
} }
} }
int main() int main()
{ {
test<float>(); test<float>();
test<double>(); test<double>();
test<long double>(); test<long double>();
test_edges(); test_edges();
} }

test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp

Show All 22 Lines
test() test()
{ {
std::complex<T> z(3, 4); std::complex<T> z(3, 4);
assert(abs(z) == 5); assert(abs(z) == 5);
} }
void test_edges() void test_edges()
{ {
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
double r = abs(x[i]); double r = abs(testcases[i]);
switch (classify(x[i])) switch (classify(testcases[i]))
{ {
case zero: case zero:
assert(r == 0); assert(r == 0);
assert(!std::signbit(r)); assert(!std::signbit(r));
break; break;
case non_zero: case non_zero:
assert(std::isfinite(r) && r > 0); assert(std::isfinite(r) && r > 0);
break; break;
Show All 20 Lines

test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp

Show All 23 Lines
{ {
std::complex<T> z(1, 0); std::complex<T> z(1, 0);
assert(arg(z) == 0); assert(arg(z) == 0);
} }
void test_edges() void test_edges()
{ {
const double pi = std::atan2(+0., -0.); const double pi = std::atan2(+0., -0.);
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
double r = arg(x[i]); double r = arg(testcases[i]);
if (std::isnan(x[i].real()) || std::isnan(x[i].imag())) if (std::isnan(testcases[i].real()) || std::isnan(testcases[i].imag()))
assert(std::isnan(r)); assert(std::isnan(r));
else else
{ {
switch (classify(x[i])) switch (classify(testcases[i]))
{ {
case zero: case zero:
if (std::signbit(x[i].real())) if (std::signbit(testcases[i].real()))
{ {
if (std::signbit(x[i].imag())) if (std::signbit(testcases[i].imag()))
is_about(r, -pi); is_about(r, -pi);
else else
is_about(r, pi); is_about(r, pi);
} }
else else
{ {
assert(std::signbit(x[i].imag()) == std::signbit(r)); assert(std::signbit(testcases[i].imag()) == std::signbit(r));
} }
break; break;
case non_zero: case non_zero:
if (x[i].real() == 0) if (testcases[i].real() == 0)
{ {
if (x[i].imag() < 0) if (testcases[i].imag() < 0)
is_about(r, -pi/2); is_about(r, -pi/2);
else else
is_about(r, pi/2); is_about(r, pi/2);
} }
else if (x[i].imag() == 0) else if (testcases[i].imag() == 0)
{ {
if (x[i].real() < 0) if (testcases[i].real() < 0)
{ {
if (std::signbit(x[i].imag())) if (std::signbit(testcases[i].imag()))
is_about(r, -pi); is_about(r, -pi);
else else
is_about(r, pi); is_about(r, pi);
} }
else else
{ {
assert(r == 0); assert(r == 0);
assert(std::signbit(x[i].imag()) == std::signbit(r)); assert(std::signbit(testcases[i].imag()) == std::signbit(r));
} }
} }
else if (x[i].imag() > 0) else if (testcases[i].imag() > 0)
assert(r > 0); assert(r > 0);
else else
assert(r < 0); assert(r < 0);
break; break;
case inf: case inf:
if (std::isinf(x[i].real()) && std::isinf(x[i].imag())) if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
{ {
if (x[i].real() < 0) if (testcases[i].real() < 0)
{ {
if (x[i].imag() > 0) if (testcases[i].imag() > 0)
is_about(r, 0.75 * pi); is_about(r, 0.75 * pi);
else else
is_about(r, -0.75 * pi); is_about(r, -0.75 * pi);
} }
else else
{ {
if (x[i].imag() > 0) if (testcases[i].imag() > 0)
is_about(r, 0.25 * pi); is_about(r, 0.25 * pi);
else else
is_about(r, -0.25 * pi); is_about(r, -0.25 * pi);
} }
} }
else if (std::isinf(x[i].real())) else if (std::isinf(testcases[i].real()))
{ {
if (x[i].real() < 0) if (testcases[i].real() < 0)
{ {
if (std::signbit(x[i].imag())) if (std::signbit(testcases[i].imag()))
is_about(r, -pi); is_about(r, -pi);
else else
is_about(r, pi); is_about(r, pi);
} }
else else
{ {
assert(r == 0); assert(r == 0);
assert(std::signbit(r) == std::signbit(x[i].imag())); assert(std::signbit(r) == std::signbit(testcases[i].imag()));
} }
} }
else else
{ {
if (x[i].imag() < 0) if (testcases[i].imag() < 0)
is_about(r, -pi/2); is_about(r, -pi/2);
else else
is_about(r, pi/2); is_about(r, pi/2);
} }
break; break;
} }
} }
} }
Show All 9 Lines

test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp

Show All 22 Lines
test() test()
{ {
std::complex<T> z(3, 4); std::complex<T> z(3, 4);
assert(norm(z) == 25); assert(norm(z) == 25);
} }
void test_edges() void test_edges()
{ {
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
double r = norm(x[i]); double r = norm(testcases[i]);
switch (classify(x[i])) switch (classify(testcases[i]))
{ {
case zero: case zero:
assert(r == 0); assert(r == 0);
assert(!std::signbit(r)); assert(!std::signbit(r));
break; break;
case non_zero: case non_zero:
assert(std::isfinite(r) && r > 0); assert(std::isfinite(r) && r > 0);
break; break;
Show All 20 Lines

test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp

Show All 40 Linestest()
test(T(100), std::complex<T>(100, 0)); test(T(100), std::complex<T>(100, 0));
test(T(0), T(0), std::complex<T>(0, 0)); test(T(0), T(0), std::complex<T>(0, 0));
test(T(1), T(0), std::complex<T>(1, 0)); test(T(1), T(0), std::complex<T>(1, 0));
test(T(100), T(0), std::complex<T>(100, 0)); test(T(100), T(0), std::complex<T>(100, 0));
} }
void test_edges() void test_edges()
{ {
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
double r = real(x[i]); double r = real(testcases[i]);
double theta = imag(x[i]); double theta = imag(testcases[i]);
std::complex<double> z = std::polar(r, theta); std::complex<double> z = std::polar(r, theta);
switch (classify(r)) switch (classify(r))
{ {
case zero: case zero:
if (std::signbit(r) || classify(theta) == inf || classify(theta) == NaN) if (std::signbit(r) || classify(theta) == inf || classify(theta) == NaN)
{ {
int c = classify(z); int c = classify(z);
assert(c == NaN || c == non_zero_nan); assert(c == NaN || c == non_zero_nan);
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp

Show All 31 Linestest()
test(std::complex<T>(1, 2), std::complex<T>(1, 2)); test(std::complex<T>(1, 2), std::complex<T>(1, 2));
test(std::complex<T>(-1, 2), std::complex<T>(-1, 2)); test(std::complex<T>(-1, 2), std::complex<T>(-1, 2));
test(std::complex<T>(1, -2), std::complex<T>(1, -2)); test(std::complex<T>(1, -2), std::complex<T>(1, -2));
test(std::complex<T>(-1, -2), std::complex<T>(-1, -2)); test(std::complex<T>(-1, -2), std::complex<T>(-1, -2));
} }
void test_edges() void test_edges()
{ {
const unsigned N = sizeof(x) / sizeof(x[0]); const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
for (unsigned i = 0; i < N; ++i) for (unsigned i = 0; i < N; ++i)
{ {
std::complex<double> r = proj(x[i]); std::complex<double> r = proj(testcases[i]);
switch (classify(x[i])) switch (classify(testcases[i]))
{ {
case zero: case zero:
case non_zero: case non_zero:
assert(r == x[i]); assert(r == testcases[i]);
assert(std::signbit(real(r)) == std::signbit(real(x[i]))); assert(std::signbit(real(r)) == std::signbit(real(testcases[i])));
assert(std::signbit(imag(r)) == std::signbit(imag(x[i]))); assert(std::signbit(imag(r)) == std::signbit(imag(testcases[i])));
break; break;
case inf: case inf:
assert(std::isinf(real(r)) && real(r) > 0); assert(std::isinf(real(r)) && real(r) > 0);
assert(imag(r) == 0); assert(imag(r) == 0);
assert(std::signbit(imag(r)) == std::signbit(imag(x[i]))); assert(std::signbit(imag(r)) == std::signbit(imag(testcases[i])));
break; break;
case NaN: case NaN:
case non_zero_nan: case non_zero_nan:
assert(classify(r) == classify(x[i])); assert(classify(r) == classify(testcases[i]));
break; break;
} }
} }
} }
int main() int main()
{ {
test<float>(); test<float>();
test<double>(); test<double>();
test<long double>(); test<long double>();
test_edges(); test_edges();
} }