libs/multiprecision/test/test_generic_conv.cpp

   1 ///////////////////////////////////////////////////////////////
   2 //  Copyright 2012 John Maddock. Distributed under the Boost
   3 //  Software License, Version 1.0. (See accompanying file
   4 //  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
   5 //
   6
   7 #ifdef _MSC_VER
   8 #define _SCL_SECURE_NO_WARNINGS
   9 #endif
  10
  11 #include <boost/detail/lightweight_test.hpp>
  12 #include <boost/array.hpp>
  13 #include "test.hpp"
  14
  15 #include <boost/multiprecision/cpp_bin_float.hpp>
  16 #include <boost/multiprecision/cpp_dec_float.hpp>
  17 #include <boost/multiprecision/cpp_int.hpp>
  18 #include <boost/random.hpp>
  19
  20 #ifdef TEST_GMP
  21 #include <boost/multiprecision/gmp.hpp>
  22 #endif
  23 #ifdef TEST_TOMMATH
  24 #include <boost/multiprecision/tommath.hpp>
  25 #endif
  26 #ifdef TEST_MPFR
  27 #include <boost/multiprecision/mpfr.hpp>
  28 #endif
  29
  30 int main()
  31 {
  32    using namespace boost::multiprecision;
  33    using namespace boost::random;
  34
  35    independent_bits_engine<mt11213b, 1024, cpp_int> gen;
  36    mt11213b                                         small_gen;
  37
  38    for (unsigned i = 0; i < 100; ++i)
  39    {
  40       cpp_int c = gen();
  41       //
  42       // Integer to integer conversions first:
  43       //
  44 #ifdef TEST_GMP
  45       mpz_int z(c);
  46       cpp_int t(z);
  47       BOOST_CHECK_EQUAL(t, c);
  48       z.assign(-c);
  49       t.assign(-z);
  50       BOOST_CHECK_EQUAL(t, c);
  51 #endif
  52 #ifdef TEST_TOMMATH
  53       tom_int tom(c);
  54       cpp_int t2(tom);
  55       BOOST_CHECK_EQUAL(t2, c);
  56       tom.assign(-c);
  57       t2.assign(-tom);
  58       BOOST_CHECK_EQUAL(t2, c);
  59 #endif
  60       //
  61       // Now integer to float:
  62       //
  63       typedef number<cpp_dec_float<500> > dec_float_500;
  64       dec_float_500                       df(c);
  65       dec_float_500                       df2(c.str());
  66       BOOST_CHECK_EQUAL(df, df2);
  67       df.assign(-c);
  68       df2 = -df2;
  69       BOOST_CHECK_EQUAL(df, df2);
  70 #ifdef TEST_GMP
  71       typedef number<gmp_float<500> > mpf_type;
  72       mpf_type                        mpf(c);
  73       mpf_type                        mpf2(c.str());
  74       BOOST_CHECK_EQUAL(mpf, mpf2);
  75       mpf.assign(-c);
  76       mpf2 = -mpf2;
  77       BOOST_CHECK_EQUAL(mpf, mpf2);
  78 #endif
  79 #ifdef TEST_MPFR
  80       typedef number<mpfr_float_backend<500> > mpfr_type;
  81       mpfr_type                                mpfr(c);
  82       mpfr_type                                mpfr2(c.str());
  83       BOOST_CHECK_EQUAL(mpfr, mpfr2);
  84       mpfr.assign(-c);
  85       mpfr2 = -mpfr2;
  86       BOOST_CHECK_EQUAL(mpfr, mpfr2);
  87 #endif
  88       //
  89       // Now float to float:
  90       //
  91       df.assign(c);
  92       df /= dec_float_500(gen());
  93       dec_float_500 tol("1e-500");
  94 #ifdef TEST_GMP
  95       mpf.assign(df);
  96       mpf2 = static_cast<mpf_type>(df.str());
  97       BOOST_CHECK_EQUAL(mpf, mpf2);
  98       df.assign(mpf);
  99       df2 = static_cast<dec_float_500>(mpf.str());
 100       BOOST_CHECK(fabs((df - df2) / df) < tol);
 101 #endif
 102 #ifdef TEST_MPFR
 103       mpfr.assign(df);
 104       mpfr2 = static_cast<mpfr_type>(df.str());
 105       BOOST_CHECK_EQUAL(mpfr, mpfr2);
 106       df.assign(mpfr);
 107       df2 = static_cast<dec_float_500>(mpfr.str());
 108       BOOST_CHECK(fabs((df - df2) / df) < tol);
 109 #endif
 110       //
 111       // Rational to rational conversions:
 112       //
 113       cpp_rational cppr(c, gen()), cppr2, cppr3;
 114 #ifdef TEST_GMP
 115       mpq_rational mpq(cppr);
 116       cppr2.assign(mpq);
 117       BOOST_CHECK_EQUAL(cppr, cppr2);
 118 #endif
 119 #ifdef TEST_TOMMATH
 120       tom_rational tr(cppr);
 121       cppr3.assign(tr);
 122       BOOST_CHECK_EQUAL(cppr, cppr3);
 123 #endif
 124       //
 125       // Integer to rational conversions:
 126       //
 127 #ifdef TEST_GMP
 128       mpq.assign(c);
 129       mpq_rational mpq2 = static_cast<mpq_rational>(c.str());
 130       BOOST_CHECK_EQUAL(mpq, mpq2);
 131 #endif
 132 #ifdef TEST_TOMMATH
 133       tr.assign(c);
 134       tom_rational tr2 = static_cast<tom_rational>(c.str());
 135       BOOST_CHECK_EQUAL(tr, tr2);
 136 #endif
 137       //
 138       // Rational to float:
 139       //
 140       df.assign(cppr);
 141       df2.assign(numerator(cppr));
 142       df2 /= dec_float_500(denominator(cppr));
 143       BOOST_CHECK(fabs(df - df2) / df2 < tol);
 144       //
 145       // Float to rational:
 146       //
 147       static const int                                       max_range = std::numeric_limits<double>::digits >= std::numeric_limits<int>::digits ? (std::numeric_limits<int>::max)() : (1 << (std::numeric_limits<double>::digits - 1)) - 1;
 148       static const int                                       min_range = std::numeric_limits<double>::digits >= std::numeric_limits<int>::digits ? (std::numeric_limits<int>::min)() : -(1 << (std::numeric_limits<double>::digits - 1)) + 1;
 149       static const boost::random::uniform_int_distribution<> i_val_dist(min_range, max_range);
 150       static const boost::random::uniform_int_distribution<> i_exp_dist(std::numeric_limits<double>::min_exponent, std::numeric_limits<double>::max_exponent - 2 - std::numeric_limits<int>::digits);
 151       int                                                    iv   = i_val_dist(small_gen);
 152       int                                                    eval = i_exp_dist(small_gen);
 153       double                                                 dv   = iv;
 154       dv                                                          = ldexp(dv, eval);
 155       cppr                                                        = dv;
 156       cppr2                                                       = iv;
 157       cpp_int cppi                                                = 1;
 158       cppi <<= abs(eval);
 159       if (eval < 0)
 160          cppr2 /= cppi;
 161       else
 162          cppr2 *= cppi;
 163       BOOST_CHECK_EQUAL(cppr, cppr2);
 164       //
 165       // Again but with bigger numbers:
 166       //
 167       cpp_int                      cppi2 = gen();
 168       number<cpp_bin_float<1030> > cppbf(cppi2);
 169       cppbf = ldexp(cppbf, eval);
 170       cppr.assign(cppbf);
 171       cppr2 = cppi2;
 172       if (eval < 0)
 173          cppr2 /= cppi;
 174       else
 175          cppr2 *= cppi;
 176       BOOST_CHECK_EQUAL(cppr, cppr2);
 177       //
 178       // MSVC will compile either the code above, or
 179       // the code below, but not both in the same file.
 180       // Other compilers including Intel in msvc-compatibity
 181       // mode have no such difficulty.  Indeed the fact that
 182       // the presence of the code below causes the code above to
 183       // fail to compile strongly suggests a compiler bug.
 184       //
 185 #if !defined(BOOST_MSVC)
 186       //
 187       // Again but with bigger base 10 numbers:
 188       //
 189       number<cpp_dec_float<std::numeric_limits<int1024_t>::digits10 + 3> > cppdec2(cppi2);
 190       cppdec2 = scalbn(cppdec2, eval);
 191       cppr.assign(cppdec2);
 192       cppr2 = cppi2;
 193       cppi  = 10;
 194       cppi  = pow(cppi, abs(eval));
 195       if (eval < 0)
 196          cppr2 /= cppi;
 197       else
 198          cppr2 *= cppi;
 199       BOOST_CHECK_EQUAL(cppr, cppr2);
 200 #endif
 201    }
 202
 203    return boost::report_errors();
 204 }