diff --git a/include/boost/multiprecision/cpp_double_float.hpp b/include/boost/multiprecision/cpp_double_float.hpp
index 8d41fd27..2641dc93 100644
--- a/include/boost/multiprecision/cpp_double_float.hpp
+++ b/include/boost/multiprecision/cpp_double_float.hpp
@@ -41,6 +41,24 @@ struct number_category<backends::cpp_double_float<FloatingPointType>>
 
 namespace backends {
 
+namespace detail {
+template <class T> struct is_arithmetic_or_float128 {
+static constexpr bool value = std::is_arithmetic<T>::value == true
+#ifdef BOOST_MATH_USE_FLOAT128
+             || std::is_same<typename std::decay<T>::type, boost::multiprecision::float128>::value == true
+#endif
+             ;
+};
+
+template <class T> struct is_floating_point_or_float128 {
+static constexpr bool value = std::is_floating_point<T>::value == true
+#ifdef BOOST_MATH_USE_FLOAT128
+             || std::is_same<typename std::decay<T>::type, boost::multiprecision::float128>::value == true
+#endif
+             ;
+};
+}
+
 /*
 * A cpp_double_float is represented by an unevaluated sum of two floating-point
 * units (say a0 and a1) which satisfy |a1| <= (1 / 2) * ulp(a0)
@@ -64,8 +82,8 @@ class cpp_double_float
 
    // Constructors from other floating-point types
    template <typename FloatType,
-             typename std::enable_if<(   (std::is_floating_point<FloatType>::value == true)
-                                      && (std::numeric_limits<FloatType>::digits <= std::numeric_limits<float_type>::digits))>::type const* = nullptr>
+             typename std::enable_if<    (detail::is_floating_point_or_float128<FloatType>::value == true)
+                                      && (std::numeric_limits<FloatType>::digits <= std::numeric_limits<float_type>::digits)>::type const* = nullptr>
    constexpr cpp_double_float(const FloatType& f) : data(std::make_pair(f, (float_type)0)) {}
 
    template <typename FloatType,
@@ -135,6 +153,9 @@ class cpp_double_float
    operator float             () const { return (float)data.first + (float)data.second; }
    operator double            () const { return (double)data.first + (double)data.second; }
    operator long double       () const { return (long double)data.first + (long double)data.second; }
+#ifdef BOOST_MATH_USE_FLOAT128
+   explicit operator boost::multiprecision::float128() const { return static_cast<boost::multiprecision::float128>(data.first) + static_cast<boost::multiprecision::float128>(data.second); }
+#endif
 
    // Methods
    constexpr cpp_double_float<float_type> negative()    const { return cpp_double_float<float_type>(-data.first, -data.second); }
@@ -593,7 +614,7 @@ cpp_double_float<FloatingPointType>::operator--(int)
 
 // operator>
 template <typename FloatingPointType, typename ComparisionType>
-inline constexpr typename std::enable_if<std::is_arithmetic<ComparisionType>::value, bool>::type
+inline constexpr typename std::enable_if<detail::is_arithmetic_or_float128<ComparisionType>::value, bool>::type
 operator>(const cpp_double_float<FloatingPointType>& a, const ComparisionType& b)
 {
    using first_type  = typename std::remove_reference<decltype(a)>::type;
@@ -624,7 +645,7 @@ operator>(const cpp_double_float<FloatingPointType>& a, const cpp_double_float<C
 }
 
 template <typename ComparisionType, typename FloatingPointType>
-inline constexpr typename std::enable_if<std::is_arithmetic<ComparisionType>::value, bool>::type
+inline constexpr typename std::enable_if<detail::is_arithmetic_or_float128<ComparisionType>::value, bool>::type
 operator>(const ComparisionType& a, const cpp_double_float<FloatingPointType>& b)
 {
    return b < a;
@@ -632,7 +653,7 @@ operator>(const ComparisionType& a, const cpp_double_float<FloatingPointType>& b
 
 // operator<
 template <typename FloatingPointType, typename ComparisionType>
-inline constexpr typename std::enable_if<std::is_arithmetic<ComparisionType>::value, bool>::type
+inline constexpr typename std::enable_if<detail::is_arithmetic_or_float128<ComparisionType>::value, bool>::type
 operator<(const cpp_double_float<FloatingPointType>& a, const ComparisionType& b)
 {
    using first_type  = typename std::remove_reference<decltype(a)>::type;
@@ -663,7 +684,7 @@ operator<(const cpp_double_float<FloatingPointType>& a, const cpp_double_float<C
 }
 
 template <typename ComparisionType, typename FloatingPointType>
-inline constexpr typename std::enable_if<std::is_arithmetic<ComparisionType>::value, bool>::type
+inline constexpr typename std::enable_if<detail::is_arithmetic_or_float128<ComparisionType>::value, bool>::type
 operator<(const ComparisionType& a, const cpp_double_float<FloatingPointType>& b)
 {
    return b > a;
@@ -671,7 +692,7 @@ operator<(const ComparisionType& a, const cpp_double_float<FloatingPointType>& b
 
 // operator>=
 template <typename FloatingPointType, typename ComparisionType>
-inline constexpr typename std::enable_if<std::is_arithmetic<ComparisionType>::value, bool>::type
+inline constexpr typename std::enable_if<detail::is_arithmetic_or_float128<ComparisionType>::value, bool>::type
 operator>=(const cpp_double_float<FloatingPointType>& a, const ComparisionType& b)
 {
    using first_type  = typename std::remove_reference<decltype(a)>::type;
@@ -702,7 +723,7 @@ operator>=(const cpp_double_float<FloatingPointType>& a, const cpp_double_float<
 }
 
 template <typename ComparisionType, typename FloatingPointType>
-inline constexpr typename std::enable_if<std::is_arithmetic<ComparisionType>::value, bool>::type
+inline constexpr typename std::enable_if<detail::is_arithmetic_or_float128<ComparisionType>::value, bool>::type
 operator>=(const ComparisionType& a, const cpp_double_float<FloatingPointType>& b)
 {
    return b <= a;
@@ -710,7 +731,7 @@ operator>=(const ComparisionType& a, const cpp_double_float<FloatingPointType>&
 
 // operator <=
 template <typename FloatingPointType, typename ComparisionType>
-inline constexpr typename std::enable_if<std::is_arithmetic<ComparisionType>::value, bool>::type
+inline constexpr typename std::enable_if<detail::is_arithmetic_or_float128<ComparisionType>::value, bool>::type
 operator<=(const cpp_double_float<FloatingPointType>& a, const ComparisionType& b)
 {
    using first_type  = typename std::remove_reference<decltype(a)>::type;
@@ -741,7 +762,7 @@ operator<=(const cpp_double_float<FloatingPointType>& a, const cpp_double_float<
 }
 
 template <typename ComparisionType, typename FloatingPointType>
-inline constexpr typename std::enable_if<std::is_arithmetic<ComparisionType>::value, bool>::type
+inline constexpr typename std::enable_if<detail::is_arithmetic_or_float128<ComparisionType>::value, bool>::type
 operator<=(const ComparisionType& a, const cpp_double_float<FloatingPointType>& b)
 {
    return b >= a;
@@ -749,7 +770,7 @@ operator<=(const ComparisionType& a, const cpp_double_float<FloatingPointType>&
 
 // operator ==
 template <typename FloatingPointType, typename ComparisionType>
-inline constexpr typename std::enable_if<std::is_arithmetic<ComparisionType>::value, bool>::type
+inline constexpr typename std::enable_if<detail::is_arithmetic_or_float128<ComparisionType>::value, bool>::type
 operator==(const cpp_double_float<FloatingPointType>& a, const ComparisionType& b)
 {
    using first_type  = typename std::remove_reference<decltype(a)>::type;
@@ -780,7 +801,7 @@ operator==(const cpp_double_float<FloatingPointType>& a, const cpp_double_float<
 }
 
 template <typename ComparisionType, typename FloatingPointType>
-inline constexpr typename std::enable_if<std::is_arithmetic<ComparisionType>::value, bool>::type
+inline constexpr typename std::enable_if<detail::is_arithmetic_or_float128<ComparisionType>::value, bool>::type
 operator==(const ComparisionType& a, const cpp_double_float<FloatingPointType>& b)
 {
    return b == a;
@@ -788,7 +809,7 @@ operator==(const ComparisionType& a, const cpp_double_float<FloatingPointType>&
 
 // operator !=
 template <typename FloatingPointType, typename ComparisionType>
-inline constexpr typename std::enable_if<std::is_arithmetic<ComparisionType>::value, bool>::type
+inline constexpr typename std::enable_if<detail::is_arithmetic_or_float128<ComparisionType>::value, bool>::type
 operator!=(const cpp_double_float<FloatingPointType>& a, const ComparisionType& b)
 {
    using first_type  = typename std::remove_reference<decltype(a)>::type;
@@ -819,7 +840,7 @@ operator!=(const cpp_double_float<FloatingPointType>& a, const cpp_double_float<
 }
 
 template <typename ComparisionType, typename FloatingPointType>
-inline constexpr typename std::enable_if<std::is_arithmetic<ComparisionType>::value, bool>::type
+inline constexpr typename std::enable_if<detail::is_arithmetic_or_float128<ComparisionType>::value, bool>::type
 operator!=(const ComparisionType& a, const cpp_double_float<FloatingPointType>& b)
 {
    return b != a;
diff --git a/test/test_cpp_double_float_arithmetic.cpp b/test/test_cpp_double_float_arithmetic.cpp
index 66a38420..d27aa47c 100644
--- a/test/test_cpp_double_float_arithmetic.cpp
+++ b/test/test_cpp_double_float_arithmetic.cpp
@@ -22,22 +22,19 @@
 #include <vector>
 
 #include <boost/config.hpp>
-#include <boost/multiprecision/cpp_double_float.hpp>
-#include <boost/multiprecision/cpp_dec_float.hpp>
-#include <boost/random/uniform_real_distribution.hpp>
+#include <boost/multiprecision/number.hpp>
 #ifdef BOOST_MATH_USE_FLOAT128
 #include <boost/multiprecision/float128.hpp>
 #endif
+#include <boost/multiprecision/cpp_double_float.hpp>
+#include <boost/multiprecision/cpp_dec_float.hpp>
+#include <boost/random/uniform_real_distribution.hpp>
 #include <boost/core/demangle.hpp>
 
 namespace test_arithmetic_cpp_double_float {
 
 template <typename FloatingPointType,
-          typename std::enable_if<(  std::is_floating_point<FloatingPointType>::value                       == true
-#ifdef BOOST_MATH_USE_FLOAT128
-                                   ||std::is_same<FloatingPointType,boost::multiprecision::float128>::value == true
-#endif
-                                  ), bool>::type = true>
+          typename std::enable_if<(  boost::multiprecision::backends::detail::is_floating_point_or_float128<FloatingPointType>::value == true), bool>::type = true>
 FloatingPointType uniform_real()
 {
    using distribution_type = boost::random::uniform_real_distribution<FloatingPointType>;
@@ -62,11 +59,7 @@ int rand_in_range(int a, int b)
 }
 
 template <typename FloatingPointType,
-          typename std::enable_if<(  std::is_floating_point<FloatingPointType>::value                       == true
-#ifdef BOOST_MATH_USE_FLOAT128
-                                   ||std::is_same<FloatingPointType,boost::multiprecision::float128>::value == true
-#endif
-                                  ), bool>::type = true>
+          typename std::enable_if<(  boost::multiprecision::backends::detail::is_floating_point_or_float128<FloatingPointType>::value == true), bool>::type = true>
 FloatingPointType uniform_rand()
 {
    return uniform_real<FloatingPointType>();
@@ -81,11 +74,7 @@ boost::multiprecision::backends::cpp_double_float<typename FloatingPointType::fl
 
 
 template <typename FloatingPointType>
-typename std::enable_if<(  std::is_floating_point<FloatingPointType>::value                       == true
-#ifdef BOOST_MATH_USE_FLOAT128
-                         ||std::is_same<FloatingPointType,boost::multiprecision::float128>::value == true
-#endif
-                        ), FloatingPointType>::type
+typename std::enable_if<(  boost::multiprecision::backends::detail::is_floating_point_or_float128<FloatingPointType>::value == true), FloatingPointType>::type
 log_rand()
 {
    if (uniform_real<float>() < (1. / 100.))
diff --git a/test/test_cpp_double_float_comparision.cpp b/test/test_cpp_double_float_comparision.cpp
index ed263da7..7952ce24 100644
--- a/test/test_cpp_double_float_comparision.cpp
+++ b/test/test_cpp_double_float_comparision.cpp
@@ -11,12 +11,12 @@
 //       so please run test_cpp_double_float_constructors.cpp before this
 
 #include <boost/config.hpp>
-#include <boost/multiprecision/cpp_double_float.hpp>
-
-#include <boost/random/uniform_real_distribution.hpp>
+#include <boost/multiprecision/number.hpp>
 #ifdef BOOST_MATH_USE_FLOAT128
 #include <boost/multiprecision/float128.hpp>
 #endif
+#include <boost/multiprecision/cpp_double_float.hpp>
+#include <boost/random/uniform_real_distribution.hpp>
 #include <boost/core/demangle.hpp>
 #include <iostream>
 #include <cstdlib>
@@ -25,18 +25,8 @@
 #include <iomanip>
 
 namespace test_cpp_double_comparision {
-// FIXME: this looks like a duplicate from test_cpp_double_float_comparision.cpp file.
-template<typename FloatingPointType> struct is_floating_point {
-static const bool value;
-};
-template<typename FloatingPointType> const bool is_floating_point<FloatingPointType>::value = std::is_floating_point<FloatingPointType>::value
-#ifdef BOOST_MATH_USE_FLOAT128
-or std::is_same<FloatingPointType,boost::multiprecision::float128>::value
-#endif
-;
-
 template <typename FloatingPointType,
-          typename std::enable_if<is_floating_point<FloatingPointType>::value, bool>::type = true>
+          typename std::enable_if<boost::multiprecision::backends::detail::is_floating_point_or_float128<FloatingPointType>::value, bool>::type = true>
 FloatingPointType uniform_real()
 {
    //static std::random_device                                rd;
@@ -47,7 +37,7 @@ FloatingPointType uniform_real()
 }
 
 template <typename NumericType,
-          typename std::enable_if<std::is_integral<NumericType>::value && !is_floating_point<NumericType>::value, bool>::type = true>
+          typename std::enable_if<std::is_integral<NumericType>::value && !boost::multiprecision::backends::detail::is_floating_point_or_float128<NumericType>::value, bool>::type = true>
 NumericType uniform_integral_number()
 {
    NumericType out = 0;
@@ -64,14 +54,14 @@ int rand_in_range(int a, int b)
 }
 
 template <typename NumericType,
-          typename std::enable_if<std::is_integral<NumericType>::value && !is_floating_point<NumericType>::value, bool>::type = true>
+          typename std::enable_if<std::is_integral<NumericType>::value && !boost::multiprecision::backends::detail::is_floating_point_or_float128<NumericType>::value, bool>::type = true>
 NumericType uniform_rand()
 {
    return uniform_integral_number<NumericType>();
 }
 
 template <typename FloatingPointType,
-          typename std::enable_if<is_floating_point<FloatingPointType>::value, bool>::type = true>
+          typename std::enable_if<boost::multiprecision::backends::detail::is_floating_point_or_float128<FloatingPointType>::value, bool>::type = true>
 FloatingPointType uniform_rand()
 {
    return uniform_real<FloatingPointType>();
@@ -91,12 +81,13 @@ NumericType log_rand()
    return uniform_integral_number<NumericType>() >> int(uniform_real<float>() * float(std::numeric_limits<NumericType>::digits+1));
 }
 
-template <typename FloatingPointType, typename std::enable_if<is_floating_point<FloatingPointType>::value>::type const* = nullptr>
+template <typename FloatingPointType, typename std::enable_if<boost::multiprecision::backends::detail::is_floating_point_or_float128<FloatingPointType>::value>::type const* = nullptr>
 FloatingPointType log_rand()
 {
    if (uniform_real<float>() < (1. / 100.))
       return 0; // throw in a few zeroes
-   return std::ldexp(uniform_real<FloatingPointType>(), rand_in_range(std::numeric_limits<FloatingPointType>::min_exponent, std::numeric_limits<FloatingPointType>::max_exponent));
+   using std::ldexp;
+   return ldexp(uniform_real<FloatingPointType>(), rand_in_range(std::numeric_limits<FloatingPointType>::min_exponent, std::numeric_limits<FloatingPointType>::max_exponent));
 }
 
 template <typename FloatingPointType>
@@ -111,7 +102,11 @@ template <typename FloatingPointType, typename ComparisionType>
 int test()
 {
    using double_float_t = boost::multiprecision::backends::cpp_double_float<FloatingPointType>;
-   using largest_type   = boost::multiprecision::backends::cpp_double_float<double>;
+#ifdef BOOST_MATH_USE_FLOAT128
+   using largest_type   = boost::multiprecision::backends::cpp_double_float<boost::multiprecision::float128>;
+#else
+   using largest_type   = boost::multiprecision::backends::cpp_double_float<long double>;
+#endif
 
    std::string type_name = typeid(ComparisionType).name();
    size_t      idx;
@@ -370,15 +365,13 @@ int test_comparison() {
    e += test_cpp_double_comparision::test<FloatingPointType, double>();
    e += test_cpp_double_comparision::test<FloatingPointType, long double>();
 #ifdef BOOST_MATH_USE_FLOAT128
-// FIXME:
-// e += test_cpp_double_comparision::test<FloatingPointType, boost::multiprecision::float128>();
+   e += test_cpp_double_comparision::test<FloatingPointType, boost::multiprecision::float128>();
 #endif
    e += test_cpp_double_comparision::test<FloatingPointType, boost::multiprecision::backends::cpp_double_float<float> >();
    e += test_cpp_double_comparision::test<FloatingPointType, boost::multiprecision::backends::cpp_double_float<double> >();
    e += test_cpp_double_comparision::test<FloatingPointType, boost::multiprecision::backends::cpp_double_float<long double> >();
 #ifdef BOOST_MATH_USE_FLOAT128
-// FIXME:
-// e += test_cpp_double_comparision::test<FloatingPointType, boost::multiprecision::backends::cpp_double_float<boost::multiprecision::float128> >();
+   e += test_cpp_double_comparision::test<FloatingPointType, boost::multiprecision::backends::cpp_double_float<boost::multiprecision::float128> >();
 #endif
    std::cout << std::endl;
    return e;
@@ -391,8 +384,7 @@ int main()
    e += test_comparison<double>();
    e += test_comparison<long double>();
 #ifdef BOOST_MATH_USE_FLOAT128
-// FIXME:
-// e += test_comparison<boost::multiprecision::float128>();
+   e += test_comparison<boost::multiprecision::float128>();
 #endif
 
    std::cout << (e == 0 ? "PASSED all tests" : "FAILED some test(s)") << std::endl;
diff --git a/test/test_cpp_double_float_constructors.cpp b/test/test_cpp_double_float_constructors.cpp
index b1746142..4b37bff9 100644
--- a/test/test_cpp_double_float_constructors.cpp
+++ b/test/test_cpp_double_float_constructors.cpp
@@ -12,13 +12,13 @@
 // g++ -O3 -Wall -march=native -std=c++11 -I/mnt/c/MyGitRepos/BoostGSoC21_multiprecision/include -I/mnt/c/boost/boost_1_76_0 test.cpp -o test_double_float.exe
 
 #include <boost/config.hpp>
-#include <boost/multiprecision/cpp_double_float.hpp>
-
-#include <boost/random/uniform_real_distribution.hpp>
+#include <boost/multiprecision/number.hpp>
 #ifdef BOOST_MATH_USE_FLOAT128
 #include <boost/multiprecision/float128.hpp>
 #endif
+#include <boost/multiprecision/cpp_double_float.hpp>
 #include <boost/multiprecision/cpp_bin_float.hpp>
+#include <boost/random/uniform_real_distribution.hpp>
 #include <iostream>
 #include <cstdlib>
 #include <random>
@@ -36,17 +36,8 @@ constexpr T max(T a, T b)
 
 }
 
-// FIXME: this looks like a duplicate from test_cpp_double_float_comparision.cpp file.
-template<typename FloatingPointType> struct is_floating_point {
-   static constexpr bool value = std::is_floating_point<FloatingPointType>::value
-#ifdef BOOST_MATH_USE_FLOAT128
-                                 or std::is_same<FloatingPointType, boost::multiprecision::float128>::value
-#endif
-       ;
-};
-
 template <typename FloatingPointType,
-          typename std::enable_if<is_floating_point<FloatingPointType>::value, bool>::type = true>
+          typename std::enable_if<boost::multiprecision::backends::detail::is_floating_point_or_float128<FloatingPointType>::value, bool>::type = true>
 FloatingPointType uniform_real()
 {
    static std::random_device                                rd;
@@ -77,7 +68,7 @@ NumericType get_rand()
 }
 
 template <typename FloatingPointType,
-          typename std::enable_if<is_floating_point<FloatingPointType>::value, bool>::type = true>
+          typename std::enable_if<boost::multiprecision::backends::detail::is_floating_point_or_float128<FloatingPointType>::value, bool>::type = true>
 FloatingPointType get_rand()
 {
    return uniform_real<FloatingPointType>();
@@ -90,15 +81,17 @@ boost::multiprecision::backends::cpp_double_float<typename FloatingPointType::fl
    return boost::multiprecision::backends::cpp_double_float<float_type>(uniform_real<float_type>()) * boost::multiprecision::backends::cpp_double_float<float_type>(uniform_real<float_type>());
 }
 
-template <typename ConstructionType, typename ArithmeticType, typename std::enable_if<std::is_arithmetic<ArithmeticType>::value>::type const* = nullptr>
+template <typename ConstructionType, typename ArithmeticType, typename std::enable_if<std::is_arithmetic<ArithmeticType>::value || boost::multiprecision::backends::detail::is_floating_point_or_float128<ArithmeticType>::value>::type const* = nullptr>
 ConstructionType construct_from(ArithmeticType f)
 {
    return ConstructionType(f);
 }
 
-template <typename ConstructionType, typename DoubleFloatType, typename std::enable_if<!std::is_arithmetic<DoubleFloatType>::value>::type const* = nullptr>
+template <typename ConstructionType, typename DoubleFloatType, typename std::enable_if<!(std::is_arithmetic<DoubleFloatType>::value || boost::multiprecision::backends::detail::is_floating_point_or_float128<DoubleFloatType>::value)>::type const* = nullptr>
 ConstructionType construct_from(DoubleFloatType f)
 {
+   static_assert(std::is_same< boost::multiprecision::backends::cpp_double_float<typename DoubleFloatType::float_type>
+                 , typename std::decay<DoubleFloatType>::type>::value, "Only double float should come here");
    return ConstructionType(f.first()) + ConstructionType(f.second());
 }
 
@@ -172,15 +165,13 @@ int test_constructors()
    e += test_constructor<FloatingPointType, double>();
    e += test_constructor<FloatingPointType, long double>();
 #ifdef BOOST_MATH_USE_FLOAT128
-// FIXME:
-// e += test_constructor<FloatingPointType, boost::multiprecision::float128>();
+   e += test_constructor<FloatingPointType, boost::multiprecision::float128>();
 #endif
    e += test_constructor<FloatingPointType, boost::multiprecision::backends::cpp_double_float<float>>();
    e += test_constructor<FloatingPointType, boost::multiprecision::backends::cpp_double_float<double>>();
    e += test_constructor<FloatingPointType, boost::multiprecision::backends::cpp_double_float<long double>>();
 #ifdef BOOST_MATH_USE_FLOAT128
-// FIXME:
-// e += test_constructor<FloatingPointType, boost::multiprecision::backends::cpp_double_float<boost::multiprecision::float128>>();
+   e += test_constructor<FloatingPointType, boost::multiprecision::backends::cpp_double_float<boost::multiprecision::float128>>();
 #endif
 
    if (e == 0)
@@ -203,8 +194,7 @@ int main()
    e += test_cpp_double_constructors::test_constructors<double>();
    e += test_cpp_double_constructors::test_constructors<long double>();
 #ifdef BOOST_MATH_USE_FLOAT128
-// FIXME:
-// e += test_cpp_double_constructors::test_constructors<boost::multiprecision::float128>();
+   e += test_cpp_double_constructors::test_constructors<boost::multiprecision::float128>();
 #endif
 
    return e;
diff --git a/test/test_cpp_double_float_decomposition.cpp b/test/test_cpp_double_float_decomposition.cpp
index 014cd5dd..516106c1 100644
--- a/test/test_cpp_double_float_decomposition.cpp
+++ b/test/test_cpp_double_float_decomposition.cpp
@@ -10,12 +10,13 @@
 
 
 #include <boost/config.hpp>
-#include <boost/multiprecision/cpp_double_float.hpp>
-#include <boost/multiprecision/cpp_dec_float.hpp>
-#include <boost/random/uniform_real_distribution.hpp>
+#include <boost/multiprecision/number.hpp>
 #ifdef BOOST_MATH_USE_FLOAT128
 #include <boost/multiprecision/float128.hpp>
 #endif
+#include <boost/multiprecision/cpp_double_float.hpp>
+#include <boost/multiprecision/cpp_dec_float.hpp>
+#include <boost/random/uniform_real_distribution.hpp>
 #include <boost/core/demangle.hpp>
 #include <iomanip>
 #include <iostream>
diff --git a/test/test_cpp_double_float_io.cpp b/test/test_cpp_double_float_io.cpp
index 0e1272ba..0a3cc862 100644
--- a/test/test_cpp_double_float_io.cpp
+++ b/test/test_cpp_double_float_io.cpp
@@ -11,10 +11,11 @@
 
 
 #include <boost/config.hpp>
-#include <boost/multiprecision/cpp_double_float.hpp>
+#include <boost/multiprecision/number.hpp>
 #ifdef BOOST_MATH_USE_FLOAT128
 #include <boost/multiprecision/float128.hpp>
 #endif
+#include <boost/multiprecision/cpp_double_float.hpp>
 #include <boost/random/uniform_real_distribution.hpp>
 #include <iostream>
 #include <cstdlib>
@@ -22,18 +23,8 @@
 
 namespace test_cpp_double_float_io {
 
-// FIXME: this looks like a duplicate from test_cpp_double_float_comparision.cpp file.
-template<typename FloatingPointType> struct is_floating_point {
-static const bool value;
-};
-template<typename FloatingPointType> const bool is_floating_point<FloatingPointType>::value = std::is_floating_point<FloatingPointType>::value
-#ifdef BOOST_MATH_USE_FLOAT128
-or std::is_same<FloatingPointType,boost::multiprecision::float128>::value
-#endif
-;
-
 template <typename FloatingPointType,
-          typename std::enable_if<is_floating_point<FloatingPointType>::value, bool>::type = true>
+          typename std::enable_if<boost::multiprecision::backends::detail::is_floating_point_or_float128<FloatingPointType>::value, bool>::type = true>
 FloatingPointType uniform_real()
 {
    //static std::random_device                                rd;
@@ -55,7 +46,7 @@ int rand_in_range(int a, int b)
    return a + int(float(b - a) * uniform_real<float>());
 }
 
-template <typename FloatingPointType, typename std::enable_if<is_floating_point<FloatingPointType>::value>::type const* = nullptr>
+template <typename FloatingPointType, typename std::enable_if<boost::multiprecision::backends::detail::is_floating_point_or_float128<FloatingPointType>::value>::type const* = nullptr>
 FloatingPointType log_rand()
 {
    if (uniform_real<float>() < (1. / 100.))
diff --git a/test/test_cpp_double_float_io_manual.cpp b/test/test_cpp_double_float_io_manual.cpp
index 2f871b59..9e2cc20d 100644
--- a/test/test_cpp_double_float_io_manual.cpp
+++ b/test/test_cpp_double_float_io_manual.cpp
@@ -10,10 +10,11 @@
 // Note that the I/O of cpp_double_float<> is currently extremely underdeveloped
 
 #include <boost/config.hpp>
-#include <boost/multiprecision/cpp_double_float.hpp>
+#include <boost/multiprecision/number.hpp>
 #ifdef BOOST_MATH_USE_FLOAT128
 #include <boost/multiprecision/float128.hpp>
 #endif
+#include <boost/multiprecision/cpp_double_float.hpp>
 #include <iostream>
 #include <cstdlib>