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);
14 
15 #include <complex>
16 #include <cassert>
17 
18 #include "../cases.h"
19 
20 template <class T>
21 void
22 test(const std::complex<T>& lhs, const std::complex<T>& rhs, std::complex<T> x)
23 {
24     assert(lhs / rhs == x);
25 }
26 
27 template <class T>
28 void
29 test()
30 {
31     std::complex<T> lhs(-4.0, 7.5);
32     std::complex<T> rhs(1.5, 2.5);
33     std::complex<T>   x(1.5, 2.5);
34     test(lhs, rhs, x);
35 }
36 
37 void test_edges()
38 {
39     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
40     for (unsigned i = 0; i < N; ++i)
41     {
42         for (unsigned j = 0; j < N; ++j)
43         {
44             std::complex<double> r = testcases[i] / testcases[j];
45             switch (classify(testcases[i]))
46             {
47             case zero:
48                 switch (classify(testcases[j]))
49                 {
50                 case zero:
51                     assert(classify(r) == NaN);
52                     break;
53                 case non_zero:
54                     assert(classify(r) == zero);
55                     break;
56                 case inf:
57                     assert(classify(r) == zero);
58                     break;
59                 case NaN:
60                     assert(classify(r) == NaN);
61                     break;
62                 case non_zero_nan:
63                     assert(classify(r) == NaN);
64                     break;
65                 }
66                 break;
67             case non_zero:
68                 switch (classify(testcases[j]))
69                 {
70                 case zero:
71                     assert(classify(r) == inf);
72                     break;
73                 case non_zero:
74                     assert(classify(r) == non_zero);
75                     break;
76                 case inf:
77                     assert(classify(r) == zero);
78                     break;
79                 case NaN:
80                     assert(classify(r) == NaN);
81                     break;
82                 case non_zero_nan:
83                     assert(classify(r) == NaN);
84                     break;
85                 }
86                 break;
87             case inf:
88                 switch (classify(testcases[j]))
89                 {
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 (classify(testcases[j]))
109                 {
110                 case zero:
111                     assert(classify(r) == NaN);
112                     break;
113                 case non_zero:
114                     assert(classify(r) == NaN);
115                     break;
116                 case inf:
117                     assert(classify(r) == NaN);
118                     break;
119                 case NaN:
120                     assert(classify(r) == NaN);
121                     break;
122                 case non_zero_nan:
123                     assert(classify(r) == NaN);
124                     break;
125                 }
126                 break;
127             case non_zero_nan:
128                 switch (classify(testcases[j]))
129                 {
130                 case zero:
131                     assert(classify(r) == inf);
132                     break;
133                 case non_zero:
134                     assert(classify(r) == NaN);
135                     break;
136                 case inf:
137                     assert(classify(r) == NaN);
138                     break;
139                 case NaN:
140                     assert(classify(r) == NaN);
141                     break;
142                 case non_zero_nan:
143                     assert(classify(r) == NaN);
144                     break;
145                 }
146                 break;
147             }
148         }
149     }
150 }
151 
152 int main(int, char**)
153 {
154     test<float>();
155     test<double>();
156     test<long double>();
157     test_edges();
158 
159   return 0;
160 }
161