Retry CI but pow-of-10 loop still present

Author: ckormanyos

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

@@ -40,85 +40,84 @@ constexpr auto log10_impl(T x) noexcept
     {
         result = (!signbit(x)) ? x: std::numeric_limits<T>::quiet_NaN();
     }
-    else if (x < one)
-    {
-        // Handle reflection, the [+/-] zero-pole, and non-pole, negative x.
-        if (x > zero)
-        {
-            result = -log10(one / x);
-        }
-        else if ((x == zero) || (-x == zero))
-        {
-            // Actually, this should be equivalent to -HUGE_VAL.
-
-            result = -std::numeric_limits<T>::infinity();
-        }
-        else
-        {
-            result = std::numeric_limits<T>::quiet_NaN();
-        }
-    }
-    else if(x > one)
+    else
     {
-        // The algorithm for base-10 logarithm is based on Chapter 5, pages 35-36
-        // of Cody and Waite, Software Manual for the Elementary Functions,
-        // Prentice Hall, 1980.
-
         int exp10val { };
 
         T g { frexp10(x, &exp10val) };
 
         while(g > one)
         {
-            // TODO(ckormanyos) Do we really have to multiply individual powers
-            // of 10 here? Or is there a reliable way to simply use pow10()?
-            // For instance count intagral orders of exp10val and divide by pow10().
-
-            g /= 10;
+          g /= 10;
 
-            ++exp10val;
+          ++exp10val;
         }
 
-        if(g == one)
+        const bool is_pure = (g == one);
+
+        if(is_pure)
         {
             result = T { exp10val };
         }
         else
         {
-            constexpr T inv_sqrt10 { UINT64_C(3162277660168379332), -19 };
+            if (x < one)
+            {
+                // Handle reflection, the [+/-] zero-pole, and non-pole, negative x.
+                if (x > zero)
+                {
+                    result = -log10(one / x);
+                }
+                else if ((x == zero) || (-x == zero))
+                {
+                    // Actually, this should be equivalent to -HUGE_VAL.
+
+                    result = -std::numeric_limits<T>::infinity();
+                }
+                else
+                {
+                    result = std::numeric_limits<T>::quiet_NaN();
+                }
+            }
+            else if(x > one)
+            {
+                // The algorithm for base-10 logarithm is based on Chapter 5, pages 35-36
+                // of Cody and Waite, Software Manual for the Elementary Functions,
+                // Prentice Hall, 1980.
+                constexpr T inv_sqrt10 { UINT64_C(3162277660168379332), -19 };
 
-            const bool reduce_sqrt10 { g < inv_sqrt10 };
+                const bool reduce_sqrt10 { g < inv_sqrt10 };
 
-            if (reduce_sqrt10)
-            {
-                constexpr T sqrt10 { UINT64_C(3162277660168379332), -18 };
+                if (reduce_sqrt10)
+                {
+                    constexpr T sqrt10 { UINT64_C(3162277660168379332), -18 };
 
-                g *= sqrt10;
-            }
+                    g *= sqrt10;
+                }
 
-            const T s   { (g - one) / (g + one) };
-            const T z   { s + s };
-            const T zsq { z * z };
+                const T s   { (g - one) / (g + one) };
+                const T z   { s + s };
+                const T zsq { z * z };
 
-            result = z * fma(detail::log_series_expansion(zsq), zsq, one);
+                result = z * fma(detail::log_series_expansion(zsq), zsq, one);
 
-            result /= numbers::ln10_v<T>;
+                result /= numbers::ln10_v<T>;
 
-            if(reduce_sqrt10)
-            {
-                constexpr T half { 5, -1 };
+                if(reduce_sqrt10)
+                {
+                    constexpr T half { 5, -1 };
 
-                result -= half;
-            }
+                    result -= half;
+                }
 
-            result += static_cast<T>(exp10val);
+                result += static_cast<T>(exp10val);
+            }
+            else
+            {
+                result = zero;
+            }
         }
     }
-    else
-    {
-        result = zero;
-    }
-
     return result;
 }
 

test/test_log10.cpp

@@ -156,7 +156,7 @@ namespace local
   }
 
   template<typename DecimalType, typename FloatType>
-  auto test_log10_pow10(const int tol_factor) -> bool
+  auto test_log10_pow10() -> bool
   {
     using decimal_type = DecimalType;
     using float_type   = FloatType;
@@ -167,9 +167,12 @@ namespace local
     {
       const decimal_type x_arg { 1, i };
 
-      const decimal_type log_val_p10 = log10(x_arg);
+      const decimal_type val_dec  = log10(x_arg);
+      const float_type   val_ctrl =  static_cast<float_type>(i);
 
-      const auto result_log10_pow10_is_ok = (static_cast<float_type>(log_val_p10) == static_cast<float_type>(i));
+      const float_type val_to_check = static_cast<float_type>(val_dec);
+
+      const auto result_log10_pow10_is_ok = (val_to_check == val_ctrl);
 
       result_is_ok = (result_log10_pow10_is_ok && result_is_ok);
     }
@@ -194,6 +197,15 @@ auto main() -> int
     result_is_ok = (test_log10_is_ok && result_is_ok);
   }
 
+  {
+    using decimal_type = boost::decimal::decimal32;
+    using float_type   = float;
+
+    const auto test_log10_pow10_is_ok = local::test_log10_pow10<decimal_type, float_type>();
+
+    result_is_ok = (test_log10_pow10_is_ok && result_is_ok);
+  }
+
   result_is_ok = ((boost::report_errors() == 0) && result_is_ok);
 
   return (result_is_ok ? 0 : -1);