ceph/src/boost/libs/polygon/test/voronoi_robust_fpt_test.cpp

   1 // Boost.Polygon library voronoi_robust_fpt_test.cpp file
   2
   3 //          Copyright Andrii Sydorchuk 2010-2012.
   4 // Distributed under the Boost Software License, Version 1.0.
   5 //    (See accompanying file LICENSE_1_0.txt or copy at
   6 //          http://www.boost.org/LICENSE_1_0.txt)
   7
   8 // See http://www.boost.org for updates, documentation, and revision history.
   9
  10 #include <boost/core/lightweight_test.hpp>
  11 #include <boost/polygon/detail/voronoi_ctypes.hpp>
  12 #include <boost/polygon/detail/voronoi_robust_fpt.hpp>
  13 #include <boost/random/mersenne_twister.hpp>
  14 #include <vector>
  15 #include <cmath>
  16 #include <ctime>
  17
  18 using boost::polygon::detail::int32;
  19 using boost::polygon::detail::uint32;
  20 using boost::polygon::detail::int64;
  21 using boost::polygon::detail::fpt64;
  22 using boost::polygon::detail::efpt64;
  23 using boost::polygon::detail::extended_int;
  24 using boost::polygon::detail::extended_exponent_fpt;
  25 using boost::polygon::detail::robust_fpt;
  26 using boost::polygon::detail::robust_dif;
  27 using boost::polygon::detail::robust_sqrt_expr;
  28 using boost::polygon::detail::type_converter_fpt;
  29 using boost::polygon::detail::type_converter_efpt;
  30 using boost::polygon::detail::ulp_comparison;
  31
  32 typedef robust_fpt<double> rfpt_type;
  33 typedef type_converter_fpt to_fpt_type;
  34 typedef type_converter_efpt to_efpt_type;
  35 type_converter_fpt to_fpt;
  36
  37 void robust_fpt_constructors_test1()
  38 {
  39   rfpt_type a = rfpt_type();
  40   BOOST_TEST_EQ(a.fpv(), 0.0);
  41   BOOST_TEST_EQ(a.re(), 0.0);
  42   BOOST_TEST_EQ(a.ulp(), 0);
  43 }
  44
  45 void robust_fpt_constructors_test2()
  46 {
  47   rfpt_type a(10.0, 1.0);
  48   BOOST_TEST_EQ(a.fpv(), 10.0);
  49   BOOST_TEST_EQ(a.re(), 1.0);
  50   BOOST_TEST_EQ(a.ulp(), 1.0);
  51 }
  52
  53 void robust_fpt_constructors_test3()
  54 {
  55   rfpt_type a(10.0);
  56   BOOST_TEST_EQ(a.fpv(), 10.0);
  57   BOOST_TEST_EQ(a.re(), 0.0);
  58   BOOST_TEST_EQ(a.ulp(), 0.0);
  59 }
  60
  61 void robust_fpt_constructors_test4()
  62 {
  63   rfpt_type a(10.0, 3.0);
  64   BOOST_TEST_EQ(a.fpv(), 10.0);
  65   BOOST_TEST_EQ(a.re(), 3.0);
  66   BOOST_TEST_EQ(a.ulp(), 3.0);
  67
  68   rfpt_type b(10.0, 2.75);
  69   BOOST_TEST_EQ(b.fpv(), 10.0);
  70   BOOST_TEST_EQ(b.re(), 2.75);
  71   BOOST_TEST_EQ(b.ulp(), 2.75);
  72 }
  73
  74 void robust_fpt_sum_test1()
  75 {
  76   rfpt_type a(2.0, 5.0);
  77   rfpt_type b(3.0, 4.0);
  78   rfpt_type c = a + b;
  79   BOOST_TEST_EQ(c.fpv(), 5.0);
  80   BOOST_TEST_EQ(c.re(), 6.0);
  81   BOOST_TEST_EQ(c.ulp(), 6.0);
  82
  83   c += b;
  84   BOOST_TEST_EQ(c.fpv(), 8.0);
  85   BOOST_TEST_EQ(c.re(), 7.0);
  86   BOOST_TEST_EQ(c.ulp(), 7.0);
  87 }
  88
  89 void robust_fpt_sum_test2()
  90 {
  91   rfpt_type a(3.0, 2.0);
  92   rfpt_type b(-2.0, 3.0);
  93   rfpt_type c = a + b;
  94   BOOST_TEST_EQ(c.fpv(), 1.0);
  95   BOOST_TEST_EQ(c.re(), 13.0);
  96   BOOST_TEST_EQ(c.ulp(), 13.0);
  97
  98   c += b;
  99   BOOST_TEST_EQ(c.fpv(), -1.0);
 100   BOOST_TEST_EQ(c.re(), 20.0);
 101   BOOST_TEST_EQ(c.ulp(), 20.0);
 102 }
 103
 104 void robust_fpt_dif_test1()
 105 {
 106   rfpt_type a(2.0, 5.0);
 107   rfpt_type b(-3.0, 4.0);
 108   rfpt_type c = a - b;
 109   BOOST_TEST_EQ(c.fpv(), 5.0);
 110   BOOST_TEST_EQ(c.re(), 6.0);
 111   BOOST_TEST_EQ(c.ulp(), 6.0);
 112
 113   c -= b;
 114   BOOST_TEST_EQ(c.fpv(), 8.0);
 115   BOOST_TEST_EQ(c.re(), 7.0);
 116   BOOST_TEST_EQ(c.ulp(), 7.0);
 117 }
 118
 119 void robust_fpt_dif_test2()
 120 {
 121   rfpt_type a(3.0, 2.0);
 122   rfpt_type b(2.0, 3.0);
 123   rfpt_type c = a - b;
 124   BOOST_TEST_EQ(c.fpv(), 1.0);
 125   BOOST_TEST_EQ(c.re(), 13.0);
 126   BOOST_TEST_EQ(c.ulp(), 13.0);
 127
 128   c -= b;
 129   BOOST_TEST_EQ(c.fpv(), -1.0);
 130   BOOST_TEST_EQ(c.re(), 20.0);
 131   BOOST_TEST_EQ(c.ulp(), 20.0);
 132 }
 133
 134 void robust_fpt_mult_test3()
 135 {
 136   rfpt_type a(2.0, 3.0);
 137   rfpt_type b(4.0, 1.0);
 138   rfpt_type c = a * b;
 139   BOOST_TEST_EQ(c.fpv(), 8.0);
 140   BOOST_TEST_EQ(c.re(), 5.0);
 141   BOOST_TEST_EQ(c.ulp(), 5.0);
 142
 143   c *= b;
 144   BOOST_TEST_EQ(c.fpv(), 32.0);
 145   BOOST_TEST_EQ(c.re(), 7.0);
 146   BOOST_TEST_EQ(c.ulp(), 7.0);
 147 }
 148
 149 void robust_fpt_div_test1()
 150 {
 151   rfpt_type a(2.0, 3.0);
 152   rfpt_type b(4.0, 1.0);
 153   rfpt_type c = a / b;
 154   BOOST_TEST_EQ(c.fpv(), 0.5);
 155   BOOST_TEST_EQ(c.re(), 5.0);
 156   BOOST_TEST_EQ(c.ulp(), 5.0);
 157
 158   c /= b;
 159   BOOST_TEST_EQ(c.fpv(), 0.125);
 160   BOOST_TEST_EQ(c.re(), 7.0);
 161   BOOST_TEST_EQ(c.ulp(), 7.0);
 162 }
 163
 164 void robust_dif_constructors_test()
 165 {
 166   robust_dif<int> rd1;
 167   BOOST_TEST_EQ(rd1.pos(), 0);
 168   BOOST_TEST_EQ(rd1.neg(), 0);
 169   BOOST_TEST_EQ(rd1.dif(), 0);
 170
 171   robust_dif<int> rd2(1);
 172   BOOST_TEST_EQ(rd2.pos(), 1);
 173   BOOST_TEST_EQ(rd2.neg(), 0);
 174   BOOST_TEST_EQ(rd2.dif(), 1);
 175
 176   robust_dif<int> rd3(-1);
 177   BOOST_TEST_EQ(rd3.pos(), 0);
 178   BOOST_TEST_EQ(rd3.neg(), 1);
 179   BOOST_TEST_EQ(rd3.dif(), -1);
 180
 181   robust_dif<int> rd4(1, 2);
 182   BOOST_TEST_EQ(rd4.pos(), 1);
 183   BOOST_TEST_EQ(rd4.neg(), 2);
 184   BOOST_TEST_EQ(rd4.dif(), -1);
 185 }
 186
 187 void robust_dif_operators_test1()
 188 {
 189   robust_dif<int> a(5, 2), b(1, 10);
 190   int dif_a = a.dif();
 191   int dif_b = b.dif();
 192   robust_dif<int> sum = a + b;
 193   robust_dif<int> dif = a - b;
 194   robust_dif<int> mult = a * b;
 195   robust_dif<int> umin = -a;
 196   BOOST_TEST_EQ(sum.dif(), dif_a + dif_b);
 197   BOOST_TEST_EQ(dif.dif(), dif_a - dif_b);
 198   BOOST_TEST_EQ(mult.dif(), dif_a * dif_b);
 199   BOOST_TEST_EQ(umin.dif(), -dif_a);
 200 }
 201
 202 void robust_dif_operators_test2()
 203 {
 204   robust_dif<int> a(5, 2);
 205   for (int b = -3; b <= 3; b += 6) {
 206     int dif_a = a.dif();
 207     int dif_b = b;
 208     robust_dif<int> sum = a + b;
 209     robust_dif<int> dif = a - b;
 210     robust_dif<int> mult = a * b;
 211     robust_dif<int> div = a / b;
 212     BOOST_TEST_EQ(sum.dif(), dif_a + dif_b);
 213     BOOST_TEST_EQ(dif.dif(), dif_a - dif_b);
 214     BOOST_TEST_EQ(mult.dif(), dif_a * dif_b);
 215     BOOST_TEST_EQ(div.dif(), dif_a / dif_b);
 216   }
 217 }
 218
 219 void robust_dif_operators_test3()
 220 {
 221   robust_dif<int> b(5, 2);
 222   for (int a = -3; a <= 3; a += 6) {
 223     int dif_a = a;
 224     int dif_b = b.dif();
 225     robust_dif<int> sum = a + b;
 226     robust_dif<int> dif = a - b;
 227     robust_dif<int> mult = a * b;
 228     BOOST_TEST_EQ(sum.dif(), dif_a + dif_b);
 229     BOOST_TEST_EQ(dif.dif(), dif_a - dif_b);
 230     BOOST_TEST_EQ(mult.dif(), dif_a * dif_b);
 231   }
 232 }
 233
 234 void robust_dif_operators_test4()
 235 {
 236   std::vector< robust_dif<int> > a4(4, robust_dif<int>(5, 2));
 237   std::vector< robust_dif<int> > b4(4, robust_dif<int>(1, 2));
 238   std::vector< robust_dif<int> > c4 = a4;
 239   c4[0] += b4[0];
 240   c4[1] -= b4[1];
 241   c4[2] *= b4[2];
 242   BOOST_TEST_EQ(c4[0].dif(), a4[0].dif() + b4[0].dif());
 243   BOOST_TEST_EQ(c4[1].dif(), a4[1].dif() - b4[1].dif());
 244   BOOST_TEST_EQ(c4[2].dif(), a4[2].dif() * b4[2].dif());
 245   a4[0] += b4[0].dif();
 246   a4[1] -= b4[1].dif();
 247   a4[2] *= b4[2].dif();
 248   a4[3] /= b4[3].dif();
 249   BOOST_TEST_EQ(c4[0].dif(), a4[0].dif());
 250   BOOST_TEST_EQ(c4[1].dif(), a4[1].dif());
 251   BOOST_TEST_EQ(c4[2].dif(), a4[2].dif());
 252   BOOST_TEST_EQ(c4[3].dif() / b4[3].dif(), a4[3].dif());
 253 }
 254
 255 void robust_sqrt_expr_test1()
 256 {
 257   robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr;
 258   int32 A[1] = {10};
 259   int32 B[1] = {100};
 260   BOOST_TEST_EQ(sqrt_expr.eval1(A, B), 100.0);
 261 }
 262
 263 void robust_sqrt_expr_test2()
 264 {
 265   robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr;
 266   int32 A[2] = {10, 30};
 267   int32 B[2] = {400, 100};
 268   BOOST_TEST_EQ(sqrt_expr.eval2(A, B), 500.0);
 269 }
 270
 271 void robust_sqrt_expr_test3()
 272 {
 273   robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr;
 274   int32 A[2] = {10, -30};
 275   int32 B[2] = {400, 100};
 276   BOOST_TEST_EQ(sqrt_expr.eval2(A, B), -100.0);
 277 }
 278
 279 void robust_sqrt_expr_test4()
 280 {
 281   robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr;
 282   int32 A[3] = {10, 30, 20};
 283   int32 B[3] = {4, 1, 9};
 284   BOOST_TEST_EQ(sqrt_expr.eval3(A, B), 110.0);
 285 }
 286
 287 void robust_sqrt_expr_test5()
 288 {
 289   robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr;
 290   int32 A[3] = {10, 30, -20};
 291   int32 B[3] = {4, 1, 9};
 292   BOOST_TEST_EQ(sqrt_expr.eval3(A, B), -10.0);
 293 }
 294
 295 void robust_sqrt_expr_test6()
 296 {
 297   robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr;
 298   int32 A[4] = {10, 30, 20, 5};
 299   int32 B[4] = {4, 1, 9, 16};
 300   BOOST_TEST_EQ(sqrt_expr.eval4(A, B), 130.0);
 301 }
 302
 303 void robust_sqrt_expr_test7()
 304 {
 305   robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr;
 306   int32 A[4] = {10, 30, -20, -5};
 307   int32 B[4] = {4, 1, 9, 16};
 308   BOOST_TEST_EQ(sqrt_expr.eval4(A, B), -30.0);
 309 }
 310
 311 void robust_sqrt_expr_test8()
 312 {
 313   typedef extended_int<16> eint512;
 314   robust_sqrt_expr<eint512, efpt64, to_efpt_type> sqrt_expr;
 315   int32 A[4] = {1000, 3000, -2000, -500};
 316   int32 B[4] = {400, 100, 900, 1600};
 317   eint512 AA[4], BB[4];
 318   for (std::size_t i = 0; i < 4; ++i) {
 319     AA[i] = A[i];
 320     BB[i] = B[i];
 321   }
 322   BOOST_TEST_EQ(to_fpt(sqrt_expr.eval4(AA, BB)), -30000.0);
 323 }
 324
 325 template <typename _int, typename _fpt>
 326 class sqrt_expr_tester {
 327  public:
 328   static const std::size_t MX_SQRTS = 4;
 329
 330   bool run() {
 331     static boost::mt19937 gen(static_cast<uint32>(time(NULL)));
 332     bool ret_val = true;
 333     for (std::size_t i = 0; i < MX_SQRTS; ++i) {
 334       a[i] = gen() & 1048575;
 335       int64 temp = gen() & 1048575;
 336       b[i] = temp * temp;
 337     }
 338     uint32 mask = (1 << MX_SQRTS);
 339     for (std::size_t i = 0; i < mask; i++) {
 340       fpt64 expected_val = 0.0;
 341       for (std::size_t j = 0; j < MX_SQRTS; j++) {
 342         if (i & (1 << j)) {
 343           A[j] = a[j];
 344           B[j] = b[j];
 345           expected_val += static_cast<fpt64>(a[j]) *
 346                           std::sqrt(static_cast<fpt64>(b[j]));
 347         } else {
 348           A[j] = -a[j];
 349           B[j] = b[j];
 350           expected_val -= static_cast<fpt64>(a[j]) *
 351                           std::sqrt(static_cast<fpt64>(b[j]));
 352         }
 353       }
 354       fpt64 received_val = to_fpt(sqrt_expr_.eval4(A, B));
 355       ret_val &= ulp_cmp(expected_val, received_val, 25) ==
 356                  ulp_comparison<fpt64>::EQUAL;
 357     }
 358     return ret_val;
 359   }
 360
 361  private:
 362   robust_sqrt_expr<_int, _fpt, to_efpt_type> sqrt_expr_;
 363   ulp_comparison<fpt64> ulp_cmp;
 364   _int A[MX_SQRTS];
 365   _int B[MX_SQRTS];
 366   int64 a[MX_SQRTS];
 367   int64 b[MX_SQRTS];
 368 };
 369
 370 void mpz_sqrt_evaluator_test()
 371 {
 372   typedef extended_int<16> eint512;
 373   sqrt_expr_tester<eint512, efpt64> tester;
 374   for (int i = 0; i < 2000; ++i)
 375     BOOST_TEST(tester.run());
 376 }
 377
 378 int main()
 379 {
 380     robust_fpt_constructors_test1();
 381     robust_fpt_constructors_test2();
 382     robust_fpt_constructors_test3();
 383     robust_fpt_constructors_test4();
 384     robust_fpt_sum_test1();
 385     robust_fpt_sum_test2();
 386     robust_fpt_dif_test1();
 387     robust_fpt_dif_test2();
 388     robust_fpt_mult_test3();
 389     robust_fpt_div_test1();
 390     robust_dif_constructors_test();
 391     robust_dif_operators_test1();
 392     robust_dif_operators_test2();
 393     robust_dif_operators_test3();
 394     robust_dif_operators_test4();
 395     robust_sqrt_expr_test1();
 396     robust_sqrt_expr_test2();
 397     robust_sqrt_expr_test3();
 398     robust_sqrt_expr_test4();
 399     robust_sqrt_expr_test5();
 400     robust_sqrt_expr_test6();
 401     robust_sqrt_expr_test7();
 402     robust_sqrt_expr_test8();
 403     mpz_sqrt_evaluator_test();
 404     return boost::report_errors();
 405 }