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(1.5, 2.5);
32     std::complex<T> rhs(1.5, 2.5);
33     std::complex<T>   x(-4.0, 7.5);
34     test(lhs, rhs, x);
35 }
36 
37 // test edges
38 
39 void test_edges()
40 {
41     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
42     for (unsigned i = 0; i < N; ++i)
43     {
44         for (unsigned j = 0; j < N; ++j)
45         {
46             std::complex<double> r = testcases[i] * testcases[j];
47             switch (classify(testcases[i]))
48             {
49             case zero:
50                 switch (classify(testcases[j]))
51                 {
52                 case zero:
53                     assert(classify(r) == zero);
54                     break;
55                 case non_zero:
56                     assert(classify(r) == zero);
57                     break;
58                 case inf:
59                     assert(classify(r) == NaN);
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 (classify(testcases[j]))
71                 {
72                 case zero:
73                     assert(classify(r) == zero);
74                     break;
75                 case non_zero:
76                     assert(classify(r) == non_zero);
77                     break;
78                 case inf:
79                     assert(classify(r) == inf);
80                     break;
81                 case NaN:
82                     assert(classify(r) == NaN);
83                     break;
84                 case non_zero_nan:
85                     assert(classify(r) == NaN);
86                     break;
87                 }
88                 break;
89             case inf:
90                 switch (classify(testcases[j]))
91                 {
92                 case zero:
93                     assert(classify(r) == NaN);
94                     break;
95                 case non_zero:
96                     assert(classify(r) == inf);
97                     break;
98                 case inf:
99                     assert(classify(r) == inf);
100                     break;
101                 case NaN:
102                     assert(classify(r) == NaN);
103                     break;
104                 case non_zero_nan:
105                     assert(classify(r) == inf);
106                     break;
107                 }
108                 break;
109             case NaN:
110                 switch (classify(testcases[j]))
111                 {
112                 case zero:
113                     assert(classify(r) == NaN);
114                     break;
115                 case non_zero:
116                     assert(classify(r) == NaN);
117                     break;
118                 case inf:
119                     assert(classify(r) == NaN);
120                     break;
121                 case NaN:
122                     assert(classify(r) == NaN);
123                     break;
124                 case non_zero_nan:
125                     assert(classify(r) == NaN);
126                     break;
127                 }
128                 break;
129             case non_zero_nan:
130                 switch (classify(testcases[j]))
131                 {
132                 case zero:
133                     assert(classify(r) == NaN);
134                     break;
135                 case non_zero:
136                     assert(classify(r) == NaN);
137                     break;
138                 case inf:
139                     assert(classify(r) == inf);
140                     break;
141                 case NaN:
142                     assert(classify(r) == NaN);
143                     break;
144                 case non_zero_nan:
145                     assert(classify(r) == NaN);
146                     break;
147                 }
148                 break;
149             }
150         }
151     }
152 }
153 
154 int main(int, char**)
155 {
156     test<float>();
157     test<double>();
158     test<long double>();
159     test_edges();
160 
161   return 0;
162 }
163