libs/multiprecision/test/constexpr_test_cpp_int_4.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 "test.hpp"
   9
  10 template <class F, class V>
  11 decltype(std::declval<F>()(std::declval<V>())) non_constexpr_invoke(F f, V v)
  12 {
  13    return f(v);
  14 }
  15
  16 int main()
  17 {
  18    typedef boost::multiprecision::checked_int128_t  int_backend;
  19    typedef boost::multiprecision::checked_uint128_t unsigned_backend;
  20
  21    {
  22       constexpr int_backend a(22);
  23       constexpr unsigned_backend c(22);
  24       constexpr int_backend b      = test_constexpr_add_subtract(a);
  25       constexpr unsigned_backend d = test_constexpr_add_subtract(c);
  26
  27       constexpr long long llv = (long long)b;
  28
  29       static_assert(b == -108);
  30       static_assert(d == 554);
  31
  32       BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_add_subtract<int_backend>, a));
  33       BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_add_subtract<unsigned_backend>, c));
  34    }
  35    {
  36       constexpr int_backend a(22);
  37       constexpr unsigned_backend c(22);
  38       constexpr int_backend b      = test_constexpr_mul_divide(a);
  39       constexpr unsigned_backend d = test_constexpr_mul_divide(c);
  40       static_assert(b == 22);
  41       static_assert(d == 22);
  42
  43       BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_mul_divide<int_backend>, a));
  44       BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_mul_divide<unsigned_backend>, c));
  45    }
  46    {
  47       constexpr int_backend a(22);
  48       constexpr unsigned_backend c(22);
  49       constexpr int_backend b      = test_constexpr_bitwise(a);
  50       constexpr unsigned_backend d = test_constexpr_bitwise(c);
  51 #ifdef BOOST_HAS_INT128
  52       static_assert(b == 230);
  53       static_assert(d == 120);
  54 #else
  55       static_assert(b == 210);
  56       static_assert(d == 106);
  57 #endif
  58
  59       BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_bitwise<int_backend>, a));
  60       BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_bitwise<unsigned_backend>, c));
  61    }
  62    {
  63       constexpr int_backend a(22);
  64       constexpr unsigned_backend c(22);
  65       constexpr int_backend b = test_constexpr_logical(a);
  66       constexpr unsigned_backend d = test_constexpr_logical(c);
  67 #ifdef BOOST_HAS_INT128
  68       //static_assert(b == 95);
  69       //static_assert(d == 95);
  70 #else
  71       static_assert(b == 82);
  72       static_assert(d == 82);
  73 #endif
  74       BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_logical<int_backend>, a));
  75       BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_logical<unsigned_backend>, c));
  76    }
  77    {
  78       constexpr int_backend a(22);
  79       constexpr unsigned_backend c(22);
  80       constexpr int_backend b      = test_constexpr_compare(a);
  81       constexpr unsigned_backend d = test_constexpr_compare(c);
  82 #ifdef BOOST_HAS_INT128
  83       static_assert(b == 95);
  84       static_assert(d == 95);
  85 #else
  86       static_assert(b == 95);
  87       static_assert(d == 95);
  88 #endif
  89       BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_compare<int_backend>, a));
  90       BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_compare<unsigned_backend>, c));
  91    }
  92    return boost::report_errors();
  93 }