Preliminary re-run of all tests

Author: ckormanyos

include/boost/multiprecision/cpp_double_fp.hpp

@@ -10,15 +10,10 @@
 #ifndef BOOST_MP_CPP_DOUBLE_FP_2021_06_05_HPP
 #define BOOST_MP_CPP_DOUBLE_FP_2021_06_05_HPP
 
-#if (defined(_MSC_VER) && (_MSC_VER <= 1900))
-#pragma warning(push)
-#pragma warning (disable : 4814)
+#if !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS)
+#define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
 #endif
 
-#include <limits>
-#include <string>
-#include <type_traits>
-
 #include <boost/multiprecision/cpp_dec_float.hpp>
 #include <boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp>
 #include <boost/multiprecision/detail/float_string_cvt.hpp>
@@ -42,6 +37,10 @@
 #include <boost/math/special_functions/gamma.hpp>
 #endif
 
+#include <limits>
+#include <string>
+#include <type_traits>
+
 #if (defined(__clang__) && (__clang_major__ <= 9))
 #define BOOST_MP_DF_QF_NUM_LIMITS_CLASS_TYPE struct
 #else
@@ -244,8 +243,8 @@ class cpp_double_fp_backend
 
    // Constructors from integers
    template <typename SignedIntegralType,
-             typename ::std::enable_if<(    boost::multiprecision::detail::is_integral<SignedIntegralType>::value
-                                        && !boost::multiprecision::detail::is_unsigned<SignedIntegralType>::value
+             typename ::std::enable_if<(     boost::multiprecision::detail::is_integral<SignedIntegralType>::value
+                                        && (!boost::multiprecision::detail::is_unsigned<SignedIntegralType>::value)
                                         && (static_cast<int>(sizeof(SignedIntegralType) * 8u) <= cpp_df_qf_detail::ccmath::numeric_limits<float_type>::digits))>::type const* = nullptr>
    constexpr cpp_double_fp_backend(const SignedIntegralType& n)
       : data(static_cast<float_type>(n), static_cast<float_type>(0.0F)) { }
@@ -276,8 +275,8 @@ class cpp_double_fp_backend
         ) { }
 
    template <typename SignedIntegralType,
-             typename ::std::enable_if<(    boost::multiprecision::detail::is_integral<SignedIntegralType>::value
-                                        && !boost::multiprecision::detail::is_unsigned<SignedIntegralType>::value
+             typename ::std::enable_if<(     boost::multiprecision::detail::is_integral<SignedIntegralType>::value
+                                        && (!boost::multiprecision::detail::is_unsigned<SignedIntegralType>::value)
                                         && (static_cast<int>(sizeof(SignedIntegralType) * 8u) > cpp_df_qf_detail::ccmath::numeric_limits<float_type>::digits))>::type const* = nullptr>
    constexpr cpp_double_fp_backend(SignedIntegralType n)
       : data
@@ -355,7 +354,7 @@ class cpp_double_fp_backend
       // TBD: Is there a faster or more simple hash method?
       // TBD: Is there any constexpr support for rudimentary hashing?
 
-      const auto str_to_hash = str(cpp_double_fp_backend::my_digits10, std::ios::scientific);
+      const std::string str_to_hash { str(cpp_double_fp_backend::my_digits10, std::ios::scientific) };
 
       auto result = static_cast<std::size_t>(UINT8_C(0));
 
@@ -387,11 +386,11 @@ class cpp_double_fp_backend
       }
       else if (isinf_u)
       {
-         data.first  = -data.first;
+         data.first = -data.first;
       }
       else
       {
-         data.first  = -data.first;
+         data.first = -data.first;
 
          if (data.second != 0) { data.second = -data.second; }
 
@@ -405,13 +404,14 @@ class cpp_double_fp_backend
    constexpr const float_type& my_first () const noexcept { return data.first; }
    constexpr const float_type& my_second() const noexcept { return data.second; }
 
-   constexpr rep_type& rep () noexcept { return data; }
+   constexpr rep_type& rep() noexcept { return data; }
 
-   constexpr const rep_type& rep () const noexcept { return data; }
+   constexpr const rep_type& rep() const noexcept { return data; }
 
    constexpr const rep_type& crep() const noexcept { return data; }
 
-   // Unary add/sub/mul/div.
+   // Unary add/sub/mul/div follow in the upcoming paragraphs.
+
    constexpr cpp_double_fp_backend& operator+=(const cpp_double_fp_backend& v)
    {
       const auto fpc_u = eval_fpclassify(*this);
@@ -527,12 +527,12 @@ class cpp_double_fp_backend
       const auto fpc_v = eval_fpclassify(v);
 
       // Handle special cases like zero, inf and NaN.
-      const bool isinf_u  = (fpc_u == FP_INFINITE);
-      const bool isinf_v  = (fpc_v == FP_INFINITE);
-      const bool isnan_u  = (fpc_u == FP_NAN);
-      const bool isnan_v  = (fpc_v == FP_NAN);
-      const bool iszero_u = (fpc_u == FP_ZERO);
-      const bool iszero_v = (fpc_v == FP_ZERO);
+      const bool isinf_u  { fpc_u == FP_INFINITE };
+      const bool isinf_v  { fpc_v == FP_INFINITE };
+      const bool isnan_u  { fpc_u == FP_NAN };
+      const bool isnan_v  { fpc_v == FP_NAN };
+      const bool iszero_u { fpc_u == FP_ZERO };
+      const bool iszero_v { fpc_v == FP_ZERO };
 
       if ((isnan_u || isnan_v) || (isinf_u && iszero_v) || (isinf_v && iszero_u))
       {
@@ -828,7 +828,12 @@ class cpp_double_fp_backend
       if (number_of_digits == 0)
          number_of_digits = cpp_double_fp_backend::my_digits10;
 
-      const std::string my_str = boost::multiprecision::detail::convert_to_string(*this, number_of_digits, format_flags);
+      cpp_dec_float_read_write_type f_dec { 0 };
+
+      f_dec += data.second;
+      f_dec += data.first;
+
+      const std::string my_str { f_dec.str(number_of_digits, format_flags) };
 
       return my_str;
    }
@@ -935,6 +940,18 @@ class cpp_double_fp_backend
  private:
    rep_type data;
 
+   static constexpr auto cpp_dec_float_read_write_digits10 =
+      static_cast<int>
+      (
+         static_cast<float>
+         (
+            static_cast<float>(my_digits) * 0.9F
+         )
+      );
+
+   using cpp_dec_float_read_write_type     = boost::multiprecision::cpp_dec_float<static_cast<unsigned>(cpp_dec_float_read_write_digits10), std::int32_t, std::allocator<void>>;
+   using cpp_dec_float_read_write_exp_type = typename cpp_dec_float_read_write_type::exponent_type;
+
    bool rd_string(const char* pstr);
 
    static constexpr rep_type two_sum(const float_type a, const float_type b)
@@ -982,19 +999,7 @@ bool cpp_double_fp_backend<FloatingPointType>::rd_string(const char* pstr)
 
    using local_double_fp_type = cpp_double_fp_backend<FloatingPointType>;
 
-   constexpr auto local_cpp_dec_float_digits10 =
-      static_cast<int>
-      (
-         static_cast<float>
-         (
-            static_cast<float>(local_double_fp_type::my_digits) * 0.9F
-         )
-      );
-
-   using local_cpp_dec_float_type     = boost::multiprecision::cpp_dec_float<static_cast<unsigned>(local_cpp_dec_float_digits10), std::int32_t, std::allocator<void>>;
-   using local_cpp_dec_float_exp_type = typename local_cpp_dec_float_type::exponent_type;
-
-   local_cpp_dec_float_type f_dec = pstr;
+   cpp_dec_float_read_write_type f_dec = pstr;
 
    const auto fpc = eval_fpclassify(f_dec);
 
@@ -1006,7 +1011,7 @@ bool cpp_double_fp_backend<FloatingPointType>::rd_string(const char* pstr)
    }
    else
    {
-      local_cpp_dec_float_type dummy_frexp { };
+      cpp_dec_float_read_write_type dummy_frexp { };
       auto e2_from_f_dec = int { };
       eval_frexp(dummy_frexp, f_dec, &e2_from_f_dec);
 
@@ -1015,7 +1020,7 @@ bool cpp_double_fp_backend<FloatingPointType>::rd_string(const char* pstr)
          // TBD: A detailed, clear comparison (or something close to a comparison)
          // is still needed for input values having (e2_from_f_dec == my_min_exponent).
             (fpc == FP_ZERO)
-         || (e2_from_f_dec < static_cast<local_cpp_dec_float_exp_type>(local_double_fp_type::my_min_exponent))
+         || (e2_from_f_dec < static_cast<cpp_dec_float_read_write_exp_type>(local_double_fp_type::my_min_exponent))
       );
 
       if (is_definitely_zero)
@@ -1027,7 +1032,7 @@ bool cpp_double_fp_backend<FloatingPointType>::rd_string(const char* pstr)
       {
          // TBD: A detailed, clear comparison (or something close to a comparison)
          // is still needed for input values having (e2_from_f_dec == my_max_exponent).
-         const auto is_definitely_inf = (e2_from_f_dec > static_cast<local_cpp_dec_float_exp_type>(local_double_fp_type::my_max_exponent));
+         const auto is_definitely_inf = (e2_from_f_dec > static_cast<cpp_dec_float_read_write_exp_type>(local_double_fp_type::my_max_exponent));
 
          if (is_definitely_inf)
          {
@@ -1063,18 +1068,18 @@ bool cpp_double_fp_backend<FloatingPointType>::rd_string(const char* pstr)
 
             if (has_pow2_scaling_for_small_input)
             {
-               f_dec *= local_cpp_dec_float_type::pow2(static_cast<long long>(pow2_scaling_for_small_input));
+               f_dec *= cpp_dec_float_read_write_type::pow2(static_cast<long long>(pow2_scaling_for_small_input));
             }
 
             for(auto i = static_cast<unsigned>(UINT8_C(0));
                      i < dig_lim;
                      i = static_cast<unsigned>(i + static_cast<unsigned>(cpp_df_qf_detail::ccmath::numeric_limits<local_builtin_float_type>::digits)))
             {
-               local_cpp_dec_float_type f_dec_abs { };
+               cpp_dec_float_read_write_type f_dec_abs { };
 
                eval_fabs(f_dec_abs, f_dec);
 
-               if (f_dec_abs.compare((local_cpp_dec_float_type::min)()) <= 0)
+               if (f_dec_abs.compare((cpp_dec_float_read_write_type::min)()) <= 0)
                {
                   break;
                }
@@ -1212,7 +1217,7 @@ constexpr cpp_double_fp_backend<FloatingPointType> operator/(const cpp_double_fp
 // Input/Output Streaming
 template <typename FloatingPointType, typename char_type, typename traits_type>
 ::std::basic_ostream<char_type, traits_type>&
-operator<<(std::basic_ostream<char_type, traits_type>& os, const cpp_double_fp_backend<FloatingPointType>& f)
+operator<<(::std::basic_ostream<char_type, traits_type>& os, const cpp_double_fp_backend<FloatingPointType>& f)
 {
    const auto str_result = f.str(os.precision(), os.flags());
 
@@ -1221,7 +1226,7 @@ operator<<(std::basic_ostream<char_type, traits_type>& os, const cpp_double_fp_b
 
 template <typename FloatingPointType, typename char_type, typename traits_type>
 ::std::basic_istream<char_type, traits_type>&
-operator>>(std::basic_istream<char_type, traits_type>& is, cpp_double_fp_backend<FloatingPointType>& f)
+operator>>(::std::basic_istream<char_type, traits_type>& is, cpp_double_fp_backend<FloatingPointType>& f)
 {
    std::string input_str;
 
@@ -1859,7 +1864,7 @@ constexpr void eval_log(cpp_double_fp_backend<FloatingPointType>& result, const
    else if (eval_lt(x, double_float_type(1)))
    {
       // TBD: Optimize check with 1.
-      // TBD: optimize inversion and negation.
+      // TBD: Optimize inversion and negation.
 
       double_float_type x_inv;
       eval_divide(x_inv, double_float_type(1), x);
@@ -1889,7 +1894,7 @@ constexpr void eval_log(cpp_double_fp_backend<FloatingPointType>& result, const
       // Do one single step of Newton-Raphson iteration.
       result = s + ((x2 - E) / E);
 
-      double_float_type xn2(n2);
+      double_float_type xn2 { n2 };
 
       eval_multiply(xn2, cpp_df_qf_detail::constant_df_ln_two<typename double_float_type::float_type>());
 
@@ -2304,8 +2309,4 @@ struct precision<boost::multiprecision::number<boost::multiprecision::cpp_double
 } } } // namespace boost::math::policies
 #endif
 
-#if (defined(_MSC_VER) && (_MSC_VER <= 1900))
-#pragma warning(pop)
-#endif
-
 #endif // BOOST_MP_CPP_DOUBLE_FP_2021_06_05_HPP