Improve tolerances on impls and tests

Author: ckormanyos

include/boost/decimal/detail/cmath/exp.hpp

@@ -76,8 +76,6 @@ constexpr auto exp_impl(T x) noexcept
                 x -= numbers::ln2_v<T> * nf2;
             }
 
-            // TODO: Chris: At 32-bit, reduce the number of coefficients in the Pade appxorimant of the exp() function.
-            // TODO: Chris: At 128-bit, add more coefficients to the Pade appxorimant of the exp() function.
             result = detail::exp_pade_appxroximant(x);
 
             if (nf2 > 0)

include/boost/decimal/detail/cmath/impl/cosh_impl.hpp

@@ -27,7 +27,7 @@ struct cosh_table_imp
 private:
     using d32_coeffs_t  = std::array<decimal32,   6>;
     using d64_coeffs_t  = std::array<decimal64,   9>;
-    using d128_coeffs_t = std::array<decimal128, 11>;
+    using d128_coeffs_t = std::array<decimal128, 17>;
 
 public:
     static constexpr d32_coeffs_t d32_coeffs =
@@ -59,7 +59,7 @@ struct cosh_table_imp
 
     static constexpr d128_coeffs_t d128_coeffs =
     {{
-         // Series[Cosh[x], {x, 0, 22}]
+         // Series[Cosh[x], {x, 0, 34}]
          //            (1),                                                                                                                   // * 1
          ::boost::decimal::decimal128 { 5, -1 },                                                                                              // * x^2
          ::boost::decimal::decimal128 { boost::decimal::detail::uint128 { UINT64_C(225875452601146), UINT64_C(13965751134118914724) }, -35 }, // * x^4
@@ -71,8 +71,14 @@ struct cosh_table_imp
          ::boost::decimal::decimal128 { boost::decimal::detail::uint128 { UINT64_C(259095985355981), UINT64_C(6015479145837302244)  }, -47 }, // * x^16
          ::boost::decimal::decimal128 { boost::decimal::detail::uint128 { UINT64_C(84671890639209),  UINT64_C(10767230553416093986) }, -49 }, // * x^18
          ::boost::decimal::decimal128 { boost::decimal::detail::uint128 { UINT64_C(222820764840025), UINT64_C(4062785569898205740)  }, -52 }, // * x^20
-         ::boost::decimal::decimal128 { boost::decimal::detail::uint128 { UINT64_C(482296027792262), UINT64_C(7037075391028107068)  }, -55 }  // * x^22
-     }};
+         ::boost::decimal::decimal128 { boost::decimal::detail::uint128 { UINT64_C(482296027792262), UINT64_C(7037075391028107068)  }, -55 }, // * x^22
+         ::boost::decimal::decimal128 { boost::decimal::detail::uint128 { UINT64_C(87372468802946),  UINT64_C(1542176615384940434)  }, -57 }, // * x^24
+         ::boost::decimal::decimal128 { boost::decimal::detail::uint128 { UINT64_C(134419182773763), UINT64_C(3791559721646796942)  }, -60 }, // * x^26
+         ::boost::decimal::decimal128 { boost::decimal::detail::uint128 { UINT64_C(177803151817147), UINT64_C(1794430560736952558)  }, -63 }, // * x^28
+         ::boost::decimal::decimal128 { boost::decimal::detail::uint128 { UINT64_C(204371438870284), UINT64_C(366311534299067156)   }, -66 }, // * x^30
+         ::boost::decimal::decimal128 { boost::decimal::detail::uint128 { UINT64_C(206019595635366), UINT64_C(17625897212400736954) }, -69 }, // * x^32
+         ::boost::decimal::decimal128 { boost::decimal::detail::uint128 { UINT64_C(183618177928134), UINT64_C(9987905770721758456)  }, -72 }, // * x^34
+    }};
 };
 
 #if !(defined(__cpp_inline_variables) && __cpp_inline_variables >= 201606L) && (!defined(_MSC_VER) || _MSC_VER != 1900)

include/boost/decimal/detail/cmath/impl/exp_impl.hpp

@@ -64,15 +64,16 @@ constexpr auto exp_pade_appxroximant<decimal64>(decimal64 x) noexcept
 template <>
 constexpr auto exp_pade_appxroximant<decimal128>(decimal128 x) noexcept
 {
-    // TODO: Chris: At 128-bit, add more coefficients to the Pade appxorimant of the exp() function.
-
     // Compute exp(x) - 1 for x small.
 
     // Use an order-12 Pade approximation of the exponential function.
     // PadeApproximant[Exp[x] - 1, {x, 0, 12, 12}].
 
     using local_float_t = decimal128;
 
+    // Rescale the argument even further (and note the three squarings below).
+    x /= 8;
+
     const local_float_t x2 = (x * x);
 
     const local_float_t top = (((((  local_float_t { boost::decimal::detail::uint128 { UINT64_C(130576843339991), UINT64_C(2348781707059460614)  }, -46 }   * x2
@@ -98,7 +99,13 @@ constexpr auto exp_pade_appxroximant<decimal128>(decimal128 x) noexcept
                                           + local_float_t( +boost::decimal::decimal128 { boost::decimal::detail::uint128 { UINT64_C(54210108624275),  UINT64_C(4089650035136921600)  }, -33 } ))
                                           ;
 
-    return local_float_t { 1 } + ((x * top) / bot);
+    local_float_t result { local_float_t { 1 } + ((x * top) / bot) };
+
+    result *= result;
+    result *= result;
+    result *= result;
+
+    return result;
 }
 
 } //namespace detail

test/test_cosh.cpp

@@ -268,15 +268,15 @@ namespace local
     return result_is_ok;
   }
 
-  auto test_cosh_128(const float tol_factor) -> bool
+  auto test_cosh_128(const int tol_factor) -> bool
   {
     using decimal_type = boost::decimal::decimal128;
 
     using str_ctrl_array_type = std::array<const char*, 9U>;
 
     const str_ctrl_array_type ctrl_strings =
     {{
-       // Table[N[Cosh[n/10 + n/100], 32], {n, 1, 19, 1}]
+       // Table[N[Cosh[n/10 + n/100], 36], {n, 1, 19, 1}]
        "1.00605610287769977108879617596474784",
        "1.02429776427492965125226008299305162",
        "1.05494593094785321789908314053177016",
@@ -352,9 +352,7 @@ auto main() -> int
 
   const auto result_pos64_is_ok = local::test_cosh_64(64);
 
-  // TODO: Chris: At 32-bit, reduce the number of coefficients in the Pade appxorimant of the exp() function.
-  // TODO: Chris: At 128-bit, add more coefficients to the Pade appxorimant of the exp() function.
-  const auto result_pos128_is_ok = local::test_cosh_128(1.0E10F);
+  const auto result_pos128_is_ok = local::test_cosh_128(500000);
 
   BOOST_TEST(result_pos_is_ok);
   BOOST_TEST(result_neg_is_ok);

test/test_sqrt.cpp

@@ -230,7 +230,7 @@ auto main() -> int
     using decimal_type = boost::decimal::decimal32;
     using float_type   = float;
 
-    const auto result_small_is_ok  = local::test_sqrt<decimal_type, float_type>(static_cast<std::int32_t>(INT32_C(16)), 1.0E-26L, 1.0E-01L);
+    const auto result_small_is_ok  = local::test_sqrt<decimal_type, float_type>(static_cast<std::int32_t>(INT32_C(64)), 1.0E-26L, 1.0E-01L);
     const auto result_medium_is_ok = local::test_sqrt<decimal_type, float_type>(static_cast<std::int32_t>(INT32_C(16)), 0.9E-01L, 1.1E+01L);
     const auto result_large_is_ok  = local::test_sqrt<decimal_type, float_type>(static_cast<std::int32_t>(INT32_C(16)), 1.0E+01L, 1.0E+26L);