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 #ifndef BOOST_MP_CPP_INT_CORE_HPP
7 #define BOOST_MP_CPP_INT_CORE_HPP
8
9 #include <boost/integer.hpp>
10 #include <boost/integer_traits.hpp>
11 #include <boost/mpl/if.hpp>
12 #include <boost/mpl/int.hpp>
13 #include <boost/static_assert.hpp>
14 #include <boost/assert.hpp>
15
16 namespace boost {
17 namespace multiprecision {
18
19 namespace detail {
20
21 //
22 // These traits calculate the largest type in the list
23 // [unsigned] boost::long_long_type, long, int, which has the specified number
24 // of bits. Note that intN_t and boost::int_t<N> find the first
25 // member of the above list, not the last. We want the last in the
26 // list to ensure that mixed arithmetic operations are as efficient
27 // as possible.
28 //
29 template <unsigned N>
30 struct largest_signed_type
31 {
32 typedef typename mpl::if_c<
33 1 + std::numeric_limits<boost::long_long_type>::digits == N,
34 boost::long_long_type,
35 typename mpl::if_c<
36 1 + std::numeric_limits<long>::digits == N,
37 long,
38 typename mpl::if_c<
39 1 + std::numeric_limits<int>::digits == N,
40 int,
41 typename boost::int_t<N>::exact>::type>::type>::type type;
42 };
43
44 template <unsigned N>
45 struct largest_unsigned_type
46 {
47 typedef typename mpl::if_c<
48 std::numeric_limits<boost::ulong_long_type>::digits == N,
49 boost::ulong_long_type,
50 typename mpl::if_c<
51 std::numeric_limits<unsigned long>::digits == N,
52 unsigned long,
53 typename mpl::if_c<
54 std::numeric_limits<unsigned int>::digits == N,
55 unsigned int,
56 typename boost::uint_t<N>::exact>::type>::type>::type type;
57 };
58
59 } // namespace detail
60
61 #if defined(BOOST_HAS_INT128)
62
63 typedef detail::largest_unsigned_type<64>::type limb_type;
64 typedef detail::largest_signed_type<64>::type signed_limb_type;
65 typedef boost::uint128_type double_limb_type;
66 typedef boost::int128_type signed_double_limb_type;
67 static const limb_type max_block_10 = 1000000000000000000uLL;
68 static const limb_type digits_per_block_10 = 18;
69
block_multiplier(unsigned count)70 inline BOOST_MP_CXX14_CONSTEXPR limb_type block_multiplier(unsigned count)
71 {
72 #ifdef BOOST_NO_CXX14_CONSTEXPR
73 static
74 #else
75 constexpr
76 #endif
77 const limb_type values[digits_per_block_10] = {10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 10000000000, 100000000000, 1000000000000, 10000000000000, 100000000000000, 1000000000000000, 10000000000000000, 100000000000000000, 1000000000000000000};
78 BOOST_ASSERT(count < digits_per_block_10);
79 return values[count];
80 }
81
82 // Can't do formatted IO on an __int128
83 #define BOOST_MP_NO_DOUBLE_LIMB_TYPE_IO
84
85 // Need to specialise integer_traits for __int128 as it's not a normal native type:
86 } // namespace multiprecision
87
88 template <>
89 class integer_traits<multiprecision::double_limb_type>
90 : public std::numeric_limits<multiprecision::double_limb_type>,
91 public detail::integer_traits_base<multiprecision::double_limb_type, 0, ~static_cast<multiprecision::double_limb_type>(0)>
92 {};
93 template <>
94 class integer_traits<multiprecision::signed_double_limb_type>
95 : public std::numeric_limits<multiprecision::signed_double_limb_type>,
96 public detail::integer_traits_base<multiprecision::signed_double_limb_type, static_cast<multiprecision::signed_double_limb_type>((static_cast<multiprecision::double_limb_type>(1) << 127)), static_cast<multiprecision::signed_double_limb_type>(((~static_cast<multiprecision::double_limb_type>(0)) >> 1))>
97 {};
98
99 namespace multiprecision {
100
101 #else
102
103 typedef detail::largest_unsigned_type<32>::type limb_type;
104 typedef detail::largest_signed_type<32>::type signed_limb_type;
105 typedef detail::largest_unsigned_type<64>::type double_limb_type;
106 typedef detail::largest_signed_type<64>::type signed_double_limb_type;
107 static const limb_type max_block_10 = 1000000000;
108 static const limb_type digits_per_block_10 = 9;
109
110 inline limb_type block_multiplier(unsigned count)
111 {
112 #ifdef BOOST_NO_CXX14_CONSTEXPR
113 static
114 #else
115 constexpr
116 #endif
117 const limb_type values[digits_per_block_10] = {10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};
118 BOOST_ASSERT(count < digits_per_block_10);
119 return values[count];
120 }
121
122 #endif
123
124 static const unsigned bits_per_limb = sizeof(limb_type) * CHAR_BIT;
125
126 template <class T>
minmax(const T & a,const T & b,T & aa,T & bb)127 inline BOOST_MP_CXX14_CONSTEXPR void minmax(const T& a, const T& b, T& aa, T& bb)
128 {
129 if (a < b)
130 {
131 aa = a;
132 bb = b;
133 }
134 else
135 {
136 aa = b;
137 bb = a;
138 }
139 }
140
141 enum cpp_integer_type
142 {
143 signed_magnitude = 1,
144 unsigned_magnitude = 0,
145 signed_packed = 3,
146 unsigned_packed = 2
147 };
148
149 enum cpp_int_check_type
150 {
151 checked = 1,
152 unchecked = 0
153 };
154
155 } // namespace multiprecision
156 } // namespace boost
157
158 //
159 // Figure out whether to support user-defined-literals or not:
160 //
161 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_USER_DEFINED_LITERALS) && !defined(BOOST_NO_CXX11_CONSTEXPR)
162 #define BOOST_MP_USER_DEFINED_LITERALS
163 #endif
164
165 #endif // BOOST_MP_CPP_INT_CORE_HPP
166