Skip to content

[libcxx] adds tests for complex<float> and complex<long double> #122809

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 1 commit into
base: main
Choose a base branch
from
Open

[libcxx] adds tests for complex<float> and complex<long double> #122809

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
331 changes: 165 additions & 166 deletions libcxx/test/std/numerics/complex.number/cases.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,181 +15,182 @@

#include <cassert>
#include <complex>
#include <limits>
#include <type_traits>

#include "test_macros.h"

TEST_CONSTEXPR_CXX20 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),
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<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<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<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<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<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<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<double>(-0, -1.e-6),
std::complex<double>(-0, 1.e-6),
std::complex<double>(-0, 1.e+6),
std::complex<double>(-0, -1.e+6),
std::complex<double>( 0, -1.e-6),
std::complex<double>( 0, 1.e-6),
std::complex<double>( 0, 1.e+6),
std::complex<double>( 0, -1.e+6),
std::complex<T>(-0.0, -1.e-6),
std::complex<T>(-0.0, +1.e-6),
std::complex<T>(-0.0, +1.e+6),
std::complex<T>(-0.0, -1.e+6),
std::complex<T>(+0.0, -1.e-6),
std::complex<T>(+0.0, +1.e-6),
std::complex<T>(+0.0, +1.e+6),
std::complex<T>(+0.0, -1.e+6),

std::complex<double>(-1.e-6, -0),
std::complex<double>( 1.e-6, -0),
std::complex<double>( 1.e+6, -0),
std::complex<double>(-1.e+6, -0),
std::complex<double>(-1.e-6, 0),
std::complex<double>( 1.e-6, 0),
std::complex<double>( 1.e+6, 0),
std::complex<double>(-1.e+6, 0),
std::complex<T>(-1.e-6, -0.0),
std::complex<T>(+1.e-6, -0.0),
std::complex<T>(+1.e+6, -0.0),
std::complex<T>(-1.e+6, -0.0),
std::complex<T>(-1.e-6, +0.0),
std::complex<T>(+1.e-6, +0.0),
std::complex<T>(+1.e+6, +0.0),
std::complex<T>(-1.e+6, +0.0),

std::complex<double>(std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()),
std::complex<double>(-std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN()),
std::complex<double>(-2, std::numeric_limits<double>::quiet_NaN()),
std::complex<double>(-1, std::numeric_limits<double>::quiet_NaN()),
std::complex<double>(-0.5, std::numeric_limits<double>::quiet_NaN()),
std::complex<double>(-0., std::numeric_limits<double>::quiet_NaN()),
std::complex<double>(+0., std::numeric_limits<double>::quiet_NaN()),
std::complex<double>(0.5, std::numeric_limits<double>::quiet_NaN()),
std::complex<double>(1, std::numeric_limits<double>::quiet_NaN()),
std::complex<double>(2, std::numeric_limits<double>::quiet_NaN()),
std::complex<double>(std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN()),
std::complex<T>(std::numeric_limits<T>::quiet_NaN(), std::numeric_limits<T>::quiet_NaN()),
std::complex<T>(-std::numeric_limits<T>::infinity(), std::numeric_limits<T>::quiet_NaN()),
std::complex<T>(-2, std::numeric_limits<T>::quiet_NaN()),
std::complex<T>(-1, std::numeric_limits<T>::quiet_NaN()),
std::complex<T>(-0.5, std::numeric_limits<T>::quiet_NaN()),
std::complex<T>(-0., std::numeric_limits<T>::quiet_NaN()),
std::complex<T>(+0., std::numeric_limits<T>::quiet_NaN()),
std::complex<T>(0.5, std::numeric_limits<T>::quiet_NaN()),
std::complex<T>(1, std::numeric_limits<T>::quiet_NaN()),
std::complex<T>(2, std::numeric_limits<T>::quiet_NaN()),
std::complex<T>(std::numeric_limits<T>::infinity(), std::numeric_limits<T>::quiet_NaN()),

std::complex<double>(std::numeric_limits<double>::quiet_NaN(), -std::numeric_limits<double>::infinity()),
std::complex<double>(-std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity()),
std::complex<double>(-2, -std::numeric_limits<double>::infinity()),
std::complex<double>(-1, -std::numeric_limits<double>::infinity()),
std::complex<double>(-0.5, -std::numeric_limits<double>::infinity()),
std::complex<double>(-0., -std::numeric_limits<double>::infinity()),
std::complex<double>(+0., -std::numeric_limits<double>::infinity()),
std::complex<double>(0.5, -std::numeric_limits<double>::infinity()),
std::complex<double>(1, -std::numeric_limits<double>::infinity()),
std::complex<double>(2, -std::numeric_limits<double>::infinity()),
std::complex<double>(std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity()),
std::complex<T>(std::numeric_limits<T>::quiet_NaN(), -std::numeric_limits<T>::infinity()),
std::complex<T>(-std::numeric_limits<T>::infinity(), -std::numeric_limits<T>::infinity()),
std::complex<T>(-2, -std::numeric_limits<T>::infinity()),
std::complex<T>(-1, -std::numeric_limits<T>::infinity()),
std::complex<T>(-0.5, -std::numeric_limits<T>::infinity()),
std::complex<T>(-0., -std::numeric_limits<T>::infinity()),
std::complex<T>(+0., -std::numeric_limits<T>::infinity()),
std::complex<T>(0.5, -std::numeric_limits<T>::infinity()),
std::complex<T>(1, -std::numeric_limits<T>::infinity()),
std::complex<T>(2, -std::numeric_limits<T>::infinity()),
std::complex<T>(std::numeric_limits<T>::infinity(), -std::numeric_limits<T>::infinity()),

std::complex<double>(std::numeric_limits<double>::quiet_NaN(), -2),
std::complex<double>(-std::numeric_limits<double>::infinity(), -2),
std::complex<double>(-2, -2),
std::complex<double>(-1, -2),
std::complex<double>(-0.5, -2),
std::complex<double>(-0., -2),
std::complex<double>(+0., -2),
std::complex<double>(0.5, -2),
std::complex<double>(1, -2),
std::complex<double>(2, -2),
std::complex<double>(std::numeric_limits<double>::infinity(), -2),
std::complex<T>(std::numeric_limits<T>::quiet_NaN(), -2),
std::complex<T>(-std::numeric_limits<T>::infinity(), -2),
std::complex<T>(-2, -2),
std::complex<T>(-1, -2),
std::complex<T>(-0.5, -2),
std::complex<T>(-0., -2),
std::complex<T>(+0., -2),
std::complex<T>(0.5, -2),
std::complex<T>(1, -2),
std::complex<T>(2, -2),
std::complex<T>(std::numeric_limits<T>::infinity(), -2),

std::complex<double>(std::numeric_limits<double>::quiet_NaN(), -1),
std::complex<double>(-std::numeric_limits<double>::infinity(), -1),
std::complex<double>(-2, -1),
std::complex<double>(-1, -1),
std::complex<double>(-0.5, -1),
std::complex<double>(-0., -1),
std::complex<double>(+0., -1),
std::complex<double>(0.5, -1),
std::complex<double>(1, -1),
std::complex<double>(2, -1),
std::complex<double>(std::numeric_limits<double>::infinity(), -1),
std::complex<T>(std::numeric_limits<T>::quiet_NaN(), -1),
std::complex<T>(-std::numeric_limits<T>::infinity(), -1),
std::complex<T>(-2, -1),
std::complex<T>(-1, -1),
std::complex<T>(-0.5, -1),
std::complex<T>(-0., -1),
std::complex<T>(+0., -1),
std::complex<T>(0.5, -1),
std::complex<T>(1, -1),
std::complex<T>(2, -1),
std::complex<T>(std::numeric_limits<T>::infinity(), -1),

std::complex<double>(std::numeric_limits<double>::quiet_NaN(), -0.5),
std::complex<double>(-std::numeric_limits<double>::infinity(), -0.5),
std::complex<double>(-2, -0.5),
std::complex<double>(-1, -0.5),
std::complex<double>(-0.5, -0.5),
std::complex<double>(-0., -0.5),
std::complex<double>(+0., -0.5),
std::complex<double>(0.5, -0.5),
std::complex<double>(1, -0.5),
std::complex<double>(2, -0.5),
std::complex<double>(std::numeric_limits<double>::infinity(), -0.5),
std::complex<T>(std::numeric_limits<T>::quiet_NaN(), -0.5),
std::complex<T>(-std::numeric_limits<T>::infinity(), -0.5),
std::complex<T>(-2, -0.5),
std::complex<T>(-1, -0.5),
std::complex<T>(-0.5, -0.5),
std::complex<T>(-0., -0.5),
std::complex<T>(+0., -0.5),
std::complex<T>(0.5, -0.5),
std::complex<T>(1, -0.5),
std::complex<T>(2, -0.5),
std::complex<T>(std::numeric_limits<T>::infinity(), -0.5),

std::complex<double>(std::numeric_limits<double>::quiet_NaN(), -0.),
std::complex<double>(-std::numeric_limits<double>::infinity(), -0.),
std::complex<double>(-2, -0.),
std::complex<double>(-1, -0.),
std::complex<double>(-0.5, -0.),
std::complex<double>(-0., -0.),
std::complex<double>(+0., -0.),
std::complex<double>(0.5, -0.),
std::complex<double>(1, -0.),
std::complex<double>(2, -0.),
std::complex<double>(std::numeric_limits<double>::infinity(), -0.),
std::complex<T>(std::numeric_limits<T>::quiet_NaN(), -0.),
std::complex<T>(-std::numeric_limits<T>::infinity(), -0.),
std::complex<T>(-2, -0.),
std::complex<T>(-1, -0.),
std::complex<T>(-0.5, -0.),
std::complex<T>(-0., -0.),
std::complex<T>(+0., -0.),
std::complex<T>(0.5, -0.),
std::complex<T>(1, -0.),
std::complex<T>(2, -0.),
std::complex<T>(std::numeric_limits<T>::infinity(), -0.),

std::complex<double>(std::numeric_limits<double>::quiet_NaN(), +0.),
std::complex<double>(-std::numeric_limits<double>::infinity(), +0.),
std::complex<double>(-2, +0.),
std::complex<double>(-1, +0.),
std::complex<double>(-0.5, +0.),
std::complex<double>(-0., +0.),
std::complex<double>(+0., +0.),
std::complex<double>(0.5, +0.),
std::complex<double>(1, +0.),
std::complex<double>(2, +0.),
std::complex<double>(std::numeric_limits<double>::infinity(), +0.),
std::complex<T>(std::numeric_limits<T>::quiet_NaN(), +0.),
std::complex<T>(-std::numeric_limits<T>::infinity(), +0.),
std::complex<T>(-2, +0.),
std::complex<T>(-1, +0.),
std::complex<T>(-0.5, +0.),
std::complex<T>(-0., +0.),
std::complex<T>(+0., +0.),
std::complex<T>(0.5, +0.),
std::complex<T>(1, +0.),
std::complex<T>(2, +0.),
std::complex<T>(std::numeric_limits<T>::infinity(), +0.),

std::complex<double>(std::numeric_limits<double>::quiet_NaN(), 0.5),
std::complex<double>(-std::numeric_limits<double>::infinity(), 0.5),
std::complex<double>(-2, 0.5),
std::complex<double>(-1, 0.5),
std::complex<double>(-0.5, 0.5),
std::complex<double>(-0., 0.5),
std::complex<double>(+0., 0.5),
std::complex<double>(0.5, 0.5),
std::complex<double>(1, 0.5),
std::complex<double>(2, 0.5),
std::complex<double>(std::numeric_limits<double>::infinity(), 0.5),
std::complex<T>(std::numeric_limits<T>::quiet_NaN(), 0.5),
std::complex<T>(-std::numeric_limits<T>::infinity(), 0.5),
std::complex<T>(-2, 0.5),
std::complex<T>(-1, 0.5),
std::complex<T>(-0.5, 0.5),
std::complex<T>(-0., 0.5),
std::complex<T>(+0., 0.5),
std::complex<T>(0.5, 0.5),
std::complex<T>(1, 0.5),
std::complex<T>(2, 0.5),
std::complex<T>(std::numeric_limits<T>::infinity(), 0.5),

std::complex<double>(std::numeric_limits<double>::quiet_NaN(), 1),
std::complex<double>(-std::numeric_limits<double>::infinity(), 1),
std::complex<double>(-2, 1),
std::complex<double>(-1, 1),
std::complex<double>(-0.5, 1),
std::complex<double>(-0., 1),
std::complex<double>(+0., 1),
std::complex<double>(0.5, 1),
std::complex<double>(1, 1),
std::complex<double>(2, 1),
std::complex<double>(std::numeric_limits<double>::infinity(), 1),
std::complex<T>(std::numeric_limits<T>::quiet_NaN(), 1),
std::complex<T>(-std::numeric_limits<T>::infinity(), 1),
std::complex<T>(-2, 1),
std::complex<T>(-1, 1),
std::complex<T>(-0.5, 1),
std::complex<T>(-0., 1),
std::complex<T>(+0., 1),
std::complex<T>(0.5, 1),
std::complex<T>(1, 1),
std::complex<T>(2, 1),
std::complex<T>(std::numeric_limits<T>::infinity(), 1),

std::complex<double>(std::numeric_limits<double>::quiet_NaN(), 2),
std::complex<double>(-std::numeric_limits<double>::infinity(), 2),
std::complex<double>(-2, 2),
std::complex<double>(-1, 2),
std::complex<double>(-0.5, 2),
std::complex<double>(-0., 2),
std::complex<double>(+0., 2),
std::complex<double>(0.5, 2),
std::complex<double>(1, 2),
std::complex<double>(2, 2),
std::complex<double>(std::numeric_limits<double>::infinity(), 2),
std::complex<T>(std::numeric_limits<T>::quiet_NaN(), 2),
std::complex<T>(-std::numeric_limits<T>::infinity(), 2),
std::complex<T>(-2, 2),
std::complex<T>(-1, 2),
std::complex<T>(-0.5, 2),
std::complex<T>(-0., 2),
std::complex<T>(+0., 2),
std::complex<T>(0.5, 2),
std::complex<T>(1, 2),
std::complex<T>(2, 2),
std::complex<T>(std::numeric_limits<T>::infinity(), 2),

std::complex<double>(std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::infinity()),
std::complex<double>(-std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity()),
std::complex<double>(-2, std::numeric_limits<double>::infinity()),
std::complex<double>(-1, std::numeric_limits<double>::infinity()),
std::complex<double>(-0.5, std::numeric_limits<double>::infinity()),
std::complex<double>(-0., std::numeric_limits<double>::infinity()),
std::complex<double>(+0., std::numeric_limits<double>::infinity()),
std::complex<double>(0.5, std::numeric_limits<double>::infinity()),
std::complex<double>(1, std::numeric_limits<double>::infinity()),
std::complex<double>(2, std::numeric_limits<double>::infinity()),
std::complex<double>(std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity())
std::complex<T>(std::numeric_limits<T>::quiet_NaN(), std::numeric_limits<T>::infinity()),
std::complex<T>(-std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity()),
std::complex<T>(-2, std::numeric_limits<T>::infinity()),
std::complex<T>(-1, std::numeric_limits<T>::infinity()),
std::complex<T>(-0.5, std::numeric_limits<T>::infinity()),
std::complex<T>(-0., std::numeric_limits<T>::infinity()),
std::complex<T>(+0., std::numeric_limits<T>::infinity()),
std::complex<T>(0.5, std::numeric_limits<T>::infinity()),
std::complex<T>(1, std::numeric_limits<T>::infinity()),
std::complex<T>(2, std::numeric_limits<T>::infinity()),
std::complex<T>(std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity()),
};

enum {zero, non_zero, inf, NaN, non_zero_nan};
Expand Down Expand Up @@ -230,17 +231,15 @@ classify(const std::complex<T>& x)
return non_zero;
}

inline
int
classify(double x)
{
if (x == 0)
return zero;
if (std::isinf(x))
return inf;
if (std::isnan(x))
return NaN;
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;
return non_zero;
}

void is_about(float x, float y)
Expand Down
Loading
Loading