libs/multiprecision/test/test_mixed.hpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //  Copyright 2015 John Maddock. Distributed under the Boost
   3 //  Software License, Version 1.0. (See accompanying file
   4 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5
   6 #ifndef BOOST_MATH_TEST_MIXED_HPP
   7 #define BOOST_MATH_TEST_MIXED_HPP
   8
   9 #include "test.hpp"
  10
  11 template <class Big, class Small>
  12 void test()
  13 {
  14    Big big_val = 1;
  15    big_val += std::numeric_limits<Big>::epsilon();
  16    Small small_val = 1;
  17
  18    BOOST_CHECK_EQUAL(big_val == small_val, false);
  19    BOOST_CHECK_EQUAL(big_val <= small_val, false);
  20    BOOST_CHECK_EQUAL(big_val >= small_val, true);
  21    BOOST_CHECK_EQUAL(big_val < small_val, false);
  22    BOOST_CHECK_EQUAL(big_val > small_val, true);
  23    BOOST_CHECK_EQUAL(big_val != small_val, true);
  24    BOOST_CHECK_EQUAL(small_val == big_val, false);
  25    BOOST_CHECK_EQUAL(small_val <= big_val, true);
  26    BOOST_CHECK_EQUAL(small_val >= big_val, false);
  27    BOOST_CHECK_EQUAL(small_val < big_val, true);
  28    BOOST_CHECK_EQUAL(small_val > big_val, false);
  29    BOOST_CHECK_EQUAL(small_val != big_val, true);
  30    // Again with expression templates, on one the other, or both args:
  31    BOOST_CHECK_EQUAL(big_val == small_val * 1, false);
  32    BOOST_CHECK_EQUAL(big_val <= small_val * 1, false);
  33    BOOST_CHECK_EQUAL(big_val >= small_val * 1, true);
  34    BOOST_CHECK_EQUAL(big_val < small_val * 1, false);
  35    BOOST_CHECK_EQUAL(big_val > small_val * 1, true);
  36    BOOST_CHECK_EQUAL(big_val != small_val * 1, true);
  37    BOOST_CHECK_EQUAL(small_val * 1 == big_val, false);
  38    BOOST_CHECK_EQUAL(small_val * 1 <= big_val, true);
  39    BOOST_CHECK_EQUAL(small_val * 1 >= big_val, false);
  40    BOOST_CHECK_EQUAL(small_val * 1 < big_val, true);
  41    BOOST_CHECK_EQUAL(small_val * 1 > big_val, false);
  42    BOOST_CHECK_EQUAL(small_val * 1 != big_val, true);
  43    BOOST_CHECK_EQUAL(big_val * 1 == small_val, false);
  44    BOOST_CHECK_EQUAL(big_val * 1 <= small_val, false);
  45    BOOST_CHECK_EQUAL(big_val * 1 >= small_val, true);
  46    BOOST_CHECK_EQUAL(big_val * 1 < small_val, false);
  47    BOOST_CHECK_EQUAL(big_val * 1 > small_val, true);
  48    BOOST_CHECK_EQUAL(big_val * 1 != small_val, true);
  49    BOOST_CHECK_EQUAL(small_val == big_val * 1, false);
  50    BOOST_CHECK_EQUAL(small_val <= big_val * 1, true);
  51    BOOST_CHECK_EQUAL(small_val >= big_val * 1, false);
  52    BOOST_CHECK_EQUAL(small_val < big_val * 1, true);
  53    BOOST_CHECK_EQUAL(small_val > big_val * 1, false);
  54    BOOST_CHECK_EQUAL(small_val != big_val * 1, true);
  55    BOOST_CHECK_EQUAL(big_val * 1 == small_val * 1, false);
  56    BOOST_CHECK_EQUAL(big_val * 1 <= small_val * 1, false);
  57    BOOST_CHECK_EQUAL(big_val * 1 >= small_val * 1, true);
  58    BOOST_CHECK_EQUAL(big_val * 1 < small_val * 1, false);
  59    BOOST_CHECK_EQUAL(big_val * 1 > small_val * 1, true);
  60    BOOST_CHECK_EQUAL(big_val * 1 != small_val * 1, true);
  61    BOOST_CHECK_EQUAL(small_val * 1 == big_val * 1, false);
  62    BOOST_CHECK_EQUAL(small_val * 1 <= big_val * 1, true);
  63    BOOST_CHECK_EQUAL(small_val * 1 >= big_val * 1, false);
  64    BOOST_CHECK_EQUAL(small_val * 1 < big_val * 1, true);
  65    BOOST_CHECK_EQUAL(small_val * 1 > big_val * 1, false);
  66    BOOST_CHECK_EQUAL(small_val * 1 != big_val * 1, true);
  67
  68    BOOST_CHECK_EQUAL(small_val + big_val, Big(small_val) + big_val);
  69    BOOST_CHECK_EQUAL(small_val - big_val, Big(small_val) - big_val);
  70    BOOST_CHECK_EQUAL(small_val * big_val, Big(small_val) * big_val);
  71    BOOST_CHECK_EQUAL(small_val / big_val, Big(small_val) / big_val);
  72    BOOST_CHECK_EQUAL(big_val + small_val, big_val + Big(small_val));
  73    BOOST_CHECK_EQUAL(big_val - small_val, big_val - Big(small_val));
  74    BOOST_CHECK_EQUAL(big_val * small_val, big_val * Big(small_val));
  75    BOOST_CHECK_EQUAL(big_val / small_val, big_val / Big(small_val));
  76    // Again with expression templates, on one the other, or both args:
  77    BOOST_CHECK_EQUAL(small_val + (big_val * 1), Big(small_val) + (big_val * 1));
  78    BOOST_CHECK_EQUAL(small_val - (big_val * 1), Big(small_val) - (big_val * 1));
  79    BOOST_CHECK_EQUAL(small_val * (big_val * 1), Big(small_val) * (big_val * 1));
  80    BOOST_CHECK_EQUAL(small_val / (big_val * 1), Big(small_val) / (big_val * 1));
  81    BOOST_CHECK_EQUAL((big_val * 1) + small_val, (big_val * 1) + Big(small_val));
  82    BOOST_CHECK_EQUAL((big_val * 1) - small_val, (big_val * 1) - Big(small_val));
  83    BOOST_CHECK_EQUAL((big_val * 1) * small_val, (big_val * 1) * Big(small_val));
  84    BOOST_CHECK_EQUAL((big_val * 1) / small_val, (big_val * 1) / Big(small_val));
  85    BOOST_CHECK_EQUAL((small_val * 1) + big_val, Big((small_val * 1)) + big_val);
  86    BOOST_CHECK_EQUAL((small_val * 1) - big_val, Big((small_val * 1)) - big_val);
  87    BOOST_CHECK_EQUAL((small_val * 1) * big_val, Big((small_val * 1)) * big_val);
  88    BOOST_CHECK_EQUAL((small_val * 1) / big_val, Big((small_val * 1)) / big_val);
  89    BOOST_CHECK_EQUAL(big_val + (small_val * 1), big_val + Big((small_val * 1)));
  90    BOOST_CHECK_EQUAL(big_val - (small_val * 1), big_val - Big((small_val * 1)));
  91    BOOST_CHECK_EQUAL(big_val * (small_val * 1), big_val * Big((small_val * 1)));
  92    BOOST_CHECK_EQUAL(big_val / (small_val * 1), big_val / Big((small_val * 1)));
  93    BOOST_CHECK_EQUAL((small_val * 1) + (big_val * 1), Big((small_val * 1)) + (big_val * 1));
  94    BOOST_CHECK_EQUAL((small_val * 1) - (big_val * 1), Big((small_val * 1)) - (big_val * 1));
  95    BOOST_CHECK_EQUAL((small_val * 1) * (big_val * 1), Big((small_val * 1)) * (big_val * 1));
  96    BOOST_CHECK_EQUAL((small_val * 1) / (big_val * 1), Big((small_val * 1)) / (big_val * 1));
  97    BOOST_CHECK_EQUAL((big_val * 1) + (small_val * 1), (big_val * 1) + Big((small_val * 1)));
  98    BOOST_CHECK_EQUAL((big_val * 1) - (small_val * 1), (big_val * 1) - Big((small_val * 1)));
  99    BOOST_CHECK_EQUAL((big_val * 1) * (small_val * 1), (big_val * 1) * Big((small_val * 1)));
 100    BOOST_CHECK_EQUAL((big_val * 1) / (small_val * 1), (big_val * 1) / Big((small_val * 1)));
 101
 102    big_val = 1;
 103    big_val -= std::numeric_limits<Big>::epsilon();
 104
 105    BOOST_CHECK_EQUAL(big_val == small_val, false);
 106    BOOST_CHECK_EQUAL(big_val <= small_val, true);
 107    BOOST_CHECK_EQUAL(big_val >= small_val, false);
 108    BOOST_CHECK_EQUAL(big_val < small_val, true);
 109    BOOST_CHECK_EQUAL(big_val > small_val, false);
 110    BOOST_CHECK_EQUAL(big_val != small_val, true);
 111    BOOST_CHECK_EQUAL(small_val == big_val, false);
 112    BOOST_CHECK_EQUAL(small_val <= big_val, false);
 113    BOOST_CHECK_EQUAL(small_val >= big_val, true);
 114    BOOST_CHECK_EQUAL(small_val < big_val, false);
 115    BOOST_CHECK_EQUAL(small_val > big_val, true);
 116    BOOST_CHECK_EQUAL(small_val != big_val, true);
 117    // Again with expression templates, on one the other, or both args:
 118    BOOST_CHECK_EQUAL(big_val == small_val * 1, false);
 119    BOOST_CHECK_EQUAL(big_val <= small_val * 1, true);
 120    BOOST_CHECK_EQUAL(big_val >= small_val * 1, false);
 121    BOOST_CHECK_EQUAL(big_val < small_val * 1, true);
 122    BOOST_CHECK_EQUAL(big_val > small_val * 1, false);
 123    BOOST_CHECK_EQUAL(big_val != small_val * 1, true);
 124    BOOST_CHECK_EQUAL(small_val * 1 == big_val, false);
 125    BOOST_CHECK_EQUAL(small_val * 1 <= big_val, false);
 126    BOOST_CHECK_EQUAL(small_val * 1 >= big_val, true);
 127    BOOST_CHECK_EQUAL(small_val * 1 < big_val, false);
 128    BOOST_CHECK_EQUAL(small_val * 1 > big_val, true);
 129    BOOST_CHECK_EQUAL(small_val * 1 != big_val, true);
 130    BOOST_CHECK_EQUAL(big_val * 1 == small_val, false);
 131    BOOST_CHECK_EQUAL(big_val * 1 <= small_val, true);
 132    BOOST_CHECK_EQUAL(big_val * 1 >= small_val, false);
 133    BOOST_CHECK_EQUAL(big_val * 1 < small_val, true);
 134    BOOST_CHECK_EQUAL(big_val * 1 > small_val, false);
 135    BOOST_CHECK_EQUAL(big_val * 1 != small_val, true);
 136    BOOST_CHECK_EQUAL(small_val == big_val * 1, false);
 137    BOOST_CHECK_EQUAL(small_val <= big_val * 1, false);
 138    BOOST_CHECK_EQUAL(small_val >= big_val * 1, true);
 139    BOOST_CHECK_EQUAL(small_val < big_val * 1, false);
 140    BOOST_CHECK_EQUAL(small_val > big_val * 1, true);
 141    BOOST_CHECK_EQUAL(small_val != big_val * 1, true);
 142    BOOST_CHECK_EQUAL(big_val * 1 == small_val * 1, false);
 143    BOOST_CHECK_EQUAL(big_val * 1 <= small_val * 1, true);
 144    BOOST_CHECK_EQUAL(big_val * 1 >= small_val * 1, false);
 145    BOOST_CHECK_EQUAL(big_val * 1 < small_val * 1, true);
 146    BOOST_CHECK_EQUAL(big_val * 1 > small_val * 1, false);
 147    BOOST_CHECK_EQUAL(big_val * 1 != small_val * 1, true);
 148    BOOST_CHECK_EQUAL(small_val * 1 == big_val * 1, false);
 149    BOOST_CHECK_EQUAL(small_val * 1 <= big_val * 1, false);
 150    BOOST_CHECK_EQUAL(small_val * 1 >= big_val * 1, true);
 151    BOOST_CHECK_EQUAL(small_val * 1 < big_val * 1, false);
 152    BOOST_CHECK_EQUAL(small_val * 1 > big_val * 1, true);
 153    BOOST_CHECK_EQUAL(small_val * 1 != big_val * 1, true);
 154
 155    BOOST_CHECK_EQUAL(small_val + big_val, Big(small_val) + big_val);
 156    BOOST_CHECK_EQUAL(small_val - big_val, Big(small_val) - big_val);
 157    BOOST_CHECK_EQUAL(small_val * big_val, Big(small_val) * big_val);
 158    BOOST_CHECK_EQUAL(small_val / big_val, Big(small_val) / big_val);
 159    BOOST_CHECK_EQUAL(big_val + small_val, big_val + Big(small_val));
 160    BOOST_CHECK_EQUAL(big_val - small_val, big_val - Big(small_val));
 161    BOOST_CHECK_EQUAL(big_val * small_val, big_val * Big(small_val));
 162    BOOST_CHECK_EQUAL(big_val / small_val, big_val / Big(small_val));
 163    // Again with expression templates, on one the other, or both args:
 164    BOOST_CHECK_EQUAL(small_val + (big_val * 1), Big(small_val) + (big_val * 1));
 165    BOOST_CHECK_EQUAL(small_val - (big_val * 1), Big(small_val) - (big_val * 1));
 166    BOOST_CHECK_EQUAL(small_val * (big_val * 1), Big(small_val) * (big_val * 1));
 167    BOOST_CHECK_EQUAL(small_val / (big_val * 1), Big(small_val) / (big_val * 1));
 168    BOOST_CHECK_EQUAL((big_val * 1) + small_val, (big_val * 1) + Big(small_val));
 169    BOOST_CHECK_EQUAL((big_val * 1) - small_val, (big_val * 1) - Big(small_val));
 170    BOOST_CHECK_EQUAL((big_val * 1) * small_val, (big_val * 1) * Big(small_val));
 171    BOOST_CHECK_EQUAL((big_val * 1) / small_val, (big_val * 1) / Big(small_val));
 172    BOOST_CHECK_EQUAL((small_val * 1) + big_val, Big((small_val * 1)) + big_val);
 173    BOOST_CHECK_EQUAL((small_val * 1) - big_val, Big((small_val * 1)) - big_val);
 174    BOOST_CHECK_EQUAL((small_val * 1) * big_val, Big((small_val * 1)) * big_val);
 175    BOOST_CHECK_EQUAL((small_val * 1) / big_val, Big((small_val * 1)) / big_val);
 176    BOOST_CHECK_EQUAL(big_val + (small_val * 1), big_val + Big((small_val * 1)));
 177    BOOST_CHECK_EQUAL(big_val - (small_val * 1), big_val - Big((small_val * 1)));
 178    BOOST_CHECK_EQUAL(big_val * (small_val * 1), big_val * Big((small_val * 1)));
 179    BOOST_CHECK_EQUAL(big_val / (small_val * 1), big_val / Big((small_val * 1)));
 180    BOOST_CHECK_EQUAL((small_val * 1) + (big_val * 1), Big((small_val * 1)) + (big_val * 1));
 181    BOOST_CHECK_EQUAL((small_val * 1) - (big_val * 1), Big((small_val * 1)) - (big_val * 1));
 182    BOOST_CHECK_EQUAL((small_val * 1) * (big_val * 1), Big((small_val * 1)) * (big_val * 1));
 183    BOOST_CHECK_EQUAL((small_val * 1) / (big_val * 1), Big((small_val * 1)) / (big_val * 1));
 184    BOOST_CHECK_EQUAL((big_val * 1) + (small_val * 1), (big_val * 1) + Big((small_val * 1)));
 185    BOOST_CHECK_EQUAL((big_val * 1) - (small_val * 1), (big_val * 1) - Big((small_val * 1)));
 186    BOOST_CHECK_EQUAL((big_val * 1) * (small_val * 1), (big_val * 1) * Big((small_val * 1)));
 187    BOOST_CHECK_EQUAL((big_val * 1) / (small_val * 1), (big_val * 1) / Big((small_val * 1)));
 188 }
 189
 190 #endif // BOOST_MATH_TEST_MIXED_HPP