1 //===----------------------------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 // <complex> 10 11 // template<class T> 12 // complex<T> 13 // operator/(const complex<T>& lhs, const complex<T>& rhs); // constexpr in C++20 14 15 // ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=2000000 16 17 #include <cassert> 18 #include <complex> 19 20 #include "floating_pointer_helpers.h" 21 #include "test_macros.h" 22 #include "../cases.h" 23 24 template <class T> 25 TEST_CONSTEXPR_CXX20 26 bool test()27test() 28 { 29 const std::complex<T> lhs(-4.0, 7.5); 30 const std::complex<T> rhs(1.5, 2.5); 31 const std::complex<T> c = lhs / rhs; 32 assert(is_close(c.real(), T(1.5))); 33 assert(is_close(c.imag(), T(2.5))); 34 return true; 35 } 36 37 TEST_CONSTEXPR_CXX20 38 bool test_edges()39test_edges() 40 { 41 const unsigned N = sizeof(testcases) / sizeof(testcases[0]); 42 int classification[N]; 43 for (unsigned i=0; i < N; ++i) 44 classification[i] = classify(testcases[i]); 45 46 for (unsigned i = 0; i < N; ++i) { 47 for (unsigned j = 0; j < N; ++j) { 48 std::complex<double> r = testcases[i] / testcases[j]; 49 switch (classification[i]) { 50 case zero: 51 switch (classification[j]) { 52 case zero: 53 assert(classify(r) == NaN); 54 break; 55 case non_zero: 56 assert(classify(r) == zero); 57 break; 58 case inf: 59 assert(classify(r) == zero); 60 break; 61 case NaN: 62 assert(classify(r) == NaN); 63 break; 64 case non_zero_nan: 65 assert(classify(r) == NaN); 66 break; 67 } 68 break; 69 case non_zero: 70 switch (classification[j]) { 71 case zero: 72 assert(classify(r) == inf); 73 break; 74 case non_zero: 75 assert(classify(r) == non_zero); 76 break; 77 case inf: 78 assert(classify(r) == zero); 79 break; 80 case NaN: 81 assert(classify(r) == NaN); 82 break; 83 case non_zero_nan: 84 assert(classify(r) == NaN); 85 break; 86 } 87 break; 88 case inf: 89 switch (classification[j]) { 90 case zero: 91 assert(classify(r) == inf); 92 break; 93 case non_zero: 94 assert(classify(r) == inf); 95 break; 96 case inf: 97 assert(classify(r) == NaN); 98 break; 99 case NaN: 100 assert(classify(r) == NaN); 101 break; 102 case non_zero_nan: 103 assert(classify(r) == NaN); 104 break; 105 } 106 break; 107 case NaN: 108 switch (classification[j]) { 109 case zero: 110 assert(classify(r) == NaN); 111 break; 112 case non_zero: 113 assert(classify(r) == NaN); 114 break; 115 case inf: 116 assert(classify(r) == NaN); 117 break; 118 case NaN: 119 assert(classify(r) == NaN); 120 break; 121 case non_zero_nan: 122 assert(classify(r) == NaN); 123 break; 124 } 125 break; 126 case non_zero_nan: 127 switch (classification[j]) { 128 case zero: 129 assert(classify(r) == inf); 130 break; 131 case non_zero: 132 assert(classify(r) == NaN); 133 break; 134 case inf: 135 assert(classify(r) == NaN); 136 break; 137 case NaN: 138 assert(classify(r) == NaN); 139 break; 140 case non_zero_nan: 141 assert(classify(r) == NaN); 142 break; 143 } 144 break; 145 } 146 } 147 } 148 return true; 149 } 150 main(int,char **)151int main(int, char**) 152 { 153 test<float>(); 154 test<double>(); 155 test<long double>(); 156 test_edges(); 157 158 #if TEST_STD_VER > 17 159 static_assert(test<float>()); 160 static_assert(test<double>()); 161 static_assert(test<long double>()); 162 static_assert(test_edges()); 163 #endif 164 165 return 0; 166 } 167