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
24template <class T>
25TEST_CONSTEXPR_CXX20
26bool
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
37TEST_CONSTEXPR_CXX20
38bool
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
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

source code of libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp