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
21template <class T>
22void
23test(const std::complex<T>& lhs, const std::complex<T>& rhs, std::complex<T> x)
24{
25    assert(lhs / rhs == x);
26}
27
28template <class T>
29void
30test()
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
38void test_edges()
39{
40    const unsigned N = sizeof(x) / sizeof(x[0]);
41    for (unsigned i = 0; i < N; ++i)
42    {
43        for (unsigned j = 0; j < N; ++j)
44        {
45            std::complex<double> r = x[i] / x[j];
46            switch (classify(x[i]))
47            {
48            case zero:
49                switch (classify(x[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(x[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(x[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(x[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(x[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
153int main()
154{
155    test<float>();
156    test<double>();
157    test<long double>();
158    test_edges();
159}
160