Merge pull request #1146 from cppalliance/1105v2

Fix handling of denorm next after

Author: mborland

include/boost/decimal/decimal128_t.hpp

@@ -745,7 +745,7 @@ constexpr decimal128_t::decimal128_t(T1 coeff, T2 exp, bool sign) noexcept
     auto biased_exp {static_cast<int>(exp + detail::bias_v<decimal128_t>)};
     BOOST_DECIMAL_IF_CONSTEXPR (sizeof(T1) >= sizeof(significand_type))
     {
-        if (coeff > detail::d128_max_significand_value || biased_exp < 0)
+        if (coeff > detail::d128_max_significand_value || biased_exp < -(detail::precision_v<decimal128_t> - 1))
         {
             coeff_digits = detail::coefficient_rounding<decimal128_t>(coeff, exp, biased_exp, sign, detail::num_digits(coeff));
         }
@@ -788,6 +788,19 @@ constexpr decimal128_t::decimal128_t(T1 coeff, T2 exp, bool sign) noexcept
             reduced_coeff *= detail::pow10(static_cast<significand_type>(digit_delta));
             *this = decimal128_t(reduced_coeff, exp, sign);
         }
+        else if (coeff_digits + biased_exp <= detail::precision_v<decimal128_t>)
+        {
+            // Handle the case of sub-normals that don't need further rounding
+            bits_.high = sign ? detail::d128_sign_mask : UINT64_C(0); // Reset the sign bit
+            const auto zeros {detail::remove_trailing_zeros(reduced_coeff)};
+            biased_exp += static_cast<int>(zeros.number_of_removed_zeros);
+            reduced_coeff = zeros.trimmed_number;
+            if (biased_exp > 0)
+            {
+                reduced_coeff *= detail::pow10(static_cast<significand_type>(biased_exp));
+            }
+            bits_ |= reduced_coeff;
+        }
         else if (digit_delta < 0 && coeff_digits - digit_delta <= detail::precision_v<decimal128_t>)
         {
             const auto offset {detail::precision_v<decimal128_t> - coeff_digits};

include/boost/decimal/decimal32_t.hpp

@@ -653,7 +653,7 @@ constexpr decimal32_t::decimal32_t(T1 coeff, T2 exp, bool sign) noexcept // NOLI
     // Only count the number of digits if we absolutely have to
     int coeff_digits {-1};
     auto biased_exp {static_cast<int>(exp + detail::bias)};
-    if (coeff > detail::d32_max_significand_value || biased_exp < 0)
+    if (coeff > detail::d32_max_significand_value || biased_exp < -(detail::precision_v<decimal32_t> - 1))
     {
         coeff_digits = detail::coefficient_rounding<decimal32_t>(coeff, exp, biased_exp, sign, detail::num_digits(coeff));
     }
@@ -710,6 +710,19 @@ constexpr decimal32_t::decimal32_t(T1 coeff, T2 exp, bool sign) noexcept // NOLI
             reduced_coeff *= detail::pow10(static_cast<significand_type>(digit_delta));
             *this = decimal32_t(reduced_coeff, exp, sign);
         }
+        else if (coeff_digits + biased_exp <= detail::precision)
+        {
+            // Handle the case of sub-normals that don't need further rounding
+            bits_ = sign ? detail::d32_sign_mask : UINT32_C(0); // Reset the sign bit
+            const auto zeros {detail::remove_trailing_zeros(reduced_coeff)};
+            biased_exp += static_cast<int>(zeros.number_of_removed_zeros);
+            reduced_coeff = zeros.trimmed_number;
+            if (biased_exp > 0)
+            {
+                reduced_coeff *= detail::pow10(static_cast<significand_type>(biased_exp));
+            }
+            bits_ |= reduced_coeff;
+        }
         else if (digit_delta < 0 && coeff_digits - digit_delta <= detail::precision)
         {
             // We can expand the coefficient to use the maximum number of digits

include/boost/decimal/decimal64_t.hpp

@@ -647,7 +647,7 @@ constexpr decimal64_t::decimal64_t(T1 coeff, T2 exp, bool sign) noexcept
     // If the coeff is not in range, make it so
     int coeff_digits {-1};
     auto biased_exp {static_cast<int>(exp) + detail::bias_v<decimal64_t>};
-    if (coeff > detail::d64_max_significand_value || biased_exp < 0)
+    if (coeff > detail::d64_max_significand_value || biased_exp < -(detail::precision_v<decimal64_t> - 1))
     {
         coeff_digits = detail::coefficient_rounding<decimal64_t>(coeff, exp, biased_exp, sign, detail::num_digits(coeff));
     }
@@ -704,6 +704,19 @@ constexpr decimal64_t::decimal64_t(T1 coeff, T2 exp, bool sign) noexcept
             reduced_coeff *= detail::pow10(static_cast<significand_type>(digit_delta));
             *this = decimal64_t(reduced_coeff, exp, sign);
         }
+        else if (coeff_digits + biased_exp <= detail::precision_v<decimal64_t>)
+        {
+            // Handle the case of sub-normals that don't need further rounding
+            bits_ = sign ? detail::d64_sign_mask : UINT64_C(0); // Reset the sign bit
+            const auto zeros {detail::remove_trailing_zeros(reduced_coeff)};
+            biased_exp += static_cast<int>(zeros.number_of_removed_zeros);
+            reduced_coeff = zeros.trimmed_number;
+            if (biased_exp > 0)
+            {
+                reduced_coeff *= detail::pow10(static_cast<significand_type>(biased_exp));
+            }
+            bits_ |= reduced_coeff;
+        }
         else if (digit_delta < 0 && coeff_digits - digit_delta <= detail::precision_v<decimal64_t>)
         {
             const auto offset {detail::precision_v<decimal64_t> - coeff_digits};

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

@@ -53,9 +53,24 @@ constexpr auto nextafter_impl(const DecimalType val, const bool direction) noexc
 
     if (!isnormal(val))
     {
-        // Not to make sure that denorms aren't normalized
+        // Denorms need separate handling
         sig = removed_zeros.trimmed_number;
         exp += static_cast<int>(removed_zeros.number_of_removed_zeros);
+
+        if (removed_zeros.number_of_removed_zeros > 0)
+        {
+            // We need to shift an add
+            // 1 -> 11 instead of 2 since 11e-101 < 2e-100 starting at 1e-100
+            sig *= 10U;
+            ++sig;
+            --exp;
+        }
+        else
+        {
+            ++sig;
+        }
+
+        return DecimalType{sig, exp, is_neg};
     }
 
     if (direction)

test/github_issue_1105.cpp

@@ -45,9 +45,29 @@ void test()
 
     const auto zero_next {nextafter(zero, one)};
     BOOST_TEST_EQ(zero_next, std::numeric_limits<T>::denorm_min());
+}
+
+// Per IEEE 754 nextafter is allowed to break cohort
+void test_non_preserving()
+{
+    const auto val = decimal32_t{"1e-100"};
+    const auto two_val = decimal32_t{2, boost::decimal::detail::etiny_v<decimal32_t>};
+    const auto one = decimal32_t{"1e0"};
+    const auto next = nextafter(val,one);
+    const auto between = decimal32_t{"11e-101"};
 
-    const auto two_next_zero {nextafter(zero_next, one)};
-    BOOST_TEST_EQ(two_next_zero, T(2, detail::etiny_v<T>));
+    BOOST_TEST_LE(val, between);
+    BOOST_TEST_EQ(next, between);
+    BOOST_TEST_LE(two_val, next);
+
+    const auto nines_value = decimal32_t{"99e-101"};
+    const auto next_nines_res = decimal32_t{"991e-102"};
+    const auto res = nextafter(nines_value, one);
+    BOOST_TEST_EQ(res, next_nines_res);
+
+    const auto wrap_value = decimal32_t{"9999999e-107"};
+    const auto next_after_wrap = nextafter(wrap_value, one);
+    BOOST_TEST_GT(next_after_wrap, wrap_value);
 }
 
 int main()
@@ -56,5 +76,7 @@ int main()
     test<decimal64_t>();
     test<decimal128_t>();
 
+    test_non_preserving();
+
     return boost::report_errors();
 }