ceph/src/boost/libs/test/test/writing-test-ts/fp-multiprecision-comparison-test.cpp

   1 //  Use, modification and distribution are subject to the
   2 //  Boost Software License, Version 1.0. (See accompanying file
   3 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   4
   5 // Copyright Paul A. Bristow 2013
   6 // Copyright Christopher Kormanyos 2013.
   7 // Copyright John Maddock 2013.
   8
   9 #ifdef _MSC_VER
  10 #  pragma warning (disable : 4512)
  11 #  pragma warning (disable : 4996)
  12 #endif
  13
  14 #define BOOST_TEST_MAIN
  15 #define BOOST_LIB_DIAGNOSTIC "on"// Show library file details.
  16
  17
  18
  19 //[expression_template_1
  20
  21 #include <limits>
  22 #include <iostream>
  23 #include <boost/multiprecision/cpp_dec_float.hpp>
  24
  25 #include <boost/test/tools/floating_point_comparison.hpp> // Extra test tool for FP comparison.
  26 #include <boost/test/unit_test.hpp>
  27
  28
  29 typedef boost::multiprecision::number<
  30    boost::multiprecision::cpp_dec_float<50>,
  31    boost::multiprecision::et_off> cpp_dec_float_50_noet;
  32
  33 typedef boost::multiprecision::number<
  34    boost::multiprecision::cpp_dec_float<50>,
  35    boost::multiprecision::et_on> cpp_dec_float_50_et;
  36
  37
  38 // there is no need for this anymore, however this could be defined by
  39 // the user in order to support additional types for floating point
  40 // comparison.
  41 #if 0
  42 namespace boost { namespace math { namespace fpc {
  43
  44   template <class A, boost::multiprecision::expression_template_option B>
  45   struct tolerance_based< boost::multiprecision::number<
  46    A,
  47    B > > : boost::mpl::true_ {};
  48
  49   template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
  50   struct tolerance_based<
  51     boost::multiprecision::detail::expression<
  52       tag, Arg1, Arg2, Arg3, Arg4> > : boost::mpl::true_ {};
  53
  54 } } }
  55 #endif
  56
  57
  58
  59
  60
  61 /*`To define a 50 decimal digit type using `cpp_dec_float`,
  62 you must pass two template parameters to `boost::multiprecision::number`.
  63
  64 It may be more legible to use a two-staged type definition such as this:
  65
  66 ``
  67 typedef boost::multiprecision::cpp_dec_float<50> mp_backend;
  68 typedef boost::multiprecision::number<mp_backend, boost::multiprecision::et_off> cpp_dec_float_50_noet;
  69 ``
  70
  71 Here, we first define `mp_backend` as `cpp_dec_float` with 50 digits.
  72 The second step passes this backend to `boost::multiprecision::number`
  73 with `boost::multiprecision::et_off`, an enumerated type.
  74
  75   typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_off>
  76   cpp_dec_float_50_noet;
  77
  78 You can reduce typing with a `using` directive `using namespace boost::multiprecision;`
  79 if desired, as shown below.
  80 */
  81
  82 using namespace boost::multiprecision;
  83
  84 #if 0
  85 BOOST_AUTO_TEST_CASE(multiprecision_types_are_arithmetic)
  86 {
  87   typedef number<cpp_dec_float<50>, et_off> cpp_dec_float_50_noet;
  88   BOOST_TEST((std::numeric_limits<cpp_dec_float_50_noet>::is_specialized));
  89 }
  90 #endif
  91
  92
  93 /*`Now `cpp_dec_float_50_noet` or `cpp_dec_float_50_et`
  94 can be used as a direct replacement for built-in types like `double` etc.
  95 */
  96
  97 BOOST_AUTO_TEST_CASE(cpp_float_test_check_close_noet)
  98 { // No expression templates/
  99   typedef number<cpp_dec_float<50>, et_off> cpp_dec_float_50_noet;
 100
 101   std::cout.precision(std::numeric_limits<cpp_dec_float_50_noet>::digits10); // All significant digits.
 102   std::cout << std::showpoint << std::endl; // Show trailing zeros.
 103
 104   cpp_dec_float_50_noet a ("1.0");
 105   cpp_dec_float_50_noet b ("1.0");
 106   b += std::numeric_limits<cpp_dec_float_50_noet>::epsilon(); // Increment least significant decimal digit.
 107
 108   cpp_dec_float_50_noet eps = std::numeric_limits<cpp_dec_float_50_noet>::epsilon();
 109
 110   std::cout <<"a = " << a << ",\nb = " << b << ",\neps = " << eps << std::endl;
 111
 112   BOOST_CHECK_CLOSE(a, b, eps * 100); // Expected to pass (because tolerance is as percent).
 113   BOOST_CHECK_CLOSE_FRACTION(a, b, eps); // Expected to pass (because tolerance is as fraction).
 114
 115 #ifndef BOOST_TEST_MACRO_LIMITED_SUPPORT
 116   namespace tt = boost::test_tools;
 117   BOOST_TEST( a == b, tt::tolerance( tt::fpc::percent_tolerance( eps * 100 ) ) );
 118   BOOST_TEST( a == b, tt::tolerance( eps ) );
 119 #endif
 120
 121 //] [/expression_template_1]git
 122
 123 } // BOOST_AUTO_TEST_CASE(cpp_float_test_check_close)
 124
 125 BOOST_AUTO_TEST_CASE(cpp_float_test_check_close_et)
 126 { // Using expression templates.
 127   typedef number<cpp_dec_float<50>, et_on> cpp_dec_float_50_et;
 128
 129   std::cout.precision(std::numeric_limits<cpp_dec_float_50_et>::digits10); // All significant digits.
 130   std::cout << std::showpoint << std::endl; // Show trailing zeros.
 131
 132   cpp_dec_float_50_et a("1.0");
 133   cpp_dec_float_50_et b("1.0");
 134   b += std::numeric_limits<cpp_dec_float_50_et>::epsilon(); // Increment least significant decimal digit.
 135
 136   cpp_dec_float_50_et eps = std::numeric_limits<cpp_dec_float_50_et>::epsilon();
 137
 138   std::cout << "a = " << a << ",\nb = " << b << ",\neps = " << eps << std::endl;
 139
 140   BOOST_CHECK_CLOSE(a, b, eps * 100); // Expected to pass (because tolerance is as percent).
 141   BOOST_CHECK_CLOSE_FRACTION(a, b, eps); // Expected to pass (because tolerance is as fraction).
 142
 143 #ifndef BOOST_TEST_MACRO_LIMITED_SUPPORT
 144   namespace tt = boost::test_tools;
 145   BOOST_TEST( a == b, tt::tolerance( tt::fpc::percent_tolerance<cpp_dec_float_50_et>( eps * 100 ) ) );
 146   BOOST_TEST( a == b, tt::tolerance( eps ) );
 147 #endif
 148   /*`Using `cpp_dec_float_50` with the default expression template use switched on,
 149   the compiler error message for `BOOST_CHECK_CLOSE_FRACTION(a, b, eps); would be:
 150   */
 151   // failure floating_point_comparison.hpp(59): error C2440: 'static_cast' :
 152   // cannot convert from 'int' to 'boost::multiprecision::detail::expression<tag,Arg1,Arg2,Arg3,Arg4>'
 153   //] [/expression_template_1]
 154
 155 } // BOOST_AUTO_TEST_CASE(cpp_float_test_check_close)
 156
 157 /*
 158
 159 Output:
 160
 161   Description: Autorun "J:\Cpp\big_number\Debug\test_cpp_float_close_fraction.exe"
 162   Running 1 test case...
 163
 164   a = 1.0000000000000000000000000000000000000000000000000,
 165   b = 1.0000000000000000000000000000000000000000000000001,
 166   eps = 1.0000000000000000000000000000000000000000000000000e-49
 167
 168   *** No errors detected
 169
 170 */