test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp

   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
  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
  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
  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
 153 int main()
 154 {
 155     test<float>();
 156     test<double>();
 157     test<long double>();
 158     test_edges();
 159 }