libs/multiprecision/test/constexpr_test_cpp_int_5.cpp

   1 //  (C) Copyright John Maddock 2019.
   2 //  Use, modification and distribution are subject to the
   3 //  Boost 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 #include "constexpr_arithmetric_test.hpp"
   7 #include "boost/multiprecision/cpp_int.hpp"
   8 #include "boost/multiprecision/integer.hpp"
   9 #include "test.hpp"
  10
  11 template <class F, class V>
  12 decltype(std::declval<F>()(std::declval<V>())) non_constexpr_invoke(F f, V v)
  13 {
  14    return f(v);
  15 }
  16
  17 //[factorial_decl
  18 template <class T>
  19 constexpr T factorial(const T& a)
  20 {
  21    return a ? a * factorial(a - 1) : 1;
  22 }
  23 //]
  24
  25 template <class T, class U>
  26 constexpr T big_mul(const U& a, const U& b)
  27 {
  28    using boost::multiprecision::multiply;
  29    T result = T();
  30    multiply(result, a, b);
  31    return result;
  32 }
  33 template <class T, class U>
  34 constexpr T big_add(const U& a, const U& b)
  35 {
  36    using boost::multiprecision::add;
  37    T result = T();
  38    add(result, a, b);
  39    return result;
  40 }
  41 template <class T, class U>
  42 constexpr T big_sub(const U& a, const U& b)
  43 {
  44    using boost::multiprecision::subtract;
  45    T result = T();
  46    subtract(result, a, b);
  47    return result;
  48 }
  49 template <class U>
  50 constexpr U div_qr_d(const U& a, const U& b)
  51 {
  52    using boost::multiprecision::divide_qr;
  53    U result = U();
  54    U r      = U();
  55    divide_qr(a, b, result, r);
  56    return result;
  57 }
  58 template <class U>
  59 constexpr U div_qr_r(const U& a, const U& b)
  60 {
  61    using boost::multiprecision::divide_qr;
  62    U result = U();
  63    U r      = U();
  64    divide_qr(a, b, result, r);
  65    return r;
  66 }
  67 template <class T>
  68 constexpr T do_bit_set(T val, unsigned pos)
  69 {
  70    using boost::multiprecision::bit_set;
  71    bit_set(val, pos);
  72    return val;
  73 }
  74 template <class T>
  75 constexpr T do_bit_unset(T val, unsigned pos)
  76 {
  77    using boost::multiprecision::bit_unset;
  78    bit_unset(val, pos);
  79    return val;
  80 }
  81 template <class T>
  82 constexpr T do_bit_flip(T val, unsigned pos)
  83 {
  84    using boost::multiprecision::bit_flip;
  85    bit_flip(val, pos);
  86    return val;
  87 }
  88 template <class T>
  89 constexpr T test_swap(T a, T b)
  90 {
  91    swap(a, b);
  92    a.swap(b);
  93    return a;
  94 }
  95
  96 int main()
  97 {
  98    using namespace boost::multiprecision::literals;
  99
 100    typedef boost::multiprecision::checked_int1024_t  int_backend;
 101    typedef boost::multiprecision::checked_int512_t   small_int_backend;
 102    typedef boost::multiprecision::checked_uint1024_t unsigned_backend;
 103
 104    constexpr int_backend f1 = factorial(int_backend(31));
 105    static_assert(f1 == 0x1956ad0aae33a4560c5cd2c000000_cppi);
 106    constexpr unsigned_backend f2 = factorial(unsigned_backend(31));
 107    static_assert(f2 == 0x1956ad0aae33a4560c5cd2c000000_cppui);
 108
 109    //
 110    // Test integer non-member functions:
 111    //
 112    constexpr small_int_backend si1 = (std::numeric_limits<small_int_backend>::max)();
 113    constexpr small_int_backend si2 = 239876;
 114    constexpr std::int32_t i        = (std::numeric_limits<int>::max)();
 115    constexpr std::int32_t j        = 239876;
 116    // Multiply:
 117    {
 118       constexpr int_backend i1 = big_mul<int_backend>(si1, si2);
 119       int_backend           nc;
 120       multiply(nc, si1, si2);
 121       BOOST_CHECK_EQUAL(nc, i1);
 122
 123       constexpr std::int64_t k = big_mul<std::int64_t>(i, j);
 124       std::int64_t           ii;
 125       boost::multiprecision::multiply(ii, i, j);
 126       BOOST_CHECK_EQUAL(ii, k);
 127    }
 128    // Add:
 129    {
 130       constexpr int_backend i1 = big_add<int_backend>(si1, si2);
 131       int_backend           nc;
 132       add(nc, si1, si2);
 133       BOOST_CHECK_EQUAL(nc, i1);
 134
 135       constexpr std::int64_t k = big_add<std::int64_t>(i, j);
 136       std::int64_t           ii;
 137       boost::multiprecision::add(ii, i, j);
 138       BOOST_CHECK_EQUAL(ii, k);
 139    }
 140    // Subtract:
 141    {
 142       constexpr int_backend i1 = big_sub<int_backend>(si1, -si2);
 143       int_backend           nc;
 144       subtract(nc, si1, -si2);
 145       BOOST_CHECK_EQUAL(nc, i1);
 146
 147       constexpr std::int64_t k = big_sub<std::int64_t>(i, -j);
 148       std::int64_t           ii;
 149       boost::multiprecision::subtract(ii, i, -j);
 150       BOOST_CHECK_EQUAL(ii, k);
 151    }
 152    // divide_qr:
 153    {
 154       constexpr small_int_backend i1 = div_qr_d(si1, si2);
 155       small_int_backend           nc, nc2;
 156       divide_qr(si1, si2, nc, nc2);
 157       BOOST_CHECK_EQUAL(nc, i1);
 158
 159       constexpr std::int64_t k = div_qr_d(i, j);
 160       std::int32_t           ii, ij;
 161       boost::multiprecision::divide_qr(i, j, ii, ij);
 162       BOOST_CHECK_EQUAL(ii, k);
 163    }
 164    // divide_qr:
 165    {
 166       constexpr small_int_backend i1 = div_qr_r(si1, si2);
 167       small_int_backend           nc, nc2;
 168       divide_qr(si1, si2, nc, nc2);
 169       BOOST_CHECK_EQUAL(nc2, i1);
 170
 171       constexpr std::int64_t k = div_qr_r(i, j);
 172       std::int32_t           ii, ij;
 173       boost::multiprecision::divide_qr(i, j, ii, ij);
 174       BOOST_CHECK_EQUAL(ij, k);
 175    }
 176    // integer_modulus:
 177    {
 178       constexpr int     i1 = integer_modulus(si1, 67);
 179       small_int_backend nc(si1);
 180       int               r = integer_modulus(nc, 67);
 181       BOOST_CHECK_EQUAL(r, i1);
 182
 183       constexpr std::int32_t k = boost::multiprecision::integer_modulus(i, j);
 184       std::int32_t           ii(i);
 185       r = boost::multiprecision::integer_modulus(ii, j);
 186       BOOST_CHECK_EQUAL(r, k);
 187    }
 188    // powm:
 189    {
 190       constexpr small_int_backend i1 = powm(si1, si2, si2);
 191       small_int_backend           nc(si1);
 192       nc = powm(nc, si2, si2);
 193       BOOST_CHECK_EQUAL(nc, i1);
 194
 195       constexpr std::int32_t k = boost::multiprecision::powm(i, j, j);
 196       std::int32_t           ii(i);
 197       ii = boost::multiprecision::powm(ii, j, j);
 198       BOOST_CHECK_EQUAL(ii, k);
 199    }
 200    // lsb:
 201    {
 202       constexpr int     i1 = lsb(si1);
 203       small_int_backend nc(si1);
 204       int               nci = lsb(nc);
 205       BOOST_CHECK_EQUAL(nci, i1);
 206
 207       constexpr std::int32_t k = boost::multiprecision::lsb(i);
 208       std::int32_t           ii(i);
 209       ii = boost::multiprecision::lsb(ii);
 210       BOOST_CHECK_EQUAL(ii, k);
 211    }
 212    // msb:
 213    {
 214       constexpr int     i1 = msb(si1);
 215       small_int_backend nc(si1);
 216       int               nci = msb(nc);
 217       BOOST_CHECK_EQUAL(nci, i1);
 218
 219       constexpr std::int32_t k = boost::multiprecision::msb(i);
 220       std::int32_t           ii(i);
 221       ii = boost::multiprecision::msb(ii);
 222       BOOST_CHECK_EQUAL(ii, k);
 223    }
 224    // bit_test:
 225    {
 226       constexpr bool b = bit_test(si1, 1);
 227       static_assert(b);
 228
 229       constexpr bool k = boost::multiprecision::bit_test(i, 1);
 230       static_assert(k);
 231    }
 232    // bit_set:
 233    {
 234       constexpr int_backend i(0);
 235       constexpr int_backend j = do_bit_set(i, 20);
 236       static_assert(bit_test(j, 20));
 237
 238       constexpr int ii(0);
 239       constexpr int jj = do_bit_set(ii, 20);
 240       static_assert(boost::multiprecision::bit_test(jj, 20));
 241    }
 242    // bit_unset:
 243    {
 244       constexpr int_backend r = do_bit_unset(si1, 20);
 245       static_assert(bit_test(r, 20) == false);
 246
 247       constexpr int jj = do_bit_unset(i, 20);
 248       static_assert(boost::multiprecision::bit_test(jj, 20) == false);
 249    }
 250    // bit_unset:
 251    {
 252       constexpr int_backend r = do_bit_flip(si1, 20);
 253       static_assert(bit_test(r, 20) == false);
 254
 255       constexpr int jj = do_bit_flip(i, 20);
 256       static_assert(boost::multiprecision::bit_test(jj, 20) == false);
 257    }
 258    // sqrt:
 259    {
 260       constexpr int_backend r = sqrt(si1);
 261       small_int_backend     nc(si1);
 262       nc = sqrt(nc);
 263       BOOST_CHECK_EQUAL(nc, r);
 264
 265       constexpr int jj = boost::multiprecision::sqrt(i);
 266       int           k  = i;
 267       k                = boost::multiprecision::sqrt(k);
 268       BOOST_CHECK_EQUAL(jj, k);
 269    }
 270    {
 271       // swap:
 272       constexpr small_int_backend r = test_swap(si1, si2);
 273       static_assert(si1 == r);
 274    }
 275    {
 276       // gcd:
 277       constexpr int_backend i(si1), j(si1 / 3);
 278       constexpr int_backend k = gcd(i, j);
 279
 280       int_backend ii(i), jj(j);
 281       BOOST_CHECK_EQUAL(k, gcd(ii, jj));
 282
 283       constexpr unsigned_backend ui(i), uj(j);
 284       constexpr unsigned_backend uk = gcd(ui, uj);
 285       unsigned_backend           uii(ui), ujj(uj);
 286       BOOST_CHECK_EQUAL(uk, gcd(uii, ujj));
 287
 288       constexpr int_backend l = lcm(i, j);
 289       BOOST_CHECK_EQUAL(l, lcm(ii, jj));
 290       constexpr unsigned_backend ul = lcm(ui, uj);
 291       BOOST_CHECK_EQUAL(ul, lcm(uii, ujj));
 292    }
 293    return boost::report_errors();
 294 }