Merge pull request #1385 from boostorg/1384

mborland · web-flow · commit 769c65d16feb · 2026-05-04T11:36:02.000-04:00
Potential proposal for 1384
diff --git a/include/boost/decimal/cmath.hpp b/include/boost/decimal/cmath.hpp
@@ -5,6 +5,7 @@
 #ifndef BOOST_DECIMAL_CMATH_HPP
 #define BOOST_DECIMAL_CMATH_HPP
 
+#include <boost/decimal/detail/fwd_log.hpp>
 #include <boost/decimal/detail/promotion.hpp>
 #include <boost/decimal/decimal32_t.hpp>
 #include <boost/decimal/decimal64_t.hpp>
diff --git a/include/boost/decimal/detail/cmath/acosh.hpp b/include/boost/decimal/detail/cmath/acosh.hpp
@@ -76,7 +76,7 @@ constexpr auto acosh_impl(const T x) noexcept
                 {
                     // http://functions.wolfram.com/ElementaryFunctions/ArcCosh/06/01/06/01/0001/
                     // approximation by laurent series in 1/x at 0+ order from -1 to 0
-                    result = log(x) + numbers::ln2_v<T>;
+                    result = ::boost::decimal::log(x) + numbers::ln2_v<T>;
                 }
                 else if (x < T { 15, -1 })
                 {
@@ -85,12 +85,12 @@ constexpr auto acosh_impl(const T x) noexcept
 
                     const auto two_y = y + y;
 
-                    result = log1p(y + sqrt((y * y) + two_y));
+                    result = ::boost::decimal::log1p(y + sqrt((y * y) + two_y));
                 }
                 else
                 {
                     // http://functions.wolfram.com/ElementaryFunctions/ArcCosh/02/
-                    return(log(x + sqrt((x * x) - one)));
+                    return(::boost::decimal::log(x + sqrt((x * x) - one)));
                 }
             }
             else
diff --git a/include/boost/decimal/detail/cmath/asinh.hpp b/include/boost/decimal/detail/cmath/asinh.hpp
@@ -52,17 +52,17 @@ constexpr auto asinh_impl(const T x) noexcept
             {
                 // http://functions.wolfram.com/ElementaryFunctions/ArcSinh/06/01/06/01/0001/
                 // approximation by laurent series in 1/x at 0+ order from -1 to 1
-                result = numbers::ln2_v<T> + log(x) + one / (T { 4, 0 } * xsq);
+                result = numbers::ln2_v<T> + ::boost::decimal::log(x) + one / (T { 4, 0 } * xsq);
             }
             else if(x >= T { 5 , -1 })
             {
                 // http://functions.wolfram.com/ElementaryFunctions/ArcSinh/02/
-                result = log(x + sqrt(xsq + one));
+                result = ::boost::decimal::log(x + sqrt(xsq + one));
             }
             else if (x >= fourth_root_epsilon)
             {
                 // As below, but rearranged to preserve digits:
-                result = log1p(x + (sqrt(one + xsq) - one));
+                result = ::boost::decimal::log1p(x + (sqrt(one + xsq) - one));
             }
             else
             {
diff --git a/include/boost/decimal/detail/cmath/atanh.hpp b/include/boost/decimal/detail/cmath/atanh.hpp
@@ -62,11 +62,11 @@ constexpr auto atanh_impl(const T x) noexcept
 
                 if(xx < half)
                 {
-                    result = (log1p(xx) - log1p(-xx)) / 2;
+                    result = (::boost::decimal::log1p(xx) - ::boost::decimal::log1p(-xx)) / 2;
                 }
                 else
                 {
-                    result = (log((one + xx) / (one - xx)) / 2);
+                    result = (::boost::decimal::log((one + xx) / (one - xx)) / 2);
                 }
             }
             else
diff --git a/include/boost/decimal/detail/cmath/impl/ellint_impl.hpp b/include/boost/decimal/detail/cmath/impl/ellint_impl.hpp
@@ -77,7 +77,7 @@ constexpr auto agm(T  phi,
 
     const T sp { sin(phi) };
 
-    Fpm = phi_is_pi_half ? std::numeric_limits<T>::quiet_NaN() : log((one + sp) / (one - sp)) / 2;
+    Fpm = phi_is_pi_half ? std::numeric_limits<T>::quiet_NaN() : ::boost::decimal::log((one + sp) / (one - sp)) / 2;
 
     if(has_e)
     {
diff --git a/include/boost/decimal/detail/cmath/lgamma.hpp b/include/boost/decimal/detail/cmath/lgamma.hpp
@@ -81,7 +81,7 @@ constexpr auto lgamma_impl(const T x) noexcept
 
             const auto phase = sin(numbers::pi_v<T> * za);
 
-            result = log(numbers::pi_v<T>) - log(abs(phase)) - lgamma(za);
+            result = ::boost::decimal::log(numbers::pi_v<T>) - ::boost::decimal::log(abs(phase)) - lgamma(za);
         }
         else
         {
@@ -97,11 +97,11 @@ constexpr auto lgamma_impl(const T x) noexcept
                 // Perform the Taylor series expansion.
 
                 result =   (x * fma(detail::lgamma_taylor_series_expansion(x), x, -numbers::egamma_v<T>))
-                         - log(x);
+                         - ::boost::decimal::log(x);
             }
             else if (x < T { asymp_cutoff })
             {
-                result = log(tgamma(x));
+                result = ::boost::decimal::log(tgamma(x));
             }
             else
             {
@@ -111,7 +111,7 @@ constexpr auto lgamma_impl(const T x) noexcept
 
                 constexpr T half { 5, -1 };
 
-                result = (((x - half) * (log(x)) - x)) + log(detail::tgamma_series_expansion_asymp(one / x));
+                result = (((x - half) * (::boost::decimal::log(x)) - x)) + ::boost::decimal::log(detail::tgamma_series_expansion_asymp(one / x));
             }
         }
     }
diff --git a/include/boost/decimal/detail/cmath/log.hpp b/include/boost/decimal/detail/cmath/log.hpp
@@ -53,11 +53,11 @@ constexpr auto log_impl(const T x) noexcept
     else if (x < one)
     {
         // Handle reflection.
-        result = -log(one / x);
+        result = -::boost::decimal::log(one / x);
     }
     else if(x > one)
     {
-        // Use the implementation of log10 in order to compute the natural
+        // Use the implementation of ::boost::decimal::log10 in order to compute the natural
         // logarithm. The base of the boost::decimal library is, in fact,
         // base-10. And so, somewhat uncommonly, the fastest and most accurate
         // logarithm in this system is log10 in base-10.
diff --git a/include/boost/decimal/detail/cmath/log10.hpp b/include/boost/decimal/detail/cmath/log10.hpp
@@ -79,7 +79,7 @@ constexpr auto log10_impl(const T x) noexcept
             if (x < one)
             {
                 // Handle reflection.
-                result = -log10(one / x);
+                result = -::boost::decimal::log10(one / x);
             }
             else if(x > one)
             {
diff --git a/include/boost/decimal/detail/cmath/log1p.hpp b/include/boost/decimal/detail/cmath/log1p.hpp
@@ -61,7 +61,7 @@ constexpr auto log1p_impl(const T x) noexcept
     {
         if (x > T { 5, -1 })
         {
-            result = log(x + one);
+            result = ::boost::decimal::log(x + one);
         }
         else
         {
diff --git a/include/boost/decimal/detail/cmath/log2.hpp b/include/boost/decimal/detail/cmath/log2.hpp
@@ -27,7 +27,7 @@ template <typename T>
 constexpr auto log2_impl(const T x) noexcept
     BOOST_DECIMAL_REQUIRES(detail::is_decimal_floating_point_v, T)
 {
-    return log(x) / numbers::ln2_v<T>;
+    return ::boost::decimal::log(x) / numbers::ln2_v<T>;
 }
 
 } //namespace detail
diff --git a/include/boost/decimal/detail/cmath/pow.hpp b/include/boost/decimal/detail/cmath/pow.hpp
@@ -212,12 +212,8 @@ constexpr auto pow(const T x, const T a) noexcept
         #endif
         else
         {
-            if (fpc_a == FP_ZERO)
-            {
-                result = one;
-            }
             #ifndef BOOST_DECIMAL_FAST_MATH
-            else if (fpc_a == FP_INFINITE)
+            if (fpc_a == FP_INFINITE)
             {
                 result =
                     (
@@ -226,10 +222,10 @@ constexpr auto pow(const T x, const T a) noexcept
                         : one
                     );
             }
-            #endif
             else
+            #endif
             {
-                const T a_log_x { a * log(x) };
+                const T a_log_x { a * ::boost::decimal::log(x) };
 
                 result = exp(a_log_x);
             }
diff --git a/include/boost/decimal/detail/cmath/riemann_zeta.hpp b/include/boost/decimal/detail/cmath/riemann_zeta.hpp
@@ -110,7 +110,7 @@ constexpr auto riemann_zeta_impl(const T x) noexcept
 
                 constexpr std::size_t n_primes = std::tuple_size<prime_table_type>::value;
 
-                const T lg10_max_prime { log10(detail::prime_table<T>::primes[n_primes - 1U]) };
+                const T lg10_max_prime { ::boost::decimal::log10(detail::prime_table<T>::primes[n_primes - 1U]) };
 
                 if((x * lg10_max_prime) > std::numeric_limits<T>::digits10)
                 {
diff --git a/include/boost/decimal/detail/cmath/tgamma.hpp b/include/boost/decimal/detail/cmath/tgamma.hpp
@@ -115,7 +115,7 @@ constexpr auto tgamma_impl(const T x) noexcept
                 {
                     // Use large-argument asymptotic expansion.
 
-                    const T prefix { exp(((x  - T { 5, -1 }) * log(x)) - x) };
+                    const T prefix { exp(((x  - T { 5, -1 }) * ::boost::decimal::log(x)) - x) };
 
                     result =  prefix * detail::tgamma_series_expansion_asymp(one / x);
                 }
diff --git a/include/boost/decimal/detail/fwd_log.hpp b/include/boost/decimal/detail/fwd_log.hpp
@@ -0,0 +1,39 @@
+// Copyright 2026 Christopher Kormanyos
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_DECIMAL_FWD_LOG_HPP
+#define BOOST_DECIMAL_FWD_LOG_HPP
+
+#include <boost/decimal/detail/concepts.hpp>
+
+namespace boost {
+namespace decimal {
+
+// Forward declarationf of logarithmic functions.
+// See also: https://github.com/boostorg/decimal/issues/1384
+
+BOOST_DECIMAL_EXPORT template <typename T>
+constexpr auto ilogb(const T d) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_decimal_floating_point_v, T, int);
+
+BOOST_DECIMAL_EXPORT template <typename T>
+constexpr auto log(const T x) noexcept
+    BOOST_DECIMAL_REQUIRES(detail::is_decimal_floating_point_v, T);
+
+BOOST_DECIMAL_EXPORT template <typename T>
+constexpr auto log1p(const T x) noexcept
+    BOOST_DECIMAL_REQUIRES(detail::is_decimal_floating_point_v, T);
+
+BOOST_DECIMAL_EXPORT template <typename T>
+constexpr auto log10(const T x) noexcept
+    BOOST_DECIMAL_REQUIRES(detail::is_decimal_floating_point_v, T);
+
+BOOST_DECIMAL_EXPORT template <typename T>
+constexpr auto log2(const T x) noexcept
+    BOOST_DECIMAL_REQUIRES(detail::is_decimal_floating_point_v, T);
+
+} // namespace decimal
+} // namespace boost
+
+#endif // BOOST_DECIMAL_FWD_LOG_HPP
diff --git a/test/Jamfile b/test/Jamfile
@@ -1,6 +1,6 @@
 # Copyright 2022 Peter Dimov
-# Copyright 2023 - 2024 Matt Borland
-# Copyright 2023 - 2024 Christopher Kormanyos
+# Copyright 2023 - 2026 Matt Borland
+# Copyright 2023 - 2026 Christopher Kormanyos
 # Distributed under the Boost Software License, Version 1.0.
 # https://www.boost.org/LICENSE_1_0.txt
 
@@ -93,6 +93,7 @@ run github_issue_1319.cpp ;
 run github_issue_1329.cpp ;
 run github_issue_1361.cpp ;
 run github_issue_1378.cpp ;
+run github_issue_1384.cpp ;
 
 run link_1.cpp link_2.cpp link_3.cpp ;
 run quick.cpp ;
diff --git a/test/github_issue_1384.cpp b/test/github_issue_1384.cpp
@@ -0,0 +1,51 @@
+
+#include <boost/core/lightweight_test.hpp>
+
+// This simulates upstream inclusion of Boost.Log. At the time of
+// hash commit e9951622837f63cf0020b22834ad96b01293fd07, this failed.
+
+// This odd-looking test in CI is intended to ensure that such failures
+// no longer occur in the future and that the namespace resolution
+// remains unequivocal.
+
+namespace boost {
+namespace log {
+
+auto do_something() -> void;
+
+// The presence of this namespace-local subroutine itself conflicted
+// (at the time of the issue) with Boost.Log. So this behavior is
+// simulated here.
+
+auto do_something() -> void { } // LCOV_EXCL_LINE
+
+} // namespace log
+} // namespace boost
+
+#include <boost/decimal/cmath.hpp>
+
+auto main() -> int;
+
+auto main() -> int
+{
+  boost::log::do_something(); // LCOV_EXCL_LINE
+
+  using local_decimal_type = boost::decimal::decimal64_t;
+
+  const local_decimal_type arg_dec { 123456, -5 };
+
+  // N[ArcCosh[123456/100000], 20]
+  const local_decimal_type result1 { acosh(arg_dec) };
+
+  // N[Log[Gamma[123456/100000]], 20]
+  const local_decimal_type result2 { lgamma(arg_dec) };
+
+  // N[Zeta[123456/10000], 20]
+  const local_decimal_type result3 { riemann_zeta(arg_dec * local_decimal_type { 10.0 }) };
+
+  BOOST_TEST(result1 > local_decimal_type { 0.0 }); // 0.67219624862864254285
+  BOOST_TEST(result2 < local_decimal_type { 0.0 }); // -0.094616414889227312801
+  BOOST_TEST(result3 > local_decimal_type { 1.0 }); // 1.0001934607133929720
+
+  return boost::report_errors();
+}

Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ constexpr auto acosh_impl(const T x) noexcept`
`76`	`76`	`{`
`77`	`77`	`// http://functions.wolfram.com/ElementaryFunctions/ArcCosh/06/01/06/01/0001/`
`78`	`78`	`// approximation by laurent series in 1/x at 0+ order from -1 to 0`
`79`		`- result = log(x) + numbers::ln2_v<T>;`
	`79`	`+ result = ::boost::decimal::log(x) + numbers::ln2_v<T>;`
`80`	`80`	`}`
`81`	`81`	`else if (x < T { 15, -1 })`
`82`	`82`	`{`
`@@ -85,12 +85,12 @@ constexpr auto acosh_impl(const T x) noexcept`
`85`	`85`
`86`	`86`	`const auto two_y = y + y;`
`87`	`87`
`88`		`- result = log1p(y + sqrt((y * y) + two_y));`
	`88`	`+ result = ::boost::decimal::log1p(y + sqrt((y * y) + two_y));`
`89`	`89`	`}`
`90`	`90`	`else`
`91`	`91`	`{`
`92`	`92`	`// http://functions.wolfram.com/ElementaryFunctions/ArcCosh/02/`
`93`		`- return(log(x + sqrt((x * x) - one)));`
	`93`	`+ return(::boost::decimal::log(x + sqrt((x * x) - one)));`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`	`else`
Original file line number	Diff line number	Diff line change
`@@ -52,17 +52,17 @@ constexpr auto asinh_impl(const T x) noexcept`
`52`	`52`	`{`
`53`	`53`	`// http://functions.wolfram.com/ElementaryFunctions/ArcSinh/06/01/06/01/0001/`
`54`	`54`	`// approximation by laurent series in 1/x at 0+ order from -1 to 1`
`55`		`- result = numbers::ln2_v<T> + log(x) + one / (T { 4, 0 } * xsq);`
	`55`	`+ result = numbers::ln2_v<T> + ::boost::decimal::log(x) + one / (T { 4, 0 } * xsq);`
`56`	`56`	`}`
`57`	`57`	`else if(x >= T { 5 , -1 })`
`58`	`58`	`{`
`59`	`59`	`// http://functions.wolfram.com/ElementaryFunctions/ArcSinh/02/`
`60`		`- result = log(x + sqrt(xsq + one));`
	`60`	`+ result = ::boost::decimal::log(x + sqrt(xsq + one));`
`61`	`61`	`}`
`62`	`62`	`else if (x >= fourth_root_epsilon)`
`63`	`63`	`{`
`64`	`64`	`// As below, but rearranged to preserve digits:`
`65`		`- result = log1p(x + (sqrt(one + xsq) - one));`
	`65`	`+ result = ::boost::decimal::log1p(x + (sqrt(one + xsq) - one));`
`66`	`66`	`}`
`67`	`67`	`else`
`68`	`68`	`{`
Original file line number	Diff line number	Diff line change
`@@ -62,11 +62,11 @@ constexpr auto atanh_impl(const T x) noexcept`
`62`	`62`
`63`	`63`	`if(xx < half)`
`64`	`64`	`{`
`65`		`- result = (log1p(xx) - log1p(-xx)) / 2;`
	`65`	`+ result = (::boost::decimal::log1p(xx) - ::boost::decimal::log1p(-xx)) / 2;`
`66`	`66`	`}`
`67`	`67`	`else`
`68`	`68`	`{`
`69`		`- result = (log((one + xx) / (one - xx)) / 2);`
	`69`	`+ result = (::boost::decimal::log((one + xx) / (one - xx)) / 2);`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`	`else`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ constexpr auto agm(T phi,`
`77`	`77`
`78`	`78`	`const T sp { sin(phi) };`
`79`	`79`
`80`		`- Fpm = phi_is_pi_half ? std::numeric_limits<T>::quiet_NaN() : log((one + sp) / (one - sp)) / 2;`
	`80`	`+ Fpm = phi_is_pi_half ? std::numeric_limits<T>::quiet_NaN() : ::boost::decimal::log((one + sp) / (one - sp)) / 2;`
`81`	`81`
`82`	`82`	`if(has_e)`
`83`	`83`	`{`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ constexpr auto lgamma_impl(const T x) noexcept`
`81`	`81`
`82`	`82`	`const auto phase = sin(numbers::pi_v<T> * za);`
`83`	`83`
`84`		`- result = log(numbers::pi_v<T>) - log(abs(phase)) - lgamma(za);`
	`84`	`+ result = ::boost::decimal::log(numbers::pi_v<T>) - ::boost::decimal::log(abs(phase)) - lgamma(za);`
`85`	`85`	`}`
`86`	`86`	`else`
`87`	`87`	`{`
`@@ -97,11 +97,11 @@ constexpr auto lgamma_impl(const T x) noexcept`
`97`	`97`	`// Perform the Taylor series expansion.`
`98`	`98`
`99`	`99`	`result = (x * fma(detail::lgamma_taylor_series_expansion(x), x, -numbers::egamma_v<T>))`
`100`		`- - log(x);`
	`100`	`+ - ::boost::decimal::log(x);`
`101`	`101`	`}`
`102`	`102`	`else if (x < T { asymp_cutoff })`
`103`	`103`	`{`
`104`		`- result = log(tgamma(x));`
	`104`	`+ result = ::boost::decimal::log(tgamma(x));`
`105`	`105`	`}`
`106`	`106`	`else`
`107`	`107`	`{`
`@@ -111,7 +111,7 @@ constexpr auto lgamma_impl(const T x) noexcept`
`111`	`111`
`112`	`112`	`constexpr T half { 5, -1 };`
`113`	`113`
`114`		`- result = (((x - half) * (log(x)) - x)) + log(detail::tgamma_series_expansion_asymp(one / x));`
	`114`	`+ result = (((x - half) * (::boost::decimal::log(x)) - x)) + ::boost::decimal::log(detail::tgamma_series_expansion_asymp(one / x));`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`	`}`
Original file line number	Diff line number	Diff line change
`@@ -53,11 +53,11 @@ constexpr auto log_impl(const T x) noexcept`
`53`	`53`	`else if (x < one)`
`54`	`54`	`{`
`55`	`55`	`// Handle reflection.`
`56`		`- result = -log(one / x);`
	`56`	`+ result = -::boost::decimal::log(one / x);`
`57`	`57`	`}`
`58`	`58`	`else if(x > one)`
`59`	`59`	`{`
`60`		`- // Use the implementation of log10 in order to compute the natural`
	`60`	`+ // Use the implementation of ::boost::decimal::log10 in order to compute the natural`
`61`	`61`	`// logarithm. The base of the boost::decimal library is, in fact,`
`62`	`62`	`// base-10. And so, somewhat uncommonly, the fastest and most accurate`
`63`	`63`	`// logarithm in this system is log10 in base-10.`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ constexpr auto log10_impl(const T x) noexcept`
`79`	`79`	`if (x < one)`
`80`	`80`	`{`
`81`	`81`	`// Handle reflection.`
`82`		`- result = -log10(one / x);`
	`82`	`+ result = -::boost::decimal::log10(one / x);`
`83`	`83`	`}`
`84`	`84`	`else if(x > one)`
`85`	`85`	`{`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ constexpr auto log1p_impl(const T x) noexcept`
`61`	`61`	`{`
`62`	`62`	`if (x > T { 5, -1 })`
`63`	`63`	`{`
`64`		`- result = log(x + one);`
	`64`	`+ result = ::boost::decimal::log(x + one);`
`65`	`65`	`}`
`66`	`66`	`else`
`67`	`67`	`{`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ template <typename T>`
`27`	`27`	`constexpr auto log2_impl(const T x) noexcept`
`28`	`28`	`BOOST_DECIMAL_REQUIRES(detail::is_decimal_floating_point_v, T)`
`29`	`29`	`{`
`30`		`- return log(x) / numbers::ln2_v<T>;`
	`30`	`+ return ::boost::decimal::log(x) / numbers::ln2_v<T>;`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`} //namespace detail`