1 //===----------------------------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 // <complex>
11
12 // template<class T>
13 // complex<T>
14 // operator/(const complex<T>& lhs, const complex<T>& rhs);
15
16 #include <complex>
17 #include <cassert>
18
19 #include "../cases.h"
20
21 template <class T>
22 void
test(const std::complex<T> & lhs,const std::complex<T> & rhs,std::complex<T> x)23 test(const std::complex<T>& lhs, const std::complex<T>& rhs, std::complex<T> x)
24 {
25 assert(lhs / rhs == x);
26 }
27
28 template <class T>
29 void
test()30 test()
31 {
32 std::complex<T> lhs(-4.0, 7.5);
33 std::complex<T> rhs(1.5, 2.5);
34 std::complex<T> x(1.5, 2.5);
35 test(lhs, rhs, x);
36 }
37
test_edges()38 void test_edges()
39 {
40 const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
41 for (unsigned i = 0; i < N; ++i)
42 {
43 for (unsigned j = 0; j < N; ++j)
44 {
45 std::complex<double> r = testcases[i] / testcases[j];
46 switch (classify(testcases[i]))
47 {
48 case zero:
49 switch (classify(testcases[j]))
50 {
51 case zero:
52 assert(classify(r) == NaN);
53 break;
54 case non_zero:
55 assert(classify(r) == zero);
56 break;
57 case inf:
58 assert(classify(r) == zero);
59 break;
60 case NaN:
61 assert(classify(r) == NaN);
62 break;
63 case non_zero_nan:
64 assert(classify(r) == NaN);
65 break;
66 }
67 break;
68 case non_zero:
69 switch (classify(testcases[j]))
70 {
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 (classify(testcases[j]))
90 {
91 case zero:
92 assert(classify(r) == inf);
93 break;
94 case non_zero:
95 assert(classify(r) == inf);
96 break;
97 case inf:
98 assert(classify(r) == NaN);
99 break;
100 case NaN:
101 assert(classify(r) == NaN);
102 break;
103 case non_zero_nan:
104 assert(classify(r) == NaN);
105 break;
106 }
107 break;
108 case NaN:
109 switch (classify(testcases[j]))
110 {
111 case zero:
112 assert(classify(r) == NaN);
113 break;
114 case non_zero:
115 assert(classify(r) == NaN);
116 break;
117 case inf:
118 assert(classify(r) == NaN);
119 break;
120 case NaN:
121 assert(classify(r) == NaN);
122 break;
123 case non_zero_nan:
124 assert(classify(r) == NaN);
125 break;
126 }
127 break;
128 case non_zero_nan:
129 switch (classify(testcases[j]))
130 {
131 case zero:
132 assert(classify(r) == inf);
133 break;
134 case non_zero:
135 assert(classify(r) == NaN);
136 break;
137 case inf:
138 assert(classify(r) == NaN);
139 break;
140 case NaN:
141 assert(classify(r) == NaN);
142 break;
143 case non_zero_nan:
144 assert(classify(r) == NaN);
145 break;
146 }
147 break;
148 }
149 }
150 }
151 }
152
main()153 int main()
154 {
155 test<float>();
156 test<double>();
157 test<long double>();
158 test_edges();
159 }
160