FM / multiprecision

/usr/include/boost/multiprecision

Name	Size	Mode	Actions
concepts/	-	0755	rm
cpp_bin_float/	-	0755	rm
cpp_int/	-	0755	rm
detail/	-	0755	rm
traits/	-	0755	rm
complex128.hpp	707	0644	edit dl rm
complex_adaptor.hpp	26516	0644	edit dl rm
cpp_bin_float.hpp	98102	0644	edit dl rm
cpp_complex.hpp	2784	0644	edit dl rm
cpp_dec_float.hpp	141498	0644	edit dl rm
cpp_int.hpp	97009	0644	edit dl rm
debug_adaptor.hpp	27091	0644	edit dl rm
eigen.hpp	10513	0644	edit dl rm
float128.hpp	34757	0644	edit dl rm
gmp.hpp	113421	0644	edit dl rm
integer.hpp	7339	0644	edit dl rm
logged_adaptor.hpp	34770	0644	edit dl rm
miller_rabin.hpp	6285	0644	edit dl rm
mpc.hpp	51329	0644	edit dl rm
mpfi.hpp	76273	0644	edit dl rm
mpfr.hpp	128421	0644	edit dl rm
number.hpp	104027	0644	edit dl rm
random.hpp	616	0644	edit dl rm
rational_adaptor.hpp	13475	0644	edit dl rm
tommath.hpp	34140	0644	edit dl rm

Edit: /usr/include/boost/multiprecision/eigen.hpp (10513B)

#ifndef BOOST_MP_EIGEN_HPP
#define BOOST_MP_EIGEN_HPP

#include <boost/multiprecision/number.hpp>
#include <Eigen/Core>

//
// Generic Eigen support code:
//
namespace Eigen {
template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates>
struct NumTraits<boost::multiprecision::number<Backend, ExpressionTemplates> >
{
   typedef boost::multiprecision::number<Backend, ExpressionTemplates>                          self_type;
   typedef typename boost::multiprecision::scalar_result_from_possible_complex<self_type>::type Real;
   typedef self_type                                                                            NonInteger; // Not correct but we can't do much better??
   typedef double                                                                               Literal;
   typedef self_type                                                                            Nested;
   enum
   {
      IsComplex             = boost::multiprecision::number_category<self_type>::value == boost::multiprecision::number_kind_complex,
      IsInteger             = boost::multiprecision::number_category<self_type>::value == boost::multiprecision::number_kind_integer,
      ReadCost              = 1,
      AddCost               = 4,
      MulCost               = 8,
      IsSigned              = std::numeric_limits<self_type>::is_specialized ? std::numeric_limits<self_type>::is_signed : true,
      RequireInitialization = 1,
   };
   static Real epsilon()
   {
      return std::numeric_limits<Real>::epsilon();
   }
   static Real dummy_precision()
   {
      return 1000 * epsilon();
   }
   static Real highest()
   {
      return (std::numeric_limits<Real>::max)();
   }
   static Real lowest()
   {
      return (std::numeric_limits<Real>::min)();
   }
   static int digits10_imp(const boost::mpl::true_&)
   {
      return std::numeric_limits<Real>::digits10;
   }
   template <bool B>
   static int digits10_imp(const boost::mpl::bool_<B>&)
   {
      return Real::default_precision();
   }
   static int digits10()
   {
      return digits10_imp(boost::mpl::bool_ < std::numeric_limits<Real>::digits10 && (std::numeric_limits<Real>::digits10 != INT_MAX) ? true : false > ());
   }
};
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
struct NumTraits<boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > : public NumTraits<typename boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>
{
};

#define BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(A)                                                                                                                                                                           \
   template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, typename BinaryOp>                                                                                                  \
   struct ScalarBinaryOpTraits<boost::multiprecision::number<Backend, ExpressionTemplates>, A, BinaryOp>                                                                                                               \
   {                                                                                                                                                                                                                   \
      /*static_assert(boost::multiprecision::is_compatible_arithmetic_type<A, boost::multiprecision::number<Backend, ExpressionTemplates> >::value, "Interoperability with this arithmetic type is not supported.");*/ \
      typedef boost::multiprecision::number<Backend, ExpressionTemplates> ReturnType;                                                                                                                                  \
   };                                                                                                                                                                                                                  \
   template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, typename BinaryOp>                                                                                                  \
   struct ScalarBinaryOpTraits<A, boost::multiprecision::number<Backend, ExpressionTemplates>, BinaryOp>                                                                                                               \
   {                                                                                                                                                                                                                   \
      /*static_assert(boost::multiprecision::is_compatible_arithmetic_type<A, boost::multiprecision::number<Backend, ExpressionTemplates> >::value, "Interoperability with this arithmetic type is not supported.");*/ \
      typedef boost::multiprecision::number<Backend, ExpressionTemplates> ReturnType;                                                                                                                                  \
   };

BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(float)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(double)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(long double)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(char)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(unsigned char)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(signed char)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(short)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(unsigned short)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(int)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(unsigned int)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(long)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(unsigned long)

#if 0    
      template<class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, class Backend2, boost::multiprecision::expression_template_option ExpressionTemplates2, typename BinaryOp>
   struct ScalarBinaryOpTraits<boost::multiprecision::number<Backend, ExpressionTemplates>, boost::multiprecision::number<Backend2, ExpressionTemplates2>, BinaryOp>
   {
      static_assert(
         boost::multiprecision::is_compatible_arithmetic_type<boost::multiprecision::number<Backend2, ExpressionTemplates2>, boost::multiprecision::number<Backend, ExpressionTemplates> >::value
         || boost::multiprecision::is_compatible_arithmetic_type<boost::multiprecision::number<Backend, ExpressionTemplates>, boost::multiprecision::number<Backend2, ExpressionTemplates2> >::value, "Interoperability with this arithmetic type is not supported.");
      typedef typename boost::mpl::if_c<boost::is_convertible<boost::multiprecision::number<Backend2, ExpressionTemplates2>, boost::multiprecision::number<Backend, ExpressionTemplates> >::value,
         boost::multiprecision::number<Backend, ExpressionTemplates>, boost::multiprecision::number<Backend2, ExpressionTemplates2> >::type ReturnType;
   };

template<unsigned D, typename BinaryOp>
   struct ScalarBinaryOpTraits<boost::multiprecision::number<boost::multiprecision::backends::mpc_complex_backend<D>, boost::multiprecision::et_on>, boost::multiprecision::mpfr_float, BinaryOp>
   {
      typedef boost::multiprecision::number<boost::multiprecision::backends::mpc_complex_backend<D>, boost::multiprecision::et_on> ReturnType;
   };

template<typename BinaryOp>
   struct ScalarBinaryOpTraits<boost::multiprecision::mpfr_float, boost::multiprecision::mpc_complex, BinaryOp>
   {
      typedef boost::multiprecision::number<boost::multiprecision::backends::mpc_complex_backend<0>, boost::multiprecision::et_on> ReturnType;
   };

template<class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, typename BinaryOp>
   struct ScalarBinaryOpTraits<boost::multiprecision::number<Backend, ExpressionTemplates>, boost::multiprecision::number<Backend, ExpressionTemplates>, BinaryOp>
   {
      typedef boost::multiprecision::number<Backend, ExpressionTemplates> ReturnType;
   };
#endif

template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, class tag, class Arg1, class Arg2, class Arg3, class Arg4, typename BinaryOp>
struct ScalarBinaryOpTraits<boost::multiprecision::number<Backend, ExpressionTemplates>, boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, BinaryOp>
{
   static_assert(boost::is_convertible<typename boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type, boost::multiprecision::number<Backend, ExpressionTemplates> >::value, "Interoperability with this arithmetic type is not supported.");
   typedef boost::multiprecision::number<Backend, ExpressionTemplates> ReturnType;
};

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, typename BinaryOp>
struct ScalarBinaryOpTraits<boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, boost::multiprecision::number<Backend, ExpressionTemplates>, BinaryOp>
{
   static_assert(boost::is_convertible<typename boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type, boost::multiprecision::number<Backend, ExpressionTemplates> >::value, "Interoperability with this arithmetic type is not supported.");
   typedef boost::multiprecision::number<Backend, ExpressionTemplates> ReturnType;
};

namespace internal {
template <typename Scalar>
struct conj_retval;

template <typename Scalar, bool IsComplex>
struct conj_impl;

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
struct conj_retval<boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
{
   typedef typename boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type type;
};

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
struct conj_impl<boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, true>
{
   EIGEN_DEVICE_FUNC
   static inline typename boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type run(const typename boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& x)
   {
      return conj(x);
   }
};

} // namespace internal

} // namespace Eigen

#endif

/////////////////////////////////////////////////////////////////////////////// // Copyright 2018 John Maddock. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_MP_EIGEN_HPP #define BOOST_MP_EIGEN_HPP #include #include // // Generic Eigen support code: // namespace Eigen { template struct NumTraits > { typedef boost::multiprecision::number self_type; typedef typename boost::multiprecision::scalar_result_from_possible_complex::type Real; typedef self_type NonInteger; // Not correct but we can't do much better?? typedef double Literal; typedef self_type Nested; enum { IsComplex = boost::multiprecision::number_category::value == boost::multiprecision::number_kind_complex, IsInteger = boost::multiprecision::number_category::value == boost::multiprecision::number_kind_integer, ReadCost = 1, AddCost = 4, MulCost = 8, IsSigned = std::numeric_limits::is_specialized ? std::numeric_limits::is_signed : true, RequireInitialization = 1, }; static Real epsilon() { return std::numeric_limits::epsilon(); } static Real dummy_precision() { return 1000 * epsilon(); } static Real highest() { return (std::numeric_limits::max)(); } static Real lowest() { return (std::numeric_limits::min)(); } static int digits10_imp(const boost::mpl::true_&) { return std::numeric_limits::digits10; } template static int digits10_imp(const boost::mpl::bool_&) { return Real::default_precision(); } static int digits10() { return digits10_imp(boost::mpl::bool_ < std::numeric_limits::digits10 && (std::numeric_limits::digits10 != INT_MAX) ? true : false > ()); } }; template struct NumTraits > : public NumTraits::result_type> { }; #define BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(A) \ template \ struct ScalarBinaryOpTraits, A, BinaryOp> \ { \ /*static_assert(boost::multiprecision::is_compatible_arithmetic_type >::value, "Interoperability with this arithmetic type is not supported.");*/ \ typedef boost::multiprecision::number ReturnType; \ }; \ template \ struct ScalarBinaryOpTraits, BinaryOp> \ { \ /*static_assert(boost::multiprecision::is_compatible_arithmetic_type >::value, "Interoperability with this arithmetic type is not supported.");*/ \ typedef boost::multiprecision::number ReturnType; \ }; BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(float) BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(double) BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(long double) BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(char) BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(unsigned char) BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(signed char) BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(short) BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(unsigned short) BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(int) BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(unsigned int) BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(long) BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(unsigned long) #if 0 template struct ScalarBinaryOpTraits, boost::multiprecision::number, BinaryOp> { static_assert( boost::multiprecision::is_compatible_arithmetic_type, boost::multiprecision::number >::value || boost::multiprecision::is_compatible_arithmetic_type, boost::multiprecision::number >::value, "Interoperability with this arithmetic type is not supported."); typedef typename boost::mpl::if_c, boost::multiprecision::number >::value, boost::multiprecision::number, boost::multiprecision::number >::type ReturnType; }; template struct ScalarBinaryOpTraits, boost::multiprecision::et_on>, boost::multiprecision::mpfr_float, BinaryOp> { typedef boost::multiprecision::number, boost::multiprecision::et_on> ReturnType; }; template struct ScalarBinaryOpTraits { typedef boost::multiprecision::number, boost::multiprecision::et_on> ReturnType; }; template struct ScalarBinaryOpTraits, boost::multiprecision::number, BinaryOp> { typedef boost::multiprecision::number ReturnType; }; #endif template struct ScalarBinaryOpTraits, boost::multiprecision::detail::expression, BinaryOp> { static_assert(boost::is_convertible::result_type, boost::multiprecision::number >::value, "Interoperability with this arithmetic type is not supported."); typedef boost::multiprecision::number ReturnType; }; template struct ScalarBinaryOpTraits, boost::multiprecision::number, BinaryOp> { static_assert(boost::is_convertible::result_type, boost::multiprecision::number >::value, "Interoperability with this arithmetic type is not supported."); typedef boost::multiprecision::number ReturnType; }; namespace internal { template struct conj_retval; template struct conj_impl; template struct conj_retval > { typedef typename boost::multiprecision::detail::expression::result_type type; }; template struct conj_impl, true> { EIGEN_DEVICE_FUNC static inline typename boost::multiprecision::detail::expression::result_type run(const typename boost::multiprecision::detail::expression& x) { return conj(x); } }; } // namespace internal } // namespace Eigen #endif