diff options
Diffstat (limited to 'src/boost/libs/polygon/test/voronoi_robust_fpt_test.cpp')
| -rw-r--r-- | src/boost/libs/polygon/test/voronoi_robust_fpt_test.cpp | 405 |
1 files changed, 405 insertions, 0 deletions
diff --git a/src/boost/libs/polygon/test/voronoi_robust_fpt_test.cpp b/src/boost/libs/polygon/test/voronoi_robust_fpt_test.cpp new file mode 100644 index 000000000..918530691 --- /dev/null +++ b/src/boost/libs/polygon/test/voronoi_robust_fpt_test.cpp @@ -0,0 +1,405 @@ +// Boost.Polygon library voronoi_robust_fpt_test.cpp file + +// Copyright Andrii Sydorchuk 2010-2012. +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for updates, documentation, and revision history. + +#include <boost/core/lightweight_test.hpp> +#include <boost/polygon/detail/voronoi_ctypes.hpp> +#include <boost/polygon/detail/voronoi_robust_fpt.hpp> +#include <boost/random/mersenne_twister.hpp> +#include <vector> +#include <cmath> +#include <ctime> + +using boost::polygon::detail::int32; +using boost::polygon::detail::uint32; +using boost::polygon::detail::int64; +using boost::polygon::detail::fpt64; +using boost::polygon::detail::efpt64; +using boost::polygon::detail::extended_int; +using boost::polygon::detail::extended_exponent_fpt; +using boost::polygon::detail::robust_fpt; +using boost::polygon::detail::robust_dif; +using boost::polygon::detail::robust_sqrt_expr; +using boost::polygon::detail::type_converter_fpt; +using boost::polygon::detail::type_converter_efpt; +using boost::polygon::detail::ulp_comparison; + +typedef robust_fpt<double> rfpt_type; +typedef type_converter_fpt to_fpt_type; +typedef type_converter_efpt to_efpt_type; +type_converter_fpt to_fpt; + +void robust_fpt_constructors_test1() +{ + rfpt_type a = rfpt_type(); + BOOST_TEST_EQ(a.fpv(), 0.0); + BOOST_TEST_EQ(a.re(), 0.0); + BOOST_TEST_EQ(a.ulp(), 0); +} + +void robust_fpt_constructors_test2() +{ + rfpt_type a(10.0, 1.0); + BOOST_TEST_EQ(a.fpv(), 10.0); + BOOST_TEST_EQ(a.re(), 1.0); + BOOST_TEST_EQ(a.ulp(), 1.0); +} + +void robust_fpt_constructors_test3() +{ + rfpt_type a(10.0); + BOOST_TEST_EQ(a.fpv(), 10.0); + BOOST_TEST_EQ(a.re(), 0.0); + BOOST_TEST_EQ(a.ulp(), 0.0); +} + +void robust_fpt_constructors_test4() +{ + rfpt_type a(10.0, 3.0); + BOOST_TEST_EQ(a.fpv(), 10.0); + BOOST_TEST_EQ(a.re(), 3.0); + BOOST_TEST_EQ(a.ulp(), 3.0); + + rfpt_type b(10.0, 2.75); + BOOST_TEST_EQ(b.fpv(), 10.0); + BOOST_TEST_EQ(b.re(), 2.75); + BOOST_TEST_EQ(b.ulp(), 2.75); +} + +void robust_fpt_sum_test1() +{ + rfpt_type a(2.0, 5.0); + rfpt_type b(3.0, 4.0); + rfpt_type c = a + b; + BOOST_TEST_EQ(c.fpv(), 5.0); + BOOST_TEST_EQ(c.re(), 6.0); + BOOST_TEST_EQ(c.ulp(), 6.0); + + c += b; + BOOST_TEST_EQ(c.fpv(), 8.0); + BOOST_TEST_EQ(c.re(), 7.0); + BOOST_TEST_EQ(c.ulp(), 7.0); +} + +void robust_fpt_sum_test2() +{ + rfpt_type a(3.0, 2.0); + rfpt_type b(-2.0, 3.0); + rfpt_type c = a + b; + BOOST_TEST_EQ(c.fpv(), 1.0); + BOOST_TEST_EQ(c.re(), 13.0); + BOOST_TEST_EQ(c.ulp(), 13.0); + + c += b; + BOOST_TEST_EQ(c.fpv(), -1.0); + BOOST_TEST_EQ(c.re(), 20.0); + BOOST_TEST_EQ(c.ulp(), 20.0); +} + +void robust_fpt_dif_test1() +{ + rfpt_type a(2.0, 5.0); + rfpt_type b(-3.0, 4.0); + rfpt_type c = a - b; + BOOST_TEST_EQ(c.fpv(), 5.0); + BOOST_TEST_EQ(c.re(), 6.0); + BOOST_TEST_EQ(c.ulp(), 6.0); + + c -= b; + BOOST_TEST_EQ(c.fpv(), 8.0); + BOOST_TEST_EQ(c.re(), 7.0); + BOOST_TEST_EQ(c.ulp(), 7.0); +} + +void robust_fpt_dif_test2() +{ + rfpt_type a(3.0, 2.0); + rfpt_type b(2.0, 3.0); + rfpt_type c = a - b; + BOOST_TEST_EQ(c.fpv(), 1.0); + BOOST_TEST_EQ(c.re(), 13.0); + BOOST_TEST_EQ(c.ulp(), 13.0); + + c -= b; + BOOST_TEST_EQ(c.fpv(), -1.0); + BOOST_TEST_EQ(c.re(), 20.0); + BOOST_TEST_EQ(c.ulp(), 20.0); +} + +void robust_fpt_mult_test3() +{ + rfpt_type a(2.0, 3.0); + rfpt_type b(4.0, 1.0); + rfpt_type c = a * b; + BOOST_TEST_EQ(c.fpv(), 8.0); + BOOST_TEST_EQ(c.re(), 5.0); + BOOST_TEST_EQ(c.ulp(), 5.0); + + c *= b; + BOOST_TEST_EQ(c.fpv(), 32.0); + BOOST_TEST_EQ(c.re(), 7.0); + BOOST_TEST_EQ(c.ulp(), 7.0); +} + +void robust_fpt_div_test1() +{ + rfpt_type a(2.0, 3.0); + rfpt_type b(4.0, 1.0); + rfpt_type c = a / b; + BOOST_TEST_EQ(c.fpv(), 0.5); + BOOST_TEST_EQ(c.re(), 5.0); + BOOST_TEST_EQ(c.ulp(), 5.0); + + c /= b; + BOOST_TEST_EQ(c.fpv(), 0.125); + BOOST_TEST_EQ(c.re(), 7.0); + BOOST_TEST_EQ(c.ulp(), 7.0); +} + +void robust_dif_constructors_test() +{ + robust_dif<int> rd1; + BOOST_TEST_EQ(rd1.pos(), 0); + BOOST_TEST_EQ(rd1.neg(), 0); + BOOST_TEST_EQ(rd1.dif(), 0); + + robust_dif<int> rd2(1); + BOOST_TEST_EQ(rd2.pos(), 1); + BOOST_TEST_EQ(rd2.neg(), 0); + BOOST_TEST_EQ(rd2.dif(), 1); + + robust_dif<int> rd3(-1); + BOOST_TEST_EQ(rd3.pos(), 0); + BOOST_TEST_EQ(rd3.neg(), 1); + BOOST_TEST_EQ(rd3.dif(), -1); + + robust_dif<int> rd4(1, 2); + BOOST_TEST_EQ(rd4.pos(), 1); + BOOST_TEST_EQ(rd4.neg(), 2); + BOOST_TEST_EQ(rd4.dif(), -1); +} + +void robust_dif_operators_test1() +{ + robust_dif<int> a(5, 2), b(1, 10); + int dif_a = a.dif(); + int dif_b = b.dif(); + robust_dif<int> sum = a + b; + robust_dif<int> dif = a - b; + robust_dif<int> mult = a * b; + robust_dif<int> umin = -a; + BOOST_TEST_EQ(sum.dif(), dif_a + dif_b); + BOOST_TEST_EQ(dif.dif(), dif_a - dif_b); + BOOST_TEST_EQ(mult.dif(), dif_a * dif_b); + BOOST_TEST_EQ(umin.dif(), -dif_a); +} + +void robust_dif_operators_test2() +{ + robust_dif<int> a(5, 2); + for (int b = -3; b <= 3; b += 6) { + int dif_a = a.dif(); + int dif_b = b; + robust_dif<int> sum = a + b; + robust_dif<int> dif = a - b; + robust_dif<int> mult = a * b; + robust_dif<int> div = a / b; + BOOST_TEST_EQ(sum.dif(), dif_a + dif_b); + BOOST_TEST_EQ(dif.dif(), dif_a - dif_b); + BOOST_TEST_EQ(mult.dif(), dif_a * dif_b); + BOOST_TEST_EQ(div.dif(), dif_a / dif_b); + } +} + +void robust_dif_operators_test3() +{ + robust_dif<int> b(5, 2); + for (int a = -3; a <= 3; a += 6) { + int dif_a = a; + int dif_b = b.dif(); + robust_dif<int> sum = a + b; + robust_dif<int> dif = a - b; + robust_dif<int> mult = a * b; + BOOST_TEST_EQ(sum.dif(), dif_a + dif_b); + BOOST_TEST_EQ(dif.dif(), dif_a - dif_b); + BOOST_TEST_EQ(mult.dif(), dif_a * dif_b); + } +} + +void robust_dif_operators_test4() +{ + std::vector< robust_dif<int> > a4(4, robust_dif<int>(5, 2)); + std::vector< robust_dif<int> > b4(4, robust_dif<int>(1, 2)); + std::vector< robust_dif<int> > c4 = a4; + c4[0] += b4[0]; + c4[1] -= b4[1]; + c4[2] *= b4[2]; + BOOST_TEST_EQ(c4[0].dif(), a4[0].dif() + b4[0].dif()); + BOOST_TEST_EQ(c4[1].dif(), a4[1].dif() - b4[1].dif()); + BOOST_TEST_EQ(c4[2].dif(), a4[2].dif() * b4[2].dif()); + a4[0] += b4[0].dif(); + a4[1] -= b4[1].dif(); + a4[2] *= b4[2].dif(); + a4[3] /= b4[3].dif(); + BOOST_TEST_EQ(c4[0].dif(), a4[0].dif()); + BOOST_TEST_EQ(c4[1].dif(), a4[1].dif()); + BOOST_TEST_EQ(c4[2].dif(), a4[2].dif()); + BOOST_TEST_EQ(c4[3].dif() / b4[3].dif(), a4[3].dif()); +} + +void robust_sqrt_expr_test1() +{ + robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr; + int32 A[1] = {10}; + int32 B[1] = {100}; + BOOST_TEST_EQ(sqrt_expr.eval1(A, B), 100.0); +} + +void robust_sqrt_expr_test2() +{ + robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr; + int32 A[2] = {10, 30}; + int32 B[2] = {400, 100}; + BOOST_TEST_EQ(sqrt_expr.eval2(A, B), 500.0); +} + +void robust_sqrt_expr_test3() +{ + robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr; + int32 A[2] = {10, -30}; + int32 B[2] = {400, 100}; + BOOST_TEST_EQ(sqrt_expr.eval2(A, B), -100.0); +} + +void robust_sqrt_expr_test4() +{ + robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr; + int32 A[3] = {10, 30, 20}; + int32 B[3] = {4, 1, 9}; + BOOST_TEST_EQ(sqrt_expr.eval3(A, B), 110.0); +} + +void robust_sqrt_expr_test5() +{ + robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr; + int32 A[3] = {10, 30, -20}; + int32 B[3] = {4, 1, 9}; + BOOST_TEST_EQ(sqrt_expr.eval3(A, B), -10.0); +} + +void robust_sqrt_expr_test6() +{ + robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr; + int32 A[4] = {10, 30, 20, 5}; + int32 B[4] = {4, 1, 9, 16}; + BOOST_TEST_EQ(sqrt_expr.eval4(A, B), 130.0); +} + +void robust_sqrt_expr_test7() +{ + robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr; + int32 A[4] = {10, 30, -20, -5}; + int32 B[4] = {4, 1, 9, 16}; + BOOST_TEST_EQ(sqrt_expr.eval4(A, B), -30.0); +} + +void robust_sqrt_expr_test8() +{ + typedef extended_int<16> eint512; + robust_sqrt_expr<eint512, efpt64, to_efpt_type> sqrt_expr; + int32 A[4] = {1000, 3000, -2000, -500}; + int32 B[4] = {400, 100, 900, 1600}; + eint512 AA[4], BB[4]; + for (std::size_t i = 0; i < 4; ++i) { + AA[i] = A[i]; + BB[i] = B[i]; + } + BOOST_TEST_EQ(to_fpt(sqrt_expr.eval4(AA, BB)), -30000.0); +} + +template <typename _int, typename _fpt> +class sqrt_expr_tester { + public: + static const std::size_t MX_SQRTS = 4; + + bool run() { + static boost::mt19937 gen(static_cast<uint32>(time(NULL))); + bool ret_val = true; + for (std::size_t i = 0; i < MX_SQRTS; ++i) { + a[i] = gen() & 1048575; + int64 temp = gen() & 1048575; + b[i] = temp * temp; + } + uint32 mask = (1 << MX_SQRTS); + for (std::size_t i = 0; i < mask; i++) { + fpt64 expected_val = 0.0; + for (std::size_t j = 0; j < MX_SQRTS; j++) { + if (i & (1 << j)) { + A[j] = a[j]; + B[j] = b[j]; + expected_val += static_cast<fpt64>(a[j]) * + std::sqrt(static_cast<fpt64>(b[j])); + } else { + A[j] = -a[j]; + B[j] = b[j]; + expected_val -= static_cast<fpt64>(a[j]) * + std::sqrt(static_cast<fpt64>(b[j])); + } + } + fpt64 received_val = to_fpt(sqrt_expr_.eval4(A, B)); + ret_val &= ulp_cmp(expected_val, received_val, 25) == + ulp_comparison<fpt64>::EQUAL; + } + return ret_val; + } + + private: + robust_sqrt_expr<_int, _fpt, to_efpt_type> sqrt_expr_; + ulp_comparison<fpt64> ulp_cmp; + _int A[MX_SQRTS]; + _int B[MX_SQRTS]; + int64 a[MX_SQRTS]; + int64 b[MX_SQRTS]; +}; + +void mpz_sqrt_evaluator_test() +{ + typedef extended_int<16> eint512; + sqrt_expr_tester<eint512, efpt64> tester; + for (int i = 0; i < 2000; ++i) + BOOST_TEST(tester.run()); +} + +int main() +{ + robust_fpt_constructors_test1(); + robust_fpt_constructors_test2(); + robust_fpt_constructors_test3(); + robust_fpt_constructors_test4(); + robust_fpt_sum_test1(); + robust_fpt_sum_test2(); + robust_fpt_dif_test1(); + robust_fpt_dif_test2(); + robust_fpt_mult_test3(); + robust_fpt_div_test1(); + robust_dif_constructors_test(); + robust_dif_operators_test1(); + robust_dif_operators_test2(); + robust_dif_operators_test3(); + robust_dif_operators_test4(); + robust_sqrt_expr_test1(); + robust_sqrt_expr_test2(); + robust_sqrt_expr_test3(); + robust_sqrt_expr_test4(); + robust_sqrt_expr_test5(); + robust_sqrt_expr_test6(); + robust_sqrt_expr_test7(); + robust_sqrt_expr_test8(); + mpz_sqrt_evaluator_test(); + return boost::report_errors(); +} |