Merge pull request #1133 from cppalliance/1105

Directly manipulate value to calculate next

Author: mborland

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

@@ -34,42 +34,54 @@ constexpr auto nextafter_impl(const DecimalType val, const bool direction) noexc
 {
     constexpr DecimalType zero {0};
 
-    // Val < direction = +
-    // Val > direction = -
-    const auto abs_val {abs(val)};
+    const bool is_neg {val < 0};
 
     if (val == zero)
     {
         const auto min_val {direction ? std::numeric_limits<DecimalType>::denorm_min() :
                                         -std::numeric_limits<DecimalType>::denorm_min()};
         return min_val;
     }
-    else if (abs_val > zero && abs_val < std::numeric_limits<DecimalType>::epsilon())
-    {
-        auto exp {val.biased_exponent()};
-        auto significand {val.full_significand()};
-        direction ? ++significand : --significand;
 
-        return {significand, exp, val.isneg()};
-    }
+    int exp {};
+    auto sig {frexp10(val, &exp)};
+    const auto removed_zeros(remove_trailing_zeros(sig));
 
-    const auto val_eps {direction ? val + std::numeric_limits<DecimalType>::epsilon() :
-                                    val - std::numeric_limits<DecimalType>::epsilon()};
+    // Our two boundaries
+    const bool is_pow_10 {removed_zeros.trimmed_number == 1U};
+    const bool is_max_sig {sig == detail::max_significand_v<DecimalType>};
 
-    // If adding epsilon does nothing, then we need to manipulate the representation
-    if (val == val_eps)
+    if (!isnormal(val))
     {
-        int exp {} ;
-        auto significand {frexp10(val, &exp)};
-
-        direction ? ++significand : --significand;
+        // Not to make sure that denorms aren't normalized
+        sig = removed_zeros.trimmed_number;
+        exp += static_cast<int>(removed_zeros.number_of_removed_zeros);
+    }
 
-        return DecimalType{significand, exp};
+    if (direction)
+    {
+        // Val < direction = +
+        ++sig;
+        if (is_max_sig)
+        {
+            sig /= 10u;
+            ++exp;
+        }
     }
     else
     {
-        return val_eps;
+        // Val > direction = -
+        --sig;
+        if (is_pow_10)
+        {
+            // 1000 becomes 999 but needs to be 9999
+            sig *= 10u;
+            sig += 9u;
+            --exp;
+        }
     }
+
+    return DecimalType{sig, exp, is_neg};
 }
 
 } // namespace detail

test/Jamfile

@@ -70,6 +70,7 @@ run github_issue_1057.cpp ;
 compile-fail github_issue_1087.cpp ;
 run github_issue_1091.cpp ;
 run github_issue_1094.cpp ;
+run github_issue_1105.cpp ;
 run github_issue_1106.cpp ;
 run github_issue_1110.cpp ;
 run github_issue_1112.cpp ;

test/github_issue_1105.cpp

@@ -0,0 +1,60 @@
+// Copyright 2025 Matt Borland
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+//
+// See: https://github.com/cppalliance/decimal/issues/1105
+
+#include <boost/decimal.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <random>
+
+static std::mt19937_64 rng(42);
+
+using namespace boost::decimal;
+
+template <typename T>
+void test()
+{
+    std::uniform_int_distribution<int> dist(1, 1);
+
+    const T one {dist(rng), 0};
+    const T zero {0, 0};
+
+    const T val {dist(rng), -5};
+    int val_exp {};
+    const auto val_sig {frexp10(val, &val_exp)};
+
+    const auto next {nextafter(val, one)};
+    int next_exp {};
+    const auto next_sig {frexp10(next, &next_exp)};
+    BOOST_TEST_EQ(next_exp, val_exp);
+    BOOST_TEST_EQ(next_sig, val_sig + 1U);
+
+    const auto prev {nextafter(val, zero)};
+    int prev_exp {};
+    const auto prev_sig {frexp10(prev, &prev_exp)};
+    BOOST_TEST_EQ(prev_exp, val_exp - 1);
+    BOOST_TEST_EQ(prev_sig, detail::max_significand_v<T>);
+
+    // Max significand + 1 should be reduced
+    const auto original_val {nextafter(prev, one)};
+    int original_exp {};
+    const auto original_sig {frexp10(original_val, &original_exp)};
+    BOOST_TEST_EQ(original_exp, val_exp);
+    BOOST_TEST_EQ(original_sig, val_sig);
+
+    const auto zero_next {nextafter(zero, one)};
+    BOOST_TEST_EQ(zero_next, std::numeric_limits<T>::denorm_min());
+
+    const auto two_next_zero {nextafter(zero_next, one)};
+    BOOST_TEST_EQ(two_next_zero, T(2, detail::etiny_v<T>));
+}
+
+int main()
+{
+    test<decimal32_t>();
+    test<decimal64_t>();
+    test<decimal128_t>();
+
+    return boost::report_errors();
+}