FM / cpp

/usr/include/boost/multiprecision/cpp_int/

/usr/include/boost/multiprecision/cpp_int

Name	Size	Mode	Actions
add.hpp	27425	0644	edit dl rm
bitwise.hpp	42935	0644	edit dl rm
checked.hpp	4026	0644	edit dl rm
comparison.hpp	18352	0644	edit dl rm
cpp_int_config.hpp	5394	0644	edit dl rm
divide.hpp	26246	0644	edit dl rm
import_export.hpp	12028	0644	edit dl rm
limits.hpp	27329	0644	edit dl rm
literals.hpp	12116	0644	edit dl rm
misc.hpp	33082	0644	edit dl rm
multiply.hpp	43707	0644	edit dl rm
serialize.hpp	6547	0644	edit dl rm
value_pack.hpp	928	0644	edit dl rm

Edit: /usr/include/boost/multiprecision/cpp_int/literals.hpp (12116B)

#ifndef BOOST_MP_CPP_INT_LITERALS_HPP
#define BOOST_MP_CPP_INT_LITERALS_HPP

#include <boost/multiprecision/cpp_int/cpp_int_config.hpp>

namespace boost { namespace multiprecision {

namespace literals {
namespace detail {

template <char>
struct hex_value;
template <>
struct hex_value<'0'>
{
   static constexpr limb_type value = 0;
};
template <>
struct hex_value<'1'>
{
   static constexpr limb_type value = 1;
};
template <>
struct hex_value<'2'>
{
   static constexpr limb_type value = 2;
};
template <>
struct hex_value<'3'>
{
   static constexpr limb_type value = 3;
};
template <>
struct hex_value<'4'>
{
   static constexpr limb_type value = 4;
};
template <>
struct hex_value<'5'>
{
   static constexpr limb_type value = 5;
};
template <>
struct hex_value<'6'>
{
   static constexpr limb_type value = 6;
};
template <>
struct hex_value<'7'>
{
   static constexpr limb_type value = 7;
};
template <>
struct hex_value<'8'>
{
   static constexpr limb_type value = 8;
};
template <>
struct hex_value<'9'>
{
   static constexpr limb_type value = 9;
};
template <>
struct hex_value<'a'>
{
   static constexpr limb_type value = 10;
};
template <>
struct hex_value<'b'>
{
   static constexpr limb_type value = 11;
};
template <>
struct hex_value<'c'>
{
   static constexpr limb_type value = 12;
};
template <>
struct hex_value<'d'>
{
   static constexpr limb_type value = 13;
};
template <>
struct hex_value<'e'>
{
   static constexpr limb_type value = 14;
};
template <>
struct hex_value<'f'>
{
   static constexpr limb_type value = 15;
};
template <>
struct hex_value<'A'>
{
   static constexpr limb_type value = 10;
};
template <>
struct hex_value<'B'>
{
   static constexpr limb_type value = 11;
};
template <>
struct hex_value<'C'>
{
   static constexpr limb_type value = 12;
};
template <>
struct hex_value<'D'>
{
   static constexpr limb_type value = 13;
};
template <>
struct hex_value<'E'>
{
   static constexpr limb_type value = 14;
};
template <>
struct hex_value<'F'>
{
   static constexpr limb_type value = 15;
};

template <class Pack, limb_type value>
struct combine_value_to_pack;
template <limb_type first, limb_type... ARGS, limb_type value>
struct combine_value_to_pack<value_pack<first, ARGS...>, value>
{
   typedef value_pack<first | value, ARGS...> type;
};

template <char NextChar, char... CHARS>
struct pack_values
{
   static constexpr unsigned chars_per_limb = sizeof(limb_type) * CHAR_BIT / 4;
   static constexpr unsigned shift          = ((sizeof...(CHARS)) % chars_per_limb) * 4;
   static constexpr limb_type value_to_add  = shift ? hex_value<NextChar>::value << shift : hex_value<NextChar>::value;

typedef typename pack_values<CHARS...>::type                          recursive_packed_type;
   typedef typename boost::mpl::if_c<shift == 0,
                                     typename recursive_packed_type::next_type,
                                     recursive_packed_type>::type        pack_type;
   typedef typename combine_value_to_pack<pack_type, value_to_add>::type type;
};
template <char NextChar>
struct pack_values<NextChar>
{
   static constexpr limb_type value_to_add = hex_value<NextChar>::value;

typedef value_pack<value_to_add> type;
};

template <class T>
struct strip_leading_zeros_from_pack;
template <limb_type... PACK>
struct strip_leading_zeros_from_pack<value_pack<PACK...> >
{
   typedef value_pack<PACK...> type;
};
template <limb_type... PACK>
struct strip_leading_zeros_from_pack<value_pack<0u, PACK...> >
{
   typedef typename strip_leading_zeros_from_pack<value_pack<PACK...> >::type type;
};

template <limb_type v, class PACK>
struct append_value_to_pack;
template <limb_type v, limb_type... PACK>
struct append_value_to_pack<v, value_pack<PACK...> >
{
   typedef value_pack<PACK..., v> type;
};

template <class T>
struct reverse_value_pack;
template <limb_type v, limb_type... VALUES>
struct reverse_value_pack<value_pack<v, VALUES...> >
{
   typedef typename reverse_value_pack<value_pack<VALUES...> >::type lead_values;
   typedef typename append_value_to_pack<v, lead_values>::type       type;
};
template <limb_type v>
struct reverse_value_pack<value_pack<v> >
{
   typedef value_pack<v> type;
};
template <>
struct reverse_value_pack<value_pack<> >
{
   typedef value_pack<> type;
};

template <char l1, char l2, char... STR>
struct make_packed_value_from_str
{
   BOOST_STATIC_ASSERT_MSG(l1 == '0', "Multi-precision integer literals must be in hexadecimal notation.");
   BOOST_STATIC_ASSERT_MSG((l2 == 'X') || (l2 == 'x'), "Multi-precision integer literals must be in hexadecimal notation.");
   typedef typename pack_values<STR...>::type                        packed_type;
   typedef typename strip_leading_zeros_from_pack<packed_type>::type stripped_type;
   typedef typename reverse_value_pack<stripped_type>::type          type;
};

template <class Pack, class B>
struct make_backend_from_pack
{
   static constexpr Pack p  = {};
   static constexpr B value = p;
};

template <class Pack, class B>
constexpr B make_backend_from_pack<Pack, B>::value;

template <unsigned Digits>
struct signed_cpp_int_literal_result_type
{
   static constexpr unsigned                                                                               bits = Digits * 4;
   typedef boost::multiprecision::backends::cpp_int_backend<bits, bits, signed_magnitude, unchecked, void> backend_type;
   typedef number<backend_type, et_off>                                                                    number_type;
};

template <unsigned Digits>
struct unsigned_cpp_int_literal_result_type
{
   static constexpr unsigned                                                                                 bits = Digits * 4;
   typedef boost::multiprecision::backends::cpp_int_backend<bits, bits, unsigned_magnitude, unchecked, void> backend_type;
   typedef number<backend_type, et_off>                                                                      number_type;
};

} // namespace detail

template <char... STR>
constexpr typename boost::multiprecision::literals::detail::signed_cpp_int_literal_result_type<(sizeof...(STR)) - 2>::number_type operator"" _cppi()
{
   typedef typename boost::multiprecision::literals::detail::make_packed_value_from_str<STR...>::type pt;
   return boost::multiprecision::literals::detail::make_backend_from_pack<pt, typename boost::multiprecision::literals::detail::signed_cpp_int_literal_result_type<(sizeof...(STR)) - 2>::backend_type>::value;
}

template <char... STR>
constexpr typename boost::multiprecision::literals::detail::unsigned_cpp_int_literal_result_type<(sizeof...(STR)) - 2>::number_type operator"" _cppui()
{
   typedef typename boost::multiprecision::literals::detail::make_packed_value_from_str<STR...>::type pt;
   return boost::multiprecision::literals::detail::make_backend_from_pack<pt, typename boost::multiprecision::literals::detail::unsigned_cpp_int_literal_result_type<(sizeof...(STR)) - 2>::backend_type>::value;
}

#define BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(Bits)                                                                                                                                                                                \
   template <char... STR>                                                                                                                                                                                                          \
   constexpr boost::multiprecision::number<boost::multiprecision::backends::cpp_int_backend<Bits, Bits, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void> > operator"" BOOST_JOIN(_cppi, Bits)()    \
   {                                                                                                                                                                                                                               \
      typedef typename boost::multiprecision::literals::detail::make_packed_value_from_str<STR...>::type pt;                                                                                                                       \
      return boost::multiprecision::literals::detail::make_backend_from_pack<                                                                                                                                                      \
          pt,                                                                                                                                                                                                                      \
          boost::multiprecision::backends::cpp_int_backend<Bits, Bits, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void> >::value;                                                                  \
   }                                                                                                                                                                                                                               \
   template <char... STR>                                                                                                                                                                                                          \
   constexpr boost::multiprecision::number<boost::multiprecision::backends::cpp_int_backend<Bits, Bits, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void> > operator"" BOOST_JOIN(_cppui, Bits)() \
   {                                                                                                                                                                                                                               \
      typedef typename boost::multiprecision::literals::detail::make_packed_value_from_str<STR...>::type pt;                                                                                                                       \
      return boost::multiprecision::literals::detail::make_backend_from_pack<                                                                                                                                                      \
          pt,                                                                                                                                                                                                                      \
          boost::multiprecision::backends::cpp_int_backend<Bits, Bits, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void> >::value;                                                                \
   }

BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(128)
BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(256)
BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(512)
BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(1024)

} // namespace literals

//
// Overload unary minus operator for constexpr use:
//
template <unsigned MinBits, cpp_int_check_type Checked>
constexpr number<cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>, et_off>
operator-(const number<cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>, et_off>& a)
{
   return cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>(a.backend(), boost::multiprecision::literals::detail::make_negate_tag());
}
template <unsigned MinBits, cpp_int_check_type Checked>
constexpr number<cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>, et_off>
operator-(number<cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>, et_off>&& a)
{
   return cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>(static_cast<const number<cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>, et_off>&>(a).backend(), boost::multiprecision::literals::detail::make_negate_tag());
}

}} // namespace boost::multiprecision

#endif // BOOST_MP_CPP_INT_CORE_HPP

/////////////////////////////////////////////////////////////// // Copyright 2013 John Maddock. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt #ifndef BOOST_MP_CPP_INT_LITERALS_HPP #define BOOST_MP_CPP_INT_LITERALS_HPP #include namespace boost { namespace multiprecision { namespace literals { namespace detail { template struct hex_value; template <> struct hex_value<'0'> { static constexpr limb_type value = 0; }; template <> struct hex_value<'1'> { static constexpr limb_type value = 1; }; template <> struct hex_value<'2'> { static constexpr limb_type value = 2; }; template <> struct hex_value<'3'> { static constexpr limb_type value = 3; }; template <> struct hex_value<'4'> { static constexpr limb_type value = 4; }; template <> struct hex_value<'5'> { static constexpr limb_type value = 5; }; template <> struct hex_value<'6'> { static constexpr limb_type value = 6; }; template <> struct hex_value<'7'> { static constexpr limb_type value = 7; }; template <> struct hex_value<'8'> { static constexpr limb_type value = 8; }; template <> struct hex_value<'9'> { static constexpr limb_type value = 9; }; template <> struct hex_value<'a'> { static constexpr limb_type value = 10; }; template <> struct hex_value<'b'> { static constexpr limb_type value = 11; }; template <> struct hex_value<'c'> { static constexpr limb_type value = 12; }; template <> struct hex_value<'d'> { static constexpr limb_type value = 13; }; template <> struct hex_value<'e'> { static constexpr limb_type value = 14; }; template <> struct hex_value<'f'> { static constexpr limb_type value = 15; }; template <> struct hex_value<'A'> { static constexpr limb_type value = 10; }; template <> struct hex_value<'B'> { static constexpr limb_type value = 11; }; template <> struct hex_value<'C'> { static constexpr limb_type value = 12; }; template <> struct hex_value<'D'> { static constexpr limb_type value = 13; }; template <> struct hex_value<'E'> { static constexpr limb_type value = 14; }; template <> struct hex_value<'F'> { static constexpr limb_type value = 15; }; template struct combine_value_to_pack; template struct combine_value_to_pack, value> { typedef value_pack type; }; template struct pack_values { static constexpr unsigned chars_per_limb = sizeof(limb_type) * CHAR_BIT / 4; static constexpr unsigned shift = ((sizeof...(CHARS)) % chars_per_limb) * 4; static constexpr limb_type value_to_add = shift ? hex_value::value << shift : hex_value::value; typedef typename pack_values::type recursive_packed_type; typedef typename boost::mpl::if_c::type pack_type; typedef typename combine_value_to_pack::type type; }; template struct pack_values { static constexpr limb_type value_to_add = hex_value::value; typedef value_pack type; }; template struct strip_leading_zeros_from_pack; template struct strip_leading_zeros_from_pack > { typedef value_pack type; }; template struct strip_leading_zeros_from_pack > { typedef typename strip_leading_zeros_from_pack >::type type; }; template struct append_value_to_pack; template struct append_value_to_pack > { typedef value_pack type; }; template struct reverse_value_pack; template struct reverse_value_pack > { typedef typename reverse_value_pack >::type lead_values; typedef typename append_value_to_pack::type type; }; template struct reverse_value_pack > { typedef value_pack type; }; template <> struct reverse_value_pack > { typedef value_pack<> type; }; template struct make_packed_value_from_str { BOOST_STATIC_ASSERT_MSG(l1 == '0', "Multi-precision integer literals must be in hexadecimal notation."); BOOST_STATIC_ASSERT_MSG((l2 == 'X') || (l2 == 'x'), "Multi-precision integer literals must be in hexadecimal notation."); typedef typename pack_values::type packed_type; typedef typename strip_leading_zeros_from_pack::type stripped_type; typedef typename reverse_value_pack::type type; }; template struct make_backend_from_pack { static constexpr Pack p = {}; static constexpr B value = p; }; template constexpr B make_backend_from_pack::value; template struct signed_cpp_int_literal_result_type { static constexpr unsigned bits = Digits * 4; typedef boost::multiprecision::backends::cpp_int_backend backend_type; typedef number number_type; }; template struct unsigned_cpp_int_literal_result_type { static constexpr unsigned bits = Digits * 4; typedef boost::multiprecision::backends::cpp_int_backend backend_type; typedef number number_type; }; } // namespace detail template constexpr typename boost::multiprecision::literals::detail::signed_cpp_int_literal_result_type<(sizeof...(STR)) - 2>::number_type operator"" _cppi() { typedef typename boost::multiprecision::literals::detail::make_packed_value_from_str::type pt; return boost::multiprecision::literals::detail::make_backend_from_pack::backend_type>::value; } template constexpr typename boost::multiprecision::literals::detail::unsigned_cpp_int_literal_result_type<(sizeof...(STR)) - 2>::number_type operator"" _cppui() { typedef typename boost::multiprecision::literals::detail::make_packed_value_from_str::type pt; return boost::multiprecision::literals::detail::make_backend_from_pack::backend_type>::value; } #define BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(Bits) \ template \ constexpr boost::multiprecision::number > operator"" BOOST_JOIN(_cppi, Bits)() \ { \ typedef typename boost::multiprecision::literals::detail::make_packed_value_from_str::type pt; \ return boost::multiprecision::literals::detail::make_backend_from_pack< \ pt, \ boost::multiprecision::backends::cpp_int_backend >::value; \ } \ template \ constexpr boost::multiprecision::number > operator"" BOOST_JOIN(_cppui, Bits)() \ { \ typedef typename boost::multiprecision::literals::detail::make_packed_value_from_str::type pt; \ return boost::multiprecision::literals::detail::make_backend_from_pack< \ pt, \ boost::multiprecision::backends::cpp_int_backend >::value; \ } BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(128) BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(256) BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(512) BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(1024) } // namespace literals // // Overload unary minus operator for constexpr use: // template constexpr number, et_off> operator-(const number, et_off>& a) { return cpp_int_backend(a.backend(), boost::multiprecision::literals::detail::make_negate_tag()); } template constexpr number, et_off> operator-(number, et_off>&& a) { return cpp_int_backend(static_cast, et_off>&>(a).backend(), boost::multiprecision::literals::detail::make_negate_tag()); } }} // namespace boost::multiprecision #endif // BOOST_MP_CPP_INT_CORE_HPP