Merge pull request #1336 from boostorg/tuning_tests

ckormanyos · web-flow · commit 17cfe8b09135 · 2026-02-09T21:12:06.000+01:00
Tuning tests cover optimize zero
diff --git a/include/boost/decimal/detail/cmath/lgamma.hpp b/include/boost/decimal/detail/cmath/lgamma.hpp
@@ -111,8 +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) * (log(x)) - x)) + log(detail::tgamma_series_expansion_asymp(one / x));
             }
         }
     }
diff --git a/test/cover/make_gcov_01_generic.gmk b/test/cover/make_gcov_01_generic.gmk
@@ -1,14 +1,14 @@
 # -----------------------------------------------------------------------------
-#  Copyright Matt Borland 2023 - 2024.
-#  Copyright Christopher Kormanyos 2023 - 2024.
+#  Copyright Matt Borland 2023 - 2026.
+#  Copyright Christopher Kormanyos 2023 - 2026.
 #  Distributed under the Boost Software License,
 #  Version 1.0. (See accompanying file LICENSE_1_0.txt
 #  or copy at http://www.boost.org/LICENSE_1_0.txt)
 # -----------------------------------------------------------------------------
 
-# cd /mnt/c/ChrisGitRepos/boostorg/decimal/test/cover
-# make prepare -f make_gcov_01_generic.gmk MY_ALL_COV=0 MY_BOOST_ROOT=/mnt/c/boost/boost_1_85_0 MY_CC=g++
-# make gcov -f make_gcov_01_generic.gmk --jobs=8 MY_ALL_COV=0 MY_BOOST_ROOT=/mnt/c/boost/boost_1_85_0 MY_CC=g++
+# cd /mnt/c/ChrisGitRepos/modular_boost/decimal/test/cover
+# make prepare -f make_gcov_01_generic.gmk MY_ALL_COV=0 MY_BOOST_ROOT=/mnt/c/boost/boost_1_90_0 MY_CC=g++
+# make gcov -f make_gcov_01_generic.gmk --jobs=8 MY_ALL_COV=0 MY_BOOST_ROOT=/mnt/c/boost/boost_1_90_0 MY_CC=g++
 
 all: gcov
 
diff --git a/test/cover/make_gcov_02_files.gmk b/test/cover/make_gcov_02_files.gmk
@@ -1,36 +1,39 @@
 ﻿# -----------------------------------------------------------------------------
-#  Copyright Matt Borland 2023 - 2024.
-#  Copyright Christopher Kormanyos 2023 - 2024.
+#  Copyright Matt Borland 2023 - 2026.
+#  Copyright Christopher Kormanyos 2023 - 2026.
 #  Distributed under the Boost Software License,
 #  Version 1.0. (See accompanying file LICENSE_1_0.txt
 #  or copy at http://www.boost.org/LICENSE_1_0.txt)
 # -----------------------------------------------------------------------------
 
 FILES_PRJ     := $(basename $(wildcard $(PATH_SRC)/*.cpp))
 
-FILES_EXCLUDE := $(PATH_SRC)/concepts_test.cpp                                      \
+FILES_EXCLUDE := $(PATH_SRC)/benchmark_uint256.cpp                                  \
+                 $(PATH_SRC)/benchmarks.cpp                                         \
+                 $(PATH_SRC)/check_cmake_version.cpp                                \
+                 $(PATH_SRC)/concepts_test.cpp                                      \
+                 $(PATH_SRC)/github_issue_1087.cpp                                  \
+                 $(PATH_SRC)/github_issue_519.cpp                                   \
                  $(PATH_SRC)/link_1.cpp                                             \
                  $(PATH_SRC)/link_2.cpp                                             \
                  $(PATH_SRC)/link_3.cpp                                             \
                  $(PATH_SRC)/limits_link_1.cpp                                      \
                  $(PATH_SRC)/limits_link_2.cpp                                      \
                  $(PATH_SRC)/limits_link_3.cpp                                      \
                  $(PATH_SRC)/test_bad_evaluation_method.cpp                         \
+                 $(PATH_SRC)/test_boost_math_univariate_stats.cpp                   \
+                 $(PATH_SRC)/test_decimal32.cpp                                     \
+                 $(PATH_SRC)/test_decimal64_basis.cpp                               \
+                 $(PATH_SRC)/test_decimal128_basis.cpp                              \
                  $(PATH_SRC)/test_explicit_floats.cpp                               \
-                 $(PATH_SRC)/test_from_chars.cpp                                    \
-                 $(PATH_SRC)/test_illegal_decimal32_implicit_conversions.cpp        \
+                 $(PATH_SRC)/test_illegal_decimal128_implicit_conversions.cpp       \
                  $(PATH_SRC)/test_illegal_decimal32_fast_implicit_conversions.cpp   \
+                 $(PATH_SRC)/test_illegal_decimal32_implicit_conversions.cpp        \
                  $(PATH_SRC)/test_illegal_decimal64_fast_implicit_conversions.cpp   \
                  $(PATH_SRC)/test_illegal_decimal64_implicit_conversions.cpp        \
-                 $(PATH_SRC)/test_illegal_decimal128_implicit_conversions.cpp       \
-                 $(PATH_SRC)/test_decimal32.cpp                                     \
-                 $(PATH_SRC)/test_decimal64_basis.cpp                               \
-                 $(PATH_SRC)/test_decimal128_basis.cpp                              \
-                 $(PATH_SRC)/benchmarks.cpp                                         \
-                 $(PATH_SRC)/test_boost_math_univariate_stats.cpp                   \
-                 $(PATH_SRC)/benchmark_uint256.cpp                                  \
-                 $(PATH_SRC)/github_issue_519.cpp                                   \
                  $(PATH_SRC)/test_fprintf.cpp                                       \
+                 $(PATH_SRC)/test_from_chars.cpp                                    \
+
 
 
 FILES_EXCLUDE := $(basename $(FILES_EXCLUDE))
diff --git a/test/cover/make_gcov_03_flags.gmk b/test/cover/make_gcov_03_flags.gmk
@@ -1,6 +1,6 @@
 ﻿# -----------------------------------------------------------------------------
-#  Copyright Matt Borland 2023.
-#  Copyright Christopher Kormanyos 2023.
+#  Copyright Matt Borland 2023 - 2026.
+#  Copyright Christopher Kormanyos 2023 - 2026.
 #  Distributed under the Boost Software License,
 #  Version 1.0. (See accompanying file LICENSE_1_0.txt
 #  or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -28,9 +28,13 @@ endif
 
 CXXFLAGS     = -march=native                                                   \
                -mtune=native                                                   \
-               -O1                                                             \
+               -O0                                                             \
                -Wextra                                                         \
                -Wall                                                           \
+               -Wpedantic                                                      \
+               -Wconversion                                                    \
+               -Wsign-conversion                                               \
+               -Wno-psabi                                                      \
                -fno-inline-functions                                           \
                -fprofile-arcs                                                  \
                -ftest-coverage                                                 \
diff --git a/test/test_acosh.cpp b/test/test_acosh.cpp
@@ -1,5 +1,5 @@
-// Copyright 2023 Matt Borland
-// Copyright 2023 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
 
@@ -188,6 +188,19 @@ namespace local
       result_is_ok = (result_val_one_is_ok && result_is_ok);
     }
 
+    for(auto i = static_cast<unsigned>(UINT8_C(0)); i < static_cast<unsigned>(UINT8_C(4)); ++i)
+    {
+      static_cast<void>(i);
+
+      const auto val_lt_one = acosh(::my_one() / static_cast<decimal_type>(dist(gen) * (dist(gen) * dist(gen))));
+
+      const auto result_val_lt_one_is_ok = (isnan(val_lt_one) && signbit(val_lt_one));
+
+      BOOST_TEST(result_val_lt_one_is_ok);
+
+      result_is_ok = (result_val_lt_one_is_ok && result_is_ok);
+    }
+
     for(auto i = static_cast<unsigned>(UINT8_C(0)); i < static_cast<unsigned>(UINT8_C(4)); ++i)
     {
       static_cast<void>(i);
diff --git a/test/test_atanh.cpp b/test/test_atanh.cpp
@@ -1,5 +1,5 @@
-// Copyright 2023 Matt Borland
-// Copyright 2023 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
 
@@ -216,6 +216,19 @@ namespace local
       result_is_ok = (result_val_zero_is_ok && result_is_ok);
     }
 
+    for(auto i = static_cast<unsigned>(UINT8_C(0)); i < static_cast<unsigned>(UINT8_C(4)); ++i)
+    {
+      static_cast<void>(i);
+
+      const auto val_gt_one_pos = atanh(::my_one() * static_cast<decimal_type>(dist(gen) * dist(gen) * dist(gen)));
+
+      const auto result_val_gt_one_pos_is_ok = (isnan(val_gt_one_pos) && (!signbit(val_gt_one_pos)));
+
+      BOOST_TEST(result_val_gt_one_pos_is_ok);
+
+      result_is_ok = (result_val_gt_one_pos_is_ok && result_is_ok);
+    }
+
     return result_is_ok;
   }
 
diff --git a/test/test_lgamma.cpp b/test/test_lgamma.cpp
@@ -22,7 +22,8 @@
 
 #include <boost/core/lightweight_test.hpp>
 
-template<typename DecimalType> auto my_zero() -> DecimalType& { using decimal_type = DecimalType; static decimal_type val_zero { 0, 0 }; return val_zero; }
+template<typename DecimalType> auto my_zero() -> DecimalType&;
+template<typename DecimalType> auto my_one () -> DecimalType&;
 
 namespace local
 {
@@ -314,7 +315,7 @@ namespace local
     {
       static_cast<void>(i);
 
-      const auto val_zero_neg = lgamma(-::my_zero<decimal_type>());
+      const auto val_zero_neg = lgamma(-::my_zero<decimal_type>() * static_cast<decimal_type>(dist(gen)));
 
       const auto result_val_zero_neg_is_ok = (isinf(val_zero_neg) && (!signbit(val_zero_neg)));
 
@@ -325,7 +326,7 @@ namespace local
 
     for(auto i = static_cast<unsigned>(UINT8_C(0)); i < static_cast<unsigned>(UINT8_C(6)); ++i)
     {
-      const auto n_neg = -static_cast<int>(i) - 1;
+      const auto n_neg = -static_cast<int>(i) - static_cast<int>(::my_one<decimal_type>());
 
       const auto val_neg_int = lgamma( decimal_type { n_neg, 0 } );
 
@@ -342,11 +343,11 @@ namespace local
 
       for(auto i = static_cast<unsigned>(UINT8_C(1)); i <= static_cast<unsigned>(UINT8_C(2)); ++i)
       {
-        decimal_type n_arg { i, 0 };
+        const int n_arg { static_cast<int>(decimal_type { i } + static_cast<decimal_type>(dist(gen) / 10.0F)) };
 
-        n_arg += (::my_zero<decimal_type>() * static_cast<decimal_type>(dist(gen)));
+        const decimal_type arg_one_or_two { n_arg, 0 };
 
-        const auto val_one_or_two = lgamma(n_arg);
+        const auto val_one_or_two = lgamma(arg_one_or_two);
 
         const auto result_val_one_or_two_is_ok =
         (
@@ -550,3 +551,6 @@ auto main() -> int
 
   return (result_is_ok ? 0 : -1);
 }
+
+template<typename DecimalType> auto my_zero() -> DecimalType& { using decimal_type = DecimalType; static decimal_type val_zero { 0 }; return val_zero; }
+template<typename DecimalType> auto my_one () -> DecimalType& { using decimal_type = DecimalType; static decimal_type val_one  { 1 }; return val_one; }
diff --git a/test/test_zeta.cpp b/test/test_zeta.cpp
@@ -207,27 +207,27 @@ auto test_riemann_zeta_edge() -> bool
       result_nan_is_ok = (isnan(riemann_zeta(decimal_type { 1 })));  result_is_ok = (result_nan_is_ok && result_is_ok); BOOST_TEST(result_is_ok);
     }
 
-    for(auto index = 0U; index < 8U; ++index)
     {
-      static_cast<void>(index);
-
       const decimal_type zero { ::my_zero<decimal_type>() * decimal_type(dist(gen)) };
 
       const decimal_type minus_half { -5, -1 };
 
       const bool result_zero_is_ok = (riemann_zeta(zero) == minus_half); result_is_ok = (result_zero_is_ok && result_is_ok); BOOST_TEST(result_is_ok);
     }
 
-    for(auto index = 0U; index < 8U; ++index)
     {
-      static_cast<void>(index);
-
       const int n_one { static_cast<int>(::my_one<decimal_type>() + decimal_type(dist(gen) / 150.0F)) };
 
       const decimal_type one { n_one };
 
       const bool result_one_is_ok = isnan(riemann_zeta(one)); result_is_ok = (result_one_is_ok && result_is_ok); BOOST_TEST(result_is_ok);
     }
+
+    {
+      const decimal_type asymp { sqrt((std::numeric_limits<decimal_type>::max)()) * static_cast<decimal_type>(dist(gen)) };
+
+      const bool result_asymp_is_ok = (riemann_zeta(asymp) == ::my_one<decimal_type>()); result_is_ok = (result_asymp_is_ok && result_is_ok); BOOST_TEST(result_is_ok);
+    }
   }
 
   for(auto n = static_cast<unsigned>(UINT8_C(2)); n < static_cast<unsigned>(UINT8_C(6)); ++n)

Original file line number	Diff line number	Diff line change
`@@ -111,8 +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))`
`115`		`- + log(detail::tgamma_series_expansion_asymp(one / x));`
	`114`	`+ result = (((x - half) * (log(x)) - x)) + log(detail::tgamma_series_expansion_asymp(one / x));`
`116`	`115`	`}`
`117`	`116`	`}`
`118`	`117`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,8 @@`
`22`	`22`
`23`	`23`	`#include <boost/core/lightweight_test.hpp>`
`24`	`24`
`25`		`-template<typename DecimalType> auto my_zero() -> DecimalType& { using decimal_type = DecimalType; static decimal_type val_zero { 0, 0 }; return val_zero; }`
	`25`	`+template<typename DecimalType> auto my_zero() -> DecimalType&;`
	`26`	`+template<typename DecimalType> auto my_one () -> DecimalType&;`
`26`	`27`
`27`	`28`	`namespace local`
`28`	`29`	`{`
`@@ -314,7 +315,7 @@ namespace local`
`314`	`315`	`{`
`315`	`316`	`static_cast<void>(i);`
`316`	`317`
`317`		`- const auto val_zero_neg = lgamma(-::my_zero<decimal_type>());`
	`318`	`+ const auto val_zero_neg = lgamma(-::my_zero<decimal_type>() * static_cast<decimal_type>(dist(gen)));`
`318`	`319`
`319`	`320`	`const auto result_val_zero_neg_is_ok = (isinf(val_zero_neg) && (!signbit(val_zero_neg)));`
`320`	`321`
`@@ -325,7 +326,7 @@ namespace local`
`325`	`326`
`326`	`327`	`for(auto i = static_cast<unsigned>(UINT8_C(0)); i < static_cast<unsigned>(UINT8_C(6)); ++i)`
`327`	`328`	`{`
`328`		`- const auto n_neg = -static_cast<int>(i) - 1;`
	`329`	`+ const auto n_neg = -static_cast<int>(i) - static_cast<int>(::my_one<decimal_type>());`
`329`	`330`
`330`	`331`	`const auto val_neg_int = lgamma( decimal_type { n_neg, 0 } );`
`331`	`332`
`@@ -342,11 +343,11 @@ namespace local`
`342`	`343`
`343`	`344`	`for(auto i = static_cast<unsigned>(UINT8_C(1)); i <= static_cast<unsigned>(UINT8_C(2)); ++i)`
`344`	`345`	`{`
`345`		`- decimal_type n_arg { i, 0 };`
	`346`	`+ const int n_arg { static_cast<int>(decimal_type { i } + static_cast<decimal_type>(dist(gen) / 10.0F)) };`
`346`	`347`
`347`		`- n_arg += (::my_zero<decimal_type>() * static_cast<decimal_type>(dist(gen)));`
	`348`	`+ const decimal_type arg_one_or_two { n_arg, 0 };`
`348`	`349`
`349`		`- const auto val_one_or_two = lgamma(n_arg);`
	`350`	`+ const auto val_one_or_two = lgamma(arg_one_or_two);`
`350`	`351`
`351`	`352`	`const auto result_val_one_or_two_is_ok =`
`352`	`353`	`(`
`@@ -550,3 +551,6 @@ auto main() -> int`
`550`	`551`
`551`	`552`	`return (result_is_ok ? 0 : -1);`
`552`	`553`	`}`
	`554`	`+`
	`555`	`+template<typename DecimalType> auto my_zero() -> DecimalType& { using decimal_type = DecimalType; static decimal_type val_zero { 0 }; return val_zero; }`
	`556`	`+template<typename DecimalType> auto my_one () -> DecimalType& { using decimal_type = DecimalType; static decimal_type val_one { 1 }; return val_one; }`
Original file line number	Diff line number	Diff line change
`@@ -207,27 +207,27 @@ auto test_riemann_zeta_edge() -> bool`
`207`	`207`	`result_nan_is_ok = (isnan(riemann_zeta(decimal_type { 1 }))); result_is_ok = (result_nan_is_ok && result_is_ok); BOOST_TEST(result_is_ok);`
`208`	`208`	`}`
`209`	`209`
`210`		`- for(auto index = 0U; index < 8U; ++index)`
`211`	`210`	`{`
`212`		`- static_cast<void>(index);`
`213`		`-`
`214`	`211`	`const decimal_type zero { ::my_zero<decimal_type>() * decimal_type(dist(gen)) };`
`215`	`212`
`216`	`213`	`const decimal_type minus_half { -5, -1 };`
`217`	`214`
`218`	`215`	`const bool result_zero_is_ok = (riemann_zeta(zero) == minus_half); result_is_ok = (result_zero_is_ok && result_is_ok); BOOST_TEST(result_is_ok);`
`219`	`216`	`}`
`220`	`217`
`221`		`- for(auto index = 0U; index < 8U; ++index)`
`222`	`218`	`{`
`223`		`- static_cast<void>(index);`
`224`		`-`
`225`	`219`	`const int n_one { static_cast<int>(::my_one<decimal_type>() + decimal_type(dist(gen) / 150.0F)) };`
`226`	`220`
`227`	`221`	`const decimal_type one { n_one };`
`228`	`222`
`229`	`223`	`const bool result_one_is_ok = isnan(riemann_zeta(one)); result_is_ok = (result_one_is_ok && result_is_ok); BOOST_TEST(result_is_ok);`
`230`	`224`	`}`
	`225`	`+`
	`226`	`+ {`
	`227`	`+ const decimal_type asymp { sqrt((std::numeric_limits<decimal_type>::max)()) * static_cast<decimal_type>(dist(gen)) };`
	`228`	`+`
	`229`	`+ const bool result_asymp_is_ok = (riemann_zeta(asymp) == ::my_one<decimal_type>()); result_is_ok = (result_asymp_is_ok && result_is_ok); BOOST_TEST(result_is_ok);`
	`230`	`+ }`
`231`	`231`	`}`
`232`	`232`
`233`	`233`	`for(auto n = static_cast<unsigned>(UINT8_C(2)); n < static_cast<unsigned>(UINT8_C(6)); ++n)`